四、spring成长之路——springIOC容器（下）

5.spring注解开发（Spring扩展知识）

目录

• 5.spring注解开发（Spring扩展知识）
  • 5.1定义配置类：@Configuration 声明一个类为IOC容器 @Bean定义一个Bean
  • 5.2.按照条件进行注入
  • 5.3.@Import注解进行注入
  • 5.4、FactoryBean注入
  • 5.5、后置处理详解
  • 5.6、属性赋值和自动装配
  • 5.6.在类中使用spring底层的组件
    • 5.6.@Profile的使用

5.1定义配置类：@Configuration 声明一个类为IOC容器 @Bean定义一个Bean

package com.itcloud.annotation;

import com.itcloud.pojo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CommonConfig {
    @Bean
    public Student student(){
        Student student = new Student();
        student.setId(10l);
        student.setName("configuration");
        return student;
    }
}

测试

package com.itcloud.pojo.anntation;

import com.itcloud.annotation.CommonConfig;
import com.itcloud.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AnnotationTest {
    ApplicationContext context = new AnnotationConfigApplicationContext(CommonConfig.class);
    @Test
    public void testAnnotation(){
        Student stu = context.getBean(Student.class);
    }
}

注解@ComponmentScan使用详解，该注解作用在类上面

@ComponentScan(value = "com.itcloud",useDefaultFilters = false,includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {
                Component.class, Service.class, Repository.class
        })
},excludeFilters = {
        @ComponentScan.Filter(type=FilterType.ANNOTATION,classes = {
                Controller.class
        })
})

bean的作用域，@Scope定义在方法上面

/**
     * 取值：singleton:默认值，单实例，容器加载的时候进行bean的创建
     *      prototype:允许创建多个对象，使用的时候进行队形的创建
     */
    @Scope(value = "")

bean的懒加载，@Lazy放在方法上面，在没有这个注解的时候，bean会在容器启动的时候进行加载，但是这个注解使用之后，当使用到这个bean的时候才会进行性bean的加载。

5.2.按照条件进行注入

@Conditional该注解可以根据条件进行注入操作，作用类或者方法上面

自定义判断条件：此判断条件主要的作用是判断容器中是否存在studentbean，如果存在则注入teacher，否则不注入；

package com.itcloud.annotation.conditional;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class MyConditional implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        BeanDefinitionRegistry registry = context.getRegistry();
        boolean student = registry.containsBeanDefinition("student");
        if(student){
            return true;
        }
        return false;
    }
}

	@Bean("teacher")
    @Conditional({MyConditional.class})
    public Teacher teacher(){
        Teacher t = new Teacher();
        t.setId(10l);
        t.setName("李老师");
        return t;
    }

5.3.@Import注解进行注入

具体用法：按照注解的意思我们可以导入一个ioc容器，ImportSelector或者ImportBeanDefinitionRegistrar的子类，再或者是一个普通的组件类，即被@Component相关注解修饰的类，那么普通的类可以吗？

/**
	 * {@link Configuration}, {@link ImportSelector}, {@link ImportBeanDefinitionRegistrar}
	 * or regular component classes to import.
	 */

//在这之前我们自定义了一个Color类

@Configuration
@Import({Color.class})
public class CommonConfig {...}

经过测试普通类也是可以导入的，但是普通类的bean默认的value是全类名：com.itcloud.annotation.vo.Color

ImportSelector测试

自定义一个MyImportSelector.java类实现ImportSelector接口，把需要导入的类通过字符串数组的形式进行返回，一定要是全类名

参数AnnotationMetadata可以获取IOC容器上面的注解

package com.itcloud.annotation.myimport;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.itcloud.annotation.vo.Blue","com.itcloud.annotation.vo.Red"};
    }
}

ImportBeanDefinitionRegistrar测试

package com.itcloud.annotation.myimport;

import com.itcloud.annotation.vo.Yellow;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //这里可以进行bean的注册
        RootBeanDefinition beanDefinition = new RootBeanDefinition(Yellow.class);
        registry.registerBeanDefinition("yellow", beanDefinition);
    }
}

5.4、FactoryBean注入

在2>2.7里面已经说过了，此处不再赘述:点击跳转

bean的生命周期，在注解中的表现如下:

​ 和xml配置文件相似；

@Bean(value = "student",initMethod = "init",destroyMethod = "destory")

5.5、后置处理详解

1.注解：@PostConstruct 和 @PreDestory

