Spring注解解析
Spring注解解析
@Configuration注解
该类等价 与XML中配置beans，相当于Ioc容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean，与xml中配置的bean意思一样。
@Configuration //配置类
public class MainConfig {
//向容器注入bean 类型为返回值类型 id默认为方法名
@Bean(value = "person")
public Person persons() {
return new Person("ysl",25);
}
}
1
2
3
4
5
6
7
8
9
10
获取容器中的实例通过AnnotationConfigApplicationContext 类将配置类中的Bean加载到容器中.
通过@Autowired 和 @Resource 同理都可以获取容器中的Bean实例.
@ComponentScan
该类的作用就是告诉Spring从哪里找到Bean然后进行加载.
@ComponentScan(value = {"springcode"},excludeFilters = { // 扫描的包路径 并执行排除操作
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, //配置过滤类 指定过滤类型
classes = {BookController.class}) //排除给定的类型 BookController类
},includeFilters = {
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
classes = {BookController.class}) //包含给定的类型 BookController类
},useDefaultFilters = false) //useDefaultFilters 默认为true 包含必须设置为false 否则包含规则不生效
1
2
3
4
5
6
7
@ComponentScan 源码：
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
@AliasFor("basePackages")
String[] value() default {}; 扫描包路径 返回的是String[]数组
@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; 包含加载Bean 时必须将此属性设置为false 否则包含条件不生效
ComponentScan.Filter[] includeFilters() default {}; 包含加载的Bean
ComponentScan.Filter[] excludeFilters() default {}; 排除加载的Bean
boolean lazyInit() default false;
@Retention(RetentionPolicy.RUNTIME)
@Target({})
public @interface Filter { 过滤接口
FilterType type() default FilterType.ANNOTATION; 过滤类型 默认注解类型
@AliasFor("classes")
Class<?>[] value() default {};
@AliasFor("value")
Class<?>[] classes() default {}; 过滤class
String[] pattern() default {};
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@Scope 注解：
该注解作用是用于容器中的Bean设置作用域.
value 属性:
prototype ：多实例 每次获取对象实例时将Bean注册到容器中.
singleton: 单实例 (默认值) 容器启动时将Bean注册到容器中.
@Lazy 注解：
该注解用于控制Bean注册容器的时机，容器启动时不加载获取实例时进行加载(一次)，称之为懒加载.
@Conditional 注解:
该注解始于spring4.X 开始，SpringBoot 底层大量使用，按照条件进行判断,满足条件将Bean注册容器中.(也可以放在类上)
@Conditional(value = {WindowsCondition.class})
@Bean(value = "Bill Gates")
public Person personTo() {
System.out.println("Bill Gates");
return new Person("Bill Gates",49);
}
@Conditional(value = {LinuxCondition.class})
@Bean(value = "Linus")
public Person personThree() {
System.out.println("Linus");
return new Person("Linus",50);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class LinuxCondition implements Condition {
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
//获取BeanFactory工厂
ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
//获取类加载器
ClassLoader classLoader = conditionContext.getClassLoader();
//获取系统资源
Environment environment = conditionContext.getEnvironment();
String property = environment.getProperty("os.name");
if(property.contains("Linux")) {
return true;
}
return false;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class WindowsCondition implements Condition {
@Override
public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
//获取BeanFactory工厂
ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
//获取类加载器
ClassLoader classLoader = conditionContext.getClassLoader();
//获取系统资源
Environment environment = conditionContext.getEnvironment();
String property = environment.getProperty("os.name");
if(property.contains("Windows")) {
return true;
}
return false;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
以上代码容器中注入的两个Bean分别加上条件过滤，但是只有一个注册成功 如图：
@Import 注解：
该注解作用是快速将Bean注册到容器中，id默认全类名.
value 属性：全类名Bean注册容器或者自定义类实现ImportSelector 接口自定义需要注册的Bean或者实现ImportBeanDefinitionRegistrar接口自定义注册Bean.
注册Bean的方式：
xml文件注册
@Configuration+@Bean
@Import
1.实现ImportSelector接口自定义注册Bean
2.实现ImportBeanDefinitionRegistrar接口自定义注册Bean
通过FactoryBean接口注册Bean
Bean 生命周期：
@Bean(initMethod = “init”,destroyMethod = “destroy”) 注解：
public class A {
public A() {
System.out.println("A 构造...");
}
public void init() {
System.out.println("A 初始化...");
}
public void destroy() { // AnnotationConfigApplication.close 关闭容器 开始销毁
System.out.println("A 销毁...");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Bean(initMethod = "init",destroyMethod = "destroy") //自定义Bean的初始化方法和销毁方法(构造方法在之前执行)
public A a() {
return new A();
}
1
2
3
4
注意：如使用@Scope(“prototype”) 多实例的话,容器启动时不会进行初始化操作只用在获取Bean时才进行初始化还有就是调用close方法Bean的实例不会自动销毁(手动调用可以销毁).
Bean实现InitializingBean(初始化)和DisposableBean(销毁)接口：
public class B implements InitializingBean,DisposableBean {
//同理都可以控制Bean的生命周期.
public B() {
System.out.println("B 构造...");
}
@Override
public void afterPropertiesSet() throws Exception { //初始化
System.out.println("B init...");
}
@Override
public void destroy() throws Exception { //销毁
System.out.println("B destroy...");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@PostConstruct和@PreDestroy注解：
@Component
public class C {
public C() {
System.out.println("C 构造..");
}
//对象创建并赋值之后进行初始化
@PostConstruct
public void init() {
System.out.println("C init...");
}
@PreDestroy
public void destroy() {
System.out.println("C destroy...");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
BeanPostProcessor 接口：
/**
* 后置处理器：Bean初始化前后进行包装工作 Spring底层使用此接口实现Bean注册工作
*/
@Component
public class D implements BeanPostProcessor {
//Bean初始化之前进行操作
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization"+beanName+"==>"+bean);
return bean;
}
//Bean初始化之后进行操作
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization"+beanName+"==>"+bean);
return bean;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Value注解：
/**
* @Value 属性赋值
* 1.基本数值
* 2.spel: #{}
* 3.${} 配置文件中的值
*/
@Value("张三")
private String name;
@Value("#{20-2}")
private Integer age;
@Value("${person.nikeName}") //配置文件中根据K拿到V
private String nikeName;
public void profile1(@Value("${bird.name}")String name) {}
还可以通过接口EmbeddedValueResolverAware 重写setEmbeddedValueResolver方法来获取resolver.resolveStringValue("${bird.nikename}") 配置文件中的值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//@PropertySource 读取外部配置文件中的K/V保存到运行环境变量中
@PropertySource(value = {"classpath:/person.properties"})
@Configuration
public class MainConfigOfProperty {
@Bean
public Person person() {
return new Person();
}
}
1
2
3
4
5
6
7
8
9
@Autowired注解：spring
@Qualifier("bookDao2") //指定装备组件
@Autowired(required = false) // 容器中Bean不存在不抛异常
private BookDao bookDao2;
1
2
3
@Resource和@Inject注解：java
@Resource(name="") 容器中的bean组件必须存在
同上注解作用一样都是注入,这两个注解时jdk的默认按照名字注入，而Autowired注解是Spring (强大)默认按照类型注入。
@Profile 注解：用于方法 或者 类上
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
context.getEnvironment().setActiveProfiles(“test”,“dev”); //设置需要激活的环境
context.register(MainConfigProfile.class); //注册配置
context.refresh(); //刷新容器
该注解作用用于判断系统环境来注册不同的Bean组件。
————————————————
版权声明：本文为CSDN博主「ysl_20190905」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ysl_20190905/article/details/100583906
以上是 Spring注解解析 的全部内容， 来源链接： utcz.com/z/514629.html
