10-自动装配

最新推荐文章于 2023-06-20 17:03:13 发布

珂-瑞

最新推荐文章于 2023-06-20 17:03:13 发布

阅读量295

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/xaccpJ2EE/article/details/105183939

版权

spring 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

本文深入解析Spring框架中@Autowired注解的使用，涵盖依赖注入、自动装配原则、与@Resource及@Inject的区别，以及如何在构造器、方法和属性中应用。同时探讨自定义组件如何使用Spring底层组件，和@Profile注解在不同环境下的组件注册。

摘要由CSDN通过智能技术生成

1、@Autowired：

2、Spring 支持使用@Resource（JSR250）和 @Inject（JSR330）【java规范】

3、@Autowired ：构造器、参数、方法、属性都是从容器中获取参数组件的值

4、自定义组件，想要使用Spring容器底层的一些组件（ApplicationConext、BeanFactory、xxx）

5、@profile:指定组件在哪个环境的情况下，才能被注册到容器中。

1、@Autowired：

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

1）、默认优先按照类型去容器中找对应的组件：annotationConfigApplicationContext.getBean(BookService.class)

2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id，去容器中查找。

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

4）、自动装配默认一定要将属性赋值好，没有就会报错；

可以使用@Autowired（required=false）；

5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean

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

package com.spring.controller;
import com.spring.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class BookController {
    @Autowired
    private BookService bookService;
}


package com.spring.service;

import com.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class BookService {

    @Qualifier("bookDao")  //指定需要装配的组件的id，而不是使用属性名
    @Autowired
    private BookDao bookDao;

    private void print(){
        System.out.println(bookDao);
    }

    @Override
    public String toString() {
        return "BookService{" +
                "bookDao=" + bookDao +
                '}';
    }
}


package com.spring.dao;

import org.springframework.stereotype.Repository;

@Repository
public class BookDao {

    private String tag="1";

    public String getTag() {
        return tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    @Override
    public String toString() {
        return "BookDao{" +
                "tag='" + tag + '\'' +
                '}';
    }
}

编写配置类，这里通过@Bean方式也向容器中注册了一个

package com.spring.Condition;

import com.spring.dao.BookDao;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * 自动装配：Autowired
 *       Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值
 *  1）、默认优先按照类型去容器中找对应的组件：annotationConfigApplicationContext.getBean(BookService.class)
 *  2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id，去容器中查找。
 *
 */
@Configuration
@ComponentScan(value = {"com.spring.controller","com.spring.dao","com.spring.service"})
public class MainConfigOfAutowired {

    @Primary
    @Bean("bookDao")
    public BookDao bookDao(){
        BookDao bookDao = new BookDao();
        bookDao.setTag("2");
        return bookDao;
    }
}

编写测试代码

package com.spring.test;

import com.spring.Condition.MainConfigOfAutowired;
import com.spring.service.BookService;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class IocTest_Autowired {

    AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(MainConfigOfAutowired.class);

    @Test
    public void test01(){
        BookService bookService =  annotationConfigApplicationContext.getBean(BookService.class);
        System.out.println(bookService);
        annotationConfigApplicationContext.close();
    }
}

测试结果为：

BookService{bookDao=BookDao{tag='1'}}

2、Spring 支持使用@Resource（JSR250）和 @Inject（JSR330）【java规范】

@Service
public class BookService {

    @Resource
    private BookDao bookDao;

    private void print(){
        System.out.println(bookDao);
    }

    @Override
    public String toString() {
        return "BookService{" +
                "bookDao=" + bookDao +
                '}';
    }
}

@Resource（JSR250）

可以和@Autowired 一样实现自动装配功能，默认是按照组件名称进行装配的。

缺点：没有能支持@Primary 功能，没有支持@Autowired（reqiured=false）的功能。

@Inject 需要加入pom依赖，和Autowired一样，没有reqiured=false的功能

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

import com.spring.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.inject.Inject;

@Service
public class BookService {

    @Inject
    private BookDao bookDao;

    private void print(){
        System.out.println(bookDao);
    }

    @Override
    public String toString() {
        return "BookService{" +
                "bookDao=" + bookDao +
                '}';
    }
}

区别：@Autowired 是spring的。

@Resource 和 @Inject 是java规范。

3、@Autowired ：构造器、参数、方法、属性都是从容器中获取参数组件的值

1）、标注在方法位置

2）、【标注构造器】：如果组件只有一个有参构造器，这个参数构造器的@Aurowired 可以省略

3）、标注在参数位置。

package com.spring.bean;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Boss {

    //@Autowired
    private Car car;

    //@Autowired
    public Boss(@Autowired Car car){
        this.car=car;
        System.out.println("Boss...有参构造器");
    }

    @Override
    public String toString() {
        return "Boss{" +
                "car=" + car +
                '}';
    }

    public Car getCar() {
        return car;
    }

    //@Autowired
    //标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值。
    //方法使用的参数，自定义类型的值从ioc容器中取
    public void setCar(Car car) {
        this.car = car;
    }
}

4、自定义组件，想要使用Spring容器底层的一些组件（ApplicationConext、BeanFactory、xxx）

自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；

把Spring底层的一些组件注入到自定义的Bean中

xxxAware：功能使用xxxProcessor来处理的。

跟ApplicationContextAware 对应的有ApplicationContextAwareProcessor

package com.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.stereotype.Component;
import org.springframework.util.StringValueResolver;

@Component
public class User implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

