资讯专栏INFORMATION COLUMN

Spring【依赖注入】就是这么简单

Lyux / 3619人阅读

摘要:前言在的第二篇中主要讲解了模块的使用容器创建对象的问题,模块主要是解决对象的创建和对象之间的依赖关系,因此本博文主要讲解如何使用容器来解决对象之间的依赖关系回顾以前对象依赖我们来看一下我们以前关于对象依赖,是怎么的历程直接对象在最开始,我们

前言

在Spring的第二篇中主要讲解了Spring Core模块的使用IOC容器创建对象的问题,Spring Core模块主要是解决对象的创建和对象之间的依赖关系,因此本博文主要讲解如何使用IOC容器来解决对象之间的依赖关系

回顾以前对象依赖

我们来看一下我们以前关于对象依赖,是怎么的历程

直接new对象

在最开始,我们是直接new对象给serice的userDao属性赋值...

</>复制代码

  1. class UserService{
  2. UserDao userDao = new UserDao();
  3. }
写DaoFactory,用字符串来维护依赖关系

后来,我们发现service层紧紧耦合了dao层。我们就写了DaoFactory,在service层只要通过字符串就能够创建对应的dao层的对象了。

DaoFactory

</>复制代码

  1. public class DaoFactory {
  2. private static final DaoFactory factory = new DaoFactory();
  3. private DaoFactory(){}
  4. public static DaoFactory getInstance(){
  5. return factory;
  6. }
  7. public T createDao(String className,Class clazz){
  8. try{
  9. T t = (T) Class.forName(className).newInstance();
  10. return t;
  11. }catch (Exception e) {
  12. throw new RuntimeException(e);
  13. }
  14. }
  15. }

serivce

</>复制代码

  1. private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);
  2. private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);
  3. private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);
  4. private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);
DaoFactory读取配置文件

再后来,我们发现要修改Dao的实现类,还是得修改service层的源代码呀..于是我们就在DaoFactory中读取关于daoImpl的配置文件,根据配置文件来创建对象,这样一来,创建的是哪个daoImpl对service层就是透明的

DaoFactory

</>复制代码

  1. public class DaoFactory {
  2. private UserDao userdao = null;
  3. private DaoFactory(){
  4. try{
  5. InputStream in = DaoFactory.class.getClassLoader().getResourceAsStream("dao.properties");
  6. Properties prop = new Properties();
  7. prop.load(in);
  8. String daoClassName = prop.getProperty("userdao");
  9. userdao = (UserDao)Class.forName(daoClassName).newInstance();
  10. }catch (Exception e) {
  11. throw new RuntimeException(e);
  12. }
  13. }
  14. private static final DaoFactory instance = new DaoFactory();
  15. public static DaoFactory getInstance(){
  16. return instance;
  17. }
  18. public UserDao createUserDao(){
  19. return userdao;
  20. }
  21. }

service

</>复制代码

  1. UserDao dao = DaoFactory.getInstance().createUserDao();
Spring依赖注入

通过上面的历程,我们可以清晰地发现:对象之间的依赖关系,其实就是给对象上的属性赋值!因为对象上有其他对象的变量,因此存在了依赖...

Spring提供了好几种的方式来给属性赋值

1) 通过构造函数

2) 通过set方法给属性注入值

3) p名称空间

4)自动装配(了解)

5) 注解

搭建测试环境

UserService中使用userDao变量来维护与Dao层之间的依赖关系

UserAction中使用userService变量来维护与Service层之间的依赖关系

userDao

</>复制代码

  1. public class UserDao {
  2. public void save() {
  3. System.out.println("DB:保存用户");
  4. }
  5. }

userService

</>复制代码

  1. public class UserService {
  2. private UserDao userDao;
  3. public void save() {
  4. userDao.save();
  5. }
  6. }

userAnction

</>复制代码

  1. public class UserAction {
  2. private UserService userService;
  3. public String execute() {
  4. userService.save();
  5. return null;
  6. }
  7. }
构造函数给属性赋值

其实我们在讲解创建带参数的构造函数的时候已经讲过了...我们还是来回顾一下呗..

我们测试service和dao的依赖关系就好了....在serice中加入一个构造函数,参数就是userDao

</>复制代码

  1. public UserService(UserDao userDao) {
  2. this.userDao = userDao;
  3. //看看有没有拿到userDao
  4. System.out.println(userDao);
  5. }

applicationContext.xml配置文件

