Spring 注解驱动开发_自动装配

已于 2022-04-03 21:47:19 修改
阅读量345 收藏
点赞数
分类专栏： Spring 文章标签： spring
于 2022-03-28 13:45:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingd1234/article/details/123793485
版权

一、Autowired

创建 BookController、BookService、BookDao，并通过 @Autowired 注解将 BookService 注入到 BookController 中，将 BookDao 注入到 BookService 中

BookDao：

package org.example.dao;

import org.springframework.stereotype.Repository;

@Repository
public class BookDao {
}

BookService：

package org.example.service;

import org.example.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {

    @Autowired
    private BookDao bookDao;

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

BookController：

package org.example.controller;

import org.example.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class BookController {

    @Autowired
    private BookService bookService;
}

配置类，通过 @ComponentScan 注解将上述三个类扫描到容器中：

package org.example.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@ComponentScan({"org.example.controller","org.example.service","org.example.dao"})
@Configuration
public class MainConfigOfAutowired {
}

测试方法，验证通过自动注入的方式以及直接从容器中获取这两种方式得到的 BookDao 是否是同一个：

@Test
public void testAutowired(){
     ApplicationContext ac = new AnnotationConfigApplicationContext(MainConfigOfAutowired.class);
     BookService bookService = ac.getBean(BookService.class);
     System.out.println(bookService);

     BookDao bookDao = ac.getBean(BookDao.class);
     System.out.println(bookDao);
 }

测试结果：
在这里插入图片描述
结果证明，两种获取方式得到的 BookDao 为同一个。

@Autowired默认是根据类型进行注入的，因此如果有多个类型一样的Bean候选者，则需要限定其中一个候选者，否则将抛出异常

二、@Qualifier 注解

创建 PersonDao

package org.example.dao;

public interface PersonDao {

}

创建 PersonDao 的两个实现类 PersonDaoImpl01 和 PersonDaoImpl02

PersonDaoImpl01

package org.example.dao.impl;

import org.example.dao.PersonDao;
import org.springframework.stereotype.Repository;

@Repository("personDao01")
public class PersonDaoImpl01 implements PersonDao {
}

PersonDaoImpl02

package org.example.dao.impl;

import org.example.dao.PersonDao;
import org.springframework.stereotype.Repository;

@Repository("personDao02")
public class PersonDaoImpl02 implements PersonDao {
}

PersonService

package org.example.service;

import org.example.dao.PersonDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class PersonService {

    @Qualifier("personDao02")
    @Autowired
    private PersonDao personDao;

    public void print(){
        System.out.println(personDao);
    }
}

PersonDao 接口有多个实现类，而在 PersonService 中注入 PersonDao 时，Spring 会不确定注入哪一个实现类。而 @Qualifier 可以解决这个问题。

测试方法：

@Test
public void testAutowiredPerson(){
    ApplicationContext ac = new AnnotationConfigApplicationContext(MainConfigOfAutowired.class);
    PersonService personService = ac.getBean(PersonService.class);
    personService.print();

}

测试结果：
在这里插入图片描述
取出的是 PersonDaoImpl02 实现类

三、@Primary 注解

@Primary注解可以让 Spring 进行自动装配的时候，默认使用首选的 bean

在 PersonDaoImpl01 上使用 @Primary 注解：

package org.example.dao.impl;

import org.example.dao.PersonDao;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Repository;

@Primary
@Repository("personDao01")
public class PersonDaoImpl01 implements PersonDao {
}

PersonDaoImpl02 保持不变

PersonService 去掉 @Qualifier 注解

package org.example.service;

import org.example.dao.PersonDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class PersonService {

    @Autowired
    private PersonDao personDao;

    public void print(){
        System.out.println(personDao);
    }
}

测试代码不变，测试结果如下：
在这里插入图片描述

四、@Resource 注解

@Resource：可以根据类型注入，也可以根据名称注入

PersonService 使用 @Resource 注解进行注入

package org.example.service;

import org.example.dao.PersonDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;


@Service
public class PersonService {

    @Resource(name = "personDao02")
    private PersonDao personDao;

    public void print(){
        System.out.println(personDao);
    }
}

测试代码不变，测试结果：
在这里插入图片描述

五、Aware 接口注入 Spring 底层组件

自定义组件实现 XXXAware，在创建对象的时候，会调用接口规定的方法注入相关组件。Aware 会把 Spring 底层一些组件注入到自定义的 bean 中。

package org.example.pojo;

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 Color implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {

    private ApplicationContext applicationContext;

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

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

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

配置文件：

package org.example.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@ComponentScan({"org.example.controller","org.example.service","org.example.dao","org.example.pojo"})
@Configuration
public class MainConfigOfAutowired {

}

测试代码：

 @Test
 public void testAware(){
     ApplicationContext ac = new AnnotationConfigApplicationContext(MainConfigOfAutowired.class);
     String[] beanDefinitionNames = ac.getBeanDefinitionNames();
     for (String beanDefinitionName : beanDefinitionNames) {
         System.out.println(beanDefinitionName);
     }
 }

测试结果：
在这里插入图片描述

六、@Profile 注解

@Profile 注解可以指定组件在哪个环境的情况下才能被注册到容器中，如果未指定，则任何环境下都可以注册

  • 添加了 @Profile 注解的 bean，只有在该环境被激活的时候才能注册到容器中，默认是 default 环境
  • 当 @Profile 注解标注在配置类上时，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效。

pom 文件

创建 dbconfig.properties

db.user=root
db.password=root
db.driverClass=com.mysql.cj.jdbc.Driver

创建 MaiinTestOfProfile 配置类

package org.example.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.example.pojo.Yellow;
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;

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

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

    private String driverClass;

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

    @Profile("testDataSource")
    @Bean
    public DataSource dataSourceTest(@Value("${db.password}") String password){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setUser(user);
            dataSource.setPassword(password);
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test?serverTimezone=GMT&useSSL=false&useUnicode=true&characterEncoding=utf8");
            dataSource.setDriverClass(driverClass);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

    @Profile("devDataSource")
    @Bean
    public DataSource dataSourceDev(@Value("${db.password}") String password){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setUser(user);
            dataSource.setPassword(password);
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/sys?serverTimezone=GMT&useSSL=false&useUnicode=true&characterEncoding=utf8");
            dataSource.setDriverClass(driverClass);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

    @Profile("prodDataSource")
    @Bean
    public DataSource dataSourceProd(@Value("${db.password}") String password){
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        try {
            dataSource.setUser(user);
            dataSource.setPassword(password);
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mysql?serverTimezone=GMT&useSSL=false&useUnicode=true&characterEncoding=utf8");
            dataSource.setDriverClass(driverClass);
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        }
        return dataSource;
    }

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

测试方法

@Test
public void testProfile01(){
    // 创建 ApplicationContext
    AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    // 设置需要激活的环境
    ac.getEnvironment().setActiveProfiles("testDataSource", "devDataSource");
    // 注册主配置类
    ac.register(MainConfigOfProfile.class);
    // 刷新容器
    ac.refresh();
    String[] beanDefinitionNames = ac.getBeanDefinitionNames();
    for (String beanDefinitionName : beanDefinitionNames) {
        System.out.println(beanDefinitionName);
    }
}

测试结果：
在这里插入图片描述

喵先森爱吃鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring注解驱动开发
weixin_52055811的博客
01-08 686
Spring注解驱动开发
Spring注解驱动开发实战-annotation
02-16
Spring注解驱动开发实战 组件注册，生命周期，自动装配
Spring 注解驱动开发（五）—自动装配
小小葩的博客
01-12 132
自动装配：Spring 利用依赖注入(DI)，完成对IOC容器中各个组件的依赖关系赋值 相关注解：@Autowired @Resource @Inject 例子如下，还有其他的组件可了解 这样applicationContext就被注入到Red实例中了 ...
spring注解驱动系列--自动装配
weixin_42972832的博客
03-03 597
1、默认优先按照类型去容器中找对应的组件；2、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找3、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名4、自动装配默认一定要将属性赋值好，没有就会报错；可以使用@Autowired(required=false);5、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；也可以继续使用@Qualifier指定需要装配的bean的名字。
Spring注解驱动开发（四）
越努力越幸运的博客
01-16 2397
Spring注解驱动开发（四）AOP-AOP功能测试[源码]-AOP原理-`@EnableAspectJAutoProxy`[源码]-AOP原理-AnnotationAwareAspectJAutoProxyCreator分析[源码]-AOP原理-注册AnnotationAwareAspectJAutoProxyCreator[源码]-AOP原理-AnnotationAwareAspectJAut...
Spring注解驱动开发——自动装配(1)
如不來的博客
03-20 271
自动装配：Spring利用依赖注入(DI)，完成对IOC容器中各个组件的依赖赋值 1、@Autowired: 默认先按照类型去容器中找相应的组件(applicationContext.getBean(Xxx.class))，若只找到一个则进行装配，若找到多个则再按照属性的名称作为id找对应的组件(applicationContext.getBean("beanId"));另外可使用@Q...
Spring注解驱动开发——IOC的常用注解
紫罗兰与海棠的博客
01-07 1457
一、用于注解驱动的注解 @Configuration (一) 作用 它是在spring3.0版本之后加入的。此注解是spring支持注解驱动开发的一个标志。表明当前类是spring的一个配置类，作用是替代spring的applicationContext.xml。但其本质就是@Component注解，被此注解修饰的类，也会被存入spring的ioc容器。 (二) 属性 value:用于存入spring的Ioc容器中Bean的id。 (三) 本质 就是@Component注解，被此注解修饰的类，也会被存入s
Spring Boot：注解驱动开发综合指南
陈书予
03-23 7514
Spring Boot注解是一种特殊的注释，用于指示Spring Boot框架应该如何配置应用程序。Spring Boot注解可以用于许多不同的方面，包括配置文件、控制器、服务、数据访问、安全性和测试。
spring注解驱动开发
qq_34429554的博客
07-20 153
aop面向切面编程，指程序运行期间动态的将某段代码切入到指定方法指定位置执行的编程方式。2种方式激活某个环境数据源。spring思想总结。
Spring注解驱动_目录
Mo_Ming_的博客
07-03 337
文章目录官方视频IOC容器AOP切面声明式事务扩展原理web相关 重要参考 https://liayun.blog.csdn.net/article/details/115053350 官方视频 https://www.bilibili.com/video/BV1gW411W7wy 尚硅谷Spring注解驱动教程(雷丰阳源码级讲解) IOC容器 Spring注解驱动开发第1讲——今天，我
Spring 注解开发详解
xiaotiaoza的博客
04-24 854
我们在注入bean对象时，可选的方式有很多种。例如：我们自己写的类，可以使用@Component,@Service,@Repository,@Controller等等。我们导入第三方库中的类时可以使用@Bean(当需要做一些初始化操作时，比如DataSource)，也可以使用@Import注解，直接指定要引入的类的字节码。但当我们的类很多时，在每个类上加注解会很繁琐，同时使用@Bean或者@Import写起来也很麻烦。此时我们就可以采用自定义或者来实现。
springLean:spring注解驱动开及源码分析
03-24
spring注解驱动开及源码分析 目录 1，组件注册 2，生命周期 3，属性赋值 4，自动装配 5，IOC小结 6，AOP源码分析 7，声明式事务演示 8，扩展原理 8.1-BeanFactoryPostProcessor 8.2-...
基于注解驱动的 Spring MVC
04-13
接下来，我们深入理解 Spring MVC 中的注解驱动配置： 1. **@Autowired** 注解：在 BbtForumController 类中，我们看到了 @Autowired 注解用于注入 BbtForumService 实例。这是 Spring 自动装配依赖的一种方式，它...
spring注解完整版[定义].pdf
10-12
这些注解共同构建了Spring的注解驱动IoC功能，使得开发更加便捷高效。 注解配置相比XML配置的优势还包括： 1. 更少的配置文件：通过注解，我们可以减少XML配置文件的数量和复杂性，使项目更易于维护。 2. 结构清晰...
Spring 2.5 基于注解驱动的 Spring MVC.docx
09-01
ler 主要是处理 HTTP 请求，所以 @Controller 更具针对性，它标识了一个类作为 Spring MVC 的控制器。... ...随着 Spring 框架的不断发展，注解驱动的编程模式已经成为现代 Java Web 开发的标准实践。
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
gb4215287的博客
06-21 300
springboot中获取某个注解下面的某个方法的方法名，参数值等等详细实例
Vue + SpringBoot 实现文件的断点上传、秒传，存储到Minio
m0_73179389的博客
06-19 582
前端页面使用的elment-plus的el-upload组件。当上传文件后，会调用handleChange 方法，可以在这里进行文件相关的操作。计算文件的MD5值。
kafka（五）spring-kafka（2）详解与demo
最新发布
w_t_y_y的博客
06-22 202
一、收发demo 1、生产者 2、消费者-1 3、消费者-2
小白快速入门之SpringBoot面向切面编程（AOP）
weixin_42415173的博客
06-18 212
AOP、切面编程、SpringBoot
Spring注解驱动开发1
08-03
Spring注解驱动开发是一种使用注解来驱动Spring框架进行开发的方式。本文整理于csdn博主 "让优秀成为你的习惯" 的笔记，主要涉及组件注册和@Configuration注解。 在传统的Spring开发中，我们需要在XML配置文件中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值