Spring-注解简述

配置组件

---

@Configuration

概述：

把一个类作为一个loC容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean

栗子

@Configuration
public class MyConfig {

    @Bean(value = "student2")
    public Student xiaoQiang() {
        System.out.println("xiaoQiang add ...");
        return new Student();
    }

}

---

@ComponentScan

在配置类上添加@ComponentScan 注解。该注解默认会扫描该类所在的包下所有的配置类，ComponentScan相当于之前的<context:component-scan>

栗子

@Configuration
@ComponentScan(
//        value = "com.xxq.spring.one.componentScan.rest",
        // 根据注解
//        includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class})}
        // 根据注解了的类
//            includeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = UserController.class)}
        includeFilters = {@ComponentScan.Filter(type = FilterType.CUSTOM,value = {MyTypeFilter.class})}
)
public class MyConfig2 {


}
public class MyTypeFilter 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);

        if (className.contains("er")) {
            return true;
        } else {
            return false;
        }
    }
}

---

@scope

• 用于指定scope作用域的（用在类上)
• prototype际里，多例singleton单例
• request主要应用于web模块，同一次请求只创建一个实例
• session主要应用于web模块，同一个session只创建一个对象

栗子

@Configuration
public class MyConfig {
    @Scope("prototype")
    @Bean(value = "student2")
    public Student student() {
        return new Student();
    }
}

---

@Lazy

 表示延迟初始化

@Configuration
public class MyConfig {

    // 默认非延迟加载，懒加载只针对单例bean起作用；
    @Lazy
    @Bean(value = "student2")
    public Student student() {
        System.out.println("lazy load");
        return new Student();
    }
}

---

@Conditional

Spring4开始提供，它的作用是按照一定的条件进行判断，满足条件给容器注册Bean
 

public class WindosCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        Environment environment = context.getEnvironment();
        String osName = environment.getProperty("os");
        System.out.println(osName);
        if (osName.contains("Windows")) {
            return true;
        }
        return false;
    }
}

@Configuration
public class MyConfig {

    @Conditional(WindosCondition.class)
    @Bean(value = "student2")
    public Student daQiang() {
        System.out.println("daqiang add ...");
        return new Student();
    }

}

---

@Import

导入外部资源

• 给IOC容器注册Bean的方式
  • 1、@Bean直接导入单个类
  • 2、@ComponentScan 默认扫描（@Controller.@Service、@Repostory
    @component)
  • 3、@Import快速给容器导入Bean的方式
    • a.@Import直接参数导入
    • b.实现importSelector自定义规则实
    • c.实现ImportBeanDefinitionRegistrar
  • 4、FactoryBean 把需要注入的对象封装为FactoryBean

栗子

// 实现ImportSelector  导入bean
public class MyImportsSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.xxq.spring.one.componentScan.rest.Dog",
                "com.xxq.spring.one.componentScan.rest.Book"};
    }

    @Override
    public Predicate<String> getExclusionFilter() {
        return null;
    }
}


// 实现ImportBeanDefinitionRegistrar  导入bean
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean company = registry.containsBeanDefinition("com.xxq.spring.one.componentScan.rest.Dog");
        boolean member = registry.containsBeanDefinition("com.xxq.spring.one.componentScan.rest.Book");

        if (company && member) {
            BeanDefinition beanDefinition = new RootBeanDefinition(JavaNote.class);
            registry.registerBeanDefinition("user", beanDefinition);
        }
    }
}

// 导入工厂bean
public class MyFactoryBean implements FactoryBean<JavaVideo> {

    @Override
    public JavaVideo getObject() throws Exception {
        return new JavaVideo();
    }

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

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

@Import({Jianke.class, MyImportsSelector.class,MyImportBeanDefinitionRegistrar.class})
@Configuration
public class MyConfig {

    @Bean(value = "student2")
    public Student student() {
        return new Student();
    }

    @Bean
    public MyTest myTest() {
        return new MyTest();
    }

    @Bean
    public MyFactoryBean javaVideo(){
        return new MyFactoryBean();
    }

}

---

生命周期控制

4种方式
 1.添加initMethod 和 destroyMethod
 2.实现InitializingBean和DisposableBean接口
 3.使用@PostConstruct和@PreDestroy注解
 4.implements BeanPostProcessor

栗子

// 实现BeanPostProcessor 
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization" + beanName + "," + bean);
        return bean;
    }



    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization" + beanName + "," + bean);
        return bean;
    }
}

// 基于注解 
@Component
public class AirPlane {

    public AirPlane() {
        System.out.println("调用AirPlane的构造方法");
    }

    @PostConstruct
    public void addOil(){
        System.out.println("飞机飞行前加油");
    }

    public void run(){
        System.out.println("正在空中巡航");
    }

    @PreDestroy
    public void close(){
        System.out.println("飞机落地熄火");
    }
}

// 基于初始化bean,InitializingBean,DisposableBean 等接口
@Component
public class Train implements InitializingBean,DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("火车对象销毁");
    }

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

// 基于@bean注解
@Configuration
public class MyConfig {

    @Lazy
    @Bean(initMethod = "addOil",destroyMethod = "close")
    public Car car(){
        return new Car();
    }

}

赋值组件

@Component	泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@Service	用于标注业务层组件
@Controller	用于标注控制层组件
@Repository	用于标注数据访问组件，即DAO组件。
@Value	普通数据类型赋值
@Autowired	默认按类型装配，如果我们想使用按名称装配，可以结合@Qualifier注解一起使用
@PropertySource	读取配置文件赋值
@Qualifier	存在多个实例配合使用
@Primary	自动装配时当出现多个Bean候选者时，被注解为@Primary的Bean将作为首选者，否则将抛出异常
@Resource	默认按名称装配，当找不到与名称匹配的bean才会按类型装配

---

织入组件

ApplicationContextAware	可以通过这个上下文环境对象得到Spring容器中的Bean
BeanDefinitionRegistryPostProcessor	BeanDefinitionRegistryPostProcesso BeanFactoryPostProcessor接口，是Spring框架的BeanDefinitionRegistry的后处理器，用来注册额外的BeanDefinition

---

修改于公元2021年7月10日下午15点30分