</>复制代码

测试:可以成功获取到userDao对象

</>复制代码

  1. // 创建容器对象
  2. ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  3. //得到service对象
  4. UserService userService = (UserService) ac.getBean("userService");

通过set方法给属性注入值

我们这里也是测试service和dao层的依赖关系就好了...在service层通过set方法来把userDao注入到UserService中

为UserService添加set方法

</>复制代码

  1. public class UserService {
  2. private UserDao userDao;
  3. public void setUserDao(UserDao userDao) {
  4. this.userDao = userDao;
  5. //看看有没有拿到userDao
  6. System.out.println(userDao);
  7. }
  8. public void save() {
  9. userDao.save();
  10. }
  11. }

applicationContext.xml配置文件:通过property节点来给属性赋值

引用类型使用ref属性

基本类型使用value属性

</>复制代码

测试:

内部Bean

我们刚才是先创建userDao对象,再由userService对userDao对象进行引用...我们还有另一种思维:先创建userService,发现userService需要userDao的属性,再创建userDao...我们来看看这种思维方式是怎么配置的:

applicationContext.xml配置文件:property节点内置bean节点

</>复制代码

测试

我们发现这种思维方式和服务器访问的执行顺序是一样的,但是如果userDao要多次被其他service使用的话,就要多次配置了...

p 名称空间注入属性值

p名称控件这种方式其实就是set方法的一种优化,优化了配置而已...p名称空间这个内容需要在Spring3版本以上才能使用...我们来看看:

applicationContext.xml配置文件:使用p名称空间

</>复制代码

测试

自动装配

Spring还提供了自动装配的功能,能够非常简化我们的配置

自动装载默认是不打开的,自动装配常用的可分为两种:

根据名字来装配

根据类型类装配

XML配置根据名字

applicationContext.xml配置文件:使用自动装配,根据名字

</>复制代码

测试

XML配置根据类型

applicationContext.xml配置文件:使用自动装配,根据类型

值得注意的是:如果使用了根据类型来自动装配,那么在IOC容器中只能有一个这样的类型,否则就会报错!

</>复制代码

测试:

我们这只是测试两个对象之间的依赖关系,如果我们有很多对象,我们也可以使用默认自动分配

使用注解来实现自动装配

@Autowired注解来实现自动装配:

可以在构造器上修饰

也可以在setter方法上修饰

来自java的@Inject的和@AutoWired有相同的功能

如果没有匹配到bean,又为了避免异常的出现,我们可以使用required属性上设置为false。【谨慎对待】

测试代码

</>复制代码

  1. @Component
  2. public class UserService {
  3. private UserDao userDao ;
  4. @Autowired
  5. public void setUserDao(UserDao userDao) {
  6. this.userDao = userDao;
  7. }
  8. }

顺利拿到userDao的引用

使用JavaConfig配置类实现对象依赖

有两种方法(但我测试不出来,如果会的请在评论去告诉我.....)

第一种(测试不出来)

</>复制代码

  1. import org.springframework.context.annotation.Bean;
  2. @org.springframework.context.annotation.Configuration
  3. public class Configuration {
  4. @Bean()
  5. public UserDao userDao() {
  6. return new UserDao();
  7. }
  8. @Bean
  9. public UserService userService() {
  10. //直接调用@bean的方法
  11. return new UserService(userDao());
  12. }
  13. }

第二种(测试不出来)

</>复制代码

  1. import org.springframework.context.annotation.Bean;
  2. @org.springframework.context.annotation.Configuration
  3. public class Configuration {
  4. @Bean()
  5. public UserDao userDao() {
  6. return new UserDao();
  7. }
  8. @Bean
  9. public UserService userService(UserDao userDao) {
  10. //通过构造函数依赖注入
  11. return new UserService(userDao);
  12. }
  13. }

如果我直接通过构造器传入的话,那么报错了

</>复制代码

  1. import org.springframework.beans.factory.annotation.Autowire;
  2. import org.springframework.context.annotation.Bean;
  3. @org.springframework.context.annotation.Configuration
  4. public class Configuration {
  5. @Bean()
  6. public UserDao userDao() {
  7. return new UserDao();
  8. }
  9. @Bean(autowire = Autowire.BY_TYPE)
  10. public UserService userService(UserDao userDao) {
  11. return new UserService(userDao);
  12. }
  13. }

我测试中只有通过这种方法才能拿到userDao的引用。

