Spring注解之四组件注入

作者: Java及SpringBoot | 来源:发表于2019-11-27 11:03 被阅读0次

1.4. 组件注入

@Autowired&@Qualifier&@Primary@Resource&@Inject

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

@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的名字
Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]

@Resource:
1. 可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
2. 没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
@Inject:
1. 需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
@Autowired:Spring定义的； @Resource、@Inject都是java规范
AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；

/**
 * 组件注入
 */
@Configuration
@ComponentScan({"com.xubh.service", "com.xubh.dao",
        "com.xubh.controller", "com.xubh.bean"})
public class MainConifgOfAutowired {

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

    /**
     * @param car
     * @return
     * @Bean标注的方法创建对象的时候，方法参数的值从容器中获取
     */
    @Bean
    public Color color(Car car) {
        Color color = new Color();
        color.setCar(car);
        return color;
    }
}

public class IOCTest_Autowired {
    
    @Test
    public void test01(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConifgOfAutowired.class);
        
        BookService bookService = applicationContext.getBean(BookService.class);
        System.out.println(bookService);
        
        //BookDao bean = applicationContext.getBean(BookDao.class);
        //System.out.println(bean);
        
        Boss boss = applicationContext.getBean(Boss.class);
        System.out.println(boss);
        Car car = applicationContext.getBean(Car.class);
        System.out.println(car);
        
        Color color = applicationContext.getBean(Color.class);
        System.out.println(color);
        System.out.println(applicationContext);
        applicationContext.close();
    }

}

方法、构造器位置的自动装配

@Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
1. [标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
2. [标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
3. 放在参数位置：

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


    private Car car;

    //构造器要用的组件，都是从容器中获取
    public Boss(Car car) {
        this.car = car;
        System.out.println("Boss...有参构造器");
    }


    public Car getCar() {
        return car;
    }


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


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

依赖注入的方式

构造器方式注入
- 构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。
setter方法注入
- 之所以叫setter方法注入，因为这是通过找到类的对应的setter方法，再进行相应的注入
- Setter方法注入是容器通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。
循环依赖
- 构造器方式无法解决，只能抛出异常
- 多例方式无法解决，只能抛出异常
  - 因为Spring容器不缓存"prototype"作用域的bean，因此无法提前暴露一个创建中的bean
- 单例模式可以解决
  - 通过提前暴露一个单例工厂方法，从而使其他bean能够引用到该bean/提前暴露一个正在创建中的bean

Aware注入Spring底层组件&原理

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

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

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

xxxAware：功能使用xxxProcessor；

ApplicationContextAware==>ApplicationContextAwareProcessor；

if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
            }
            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }
            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
            }
            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
            }
            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
            }
            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
            }
        }

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

    private ApplicationContext applicationContext;

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

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

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

}

@Profile环境搭建&@Profile根据环境注册bean

Profile：
- Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能；
开发环境、测试环境、生产环境；
数据源：(/A)(/B)(/C)；
@Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件
- 加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
- 写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
- 没有标注环境标识的bean在，任何环境下都是加载的；

/**
 * Profile：
 */
@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {

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

    private StringValueResolver valueResolver;

    private String driverClass;


    @Bean
    public Yellow yellow() {
        return new Yellow();
    }

    @Profile("test")
    @Bean("testDataSource")
    public DataSource dataSourceTest(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }


    @Profile("dev")
    @Bean("devDataSource")
    public DataSource dataSourceDev(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm_crud");
        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

    @Profile("prod")
    @Bean("prodDataSource")
    public DataSource dataSourceProd(@Value("${db.password}") String pwd) throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setUser(user);
        dataSource.setPassword(pwd);
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/scw_0515");

        dataSource.setDriverClass(driverClass);
        return dataSource;
    }

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

}

public class IOCTest_Profile {

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

        String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
        for (String string : namesForType) {
            System.out.println(string);
        }

        Yellow bean = applicationContext.getBean(Yellow.class);
        System.out.println(bean);
        applicatio nContext.close();
    }

}

Spring依赖注入(IoC)的四种方式
Spring中四种依赖注入的方式(推荐注解注入) 注解注入(1) 注解注入 (2) 构造函数注入代码如下(如果不...
细说Spring——IoC详解（注解驱动开发之包扫描过滤和Fac
一、前言上一篇博客（细说Spring——IoC详解（注解驱动开发之Bean的注入））中简单的介绍了将组件注入容器...
spring给容器中注入组件的几种方式
目录环境搭建 spring给容器中注入组件 1.包扫描+组件标注注解（@Controller/@Service/...
Spring @Import注解
一分钟学会spring注解之@Import注解 Spring Boot自动注入的关键注解@EnableAutoCo...
spring 源码学习②-盘点spring 组件注入的几种方式
盘点Spring中组件注入的几种方式： 1、@Configuration注解该注解虽然不能直接将Bean对象注...
Spring注解之四组件注入
个人专题目录： ActiviMQ专题链路追踪 Dubbo专题 Docker专题 Git专题 Idea专题 Jav...
Spring通过注解注入组件
组件声明在类上声明 @Component、@Configuration、@RestController、@Ser...
Spring之autowired
spring提供@autowired注解来对组件进行注入初始化，其底层机制是利用java反射来控制组件的访问，这简...
69道Spring面试题和答案
目录 Spring 概述依赖注入 Spring beans Spring注解 Spring数据访问 Spring...
java干货 | 最全 69 道 Spring 面试题和答案
目录 Spring 概述依赖注入 Spring beans Spring注解 Spring数据访问 Spring...

Spring注解之四组件注入

个人专题目录：

1.4. 组件注入

@Autowired&@Qualifier&@Primary@Resource&@Inject

方法、构造器位置的自动装配

依赖注入的方式

Aware注入Spring底层组件&原理

@Profile环境搭建&@Profile根据环境注册bean

相关文章

Spring依赖注入(IoC)的四种方式

细说Spring——IoC详解（注解驱动开发之包扫描过滤和Fac

spring给容器中注入组件的几种方式

Spring @Import注解

spring 源码学习②-盘点spring 组件注入的几种方式

Spring注解之四组件注入

Spring通过注解注入组件

Spring之autowired

69道Spring面试题和答案

java干货 | 最全 69 道 Spring 面试题和答案

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读