spring注解之自动装配和属性赋值

1.自动装配

1.1什么是自动装配？

　　Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值；

1.2@Autowired/@Qualifier/@Primary

1.2.1@Autowired基本使用

-默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class) 找到就赋值；

@Service
public class BookService {
    @Autowired //将BookDao组件装配到当前组件中，找到就赋值
    private BookDao bookDao;  ①
}

-如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找  applicationContext.getBean("bookDao")

比方说在配置类中再添加个BookDao组件代码如下：

@ComponentScan({"com.athome.service","com.athome.dao"})
@Configuration
public class MainAutowiredConfig {
    @Bean("bookDao2") ②
    public BookDao bookDao(){
        BookDao bookDao = new BookDao();
        bookDao.setTag("2");
        return  bookDao;
    }
}

那么上面的两段代码都有相同类型BookDao组件，这种情况下按照属性名称找对应的组件，找到就赋值；

如上面代码①处 ，属性名是bookDao，则找该组件，如果①处 属性名改为成 ②处的名字( bookDao2) ，这种情况则找id为bookDao2的组件。

@Autowired 详解

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

    /**
     * Declares whether the annotated dependency is required.
     * <p>Defaults to {@code true}.
     */
    boolean required() default true;

}

从@Autowired定义来看，该注解可修饰 构造器、方法、参数、属性、注解

• 标注在方法上：根据方法的形参，从容器中查找

@Component
public class Teacher {
    private Book book;

    @Autowired
　　//标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值；
    //方法使用的参数，自定义类型的值从ioc容器中获取
    public Book getBook() {
        return book;
    }
    public void setBook(Book book) {
        this.book = book;
    }
    @Override
    public String toString() {
        return "Teacher{" + "book=" + book + '}';
    }
}

    @Bean("teacher2")
    public Teacher teacher(@Autowired Book book){
        Teacher teacher = new Teacher();
        teacher.setBook(book);
        return  teacher;
    }
//@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
上面浅紫色区域可以不写

• 标注在构造器：默认调用无参构造器；

//默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Teacher {
    private Book book;

    //构造器要用的组件，都是从容器中获得
    @Autowired
    public Teacher (Book book){
        this.book = book;
    }

    public Book getBook() {
        return book;
    }
    public void setBook(Book book) {
        this.book = book;
    }
    @Override
    public String toString() {
        return "Teacher{" + "book=" + book + '}';
    }
}

//如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取

• 标注在参数中：根据参数组件值从容器中查找对应的组件

@Component
public class Teacher {
    private Book book;

    //标注在形参上也是一样，都是从容器中获得public Teacher ( @Autowired Book book){
        this.book = book;
    }

    @Autowired
    public Book getBook() {
        return book;
    }
    public void setBook(Book book) {
        this.book = book;
    }
    @Override
    public String toString() {
        return "Teacher{" + "book=" + book + '}';
    }
}

1.2.2@Qualifier

@Qualifier指定需要装配的组件的id，而不是使用属性名

@Service
public class BookService {

    @Qualifier("bookDao2")
    @Autowired
    private BookDao bookDao;
    public void print(){
        System.out.println(bookDao);
    }
    @Override
    public String toString() {
        return "BookService{" + "bookDao=" + bookDao + '}';
    }
}

上面这段代码，装配组件id为 bookDao2 的组件，并不是 属性名为bookDao 的组件

1.2.3@Primary

让Spring进行自动装配的时候，默认使用首选的bean； 

也可以继续使用@Qualifier指定需要装配的bean的名字；

@ComponentScan({"com.athome.service","com.athome.dao"})
@Configuration
public class MainAutowiredConfig {
    @Primary
    @Bean("bookDao2")
    public BookDao bookDao(){
        BookDao bookDao = new BookDao();
        bookDao.setTag("2");
        return  bookDao;
    }
}

在没有使用@Qualifier指定装配的情况下，上面的代码则会，首选装配 bookDao2组件
--------------------------------------------------------------------

 @Service public class BookService {
　　 @Qualifier("bookDao")
    @Autowired 
    private BookDao bookDao; 
}

 @Primary和 @Qualifier("bookDao") 都在使用的话，则  使用@Qualifier("bookDao")指定的组件

1.2.4 @Autowired(required=false)

 因为 required=false，如果spring找不到对应的组件的话会赋空值进去；

@Service
public class BookService {
　　
    @Autowired(required = false)//如果容器中没有BookDao组件的话， 则bookDao=null
    private BookDao bookDao;
    public void print(){
        System.out.println(bookDao);
    }
    @Override
    public String toString() {
        return "BookService{" + "bookDao=" + bookDao + '}';
    }
}

1.3@Resource(JSR250)和@Inject(JSR330)

• @Resource：默认是按照组件名称进行装配的；

@Service
public class BookService {

 //   @Qualifier("bookDao2")
//    @Autowired(required = false)
    @Resource
    private BookDao bookDao;
    public void print(){
        System.out.println(bookDao);
    }
    @Override
    public String toString() {
        return "BookService{" + "bookDao=" + bookDao + '}';
    }
}

@Resource和@Autowired一样实现自动装配功能；
默认是按照组件名称进行装配的；
没有能支持@Primary功能，没有支持@Autowired（reqiured=false）和 Qualifier
@Resource(name = "bookDao2"),则装配bookDao2组件

