【Spring-IOC】你需要掌握的注解版开发！

public class Person {
 private String name;
 private Integer age;
 //省略 get / set 方法
}

//配置类==配置文件
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
 //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
 //也可以通过@Bean(value)的方式指定ID
 @Bean("person")
 public Person person01(){
  return new Person("Cbuc", 22);
 }
}

public void test01(){
    //可以注意到之前基于xml的时候是 new ClassPathXmlApplicationContext() ，现在基于注解是 new AnnotationConfigApplicationContext()
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
    Person person = (Person) applicationContext.getBean("person");
    System.out.println(person);
}

<context:component-scan base-package="cbuc.lie" use-default-filters="false"></context:component-scan>

/**
 * @ComponentScan  value:指定要扫描的包
 * excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件
 * includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件
 * FilterType.ANNOTATION：按照注解
 * FilterType.ASSIGNABLE_TYPE：按照给定的类型；
 * FilterType.ASPECTJ：使用ASPECTJ表达式
 * FilterType.REGEX：使用正则指定
 * FilterType.CUSTOM：使用自定义规则
 */

//配置类==配置文件
@ Configuration     //告诉Spring这是一个配置类
@ ComponentScans( //componentScan 的组合
  value = {
    @ ComponentScan(value="cbuc.life.bean",includeFilters = {
      @Filter(type=FilterType.ANNOTATION,classes={Component.class})
     /* @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),
      @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class}) */
      },
      useDefaultFilters = false)
    }
)
public class MainConfig {
 //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id
 @Bean("person")
 public Person person01(){
  return new Person("Cbuc", 22);
 }
}

public class MyTypeFilter implements TypeFilter {
 /**
  * metadataReader：读取到的当前正在扫描的类的信息
  * metadataReaderFactory:可以获取到其他任何类信息的
  */
 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();
  System.out.println("--->"+className);
  if(className.contains("er")){ //放行类名中含有“er”的类
   return true;
  }
  return false;
 }
}

//判断当前环境是否是windows系统
public class WindowsCondition implements Condition {
 public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
  Environment environment = context.getEnvironment();
  String property = environment.getProperty("os.name");
  if(property.contains("Windows")){
   return true;
  }
  return false;
 }
}

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

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

public class Car {
 public Car(){
  System.out.println("car constructor...");
 }
 public void init(){
  System.out.println("car ... init...");
 }
 public void detory(){
  System.out.println("car ... detory...");
 }
}

//在 Bean 注解里面指定初始化和销毁方法
@Bean(initMethod="init",destroyMethod="detory")
public Car car(){
 return new Car();
}

@Component  //在配置类中开启包扫描，自动注册到 IOC 容器中
public class Cat implements InitializingBean,DisposableBean {
 public Cat(){
  System.out.println("cat constructor...");
 }
 public void afterPropertiesSet() throws Exception {
  //初始化方法
  System.out.println("cat...afterPropertiesSet...");
 }
 public void destroy() throws Exception {
  //销毁方法
  System.out.println("cat...destroy...");
 }
}

@Component  //在配置类中开启包扫描，自动注册到 IOC 容器中
public class Dog {
 public Dog(){
  System.out.println("dog constructor...");
 }
 //对象创建并赋值之后调用
 @PostConstruct
 public void init(){
  System.out.println("Dog....@PostConstruct...");
 }
 //容器移除对象之前
 @PreDestroy
 public void detory(){
  System.out.println("Dog....@PreDestroy...");
 }
}

@Component
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;
 }
}

//1、创建一个applicationContext
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
//2、设置需要激活的环境
applicationContext.getEnvironment().setActiveProfiles("dev");
//3、注册主配置类
applicationContext.register(MainConfigOfProfile.class);
//4、启动刷新容器
applicationContext.refresh();