Spring注解之属性赋值与自动装配

于 2020-08-05 14:32:44 发布
阅读量582 收藏
点赞数 1
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/codinglover5/article/details/107800542
版权
本文详细讲解了Spring框架中属性赋值和自动装配的多种方式，包括使用@Value注解进行属性赋值，@Autowired和@Qualifier进行自动装配，以及@Primary和@Profile等注解的高级应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.属性赋值

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

public class Person {
    //@Value注解既1.可以完成基本的变量赋值
    // 2.spEL 取值例如  @Value("#{20-2}")
    //3.读取配置文件的值并赋值 @Value("${XX}")
    @Value("zhangsan")
    private String name;
    @Value("#{20-2}")
    private  int age;
    private String grader;
    @Value("${person.nickName}")
	private String nikName;
    public Person(String name, int age, String grader) {
        this.name = name;
        this.age = age;
        this.grader = grader;}
        }

在这里插入图片描述 配置类：

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

@PropertySource(value = {"classpath:/person.properties"})//可以导入外部的配置文件

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

测试类

public class TestProperties {

    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfValue.class);

    @Test
    public void test1(){
        printName(context);

        System.out.println("======");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
        //可以通过运行环境来获取配置文件中的数据
        ConfigurableEnvironment environment = context.getEnvironment();
        String property = environment.getProperty("person.nickName");
        System.out.println("运行环境取配置文件中的值： "+property);
        context.close();
    }
    public void printName(AnnotationConfigApplicationContext annotationConfigApplicationContext){
        String[] names = annotationConfigApplicationContext.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
}

在这里插入图片描述

2.自动装配

2.1什么是自动装配？

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

2.2@Autowired基本使用

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

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

public class AutowiredTest {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfigAutowired.class);
    @Test
    public void test1(){
        printName(context);
        Object bookService = context.getBean(BookService.class);
        System.out.println(bookService);
        BookDao bean = context.getBean(BookDao.class);
        System.out.println(bean);
    }
    public void printName(AnnotationConfigApplicationContext annotationConfigApplicationContext){
        String[] names = annotationConfigApplicationContext.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }
    }
}

在这里插入图片描述-如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找 applicationContext.getBean(“bookDao”)

@ComponentScan({"com.zy.service","com.zy.dao"})
@Configuration
public class MainAutowiredConfig {
    @Bean("bookDao2") (2)
    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定义来看，该注解可修饰 构造器、方法、参数、属性、注解

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

2.3@Qualifler

@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 + '}';
    }
}

在这里插入图片描述

2.4@Primary

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

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

@ComponentScan({"com.zy.service","com.zy.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")指定的组件

2.5@Aurowired(required=fasle)

因为 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 + '}';
    }
}

2.6 @Resource(JSR250)

@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组件

2.7 @Inject(JSR330)

@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 可组合使用

2.8 @Autoried注入spring的底层组件

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

public class Read implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("注入的ioc容器是"+applicationContext);
        this.applicationContext=applicationContext;
    }

    public void setBeanName(String s) {
        System.out.println("注入的bean的名字是："+s);
    }

    public void setEmbeddedValueResolver(StringValueResolver stringValueResolver) {
        String s = stringValueResolver.resolveStringValue(("你好 ${os.name} ,我是 #{20*18}");
        System.out.println("解析出来的的值是"+s);
    }
}

分析：Aware注入Spring底层组件原理
把Spring底层的组件可以注入到自定义的bean中，ApplicationContextAware是利用ApplicationContextAwareProcessor来处理的，
其它XXXAware也类似， 都有相关的Processor来处理，其实就是后置处理器来处理。
XXXAware---->功能使用了XXXProcessor来处理的，这就是后置处理器的作用；
ApplicaitonContextAware—>ApplicationContextProcessor后置处理器来处理的

2.9@Profile

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

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

package com.zy.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.util.StringValueResolver;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;

/**
 * Created by MR.ZHANG on 2020/8/5 11:44
 */
@PropertySource("classpath:/db.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {
    @Value("${db.user}")
    private String user;
    private StringValueResolver valueResolver;

    private String driverClass;

    @Profile("test")
    @Bean("TestDateSource")
    public DataSource TestDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
        ComboPooledDataSource source = new ComboPooledDataSource();
        source.setUser(user);
        source.setPassword(pwd);
        source.setJdbcUrl("jdbc:mysql://localhost:3306/db_bbs");
        source.setDriverClass(driverClass);

        return source;
    }
     @Profile("dev")
    @Bean("DevDataSource")
    public DataSource DevDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
        ComboPooledDataSource source2 = new ComboPooledDataSource();
        source2.setUser(user);
        source2.setPassword(pwd);
        source2.setJdbcUrl("jdbc:mysql://localhost:3306/jsp_bbs");
        source2.setDriverClass(driverClass);

        return source2;
    }
    
        @Profile("prod")
        @Bean("ProductDataSource")
        public DataSource ProductDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
            ComboPooledDataSource source1 = new ComboPooledDataSource();
            source1.setUser(user);
            source1.setPassword(pwd);
            source1.setJdbcUrl("jdbc:mysql://localhost:3306/doudou");

            source1.setDriverClass(driverClass);

            return source1;
        }

    public void setEmbeddedValueResolver(StringValueResolver resolver) {
            this.valueResolver=resolver;
              driverClass = valueResolver.resolveStringValue("${db.jdbcDriver}");
    }
}

测试

public class ProfilerTest {
    @Test
    public void test(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfProfile.class);

        String[] names = context.getBeanNamesForType(DataSource.class);
        for (String name : names) {
            System.out.println(name);
        }
    }
}

结果
在这里插入图片描述

3。总结

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；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值