Spring五、注解编程基础组件

目录

• 一、配置组件
  • 1. @Configuration
  • 2. @ComponentScan、@ComponentScans
  • 3. @Scope
  • 4. @Lazy
  • 5. @Conditional
  • 6. @Import
  • 7.生命周期控制 @PostConstruct、@PreDestroy、@DependsOn
• 二、赋值组件、自动装配
  • 1. @Componment
  • 2. @Service、@Controller、@Repository
  • 3. @Value
  • 4. @Autowired
  • 5. @Resource
  • 6 @PropertySource
  • 7. @Qualifier
  • 8. @Primary
• 三、织入组件
  • 1. ApplicationContextAware
  • 2. BeanDefinitionRegistryPostProcessor
• 四、切面组件
  • 1. @EnableTransactionManagement
  • 2. @Transactional

  Spring5开启了零配置编程时代，脱离xml完全使用注解编程，为Spring Boot奠定了开发基础。
  案例demo地址

一、配置组件

1. @Configuration

  声明一个类为Spring IOC容器,如果这个类方法头上注册了@Bean，就会作为Spring容器中的Bean。等价于xml配置文件。

@Configuration
public class MyConfig {

    /**
     * 1. 默认类名首字母小写
     * 2. 其次就是取方法名
     * 3. 最后优先取Bean的value
     * @return
     */
    @Bean(value = "myPerson")
    public Person getPerson() {
        System.out.println("create person by myself");
        return new Person("shen", "18");
    }

}

  普通xml方式配置的IOC容器获取方法：
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
    Person person = (Person) applicationContext.getBean("myPerson");
  注解@Configuration方式配置的IOC容器获取方法：
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
    Person person = (Person) applicationContext.getBean("person");

2. @ComponentScan、@ComponentScans

  在配置类上添加@ComponentScan注解，相当于之前的context:component-scan

@Configuration
//1. 简单使用ComponentScan注解扫描，扫描包下的bean使用@Service、@Controller、@Component等注解配合，可以扫描到
//@ComponentScan(value = "com.bigshen.demo.project")
//2. useDefaultFilters = false， 不使用Spring默认的扫描filter，
//  自己指定扫描规则
@ComponentScan(
        value = "com.bigshen.demo.project",
        useDefaultFilters = false,       // 使用自定义的扫描过滤规则
        includeFilters = {
//                @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class),  // 使用注解扫描
//                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, value = MyDao.class),     // 直接指定类型扫描
                @ComponentScan.Filter(type = FilterType.CUSTOM, value = MatchedFilter .class)},     // 直接自定义类型扫描
        excludeFilters = {
                @ComponentScan.Filter(type = FilterType.CUSTOM, value = UnMatchedFilter.class)   // 直接自定义类型排除
        }
        )
public class MyConfig {


}



public class MatchedFilter implements TypeFilter {

    /**
     *
     * @param metadataReader  类的信息
     * @param metadataReaderFactory  spring上下文
     * @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 clazzName = classMetadata.getClassName();
        System.out.println("--------- " + clazzName);

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

}


public class UnMatchedFilter implements TypeFilter {

    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {

        ClassMetadata classMetadata = metadataReader.getClassMetadata();

        String className = classMetadata.getClassName();
        if (className.contains("Controller")) {
            // 不匹配
            return true;
        }
        return false;
    }

}

3. @Scope

  指定类的作用域，singleton、prototype、request、session

4. @Lazy

  Spring中Bean默认是非懒加载的，即在容器初始化时就将实例初始化，使用@Lazy注解指定该Bean为懒加载。

5. @Conditional

  Spring4开始提供，按照一定的条件进行判断，满足条件给容器注册Bean。 自定义的条件实现'org.springframework.context.annotation.Condition'

  public class WindowCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {

        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        Environment environment = context.getEnvironment();
        String system = environment.getProperty("os.name");
        System.out.println("System --  " + system);
        if (system.contains("Window")) {
            return true;
        }
        return false;
    }

}

@Configuration
public class MyConfig {

    @Conditional(WindowCondition.class)
    @Bean
    public Person shen() {
        System.out.println("将shen添加到ioc容器中");
        return new Person("Shen", "18");
    }

    @Bean
    @Conditional(LinuxCondition.class)
    public Person liu() {
        System.out.println("将liu添加到ioc容器中");
        return new Person("liu", "18");
    }

    @Bean
    @Conditional(WindowCondition.class)
    public Person wang() {
        System.out.println("将wang添加到ioc容器中");
        return new Person("wang", "18");
    }

}

6. @Import

  导入外部资源
  @Import源码，可以指定 org.springframework.context.annotation.ImportSelector 或者 org.springframework.context.annotation.ImportBeanDefinitionRegistrar 的实现类来作为导入规则，也可以是普通的类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {

	/**
	 * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
	 * or regular component classes to import.
	 */
	Class<?>[] value();

}

 

  
@Configuration
@Import(value = {Cat.class, MyImport.class, MyRegistry.class})
public class MyConfig {

