《Spring(5.x)注解驱动开发》bean(一) 《Spring(5.x)注解驱动开发》be

1.配置类
使用配置文件的形式代替配置类
2.包扫描注解

xml配置文件
配置类
- @Configuration：告诉spring这是一个配置类
- @ComponentScan(value = "https://www.it610.com/article/url")：指定扫描包的路径,ComponentScan在java1.8后为可重复拒接，即可以多次使用定义扫描策略
配置属性excludeFilters
excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})}
- 该属性指排除那些注解下的bean被扫描到。
  其中：FilterType指使用哪种策略
配置属性includeFilters
includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})}
- 该属性指包括那些注解下的bean被扫描到。
- 该属性与配置属性useDefaultFilters配合使用
配置属性useDefaultFilters
- useDefaultFilters是值是否使用默认配置，默认值为true,当指定扫描固定注解的bean扫描时，要关闭默认全部bean扫描。

3.指定扫描规则：Filter的扫描规则

FilterType.ANNOTATION：默认扫描规则，按照注解的方式
@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
FilterType.ASSIGNABLE_TYPE：按照给定的类型
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,classes = {BookService.class})
FilterType.ASPECTJ:使用ASPECTJ表达式
FilterType.REGEX：使用正则表达式
FilterType.CUSTOM：自定义规则
@ComponentScan.Filter(type = FilterType.CUSTOM,classes = {CustomTypeFilter.class})
- 使用自定义规则，需要编写自定义配置类，该类实现接口FilterType
/** * 自定义扫描规则 * 由于： *@ComponentScan(value = "https://www.it610.com/article/com.tarot", *includeFilters = { *@ComponentScan.Filter(type = FilterType.CUSTOM,classes = {CustomTypeFilter.class}) *}, *useDefaultFilters = false *) * value配置的路径是：com.tarot，所以所有的该路径下的类都会去匹配该自定义包扫描规则 * @ClassPath: com.tarot.config.CustomTypeFilter * @Author: ZhaoHeJia * @Date: 2018/12/2411:22 */ public class CustomTypeFilter implements TypeFilter { /** * * @param metadataReader 读取到当前正在扫描的类的信息 * @param metadataReaderFactory读取其他类信息 * @return 比对结果boolean * @throws IOException io异常 */ @Override public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { //获取当前类注解的信息 AnnotationMetadata annotationMetadata = https://www.it610.com/article/metadataReader.getAnnotationMetadata(); //获取当前正在扫描的类的信息 ClassMetadata classMetadata = metadataReader.getClassMetadata(); //获取当前类资源(类路径) Resource resource = metadataReader.getResource(); String className = classMetadata.getClassName(); //自定义扫描规则 if (className.contains("service")){ return true; } return false; } }

4.配置Bean组件

@Bean注解：往容器中注册bean
@Bean public Person person(){ returnnew Person("22","zhj"); }
- 给容器注册一个Bean,类型为返回值类型,id为方法名。即返回值Person相当于xml文件的class属性,方法名相当于xml文件的id属性

5.@Scope注解(Bean的作用域)

@Scope注解：bean的作用域,默认为singleton
取值：

SINGLETON：单实例，当ioc容器启动时会创建该方法的实例，加入到ioc容器中，之后直接调用
当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。
PROTOTYPE：多实例，ioc实例启动并不创建实例，每次获取该实例对象时才会ioc才会创建该实例
prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例，相当与一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用
REQUEST：同一次请求创建一个实例，web环境
request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
SESSION：同一个session创建一个实例，web环境
session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
ps:spring中scope作用域

6.@Lazy注解(懒加载)

在单实例的情况下
在容器启动的时候并不创建对象，而是在第一次使用(获取)Bean对象时创建。

7.@Conditional注解(在一定条件下创建bean)

可以注解在配置类和bean上
只在一定条件下该bean生效
@Conditional的配置属性value可以是一个类，该类逻辑判断由实现Condition接口完成。
- 当不同操作系统注入不同的bean
@Configuration public class MainConfig2 {/** * 在windows操作系统下该bean注册生效 * @return bean类型 */ @Conditional(value = https://www.it610.com/article/WindowCondition.class) @Bean("window") public Person person01(){ returnnew Person("1111","win"); }/*** * 在linux操作系统下该bean生效 * @return bean类型 */ @Conditional(value = https://www.it610.com/article/LinuxCondition.class) @Bean("linux") public Person person02(){ returnnew Person("0000","lnx"); } }
- 编写Condition注解的条件
public class WindowCondition implements Condition {/** * * @param context 判断条件的上下文对象 * @param metadata 当前标注了condition的注释信息 * @return */ @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { //获取ioc使用的beanFactory ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); //获取类加载器 ClassLoader classLoader = context.getClassLoader(); //获取当前环境信息 Environment environment = context.getEnvironment(); //获取bean注册的注册类 BeanDefinitionRegistry registry = context.getRegistry(); //获取当前操作系统类型信息 String property = environment.getProperty("os.name"); //忽略大小写 if(property.toLowerCase().contains("window")){ return true; } return false; } }

public class LinuxCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {Environment environment = context.getEnvironment(); String property = environment.getProperty("os.name"); if (property.toLowerCase().contains("linux")){ return true; } return false; } }
- 测试
public class IOCTest { @Test @SuppressWarnings("resource") public void test03(){ //获取使用注解配置的bean AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class); //获取当前的运行环境 ConfigurableEnvironment environment = applicationContext.getEnvironment(); String property = environment.getProperty("os.name"); System.out.println("当前操作系统："+property); //根据类型获取ioc注册的bean，由于注册的name="linux"的bean生效为linux系统，故此时并没有注册 String[] names = applicationContext.getBeanNamesForType(Person.class); for (String name:names){ System.out.println("注册bean："+name); } //以map形式获取bean信息 Map beansOfType = applicationContext.getBeansOfType(Person.class); System.out.println(beansOfType); } }
- 测试结果
  
  文章图片
  测试window操作系统结果
- 【《Spring(5.x)注解驱动开发》bean(一)】修改运行配置
  
  文章图片
  修改当前操作系统名为linux
- 测试结果
  
  文章图片
  测试inux下结果

8.@import注解

给容器中注入bean的方式
- 包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)
- 使用Bean(导入第三方包里面的组件)
- 使用@Import方式(快速导入)
- 使用Spring提供的FactoryBean(工厂Bean)
导入组件，id默认为全类名
@Import(value = https://www.it610.com/article/{bean1.class,bean2.class})
实现ImportSelector接口方法导入多个：返回需要导入的租金按的全类名数组
- 导入组件
@Import(value = https://www.it610.com/article/{Black.class,CustomImportSelector.class}) public class MainConfig2 {}
- 实现ImportSelector接口方法
public class CustomImportSelector implements ImportSelector {/** * * @param importingClassMetadata：当前标注@import注解的类的所有注解信息 * @return 导入到容器的组件全类名 */ @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) {//返回值不能为null,可返回空数组new String[]{} return new String[]{"com.tarot.bean.Red","com.tarot.bean.Yellow"}; } }
实现ImportBeanDefinitionRegistrar接口,使用手工注册的方式注册
- 导入组件
  @Import(value = https://www.it610.com/article/{Black.class,CustomImportSelector.class,CustomImportBeanDefinitionRegistrar.class}) public class MainConfig2 {}
- 实现ImportBeanDefinitionRegistrar接口方法
  public class CustomImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {/** * * @param importingClassMetadata:当前标注@import注解的类的所有注解信息 * @param registrybean注册类 *把所有需要添加到容器中的bean,通过BeanDefinitionRegistry.registerBeanDefinition方法手工注册 */ @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //判断容器中是否有该bean boolean black = registry.containsBeanDefinition("com.tarot.bean.Black"); if(black){ //指定Bean定义信息：(Bean的类型...) RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Blue.class); //指定bean名 registry.registerBeanDefinition("Blue",rootBeanDefinition); } } }

9.使用Spring提供的FactoryBean(工厂Bean)

实现FactoryBean接口，其中T为Bean,默认实现的类的类型为Bean(T)的类型，由工厂
整合其他框架，spring内部广泛使用
FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(String BeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&
一般情况下，Spring通过反射机制利用的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。
编写一个FactoryBean的实现类，实现T为普通Bean(Black).注入到容器中。
- 编写Black的实现类
public class CustomColorFactoryBean implements FactoryBean {/** * * @return 返回Black对象 * @throws Exception */ @Override public Black getObject() throws Exception { System.out.println("into factory bean..."); return new Black(); }/** * * @return对象的类型 */ @Override public Class getObjectType() { return Black.class; }/** * 判断是否是单例 * @return true:单实例，容器保存一份；false:每次获取都创建一个新的Bean */ @Override public boolean isSingleton() { return true; } }
- 注入CustomColorFactoryBean,获取该Bean类型默认为Black
@Bean public CustomColorFactoryBean customColorFactoryBean(){ returnnew CustomColorFactoryBean(); }

ps：BeanFactory 简介以及它和FactoryBean的区别
10.Bean的生命周期

Bean的生命周期：Bean创建---初始化---销毁过程
ioc容器管理bean的生命周期，我们可以自定义初始化和销毁方法：即容器在bean进行到当前生命周期时调用我们自定义的初始化和销毁方法。
构造(创建对象)
- 单实例：在容器启动的时候创建对象
- 多实例：在每次获取的时候创建对象，并初始化
初始化：单实例，对象创建完，赋值后，调用初始化方法
销毁：
- 单实例：当ioc容器关闭时，bean销毁
- 多实例：容器不会管理bean，容器不会调用销毁方法。
调用自定义初始化和销毁方法
- 使用注解属性的方式指定哪个方法为该初始化和销毁方法。
@Bean(initMethod = "init",destroyMethod = "destroy")
- 通过Bean实现接口InitializingBean(定义初始化)
- 通过Bean实现接口DisposableBean(销毁)
public class BeanLiftCycle2 implements InitializingBean, DisposableBean {public BeanLiftCycle2(){ System.out.println("bean2 constructor..."); }@Override public void afterPropertiesSet() throws Exception { System.out.println("bean2 init..."); }@Override public void destroy() throws Exception { System.out.println("bean2 destroy..."); } }
- 使用JSR250规范注解,作用到bean的方法上
  
  @PostConstruct:在bean创建完成后并属性赋值，执行初始化。
  
  @PreDestroy:在容器销毁bean前通知清理工作。
- 使用bean的后置处理器：实现BeanPostProcessor接口
  
  其中方法：
  - postProcessBeforeInitialization：在初始化工作前调用
  - postProcessAfterInitialization：在初始化工作后调用
@Component public class CustomBeanPostProcessor implements BeanPostProcessor{ @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("bean后置处理器--初始化前调用方法"+beanName+"--->"+bean); return bean; }@Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("bean后置处理器--初始化后调用方法"+beanName+"--->"+bean); return bean; } }