常用注解
@Configuration
- 用法
@Configuration这个注解可以加在类上,让这个类的功能等同于一个bean xml配置文件,如下:
@Configuration
public class ConfigBean {
}
上面代码类似于下面的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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
</beans>
通过AnnotationConfigApplicationContext来加载@Configuration修饰的类,如下:
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConfigBean.class);
此时ConfigBean类中没有任何内容,相当于一个空的xml配置文件,此时我们要在ConfigBean类中注册bean,那么我们就要用到@Bean注解了。
总结一下
@Configuration使用步骤:
- 在类上使用@Configuration注解
- 通过AnnotationConfigApplicationContext容器来加@Configuration注解修饰的类
@Bean
这个注解类似于bean xml配置文件中的bean元素,用来在spring容器中注册一个bean。
@Bean注解用在方法上,表示通过方法来定义一个bean,默认将方法名称作为bean名称,将方法返回值作为bean对象,注册到spring容器中。
如:
@Bean
public User user1() {
return new User();
}
@Bean注解还有很多属性,我们来看一下其源码:
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE}) //@1
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Bean {
@AliasFor("name")
String[] value() default {};
@AliasFor("value")
String[] name() default {};
@Deprecated
Autowire autowire() default Autowire.NO;
boolean autowireCandidate() default true;
String initMethod() default "";
String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;
}
@1:说明这个注解可以用在方法和注解类型上面。
每个参数含义:
value和name是一样的,设置的时候,这2个参数只能选一个,原因是@AliasFor导致的
@AliasFor这个注解不清楚的可以看这个文章:详解注解
value:字符串数组,第一个值作为bean的名称,其他值作为bean的别名
autowire:这个参数上面标注了@Deprecated,表示已经过期了,不建议使用了
autowireCandidate:是否作为其他对象注入时候的候选bean,之前的文章中专门介绍过这个属性,不清楚的可以去看看:autowire-candidate详解
initMethod:bean初始化的方法,这个和生命周期有关,
destroyMethod:bean销毁的方法,也是和生命周期相关的,
被@Configuration修饰的类,spring容器中会通过cglib给这个类创建一个代理,代理会拦截所有被@Bean修饰的方法,默认情况(bean为单例)下确保这些方法只被调用一次,从而确保这些bean是同一个bean,即单例的。
如果说一个类不加@Configuration 只用@Bean修饰,那么这些bean对象将不会以单例形式注入到Spring中
spring这块的源码
spring中用下面这个类处理@Configuration这个注解:
org.springframework.context.annotation.ConfigurationClassPostProcessor
这里面重点关注这几个方法:
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory)
@ComponentScan
@ComponentScan用于批量注册bean。
这个注解会让spring去扫描某些包及其子包中所有的类,然后将满足一定条件的类作为bean注册到spring容器容器中。
具体需要扫描哪些包?以及这些包中的类满足什么条件时被注册到容器中,这些都可以通过这个注解中的参数动态配置
先来看一下这个注解的定义:
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class) //@1
public @interface ComponentScan {
@AliasFor("basePackages")
String[] value() default {};
@AliasFor("value")
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
String resourcePattern() default "**/*.class";
boolean useDefaultFilters() default true;
Filter[] includeFilters() default {};
Filter[] excludeFilters() default {};
boolean lazyInit() default false;
}
定义上可以看出此注解可以用在任何类型上面,不过我们通常将其用在类上面。
常用参数:
value:指定需要扫描的包,
basePackages:作用同value;value和basePackages不能同时存在设置,可二选一
basePackageClasses:指定一些类,spring容器会扫描这些类所在的包及其子包中的类
nameGenerator:自定义bean名称生成器
resourcePattern:需要扫描包中的那些资源,默认是:*/.class,即会扫描指定包中所有的class文件
useDefaultFilters:对扫描的类是否启用默认过滤器,默认为true
includeFilters:过滤器:用来配置被扫描出来的那些类会被作为组件注册到容器中
excludeFilters:过滤器,和includeFilters作用刚好相反,用来对扫描的类进行排除的,被排除的类不会被注册到容器中
lazyInit:是否延迟初始化被注册的bean
@1:@Repeatable(ComponentScans.class),这个注解可以同时使用多个。
@ComponentScan工作的过程:
Spring会扫描指定的包,且会递归下面子包,得到一批类的数组
然后这些类会经过上面的各种过滤器,最后剩下的类会被注册到容器中
所以玩这个注解,主要关注2个问题:
第一个:需要扫描哪些包?通过value、backPackages、basePackageClasses这3个参数来控制
第二:过滤器有哪些?通过useDefaultFilters、includeFilters、excludeFilters这3个参数来控制过滤器
这两个问题搞清楚了,就可以确定哪些类会被注册到容器中。
默认情况下,任何参数都不设置的情况下,此时,会将@ComponentScan修饰的类所在的包作为扫描包;默认情况下useDefaultFilters为true,这个为true的时候,spring容器内部会使用默认过滤器,规则是:凡是类上有@Repository、@Service、@Controller、@Component这几个注解中的任何一个的,那么这个类就会被作为bean注册到spring容器中,所以默认情况下,只需在类上加上这几个注解中的任何一个,这些类就会自动交给spring容器来管理了。
@Component、@Repository、@Service、@Controller
先说一下@Component这个注解,看一下其定义:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
String value() default "";
}
从定义中可以看出,这个注解可以用在任何类型上面。
通常情况下将这个注解用在类上面,标注这个类为一个组件,默认情况下,被扫描的时候会被作为bean注册到容器中。
value参数:被注册为bean的时候,用来指定bean的名称,如果不指定,默认为类名首字母小写。如:类UserService对应的beanname为userService
再来看看@Repository源码如下:
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
@AliasFor(annotation = Component.class)
String value() default "";
}
Repository上面有@Component注解。
value参数上面有@AliasFor(annotation =
Component.class),设置value参数的时候,也相当于给@Component注解中的value设置值。其他两个注解@Service、@Controller源码和@Repository源码类似。
这4个注解本质上是没有任何差别,都可以用在类上面,表示这个类被spring容器扫描的时候,可以作为一个bean组件注册到spring容器中。
spring容器中对这4个注解的解析并没有进行区分,统一采用@Component注解的方式进行解析,所以这几个注解之间可以相互替换。
spring提供这4个注解,是为了让系统更清晰,通常情况下,系统是分层结构的,多数系统一般分为controller层、service层、dao层。
@controller通常用来标注controller层组件,@service注解标注service层的组件,@Repository标注dao层的组件,这样可以让整个系统的结构更清晰,当看到这些注解的时候,会和清晰的知道属于哪个层,对于spring来说,将这3个注解替换成@Component注解,对系统没有任何影响,产生的效果是一样的。
componentScan 常用的参数
- 指定需要扫描的包
指定需要扫毛哪些包,可以通过value或者basePackage来配置,二者选其一,都配置运行会报错,下面我们通过value来配置。
@ComponentScan({
"com.yuan11.controller",
"com.yuan11.service"
})
public class ScanBean2 {
}
- basePackageClasses指定扫描范围
@ComponentScan(basePackageClasses = ScanClass.class)
public class ScanBean6 {
}
- includeFilters的使用
Filter[] includeFilters() default {};
是一个Filter类型的数组,多个Filter之间为或者关系,即满足任意一个就可以了,看一下Filter的代码:
@Retention(RetentionPolicy.RUNTIME)
@Target({})
@interface Filter {
FilterType type() default FilterType.ANNOTATION;
@AliasFor("classes")
Class<?>[] value() default {};
@AliasFor("value")
Class<?>[] classes() default {};
String[] pattern() default {};
}
可以看出Filter也是一个注解,参数:
type:过滤器的类型,是个枚举类型,5种类型
ANNOTATION:通过注解的方式来筛选候选者,即判断候选者是否有指定的注解
ASSIGNABLE_TYPE:通过指定的类型来筛选候选者,即判断候选者是否是指定的类型
ASPECTJ:ASPECTJ表达式方式,即判断候选者是否匹配ASPECTJ表达式
REGEX:正则表达式方式,即判断候选者的完整名称是否和正则表达式匹配
CUSTOM:用户自定义过滤器来筛选候选者,对候选者的筛选交给用户自己来判断
value:和参数classes效果一样,二选一
classes:3种情况如下
当type=FilterType.ANNOTATION时,通过classes参数可以指定一些注解,用来判断被扫描的类上是否有classes参数指定的注解
当type=FilterType.ASSIGNABLE_TYPE时,通过classes参数可以指定一些类型,用来判断被扫描的类是否是classes参数指定的类型
当type=FilterType.CUSTOM时,表示这个过滤器是用户自定义的,classes参数就是用来指定用户自定义的过滤器,自定义的过滤器需要实现org.springframework.core.type.filter.TypeFilter接口
pattern:2种情况如下
当type=FilterType.ASPECTJ时,通过pattern来指定需要匹配的ASPECTJ表达式的值
当type=FilterType.REGEX时,通过pattern来自正则表达式的值
栗子:
定义一个注解
package com.yuan11;
import java.lang.annotation.*;
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyBean {
}
创建一个类,使用这个注解标注
package com.yuan11;
@MyBean
public class Service1 {
}
再来一个类,使用spring中的@Compontent标注
package com.yuan11;
import org.springframework.stereotype.Component;
@Component
public class Service2 {
}
再来一个类,使用@CompontentScan标注
package com.yuan11;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
@ComponentScan(includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = MyBean.class)
})
public class ScanBean3 {
}
Service1上标注了@MyBean注解,被注册到容器了,但是Service2上没有标注@MyBean啊,怎么也被注册到容器了?
原因:Service2上标注了@Compontent注解,而@CompontentScan注解中的useDefaultFilters默认是true,表示也会启用默认的过滤器,而默认的过滤器会将标注有@Component、@Repository、@Service、@Controller这几个注解的类也注册到容器中
如果我们只想将标注有@MyBean注解的bean注册到容器,需要将默认过滤器关闭,即:useDefaultFilters=false,我们修改一下ScanBean3的代码如下:
@ComponentScan(
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = MyBean.class)
})
public class ScanBean3 {
}
- 包含指定类型的类
@ComponentScan(
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class) //@1
})
public class ScanBean4 {
}
这里是引用
@1:被扫描的类满足IService.class.isAssignableFrom(被扫描的类)条件的都会被注册到spring容器中
- 自定义Filter
有时候我们需要用到自定义的过滤器,使用自定义过滤器的步骤:
1.设置@Filter中type的类型为:FilterType.CUSTOM
2.自定义过滤器类,需要实现接口:org.springframework.core.type.filter.TypeFilter
3.设置@Filter中的classses为自定义的过滤器类型
来看一下TypeFilter这个接口的定义:
@FunctionalInterface
public interface TypeFilter {
boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException;
}
是一个函数式接口,包含一个match方法,方法返回boolean类型,有2个参数,都是接口类型的,下面介绍一下这2个接口。
MetadataReader接口
类元数据读取器,可以读取一个类上的任意信息,如类上面的注解信息、类的磁盘路径信息、类的class对象的各种信息,spring进行了封装,提供了各种方便使用的方法。
看一下这个接口的定义:
public interface MetadataReader {
/**
* 返回类文件的资源引用
*/
Resource getResource();
/**
* 返回一个ClassMetadata对象,可以通过这个读想获取类的一些元数据信息,如类的class对象、是否是接口、是否有注解、是否是抽象类、父类名称、接口名称、内部包含的之类列表等等,可以去看一下源码
*/
ClassMetadata getClassMetadata();
/**
* 获取类上所有的注解信息
*/
AnnotationMetadata getAnnotationMetadata();
}
MetadataReaderFactory接口:
类元数据读取器工厂,可以通过这个类获取任意一个类的MetadataReader对象。
源码:
public interface MetadataReaderFactory {
/**
* 返回给定类名的MetadataReader对象
*/
MetadataReader getMetadataReader(String className) throws IOException;
/**
* 返回指定资源的MetadataReader对象
*/
MetadataReader getMetadataReader(Resource resource) throws IOException;
}
栗子:
public class MyFilter implements TypeFilter {
/**
* @param metadataReader
* @param metadataReaderFactory
* @return
* @throws IOException
*/
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
Class curClass = null;
try {
//当前被扫描的类
curClass = Class.forName(metadataReader.getClassMetadata().getClassName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//判断curClass是否是IService类型
boolean result = IService.class.isAssignableFrom(curClass);
return result;
}
}
@ComponentScan(
basePackages = {"com.yuan11"},
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM, classes = MyFilter.class) //@1
})
public class ScanBean5 {
}
@1:type为FilterType.CUSTOM,表示Filter是用户自定义的,classes为自定义的过滤器
- excludeFilters
类似于includFilters
- @ComponentScan重复使用
从这个注解的定义上可以看出这个注解可以同时使用多个,如:
@ComponentScan(basePackageClasses = ScanClass.class)
@ComponentScan(
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class)
})
public class ScanBean7 {
}
还有一种写法,使用@ComponentScans的方式:
@ComponentScans({
@ComponentScan(basePackageClasses = ScanClass.class),
@ComponentScan(
useDefaultFilters = false, //不启用默认过滤器
includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = IService.class)
})})
public class ScanBean7 {
}
Spring中这块的源码
@CompontentScan注解是被下面这个类处理的
org.springframework.context.annotation.ConfigurationClassPostProcessor
这个类非常非常关键,主要用户bean的注册,前面我们介绍的@Configuration,@Bean注解也是被这个类处理的。
还有下面这些注解:
@PropertySource
@Import
@ImportResource
@Compontent
以上这些注解都是被ConfigurationClassPostProcessor这个类处理的,内部会递归处理这些注解,完成bean的注册。
以@CompontentScan来说一下过程,第一次扫描之后会得到一批需要注册的类,然后会对这些需要注册的类进行遍历,判断是否有上面任意一个注解,如果有,会将这个类交给ConfigurationClassPostProcessor继续处理,直到递归完成所有bean的注册
- 总结
@ComponentScan用于批量注册bean,spring会按照这个注解的配置,递归扫描指定包中的所有类,将满足条件的类批量注册到spring容器中
可以通过value、basePackages、basePackageClasses 这几个参数来配置包的扫描范围
可以通过useDefaultFilters、includeFilters、excludeFilters这几个参数来配置类的过滤器,被过滤器处理之后剩下的类会被注册到容器中
指定包名的方式配置扫描范围存在隐患,包名被重命名之后,会导致扫描实现,所以一般我们在需要扫描的包中可以创建一个标记的接口或者类,作为basePackageClasses的值,通过这个来控制包的扫描范围
@CompontScan注解会被ConfigurationClassPostProcessor类递归处理,最终得到所有需要注册的类