    /**
     *
     * 注册Bean的几种方式
     * 1. @Bean 导入单个Bean
     * 2. @ComponentScan (默认扫描 @Controller、@Service、@Repository、@Component)
     * 3. @Import 快速导入Bean
     *      a. @Import 直接参数导入
     *      b. 实现 ImportSelector 自定义规则实现
     *      c. 实现 ImportBeanDefinitionRegistrar 直接往IOC容器中注册
     * 4. FactoryBean ， 把需要注册的对象封装为FactoryBean
     *      a. FactoryBean 负责将Bean注册到Ioc的Bean
     *      b. BeanFactory Ioc容器，从中获得Bean对象
     * @return
     */
    @Bean
    public Person person() {
        return new Person("shen", "19");
    }

    @Bean
    public FactoryBean world() {
        return new MyFactoryBean();
    }

}


public class MyImport implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        // 直接返回 class集合，放入IOC容器
        return new String[]{"com.bigshen.demo.project.entity.Apple", "com.bigshen.demo.project.entity.Orange"};
    }

}

public class MyRegistry implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        // 包里同时声明了Apple 和 Orange ，才把Fruit放入IOC容器

        Boolean containsApple = registry.containsBeanDefinition("com.bigshen.demo.project.entity.Apple");
        Boolean containsOrange = registry.containsBeanDefinition("com.bigshen.demo.project.entity.Orange");

        if (containsApple && containsOrange) {
            BeanDefinition beanDefinition = new RootBeanDefinition(Apple.class);
            registry.registerBeanDefinition("apple", beanDefinition);
        }

    }

}

public class MyFactoryBean implements FactoryBean<World> {

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

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

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

7.生命周期控制 @PostConstruct、@PreDestroy、@DependsOn

  @PostConstruct 用在方法上，用于指定Bean的初始化方法
  @PreDestroy 用在方法上，用于指定销毁方法
  @DependsOn 定义Bean初始化及销毁时的顺序

  /**
     *  bean的生命周期 ： 创建(实例化-初始化)、使用、销毁
     * 3中方式都可实现 对生命周期进行控制：
     * a、@PostConstruct、@PreDestroy
     * b、@Bean本身的 initMethod()、destroyMethod()
     * c、接口 InitializingBean#afterPropertiesSet()、DisposableBean#destroy()
     * @return
     */

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1、Bean自身的方法　　：　　这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法

2、Bean级生命周期接口方法　　：　　这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法

3、容器级生命周期接口方法　　：　　这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

4、工厂后处理器接口方法　　：　　这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器　　接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

二、赋值组件、自动装配

1. @Componment

  泛指组件，当组件不好归类时使用

2. @Service、@Controller、@Repository

  @Service 用于标注业务层组件
  @Controller 用于标注控制层组件
  @Repository 用于标注数据访问层、即Dao层组件

3. @Value

  普通数据类型赋值 可结合Spring EL表达式从配置文件取值

    @Value("${child.family}")
    private String family;

4. @Autowired

  默认按照类型装配，如果想按名称进行装配，可配合@Qualifier使用

5. @Resource

  按照名称装配，如果找不到名称匹配的Bean则会按照类型装配

6 @PropertySource

  读取配置文件

@Configuration
@PropertySource("classpath:values.properties")
public class MyConfig {

    @Bean
    public Child child() {
        return new Child();
    }

}

7. @Qualifier

  如存在多个实例，配合@Autowired使用，指定根据名称装配

    @Autowired
    @Qualifier("childService")
    public HumanService humanService;

8. @Primary

  自动装配时如果匹配到多个Bean，使用@Primary作为首选者，否则抛出异常
  如一个接口有多个实现类，这些实现类中有一个使用了@Primary注解，则在@Autowired注入时会优先使用这个实现类

三、织入组件

1. ApplicationContextAware

  可以通过这个上下文环境对象得到Spring容器中的Bean

2. BeanDefinitionRegistryPostProcessor

  BeanDefinitionRegistryPostProcessor实现了BeanFactoryPostProcessor接口，是Spring框架的BeanDefinitionRegistry的后处理器，用来注册额外的BeanDefinition

四、切面组件

1. @EnableTransactionManagement

 启用对事物管理的支持

2. @Transactional

 配置声明式事物信息