• @Inject：需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能，加@Named注解指定bean 的Id；

@Service
public class BookService {

   // @Qualifier("bookDao2")
    @Inject
    @Named("bookDao2")
    private BookDao bookDao;
    public void print(){
        System.out.println(bookDao);
    }
    @Override
    public String toString() {
        return "BookService{" + "bookDao=" + bookDao + '}';
    }
}

@Inject 和 @Qualifier 、@Primary 、@Named 可组合使用

1.4Aware注入Spring底层组件

自定义组件想要使用Spring容器底层的组件(ApplicationContext、BeanFactory、 ......)
思路: 自定义组件实现xxxAware, 在创建对象的时候, 会调用接口规定的方法注入到相关组件:XXXAware

 查看有哪些接口继承了Aware接口：

参考代码：

@Component
public class Person implements ApplicationContextAware,BeanNameAware,EmbeddedValueResolverAware {
    
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("传入的ioc："+applicationContext);
        this.applicationContext = applicationContext;
    }

    @Override
    public void setBeanName(String name) {
        // TODO Auto-generated method stub
        System.out.println("当前bean的名字："+name);
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        // TODO Auto-generated method stub
        String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
        System.out.println("解析的字符串："+resolveStringValue);
    }
}

 

分析：Aware注入Spring底层组件原理

把Spring底层的组件可以注入到自定义的bean中，ApplicationContextAware是利用ApplicationContextAwareProcessor来处理的，

其它XXXAware也类似， 都有相关的Processor来处理，其实就是后置处理器来处理。
XXXAware---->功能使用了XXXProcessor来处理的，这就是后置处理器的作用；
ApplicaitonContextAware--->ApplicationContextProcessor后置处理器来处理的

 

1.5@Profile

 @Profile:Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能;

指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件

参考代码：

/**
 * Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件
 * 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
 * 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
 * 3）、没有标注环境标识的bean在，任何环境下都是加载的；
 */
@Configuration
public class ConfigProfile {

    @Profile("test")
    @Bean("profileTest")
    public void profileTest() {
        System.out.println("profileTest");
    }

    @Profile("dev")
    //@Profile("default") 默认生效该Bean组件
    @Bean("profileDev")
    public void profileDev() {
        System.out.println("profileDev");
    }

    @Profile("prod")
    @Bean("profileProd")
    public void profileProd() {
        System.out.println("profileProd");
    }
}

 测试代码：

public class IOC_ProfileTest {
    //1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
    //2、代码的方式激活某种环境；
    @Test
    public void test(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        //1、创建一个applicationContext
        //2、设置需要激活的环境
        context.getEnvironment().setActiveProfiles("dev");
        //3、注册主配置类
        context.register(ConfigProfile.class);
        //4、启动刷新容器
        context.refresh();

        String[] names = context.getBeanDefinitionNames();
        for (String s: names) {
            System.out.println(s);
        }
    }
}

测试结果：

2.属性赋值

使用@Value赋值：
  1.基本数值
  2.可以写SpEL； #{}
  3.可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）


下面是一个Bean： Person类

public class Person {

    @Value("高菲") //基本数值
    private String name;

    @Value("#{20-2}") //SpEL表达式 #{}
    private Integer age;

    @Value("${person.nickName}") //取出配置文件中的数据 ${}
    private String nickName;

　　下面代码是 setter/getter/toString方法
}

 配置类：

@PropertySource：读取外部配置文件中的 K / V 保存到运行环境变量中；加载完外部的配置文件以后使用${}取出配置文件的值。

@PropertySource(value = {"classpath:/person.properties"})//获取外部配置文件
@Configuration
public class MainConfigOfPropertyValue {

    @Bean
    public Person person(){
        return new Person();
    }
}

测试类：

 @Test
    public void test(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfPropertyValue.class);
        Person person = (Person) applicationContext.getBean("person");
        String[] names = applicationContext.getBeanDefinitionNames();
        for (String  s: names) {
            System.out.println("mainConfigOfPropertyValue配置类中有哪些bean -->"+s);
        }
        System.out.println(person);
        //可以通过运行环境来获取配置文件中的数据
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        String property = environment.getProperty("person.nickName");
        System.out.println("运行环境取配置文件中的值： "+property);
    }

运行结果：

3.小结

• 自动装配：Spring利用依赖注入(DI)，完成对IOC容器中各个组件的依赖关系赋值；

  1）、@Autowired：自动注入：
          1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值
          2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找
                              applicationContext.getBean("bookDao")
          3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
          4）、自动装配默认一定要将属性赋值好，没有就会报错；
              可以使用@Autowired(required=false);
          5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；
                  也可以继续使用@Qualifier指定需要装配的bean的名字
          BookService{  
              @Autowired
              BookDao  bookDao;
          }
  
  2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
          @Resource:
              可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
              没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
          @Inject:
              需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
   @Autowired:Spring定义的； @Resource、@Inject都是java规范
      
  AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；        
  
  3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
          1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
          2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
          3）、放在参数位置：
  
  4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
          自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
          把Spring底层一些组件注入到自定义的Bean中；
          xxxAware：功能使用xxxProcessor；ApplicationContextAware==》ApplicationContextAwareProcessor；

• 属性赋值

　　@Value("基本数值")

　　@Value("SpEL表达式")    - #{}

　　@Value("获取配置文件中值")  - ${}