</>复制代码

  1. public class Configuration {
  2. @Bean()
  3. public UserDao userDao() {
  4. return new UserDao();
  5. }
  6. @Bean(autowire = Autowire.BY_TYPE)
  7. public UserService userService() {
  8. return new UserService(userDao());
  9. }
  10. }

当然了,最简单直观的方法还有一种:在UserService中加入setUser()方法,那么只要set进去就行了..

UserService

</>复制代码

  1. public class UserService {
  2. private UserDao userDao ;
  3. public UserService() {
  4. }
  5. public UserService(UserDao userDao) {
  6. }
  7. public void setUserDao(UserDao userDao) {
  8. this.userDao = userDao;
  9. }
  10. }

Config

</>复制代码

  1. import org.springframework.context.annotation.Bean;
  2. @org.springframework.context.annotation.Configuration
  3. public class Config1 {
  4. @Bean(name = "userDao")
  5. public UserDao userDao() {
  6. return new UserDao();
  7. }
  8. @Bean(name="userService")
  9. public UserService userService() {
  10. UserService userService = new UserService();
  11. userService.setUserDao(userDao());
  12. return userService;
  13. }
  14. }

最后

扩展阅读:

https://zhuanlan.zhihu.com/p/29426019

</>复制代码

  1. 如果文章有错的地方欢迎指正,大家互相交流。习惯在微信看技术文章,想要获取更多的Java资源的同学,可以关注微信公众号:Java3y

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/68793.html

相关文章

  • Spring IOC知识点一网打尽!

    摘要:使用的好处知乎的回答不用自己组装,拿来就用。统一配置,便于修改。 前言 只有光头才能变强 回顾前面: 给女朋友讲解什么是代理模式 包装模式就是这么简单啦 单例模式你会几种写法? 工厂模式理解了没有? 在刷Spring书籍的时候花了点时间去学习了单例模式和工厂模式,总的来说还是非常值得的! 本来想的是刷完《Spring 实战 (第4版)》和《精通Spring4.x 企业应用开发实战》...

    djfml 评论0 收藏0
  • Spring还可以这么学--IoC(控制反转) / DI(依赖注入)理解

    摘要:对象之间耦合度过高的系统,必然会出现牵一发而动全身的情形。控制被反转之后,获得依赖对象的过程由自身管理变为了由容器主动注入。于是,他给控制反转取了一个更合适的名字叫做依赖注入。 Spring还可以这么学--IoC(控制反转) / DI(依赖注入)理解 声明:文章的前三部分参考博文:https://www.cnblogs.com/Nouno...这篇文章首发是在我的个人微信订阅号每天学编...

    atinosun 评论0 收藏0
  • Spring入门IOC和AOP学习笔记

    摘要:入门和学习笔记概述框架的核心有两个容器作为超级大工厂,负责管理创建所有的对象,这些对象被称为。中的一些术语切面切面组织多个,放在切面中定义。 Spring入门IOC和AOP学习笔记 概述 Spring框架的核心有两个: Spring容器作为超级大工厂,负责管理、创建所有的Java对象,这些Java对象被称为Bean。 Spring容器管理容器中Bean之间的依赖关系,使用一种叫做依赖...

    wenyiweb 评论0 收藏0
  • 面试被问烂的 Spring IOC(求求你别再问了)

    摘要:例如资源的获取,支持多种消息例如的支持,对多了工具级别的支持等待。最上面的知道吧我就不讲了。生命周期事件回调等。他支持不同信息源头,支持工具类,支持层级容器,支持访问文件资源,支持事件发布通知,支持接口回调等等。 广义的 IOC IoC(Inversion of Control) 控制反转,即不用打电话过来,我们会打给你。 两种实现: 依赖查找(DL)和依赖注入(DI)。 IOC 和...

    denson 评论0 收藏0
  • Spring框架之我见(三)——IOC、AOP

    摘要:模块负责的所有面向切面的功能。总结的统一管理,降低了对象之间的耦合对主流的框架提供了很好的集成支持提供众多组件,事务管理,等具有高度可开放性,开发者可以自由选择部分或全部主要使用工厂模式和代理模式。 聊完了Spring框架中最重要的两种设计模式,我们来看一下Spring框架的模块和结构图。 Spring框架的结构 下图是Spring官方给出的Spring框架的结构图。 showImg(...

    khs1994 评论0 收藏0

发表评论

0条评论

Lyux

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<