Spring相关注解

@Configuration

将类标注为配置类

@ComponentScan

标注扫描的包。value 指定包路径，includeFilters 指定过滤规则，useDefaultFilters 关闭自动扫描

@Configuration
@ComponentScan(value = "com.zhengmo",includeFilters = {
//        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class}),
//        @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {PersonService.class}),
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyFilter.class})
}, useDefaultFilters = false)
@Conditional(WindowConditional.class)
@Import({Color.class, Red.class, MyImportSelect.class,MyImportBeanDefinitionRegistrar.class})
//@ComponentScan 指定扫描的包 @Filter 配置过滤规则
public class MyConfig {
    @Bean(name = "person"，initMethod = "initMethod",destroyMethod = "destroyMethod")
    @Lazy//懒加载，在使用使用对象的时候才把对象放入容器中
    public Person creatPerson(){
        return new Person("李四",20);
    }

    @Bean
    public ColorFactory colorFactory(){
        return new ColorFactory();
    }
}

@Bean

可以将对象放入 spring 容器中管理

name 指定对象 id、initMethod 对象初始化执行的方法、destroyMethod 对象销毁时执行的方法

 通过@PostConstruct、@PreDestroy实现调用对象初始化后执行的方法和对象销毁时执行的方法

    @PostConstruct
    public void initMethod(){
        System.out.println("初始化 dog");
    }

    @PreDestroy
    public void destroyMethod(){
        System.out.println("销毁 dog");
    }

通过实现InitializingBean 和 DisposableBean，指定对象初始化后执行的方法和对象销毁时执行的方法

@Component
public class Cat implements InitializingBean, DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("销毁 cat");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化 cat");
    }
}

MyFilter 自定义过滤规则

public class MyFilter implements TypeFilter {

    /**
     *
     * @param metadataReader 读取到当前正在扫描到的类的信息
     * @param metadataReaderFactory 可以获取到其他任何类的信息
     * @return
     * @throws IOException
     */
    @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();
        System.out.println("className" + className);
        if (className.contains("er")){
            return true;
        }
        return false;
    }
}

@Condition

自定义扫描规则，只有当操作系统为 Windows 时才加载该配置类

public class WindowConditional implements Condition {

    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {

//        获取到ioc使用beanfactory
        ConfigurableListableBeanFactory beanFactory = conditionContext.getBeanFactory();

//        获取类加载器
        ClassLoader classLoader = conditionContext.getClassLoader();

//        获取当前环境信息
        Environment environment = conditionContext.getEnvironment();

//        获取到bean定义的注册类
        BeanDefinitionRegistry registry = conditionContext.getRegistry();

        String property = environment.getProperty("os.name");

        System.out.println("property：" + property);

        return property.contains("Window");
    }
}

@Import

定义放入 IOC 容器中的类

MyImportSelect

public class MyImportSelect implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
//        将需要放入spring容器的全类名返回
        return new String[]{"com.zhengmo.pojo.White","com.zhengmo.pojo.Blue"};
    }
}

MyImportBeanDefinitionRegistrar

自定义导入规则

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean beanDefinitionWhite = registry.containsBeanDefinition("com.zhengmo.pojo.White");
        boolean beanDefinitionBlue = registry.containsBeanDefinition("com.zhengmo.pojo.Blue");
        if (beanDefinitionBlue && beanDefinitionWhite){
            BeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class);
            registry.registerBeanDefinition("RainBow",beanDefinition);
        }
    }
}

通过实现FactorBean 将对象放入 IOC 容器中

public class ColorFactory implements FactoryBean<Color> {
    @Override
    public Color getObject() throws Exception {
        System.out.println("create color object");
        return new Color();
    }

    @Override
    public Class<?> getObjectType() {
        return Color.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

 获取 IOC容器中的对象

public class MainTest {


    public static void main(String[] args) {
        //读取配置配
        ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        //通过类名获取
        Person bean = annotationConfigApplicationContext.getBean(Person.class);
        Person bean2 = annotationConfigApplicationContext.getBean(Person.class);
        System.out.println(bean == bean2);
        //获取容器中所有的对象
        String[] personBeanName = annotationConfigApplicationContext.getBeanDefinitionNames();
        System.out.println(Arrays.asList(personBeanName));
        //通过 id 获取对象 因为是通过 FactorBean 实现放入 IOC 容器中的，所以获取到的是 Color
        Object bean3 = annotationConfigApplicationContext.getBean("colorFactory");
        //加上&可以获取原对象
        Object bean4 = annotationConfigApplicationContext.getBean("&colorFactory");
        System.out.println("colorFactorybean3" + bean3.getClass());
        System.out.println("colorFactorybean4" + bean4.getClass());
        System.out.println("是否相同" + (bean3==bean4)) ;
    }
}

通过实现BeanPostProcessor 自定义对象属性赋值前执行的方法，和赋值后执行的方法

@Component
public class MyBean implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization-->" + o + "-->" + s);
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessAfterInitialization-->" + o + "-->" + s);
        return o;
    }
}