作者: 一字马胡
转载标志 【2017-11-17】
更新日志
日期 | 更新内容 | 备注 |
---|---|---|
2017-11-17 | 新建文章 | 初版 |
2017-11-18 | 修改几个错误 | xx |
导入
Spring框架的一大强大之处就是框架的设计具有很好的可扩展性,所以只要有想象力,就可以在Spring框架上作出扩展,比如,在学会了熟练使用Spring的内置标签之后,如果我们想要设计自己的标签,Spring是支持这种创新的,本文将结合实际的例子来说明如何使用Spring提供的扩展接口来设计自己的自定义标签,并且实现一些动作。在阅读本文之前,你可以首先阅读下面的两篇链接文章,以更快的属性Spring的生命周期等内容,可以更流畅的阅读和理解本文的内容:
Spring的BeanFactory和FactoryBean
Spring Bean 的生命周期
下面再次放上Spring Bean的生命周期图,因为本文的内容涉及到Bean的生命周期,自定义标签需要在Bean的生命周期内做一些事情来操作bean,所以属性Spring Bean的生命周期在阅读本文之前是必须的:
上面的流程图已经展示了Spring bean生命周期的详细细节,我们知道了这些加载、初始化、设置等一系列流程之后,就可以在合适的环节加上我们想要的动作,比如,我们可以使用BeanFactoryPostProcessor的postProcessBeanFactory方法来修改bean的属性,例如,我们有一个bean的一个属性A在spring配置文件中找不到,但是我们可以在BeanFactoryPostProcessor的postProcessBeanFactory方法里面使用方法的参数beanFactory来注册一个A。我们还可以使用BeanPostProcessor来修改我们的bean的属性值,比如一个bean的一个属性A,我们可以在BeanPostProcessor的postProcessBeforeInitialization方法和postProcessAfterInitialization方法来修改其值,这些方法需要配合其他的与Spring bean生命周期相关的类来做。
可以将Spring bean的生命周期根据不同特点划分为下面的几类:
Bean自身的方法
包括我们在配置bean时候设置的init-method方法和destroy-method方法。
Spring Bean级别的生命周期方法
包括BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法。
Spring容器级别生命周期方法
包括InstantiationAwareBeanPostProcessor、BeanPostProcessor、BeanFactoryPostProcessor的实现类的方法。
特别说明,本文仅结合实际的例子来说明Spring 自定义标签的使用方法,而在此过程中涉及到的额外的技术点(比如xsd文档的编写规则)将不再本文的描述范围之内,需要自行查找资料来学习,本文的定位是学会使用Spring自定义标签做一些事情,所以需要自行去查阅相关技术资料来学习一些内容来理解Spring自定义标签。
自定义标签以实现bean注册
首先,如何自定义一个Spring标签来实现bean的注册呢?我想要实现的功能是类似于<bean .../>这样的,下面将一步一步来说明如何进行操作,达到最后的效果。
编写xsd文件
第一步是需要编写xsd文件,下面是一个例子:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://code.hujian.com/schema/ok"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:beans="http://www.springframework.org/schema/beans"
targetNamespace="http://code.hujian.com/schema/ok"
elementFormDefault="qualified" attributeFormDefault="unqualified">
<xsd:complexType name="server">
<xsd:attribute name="id" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[ The unique identifier for a bean. ]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="serverName" type="xsd:string">
<xsd:annotation>
<xsd:documentation><![CDATA[ The name of the bean. ]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="service" type="server">
<xsd:annotation>
<xsd:documentation><![CDATA[ The service config ]]></xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:schema>
将这个文件命名为任意你喜欢的名字,后缀为.xsd,比如例子中的该文件被命名为ok-1.0.xsd,这个名字将在后文中用到。上面定义的xsd文件中,我想要实现类似于:
<service id = "" serverName= "" />
看起来很简单,并且我希望可以通过加载配置文件后可以获取到这个bean(根据id来获取)。但是看起来很奇怪的是这个bean的类似是什么呢?你当然可以在xsd文件中增加一个attr叫做“class”来控制生成的bean的类型,但是本文中的例子为了简单,只可以配置一个属性,具体返回的类似后面会说到。
编写Schema文件和handler文件
这一步是比较关键的一步,你需要编写两个文件,分别为spring.schemas和spring.handlers,然后将这两个文件放在resource文件夹下的META-INF文件夹下,在spring.schemas文件里面,你需要写上;类似下面的内容:
http\://code.hujian.com/schema/ok/ok-1.0.xsd=./ok-1.0.xsd
前面的http://code.hujian.com/schema/ok/ok-1.0.xsd是我们的命名空间,后面是我们上面编写的xsd文件,这里需要注意文件名。写好spring.schemas文件后,需要写spring.handlers文件,在这个文件里面你需要定义一个处理器来处理你自定义的哪些标签,我们可以在里面做很丰富的事情,下面是为本文例子编写的spring.handlers文件的内容:
http\://code.hujian.com/schema/ok=com.hujian.spring.handler.CommonNamespaceHandler
编写Handler
经过上面两步之后,现在我们可以开始写处理我们的自定义标签的Handler了,下面首先展示了代码:
class CommonNamespaceHandler extends NamespaceHandlerSupport{
@Override
public void init() {
this.registerBeanDefinitionParser("service",
new OkServerDefinitionParser(ServerBean.class));
}
}
class OkServerDefinitionParser implements BeanDefinitionParser {
private final Class<?> clazz;
private static final String default_prefix = "ok-";
private static final AtomicLong COUNT = new AtomicLong(0);
public OkServerDefinitionParser(Class<?> clazz) {
this.clazz = clazz;
}
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
return parseHelper(element, parserContext, this.clazz);
}
private BeanDefinition parseHelper(Element element, ParserContext parserContext, Class<?> clazz) {
RootBeanDefinition bd = new RootBeanDefinition();
bd.setLazyInit(false);
String id = element.getAttribute("id");
if (id == null || id.isEmpty()) {
id = default_prefix + COUNT.getAndDecrement();
}
String serverName = element.getAttribute("serverName");
bd.setBeanClass(clazz);
bd.setInitMethodName("init");
MutablePropertyValues propertyValues = bd.getPropertyValues();
propertyValues.addPropertyValue("serverName", serverName);
parserContext.getRegistry().registerBeanDefinition(id, bd);
return bd;
}
}
上面说到我们自定义的标签还不知道返回的bean是什么类型的,为了简单,上面的代码中将返回的类型定义为了ServerBean这个类型,下面是这个类的信息:
class ServerBean {
private String serverName;
//init method
public void init() {
System.out.println("bean ServerBean init.");
}
@Override
public String toString() {
return "[Service]=>" + serverName;
}
public String getServerName() {
return serverName;
}
public void setServerName(String serverName) {
this.serverName = serverName;
}
}
其实流程还是比较容易看懂的,首先我们需要注册一个bean,而Spring中注册的bean是AbstractBeanDefinition的子类,所以你可以使用任意AbstractBeanDefinition的子类来注册你的bean,上面的例子中使用了RootBeanDefinition这个AbstractBeanDefinition的子类来注册一个bean,设置一些配置信息之后就使用ParserContext的注册器来将我们自定义的bean注册到Spring中去了,需要注意的是,我们在<service id = "" .../>中配置的id就是我们往Spring容器中注册的bean的id,所以在我们想要使用该bean的时候就可以使用这个id来获取这个bean了。
测试
经过上面的步骤之后,下面来测试一下我自定义的标签是否可以正常工作,首先需要编写Spring xml配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ok="http://code.hujian.com/schema/ok"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://code.hujian.com/schema/ok
http://code.hujian.com/schema/ok/ok-1.0.xsd">
<ok:service id="testServer" serverName="HelloWorldService"/>
</beans>
需要注意的是需要引入我们自定义的命名空间: xmlns:ok="http://code.hujian.com/schema/ok",并且需要将我们的Schema位置也告诉Spring,也就是需要在xsi:schemaLocation中设置我们的Schema路径。然后就可以使用我们的自定义标签<ok:service .../>了,可以看出上面我们配置了一个自定义bean,id为testServer,serverName属性为HelloWorldService,下面是测试代码:
public static void main(String ... args) {
String xmlFile = "tagTest.xml";
String beanId = "testServer";
ApplicationContext context = new ClassPathXmlApplicationContext(xmlFile);
ServerBean bean = (ServerBean) context.getBean(beanId);
System.out.println(bean);
}
下面是输出的结果:
[Service]=>HelloWorldService
可以看到,我们自定义的标签可以正常工作了,更为复杂的Spring自定义标签可以借助这个例子来扩展。
自定义标签以实现bean扫描
上面展示了一个简单的Spring自定义标签的用法,当然任意复杂的自定义标签都可以基于这个简单的标签来模仿出来,下面一个例子和注解有关,有时候我们希望借助Spring来帮我们解析代码中的注解,下面的例子可以在xml中使用自定义的标签设定需要扫描的package,Spring会扫描我们配置的这个package,然后我希望可以找到这个package下所有注解了OkService的类,并且基于该注解做一些统计,比如将这些注解的信息收集起来,然后最后展示出这些收集到的注解信息,因为步骤和上面的例子一样,所以不再赘述:
首先是xsd文件:
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://code.hujian.com/schema/ok"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:beans="http://www.springframework.org/schema/beans"
targetNamespace="http://code.hujian.com/schema/ok"
elementFormDefault="qualified" attributeFormDefault="unqualified">
<xsd:complexType name="annotationType">
<xsd:attribute name="id" type="xsd:ID">
<xsd:annotation>
<xsd:documentation><![CDATA[ The unique identifier for a bean. ]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="scan" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[ The scan package. ]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
<xsd:attribute name="url" type="xsd:string" use="optional">
<xsd:annotation>
<xsd:documentation><![CDATA[ The url string ]]></xsd:documentation>
</xsd:annotation>
</xsd:attribute>
</xsd:complexType>
<xsd:element name="annotation" type="annotationType">
<xsd:annotation>
<xsd:documentation><![CDATA[ The annotation config ]]></xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:schema>
接下来编写handler:
class CommonNamespaceHandler extends NamespaceHandlerSupport{
@Override
public void init() {
this.registerBeanDefinitionParser("annotation",
new OkAnnotationDefinitionParser(ScanBeanReference.class));
}
}
class OkAnnotationDefinitionParser implements BeanDefinitionParser {
private final Class<?> clazz;
private static final String default_prefix = "scan-";
private static final AtomicLong COUNT = new AtomicLong(0);
public OkAnnotationDefinitionParser(Class<?> clazz) {
this.clazz = clazz;
}
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
return parseHelper(element, parserContext, clazz);
}
private BeanDefinition parseHelper(Element element, ParserContext parserContext, Class<?> clazz) {
RootBeanDefinition bd = new RootBeanDefinition();
bd.setLazyInit(false);
String id = element.getAttribute("id");
if (id == null || id.isEmpty()) {
id = default_prefix + COUNT.getAndDecrement();
}
String scanPackage = element.getAttribute("scan");
String url = element.getAttribute("url");
bd.setBeanClass(ScanBeanParser.class);
bd.setInitMethodName("init");
MutablePropertyValues propertyValues = bd.getPropertyValues();
propertyValues.addPropertyValue("scan", scanPackage);
propertyValues.addPropertyValue("url", url);
parserContext.getRegistry().registerBeanDefinition(id, bd);
return bd;
}
}
上面的代码和上面的例子中的代码没有什么区别,但是有一个地方需要特别注意:
bd.setBeanClass(ScanBeanParser.class);
而这个ScanBeanParser类的信息如下:
class ScanBeanParser implements BeanPostProcessor,
BeanFactoryPostProcessor, ApplicationContextAware, PriorityOrdered {
private static final Pattern COMMA_SPLIT_PATTERN = Pattern.compile("\\s*[,]+\\s*");
private String scan; // the scan package
private String url; // the url
public void setScan(String scan) {
this.scan = scan;
}
public void setUrl(String url) {
this.url = url;
}
public void init() {
System.out.println("ScanBeanParser start to run...");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException {
String annotationPackage = scan == null || scan.isEmpty() ? "com.hujian" : scan;
System.out.println("get the scan package:" + annotationPackage);
if (beanFactory instanceof BeanDefinitionRegistry) {
try {
// init scanner
Class<?> scannerClass = ClassUtils
.loadClass("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
Object scanner = scannerClass.getConstructor(
new Class<?>[] { BeanDefinitionRegistry.class, boolean.class }).newInstance(
beanFactory, true);
// add filter
Class<?> filterClass = ClassUtils
.loadClass("org.springframework.core.type.filter.AnnotationTypeFilter");
Object filter = filterClass.getConstructor(Class.class).newInstance(OkService.class);
Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter",
ClassUtils.loadClass("org.springframework.core.type.filter.TypeFilter"));
addIncludeFilter.invoke(scanner, filter);
// scan packages
String[] packages = COMMA_SPLIT_PATTERN.split(annotationPackage);
Method scan = scannerClass.getMethod("scan", String[].class);
scan.invoke(scanner, new Object[] { packages });
} catch (Throwable e) {
e.printStackTrace();
}
}
}
@Override
public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
return o;
}
@Override
public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
Class<?> beanClass = AopUtils.getTargetClass(o);
if (beanClass == null) {
return o;
}
OkService service = beanClass.getAnnotation(OkService.class);
if (service != null) {
ScanBeanReference scanBeanReference = new ScanBeanReference();
scanBeanReference.setScan(service.scan());
scanBeanReference.setUrl(service.url());
scanBeanReference.setMsg(service.msg());
System.out.println("get a scan bean:" + scanBeanReference);
ScanStorageFactory.addScanBean(scanBeanReference);
}
return o;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("get the ApplicationContext:" + applicationContext);
}
@Override
public int getOrder() {
return 0;
}
}
在OkAnnotationDefinitionParser中获取了xml中的配置(比如scan属性),然后将获取到的属性值传递给ScanBeanParser这个类,这个类里面做了我们想要做的事情,就是收集所有注解了OKService的类的信息,并存储起来。读到这里就需要回头看一下文章开头的那张Spring Bean的生命周期图,ScanBeanParser实现了很多涉及Spring Bean生命周期的类。下面是测试代码:
public static void main(String ... args) {
String xmlFile = "tagTest.xml";
String beanId = "testServer";
ApplicationContext context = new ClassPathXmlApplicationContext(xmlFile);
ScanStorageFactory.getScanBeanReferenceList()
.forEach(System.out::println);
}
@OkService(scan = "com.hujian.io", url = "http://www.meituan.com", msg = "ScanTestClass1")
class ScanTestClass1 {
}
@OkService(scan = "com.hujian.rpc", url = "http://www.dianping.com", msg = "ScanTestClass2")
class ScanTestClass2 {
}
@OkService(scan = "io.hujian.com", url = "http://www.ok.com", msg = "ScanTestClass3")
class ScanTestClass3 {
}
测试的结果如下:
scanPackage:com.hujian.io, url:http://www.meituan.com, msg:ScanTestClass1
scanPackage:com.hujian.rpc, url:http://www.dianping.com, msg:ScanTestClass2
scanPackage:io.hujian.com, url:http://www.ok.com, msg:ScanTestClass3
结语
本文较为粗浅的解析了Spring中自定义标签的使用方法,可以将本文中的代码作为模板来进行Spring自定义标签的设计和处理,更为深入的分析与总结将在未来进行,关于Spring的相关分析总结会持续更新,本文相当于一个Spring自定义标签的“最佳实践”吧!
网友评论