    public void setBeanName(String name) {
        System.out.println("当前bean的名字："+name);
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
        System.out.println("传入的ioc："+applicationContext);
    }

    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        String s = resolver.resolveStringValue("你好${os.name} 我是#{22*11}");
        System.out.println(s);
    }
}

容器启动时，会执行相关Aware接口实现方法

当前bean的名字：user
你好Windows 10 我是242
传入的ioc：org.springframework.context.annotation.AnnotationConfigApplicationContext@37d31475: startup date [Mon Mar 30 15:00:17 CST 2020]; root of context hierarchy
postProcessBeforeInitialization...user bean-->com.spring.bean.User@16612a51
postProcessAfterInitialization...user bean-->com.spring.bean.User@16612a51

5、@profile:指定组件在哪个环境的情况下，才能被注册到容器中。

加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境。
@profile 写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效。
没有标注环境标识的bean，在任何环境下都是加载的。

我们测试下，根据不同的环境，注册不同的数据源组件

首先增加pom依赖

<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.5</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>

创建配置类，使用不同的方式从配置文件读取配置，来设置属性值。

增加三个不同环境数据源组件方法，test、dev、prod环境。

package com.spring.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.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.util.StringValueResolver;

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

/**
 * Profile:
 *    Spring 为我们提供的，可以根据当前环境，动态的激活和切换一系列组件的功能；
 *
 *    开发环境、测试环境、生产环境
 *    数据源：
 *
 */
//@Profile("test") //写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效。
@PropertySource("classpath:db.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {

    @Value("${db.user}")
    private String user;

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

    //@Value("${db.classDirver}")
    private String driverClass;

    //xxxAware 方式
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
     this.driverClass=resolver.resolveStringValue("${db.classDirver}");
    }

    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest() throws PropertyVetoException {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        comboPooledDataSource.setDriverClass(driverClass);
        return comboPooledDataSource;
    }

    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev() throws PropertyVetoException {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        comboPooledDataSource.setDriverClass(driverClass);
        return comboPooledDataSource;
    }

    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd() throws PropertyVetoException {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setUser(user);
        comboPooledDataSource.setPassword(password);
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        comboPooledDataSource.setDriverClass(driverClass);
        return comboPooledDataSource;
    }

}

测试类

package com.spring.test;

import com.spring.config.MainConfigOfProfile;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import javax.sql.DataSource;

public class IocTest_Profile {

    //1、使用命令行动态参数：在虚拟机参数位置加载 -Dspring.profiles.active=test
    //2、代码的方式激活某种环境
   @Test
    public void test01(){
       //1、创建一个ApplicationContext 无参构造器
       AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        //2、设置需要激活的环境
       annotationConfigApplicationContext.getEnvironment().setActiveProfiles("test");
       // 3、注册主配置类
       annotationConfigApplicationContext.register(MainConfigOfProfile.class);
       //启动刷新容器
       annotationConfigApplicationContext.refresh();
       String[] beanNamesForType = annotationConfigApplicationContext.getBeanNamesForType(DataSource.class);
        for(String bean:beanNamesForType){
            System.out.println(bean);
        }
        annotationConfigApplicationContext.close();
    }
}

两种方式传入动态参数:

1、使用命令行动态参数：在虚拟机参数位置加载 -Dspring.profiles.active=test
2、代码的方式激活某种环境

测试类中设置了test环境为生效环境，annotationConfigApplicationContext.getEnvironment().setActiveProfiles("test");

这样test对一个的数据源组件就被注册到容器中

执行结果为：

三月 30, 2020 4:49:56 下午 com.mchange.v2.c3p0.C3P0Registry 
信息: Initializing c3p0-0.9.5.5 [built 11-December-2019 22:18:33 -0800; debug? true; trace: 10]
testDataSource
三月 30, 2020 4:49:56 下午 org.springframework.context.annotation.AnnotationConfigApplicationContext doClose
信息: Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@26a7b76d: startup date [Mon Mar 30 16:49:53 CST 2020]; root of context hierarchy

如果在配置类上设置了@Profile("test")，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效。

@Profile("test") //写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效。
@PropertySource("classpath:db.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {

}