Spring

一. 组件注册

1. @Configuration：用来标记这个类是配置类，配置类就等于配置文件。
2. @Bean：用来给容器中注入Bean。Bean的id默认是方法名。

3. @ComponentScan：包扫描的方式注入Bean，

   @ComponentScan(value = "cn.guet", excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, classes = Controller.class)})  //排除@Controller

   @ComponentScan(value = "cn.guet",includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,classes = Controller.class)},useDefaultFilters = false) //只保函@Controller

4. @Scope：设置@Bean的作用域。

   @Scope(value = "prototype") //多实例bean

   @Scope(value = "singleton") //单实例bean。IOC启动时创建，并放到容器中。

5. @Lazy：单实例Bean，只有在获取bean的时候，才被创建，并放到bean中。

6. @Conditional：按照条件注册Bean。如果是放在类上面，则条件成立时，类中组件才注入。

   public class LinuxCondition implements Condition {
   /**
    * @param context  判断条件能使用的上下文
    * @param metadata 注解信息
    * @return
    */
   public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       //获取IOC使用的BeanFactory
       ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
       //获取类加载器
       ClassLoader classLoader = context.getClassLoader();
       //获取环境信息
       Environment environment = context.getEnvironment();
       //bean的定义
       BeanDefinitionRegistry contextRegistry = context.getRegistry();
       //判断操作系统
       String property = environment.getProperty("os.name");
       if (property.contains("Linux")) {
           return true;
       }
       return false;
   }
   }

   @Conditional(LinuxCondition.class)
   @Bean("linus")
   public User user02(){
       return new User("linus",30,"American");
   }

7. @Import 的3种用法

   • 直接导入组件

   //@Import 直接导入组件
   @Import({Color.class, Red.class})

   • 使用ImportSelector返回需要导入的组件全限定名

   //自定义逻辑，返回需要导入的bean
   public class MyImportSelector implements ImportSelector {
   /**
    * @param importingClassMetadata 当前标注 @Import注解的类的所有注解信息
    * @return 返回值就是要导入到容器中的组件全类名
    */
   public String[] selectImports(AnnotationMetadata importingClassMetadata) {
       return new String[]{"cn.guet.bean.Blue","cn.guet.bean.Yellow"};
   }
   }

   //@Import 直接导入组件
   @Import({MyImportSelector.class})

   • 使用ImportBeanDefinitionRegistrar手动注册Bean到容器中

   public class MyImportBeanRegistrar implements ImportBeanDefinitionRegistrar {
   /**
    * 把需要的bean注册到容器中，调用 BeanDefinitionRegistry的registerBeanDefinition方法，手工注册
    * @param importingClassMetadata 当前类的注解信息
    * @param registry               BeanDefinition注册类
    */
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
       boolean red = registry.containsBeanDefinition("red");
       boolean blue = registry.containsBeanDefinition("blue");
       if(!red&&!blue){
           RootBeanDefinition beanDefinition = new RootBeanDefinition(Yellow.class);
           registry.registerBeanDefinition("yellow", beanDefinition);
       }
   }
   }

   //@Import 直接导入组件
   @Import({MyImportBeanRegistrar.class})

8. FactoryBean注册组件

   //创建一个Spring定义的FactoryBean
   public class ColorFactoryBean implements FactoryBean {
   //返回一个Color对象，这个对象会添加到容器中
   public Color getObject() throws Exception {
       System.out.println("创建colorbean");
       return new Color();
   }
   //返回对象类型
   public Class getObjectType() {
       return Color.class;
   }
   //是否单实例。true：这个bean单实例，在容器中保存一份。false多实例，每次获取创建一个新的
   public boolean isSingleton() {
       return true;
   }
   }

   @Bean
   public ColorFactoryBean colorFactoryBean(){
       return new ColorFactoryBean();
   }

9. 总结：给容器中注册组件的4中方式
   • 包扫描+组件标注注解（@Controller、@Repository、@Component、@Service）导入自己写的Bean
   • @Bean 导入第三方包里面的组件
   • @Import 快速给容器中导入一个组件。有3种方式。
   • 使用Spring提供的FactoryBean（工厂Bean）

二. 生命周期

1. bean的生命周期
   bean的生命周期。bean创建--初始化--销毁。容器管理bean的生命周期。
   我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法
   构造（对象创建）：
   • 单实例：在容器启动的时候创建对象
   • 多实例：在容器获取的时候创建对象

   初始化：对象创建完成，并赋值，调用初始化方法。
   销毁：单实例bean容器关闭则销毁。多实例：容器不会管理这个bean，不会调用销毁方法，需要手动销毁。

2. 指定Bean 的初始化和销毁方法

   • 通过@Bean的initMethod 和 destroyMethod 指定初始化和销毁方法

   @Bean(initMethod = "init",destroyMethod = "destory")
   public Car car(){
       return  new Car();
   }

   • 通过在bean中实现 InitializingBean 和 DisposableBean 接口，指定初始化和销毁方法

   public class cat  implements InitializingBean, DisposableBean {
   public cat() {
       System.out.println("cat constructor");
   }
   
   public void destroy() throws Exception {
       System.out.println("cat destroy...");
   }
   
   public void afterPropertiesSet() throws Exception {
       System.out.println("cat afterPropertiesSet...");
   }
   }

• 可以使用JSR250中的@PostConstruct和@PreDestroy指定初始化和销毁方法

  public class Dog {
  public Dog() {
      System.out.println("dog constructor...");
  }
  
  //对象创建并赋值之后
  @PostConstruct
  public void init() {
      System.out.println("dog @PostConstruct...");
  }
  
  //容器移除之前
  @PreDestroy
  public void destory() {
      System.out.println("dog PreDestroy....");
  }
  }

1. BeanPostProcessor 后置处理器

   public class MyBeanPostProcessor implements BeanPostProcessor {
   //初始化之前
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
       System.out.println("postProcessBeforeInitialization.."+beanName + "--"+bean);
       return bean;
   }
   //初始化方法后
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
       System.out.println("postProcessAfterInitialization.."+beanName + "--"+bean);
       return bean;
   }
   }

2. 有序列表项 一
3. 有序列表项 二
4. 有序列表项 三
5. 有序列表项 一
6. 有序列表项 二
7. 有序列表项 三

8. 有序列表项 三

三. web

1. 有序列表项 一
2. 有序列表项 二
3. 有序列表项 三
4. 有序列表项 一
5. 有序列表项 二
6. 有序列表项 三
7. 有序列表项 一
8. 有序列表项 二
9. 有序列表项 三
10. 有序列表项 三

四. 无序列表

1. 有序列表项 一
2. 有序列表项 二
3. 有序列表项 三
4. 有序列表项 一
5. 有序列表项 二
6. 有序列表项 三
7. 有序列表项 一
8. 有序列表项 二
9. 有序列表项 三
10. 有序列表项 三

五. 有序列表

1. 有序列表项 一
2. 有序列表项 二
3. 有序列表项 三
4. 有序列表项 一
5. 有序列表项 二
6. 有序列表项 三
7. 有序列表项 一
8. 有序列表项 二
9. 有序列表项 三
10. 有序列表项 三