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

1.配置类

使用配置文件的形式代替配置类

2.包扫描注解

xml配置文件

配置类
- @Configuration：告诉spring这是一个配置类
- @ComponentScan(value = "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 = "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/24  11: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 = 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(){
        return  new 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 = WindowCondition.class)
        @Bean("window")
        public Person person01(){
            return  new Person("1111","win");
        }

        /***
         * 在linux操作系统下该bean生效
         * @return bean类型
         */
        @Conditional(value = LinuxCondition.class)
        @Bean("linux")
        public Person person02(){
            return  new 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操作系统结果
修改运行配置

修改当前操作系统名为linux
测试结果

测试inux下结果

8.@import注解

给容器中注入bean的方式
- 包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)
- 使用Bean(导入第三方包里面的组件)
- 使用@Import方式(快速导入)
- 使用Spring提供的FactoryBean(工厂Bean)

导入组件，id默认为全类名

    @Import(value = {bean1.class,bean2.class})

实现ImportSelector接口方法导入多个：返回需要导入的租金按的全类名数组

导入组件

    @Import(value = {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 = {Black.class,CustomImportSelector.class,CustomImportBeanDefinitionRegistrar.class})
    public class MainConfig2 {}

实现ImportBeanDefinitionRegistrar接口方法

   public class CustomImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
   
       /**
        *
        * @param importingClassMetadata:当前标注@import注解的类的所有注解信息
        * @param registry  bean注册类
        *                  把所有需要添加到容器中的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(){
            return  new 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;
        }
    }