用Annotation方式开发spring

IOC

生命周期

1. @Bean

   @Bean(value = "linux",initMethod = "",destroyMethod = "")
   

   1. 注解参数: value :id名
   2. 初始化 注解参数： initMethod = “初始化方法” ，（对象创建完成并赋值好后，多时候获取后执行init方法
   3. 销毁 注解参数：destroyMethod = “销毁方法”， (单实例在容器销毁后销毁,多实例容器不会管理这个bean所有不调用销毁方法
   4. 初始化 实体类实现 InitializingBean 接口初始化
   5. 销毁 实体类实现 DisposableBean接口销毁
   6. 初始化 注解 @PostConstruct 放在方法上面
   7. 销毁 注解 @PreDestroy 放在方法上面
   8. BeanPostProcessor[interface] 接口 ，会给更改所有类的初始化和销毁方法
      1. postProcessBeforeInitialization(Object bean, String beanName) [method] 在上面条件初始化之前
         beanName：bean的id
         bean:初始化的bean 一般作为方法的返回值
      2. postProcessAfterInitialization(Object bean, String beanName) 在上面销毁方法执行后

组件注册

1. @Configguration 将某个类设为配置文件类

2. @Scope : 设置类的作用域,默认单列

3. @ComponentScan：扫描哪些包下面的类

   1. value : 扫描的包

   2. excludeFilters:排除的包

   3. includeFilters:包含的包,useDefaultFilters = false

   4. FilterType:Annotation:自定义注解

   5. FilterType:ASSIGNABLE_TYPE 自定义规则（Person类
      @ComponentScans(
      @ComponentScan(excludeFilters = {
      @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
      classes = {Person.class})}))

   6. FilterType:CUSTOM 自定义类

      	public class MyTypeFilter implements TypeFilter {
          @Override
          public boolean match(MetadataReader metadataReader, 
          					MetadataReaderFactory metadataReaderFactory) throws IOException {
              //当前类注解信息
              AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
              //当前正在扫描的类的类信息
              ClassMetadata classMetadata = metadataReader.getClassMetadata();
              //当前类资源路径（类路径）
              metadataReader.getResource();
              //类名
              String className=classMetadata.getClassName();
              if(className.contains("er")){
                  System.out.println("类"+className);
                  return  true;
              }
              return false;
          }
      }
      

4. @Conditional(WindowConditional.class) ：过滤bean,可以放在类上，也可以放在方法上

   public class WindowConditional implements Condition {
       @Override
       public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
           //获取ioc使用的beanFactory
           ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();
           //获取类加载器
           conditionContext.getClassLoader();
           //获取当前环境信息
           Environment environment = conditionContext.getEnvironment();
           String property = environment.getProperty("os.name");
           if("Windows 10".equals(property)){
               return  true;
           }
           return false;
       }
   }
   

5. @Import import的方式创建bean

   1. @Import(Student.class) 直接导入 id为类的全限定类名

   2. @Import(MyImportSelector.class) 实现 ImportSelector 接口 返回类的全限定名

      	//自定义逻辑 返回需要导入的组件
      	public class MyImportSelector implements ImportSelector {
      	    //返回值是 导入到容器中的组件全类名
      	    //annotationMetadata：当前标注@import注解的类的所有注解信息
      	    @Override
      	    public String[] selectImports(AnnotationMetadata annotationMetadata) {
      	        //可以返回空数组 不能为Null
      	        return new String[]{"com.it.pojo.Student","com.it.pojo.Person"};
      	    }
      	}
      	```
      

   3. 实现 ImportBeanDefinitionRegistrar 接口 返回类的全限定名
      @Import(MyImportBeanDefinitionRegistrar.class)

      public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
          /**
           * @param importingClassMetadata 当前类的注解信息
           * @param registry BeanDefinition注册类   registry.registerBeanDefinition();
           */
          @Override
          public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                              BeanDefinitionRegistry registry) {
              //判断容器是否包含red和blue类
              boolean red = registry.containsBeanDefinition("com.it.pojo.Red");
              boolean blue = registry.containsBeanDefinition("com.it.pojo.Blue");
              if(red && blue){
                  //指定bean的信息（类型，作用域...
                  RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(RainBow.class);
                  //指定bean的名
                 registry.registerBeanDefinition("rainBow", rootBeanDefinition);
              }
          }
      }
      
      

   5 . FactoryBean接口 用工厂方式创建bean

    		//调用getObject方法返回red对象
           Object red = ac.getBean("redFactoryBean");
           //&前缀返回RedFactoryBean
           Object redFactoryBean = ac.getBean("&redFactoryBean");
   

      @Bean("redFactoryBean")
       public RedFactoryBean redFactoryBean() {
           return new RedFactoryBean();
       }
   

   public class RedFactoryBean implements FactoryBean<Red> {
       @Override
       public Red getObject() throws Exception {
           System.out.println("实例化一个工程bean时会调用getObject方法创建对象");
           return new Red();
       }
   
       @Override
       public Class<?> getObjectType() {
           return Red.class;
       }
   
       @Override
       public boolean isSingleton() {
           return true;
       }
   }
   

属性赋值

1. @Value

   1. value 基本数值

   2. SPEL,#{1+2}

   3. 可以些${},读取配置文件中的值（在运行环境变量里的值
      例如：

      @Value(“张三”)
      private String name;
      @Value("${a}")
      private String age;

2. @PropertySource(value = {“classpath:/a.properties”})
   引入资源文件,可以用@PropertySources引入多个

3. @Autowired(value=“属性名的别名”)
   @Qualifier (提高查找的优先级，最先匹配这个

4. @Profile(“test”)
   在test运行环境下才会创建下面的类

Aop