​ 在这里一定要将此类注入到容器中，至于怎么注入，就不再赘述

package com.itcloud.annotation.vo;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class PostBean {

    public PostBean(){
        System.out.println("构造方法执行.....");
    }

    @PostConstruct
    public void postConstruct(){
        System.out.println("postConstruct......");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("容器关闭之前执行的吗......");
    }
}

测试结果：

<!--
	构造方法执行.....
	postConstruct......
	## 容器关闭之前执行如下
	容器关闭之前执行的吗......
-->

2.两个接口 InitializingBean DisposableBean

package com.itcloud.annotation.vo;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class PostProcessorBean implements InitializingBean, DisposableBean {

    public PostProcessorBean(){
        System.out.println("PostProcessorBean.....构造方法执行");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("PostProcessorBean.......destroy()");
    }

    //属性设置完成之后执行,构造方法之后调用
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("PostProcessorBean.......afterPropertiesSet()");
    }
}

3.BeanPostProcessor原理解析

在前面后置处理器中我们已经了解了，通过实现接口BeanPostProcessor可以进行后置处理，在这里我们将要对后置处理原理进行简单的介绍

​ 定义一个后置处理器

​ 这个处理器会在所有bean创建的时候，构造方法之后执行，所有初始化方法之前执行，而方法postProcessAfterInitialization会在初始化之后调用，不需要容器关闭

package com.itcloud.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

@Component
public class MyProcessor implements BeanPostProcessor{

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

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

package com.itcloud.processor;

import com.itcloud.annotation.vo.Color;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Component;

@Configuration
@ComponentScan(useDefaultFilters = false, includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
                Component.class
        })
})
public class ProcessorConfig {

    @Bean
    public Color color(){

        return new Color();
    }
}

源码解析：

5.6、属性赋值和自动装配

1.@Value的使用

package com.itcloud.annotation.vo;

import org.springframework.beans.factory.annotation.Value;

public class Color {

    //直接赋值
    @Value("red")
    private String type;

    //EL表达式
    @Value("#{100.30-13.43}")
    private Double length;

    //引用外部属性文件

    @Value("${value.username}")
    private String username;

    @Value("${value.password}")
    private String password;
}

在配置类上面一定要引用外部文件，通过注解@PropertySource

package com.itcloud.processor;

import com.itcloud.annotation.vo.Color;
import org.springframework.context.annotation.*;
import org.springframework.stereotype.Component;

@Configuration
@ComponentScan(useDefaultFilters = false, includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
                Component.class
        })
})
@PropertySource("classpath:/properties/value.properties")
public class ProcessorConfig {

    @Bean
    public Color color(){

        return new Color();
    }
}

通过环境变量来获取属性的值

Environment environment = context.getEnvironment();
String property = environment.getProperty("value.username");

2.自动装配使用的注解

2.1、spring注解：@Autowired前面我们已经说过，这个注解可以配合@Qualifier使用，明确调用使用特定的Bean

​ @Autowired也可以配置@Primary注解使用，当类型相同的使用，会优先选择@Primary注解标识的 bean

2.2.非spring注解：@Resource按照名称注入，@Inject,@Autowired用法类似，需要引入jar:

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>

5.6.在类中使用spring底层的组件

如果一个类想要使用spring底层的组件，可以实现一些接口xxxAware,这个接口都是org.springframework.beans.factory.Aware接口的子类

1.xxxAware方法的使用

package com.itcloud.annotation.vo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.*;
import org.springframework.core.env.Environment;
import org.springframework.util.StringValueResolver;

public class Color implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {
    private ApplicationContext context;

    public void userContext(){
        Environment environment = this.context.getEnvironment();
        String property = environment.getProperty("value.url");
        System.out.println(property);

    }

    //获取applicationContext对象
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.context = context;
    }

    //获取当前bean的name
    @Override
    public void setBeanName(String name) {
        System.out.println("name===" + name);
    }

    //进行字符串的解析
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String result = resolver.resolveStringValue("数据库的名称：${value.username}, el表达式解析：#{10-3*3}");
        System.out.println(result);
    }
}

5.6.@Profile的使用

此注解既可以使用在bean上，也可以定义在一个IOC容器上面，激活的方式：

​ 1.类激活

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("development");
ctx.register(SomeConfig.class, StandaloneDataConfig.class, JndiDataConfig.class);
ctx.refresh();

​ 2.jvm参数激活：

-Dspring.profiles.active="profile1,profile2"