Java依赖注入 - DI设计模式示例教程

最新推荐文章于 2024-07-05 23:29:00 发布
最新推荐文章于 2024-07-05 23:29:00 发布
阅读量1.6k 收藏 7
点赞数 3
分类专栏： Unix&Unix-Like Java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aria_Miazzy/article/details/88376604
版权

Java依赖注入 - DI设计模式示例教程

 

Java依赖注入 设计模式允许我们删除硬编码的依赖项，并使我们的应用程序松散耦合，可扩展和可维护。我们可以在java中实现依赖注入，以将依赖项解析从编译时移动到运行时。

目录[ 隐藏 ]

Java依赖注入

Java依赖注入，Java示例教程中的依赖注入
Java依赖注入似乎很难用理论来理解，所以我将举一个简单的例子然后我们将看到如何使用依赖注入模式来实现应用程序中的松散耦合和可扩展性。

假设我们有一个EmailService用于发送电子邮件的应用程序。通常我们会像下面这样实现它。


package com.journaldev.java.legacy;

public class EmailService {

	public void sendEmail(String message, String receiver){
		//logic to send email
		System.out.println("Email sent to "+receiver+ " with Message="+message);
	}
}

EmailServiceclass拥有将电子邮件消息发送到收件人电子邮件地址的逻辑。我们的应用程序代码如下所示。


package com.journaldev.java.legacy;

public class MyApplication {

	private EmailService email = new EmailService();
	
	public void processMessages(String msg, String rec){
		//do some msg validation, manipulation logic etc
		this.email.sendEmail(msg, rec);
	}
}

我们将使用MyApplication类发送电子邮件的客户端代码如下所示。


package com.journaldev.java.legacy;

public class MyLegacyTest {

	public static void main(String[] args) {
		MyApplication app = new MyApplication();
		app.processMessages("Hi Pankaj", "pankaj@abc.com");
	}

}

初看起来，上面的实现似乎没有错。但上面的代码逻辑有一定的局限性。

  • MyApplicationclass负责初始化电子邮件服务然后使用它。这导致了硬编码的依赖性。如果我们希望将来切换到其他一些高级电子邮件服务，则需要在MyApplication类中进行代码更改。这使我们的应用程序难以扩展，如果在多个类中使用电子邮件服务，那将更加困难。
  • 如果我们想扩展我们的应用程序以提供其他消息传递功能，例如SMS或Facebook消息，那么我们需要为此编写另一个应用程序。这将涉及应用程序类和客户端类中的代码更改。
  • 由于我们的应用程序直接创建电子邮件服务实例，因此测试应用程序将非常困难。我们无法在测试类中模拟这些对象。

可以说我们可以MyApplication通过使用需要电子邮件服务作为参数的构造函数来从类中删除电子邮件服务实例创建。


package com.journaldev.java.legacy;

public class MyApplication {

	private EmailService email = null;
	
	public MyApplication(EmailService svc){
		this.email=svc;
	}
	
	public void processMessages(String msg, String rec){
		//do some msg validation, manipulation logic etc
		this.email.sendEmail(msg, rec);
	}
}

但在这种情况下，我们要求客户端应用程序或测试类初始化不是一个好的设计决策的电子邮件服务。

现在让我们看看我们如何应用java依赖注入模式来解决上述实现的所有问题。java中的依赖注入至少需要以下内容：

  1. 服务组件应设计为基类或接口。最好选择定义服务契约的接口或抽象类。
  2. 消费者类应该根据服务接口编写。
  3. 注入器类将初始化服务，然后是消费者类。

Java依赖注入 - 服务组件

对于我们的情况，我们可以MessageService声明服务实现的合同。


package com.journaldev.java.dependencyinjection.service;

public interface MessageService {

	void sendMessage(String msg, String rec);
}

现在让我们说我们有实现上述接口的电子邮件和短信服务。


package com.journaldev.java.dependencyinjection.service;

public class EmailServiceImpl implements MessageService {

	@Override
	public void sendMessage(String msg, String rec) {
		//logic to send email
		System.out.println("Email sent to "+rec+ " with Message="+msg);
	}

}


package com.journaldev.java.dependencyinjection.service;

public class SMSServiceImpl implements MessageService {

	@Override
	public void sendMessage(String msg, String rec) {
		//logic to send SMS
		System.out.println("SMS sent to "+rec+ " with Message="+msg);
	}

}

我们的依赖注入java服务已准备就绪，现在我们可以编写我们的消费者类。

Java依赖注入 - 服务使用者

我们不需要为消费者类提供基本接口，但我将有一个Consumer接口声明消费者类的合同。


package com.journaldev.java.dependencyinjection.consumer;

public interface Consumer {

	void processMessages(String msg, String rec);
}

我的消费者类实现如下。


package com.journaldev.java.dependencyinjection.consumer;

import com.journaldev.java.dependencyinjection.service.MessageService;

public class MyDIApplication implements Consumer{

	private MessageService service;
	
	public MyDIApplication(MessageService svc){
		this.service=svc;
	}
	
	@Override
	public void processMessages(String msg, String rec){
		//do some msg validation, manipulation logic etc
		this.service.sendMessage(msg, rec);
	}

}

请注意，我们的应用程序类只是使用该服务。它没有初始化导致更好的“ 关注点分离 ”的服务。使用服务接口还允许我们通过模拟MessageService轻松测试应用程序，并在运行时而不是编译时绑定服务。

现在我们准备编写初始化服务和消费者类的java依赖注入器类。

Java依赖注入 - 注入器类

让我们有一个MessageServiceInjector返回Consumer类的方法声明接口。


package com.journaldev.java.dependencyinjection.injector;

import com.journaldev.java.dependencyinjection.consumer.Consumer;

public interface MessageServiceInjector {

	public Consumer getConsumer();
}

现在，对于每项服务，我们都必须创建如下所示的注入类。

 


package com.journaldev.java.dependencyinjection.injector;

import com.journaldev.java.dependencyinjection.consumer.Consumer;
import com.journaldev.java.dependencyinjection.consumer.MyDIApplication;
import com.journaldev.java.dependencyinjection.service.EmailServiceImpl;

public class EmailServiceInjector implements MessageServiceInjector {

	@Override
	public Consumer getConsumer() {
		return new MyDIApplication(new EmailServiceImpl());
	}

}


package com.journaldev.java.dependencyinjection.injector;

import com.journaldev.java.dependencyinjection.consumer.Consumer;
import com.journaldev.java.dependencyinjection.consumer.MyDIApplication;
import com.journaldev.java.dependencyinjection.service.SMSServiceImpl;

public class SMSServiceInjector implements MessageServiceInjector {

	@Override
	public Consumer getConsumer() {
		return new MyDIApplication(new SMSServiceImpl());
	}

}

现在让我们看看我们的客户端应用程序如何通过一个简单的程序使用该应用程序。


package com.journaldev.java.dependencyinjection.test;

import com.journaldev.java.dependencyinjection.consumer.Consumer;
import com.journaldev.java.dependencyinjection.injector.EmailServiceInjector;
import com.journaldev.java.dependencyinjection.injector.MessageServiceInjector;
import com.journaldev.java.dependencyinjection.injector.SMSServiceInjector;

public class MyMessageDITest {

	public static void main(String[] args) {
		String msg = "Hi Pankaj";
		String email = "pankaj@abc.com";
		String phone = "4088888888";
		MessageServiceInjector injector = null;
		Consumer app = null;
		
		//Send email
		injector = new EmailServiceInjector();
		app = injector.getConsumer();
		app.processMessages(msg, email);
		
		//Send SMS
		injector = new SMSServiceInjector();
		app = injector.getConsumer();
		app.processMessages(msg, phone);
	}

}

如您所见，我们的应用程序类仅负责使用该服务。服务类在注入器中创建。此外，如果我们必须进一步扩展我们的应用程序以允许Facebook消息传递，我们将只需编写服务类和注入类。

因此，依赖注入实现解决了硬编码依赖的问题，并帮助我们使应用程序灵活且易于扩展。现在让我们看看我们可以通过模拟注入器和服务类来轻松测试我们的应用程序类。

Java依赖注入 - 使用模拟注入器和服务的JUnit测试用例


package com.journaldev.java.dependencyinjection.test;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.journaldev.java.dependencyinjection.consumer.Consumer;
import com.journaldev.java.dependencyinjection.consumer.MyDIApplication;
import com.journaldev.java.dependencyinjection.injector.MessageServiceInjector;
import com.journaldev.java.dependencyinjection.service.MessageService;

public class MyDIApplicationJUnitTest {

	private MessageServiceInjector injector;
	@Before
	public void setUp(){
		//mock the injector with anonymous class
		injector = new MessageServiceInjector() {
			
			@Override
			public Consumer getConsumer() {
				//mock the message service
				return new MyDIApplication(new MessageService() {
					
					@Override
					public void sendMessage(String msg, String rec) {
						System.out.println("Mock Message Service implementation");
						
					}
				});
			}
		};
	}
	
	@Test
	public void test() {
		Consumer consumer = injector.getConsumer();
		consumer.processMessages("Hi Pankaj", "pankaj@abc.com");
	}
	
	@After
	public void tear(){
		injector = null;
	}

}

正如您所看到的，我使用匿名类来模拟注入器和服务类，我可以轻松地测试我的应用程序方法。我在上面的测试类中使用JUnit 4，因此如果你在测试类之上运行，请确保它在你的项目构建路径中。

我们使用构造函数在应用程序类中注入依赖项，另一种方法是使用setter方法在应用程序类中注入依赖项。对于setter方法依赖注入，我们的应用程序类将如下所示实现。


package com.journaldev.java.dependencyinjection.consumer;

import com.journaldev.java.dependencyinjection.service.MessageService;

public class MyDIApplication implements Consumer{

	private MessageService service;
	
	public MyDIApplication(){}

	//setter dependency injection	
	public void setService(MessageService service) {
		this.service = service;
	}

	@Override
	public void processMessages(String msg, String rec){
		//do some msg validation, manipulation logic etc
		this.service.sendMessage(msg, rec);
	}

}


package com.journaldev.java.dependencyinjection.injector;

import com.journaldev.java.dependencyinjection.consumer.Consumer;
import com.journaldev.java.dependencyinjection.consumer.MyDIApplication;
import com.journaldev.java.dependencyinjection.service.EmailServiceImpl;

public class EmailServiceInjector implements MessageServiceInjector {

	@Override
	public Consumer getConsumer() {
		MyDIApplication app = new MyDIApplication();
		app.setService(new EmailServiceImpl());
		return app;
	}

}

setter依赖注入的最好例子之一是Struts2 Servlet API Aware接口。

是否使用基于构造函数的依赖注入或基于setter是一个设计决策，取决于您的要求。例如，如果我的应用程序在没有服务类的情况下根本无法工作，那么我会更喜欢基于构造函数的DI，否则我会选择基于setter方法的DI来仅在真正需要时使用它。

Java中的依赖注入是一种通过将对象从编译时绑定到运行时来实现应用程序中的控制反转（IoC）的方法。我们也可以通过工厂模式，模板方法设计模式，策略模式和服务定位模式来实现IoC 。

Spring依赖注入， Google Guice和 Java EE CDI框架通过使用 Java Reflection API和 Java注释来促进依赖注入的过程。我们所需要的只是注释字段，构造函数或setter方法，并在配置xml文件或类中配置它们。

Java依赖注入的好处

在Java中使用依赖注入的一些好处是：

  • 关注点分离
  • Boilerplate应用程序类中的代码减少，因为初始化依赖项的所有工作都由注入器组件处理
  • 可配置组件使应用程序易于扩展
  • 使用模拟对象可以轻松进行单元测试

Java依赖注入的缺点

Java依赖注入也有一些缺点：

  • 如果过度使用，则可能导致维护问题，因为更改的影响在运行时已知。
  • java中的依赖注入隐藏了可能导致在编译时捕获的运行时错误的服务类依赖项。

下载依赖注入项目

这就是java中依赖注入模式的全部内容。当我们控制服务时，了解并使用它是很好的。

 

原创翻译 原文：https://www.journaldev.com/2394/java-dependency-injection-design-pattern-example-tutorial

星河_赵梓宇
关注
专栏目录
Java代码实现依赖注入
12-20
模仿Spring实现一种基于xml配置文件的依赖注入机制。文件中将实现3中注入，一是单值注入，包括int,float，double，char等，也包括String注入；二是Java容器注入，包括List，Set，Map三种容器的注入，最后一种是java bean对象注入。
Java 新手入门：依赖注入的 N 种姿势，总有一款适合你！
最新发布
qq_36807888的博客
08-08 491
OrderService 强依赖于 ProductService 和 UserService 的具体实现，如果要替换成其他实现，就需要修改 OrderService 的代码。在 CoffeeMaker 类的字段上使用 @Autowired 注解，告诉 Spring 容器在创建 CoffeeMaker 对象后，自动为这些字段注入依赖的对象。简单来说，依赖注入就是将一个对象所依赖的其他对象，通过外部的方式传递进来，而不是由对象本身来创建。这样做的好处是可以降低代码耦合度，提高代码的可重用性和可测试性。
java中依赖注入_java设计模式之--依赖注入
weixin_29343807的博客
02-19 299
Author：Bob(林补)Date：2016/04/30代码托管在开源中国：hws/JavaDesignPatterns依赖注入的设计模式允许我们移除硬编码的依赖让我们的应用程序更加具有可拓展性和维护性。我们可以实现依赖注入模式，以实现从编译时到运行时的依赖。依赖注入模式似乎很难用理论来把握，所以我会拿一个简单的例子，然后我们将看到如何使用依赖注入模式来实现应用程序中的松散耦合和扩展性。在任何J...
java的依赖注入_Java依赖注入
weixin_39830323的博客
02-20 244
转自：https://zhidao.baidu.com/question/1822852890089115988.html假设你编写了两个类，一个是人(Person)，一个是手机(Mobile)。人有时候需要用手机打电话，需要用到手机的callUp方法。传统的写法是这样:Java codepublic class Person{public boolean makeCall(long number...
依赖注入方法
weixin_33862188的博客
11-11 137
1.属性注入 2.构造函数注入 需要带属性的构造方法 3.通过索引注入 4.工厂注入 实质是创建一个创建对象的类：如A为实体类，然后B为创建实体A的类，B中有一个方法创建并实例化A对象然后返回A对象实例。 5.静态工厂注入，当工厂的方法为静态方法时，不需要创建工厂的bean。 不需要创建工厂类的对象 转载于:https://www.cnb...
Android应用源码之用Roboguice实现依赖注入--IT计算机-毕业设计.zip
04-06
在Android应用开发中，依赖注入（Dependency Injection，简称DI）是一种设计模式，它可以帮助开发者减少代码之间的耦合，提高代码的可测试性和可维护性。本项目以"Android应用源码之用Roboguice实现依赖注入"为主题...
play-java-compile-di-example.zip_java_play
09-24
在Java中，依赖注入是一种设计模式，它允许对象之间的关系在运行时动态地建立，而不是硬编码在类内部。这使得代码更灵活，更易于测试和维护。Play框架通过Guice库支持编译时DI，Guice是Google提供的一款轻量级依赖...
java Spring DI依赖注入.rar
01-30
依赖注入是一种设计模式，它允许我们解耦组件，提高代码的可测试性和可维护性。Spring框架通过DI来管理对象的生命周期和对象间的依赖关系，使得开发者无需在代码中硬编码依赖对象的创建和获取。 在Spring框架中，...
spring-di：Spring依赖注入
02-19
依赖注入是一种设计模式，它允许我们解耦组件之间的依赖关系，将对象的创建和使用分离。在传统的Java编程中，一个类通常会直接创建或查找它所依赖的对象，这种方式导致了紧耦合，使得代码难以复用和测试。Spring框架...
用Roboguice实现依赖注入-.zip
07-30
依赖注入是一种设计模式，它允许我们解耦代码，提高组件之间的可测试性和可维护性。在Android开发中，Roboguice是一个轻量级的框架，它基于Google的Guice库，专门针对Android进行了优化，使得依赖注入变得更加简单。...
java中spring依赖注入的简单例子
03-11
javaEE 开发中 现在最成熟的框架之一应该就是spring了 spring框架最强大的地方就是实现了依赖注入 也叫控制反转 最近的一个项目中用的就是 spring框架 spring框架是工厂模式的应用结合了ＭＶＣ的设计思想 大家可以看到在spring框架中到处体现工厂模式 下面是一个简单的例子 依赖注入早期叫控制反转 也可以称反射 他们的意义都相同 当某个 Java 实例 调用者 需要另一个Java 实例 被调用者 时 在传统的程序设计过程中 通常由调用者来创建被调用者的实例 而在依赖注入的模式下 创建被调用者的工作 也就是实例化一个类 不再由调用者来完成 通常由 Spring 容器来完成 然后注入调用者 因此称为控制反转 也称为依赖注入 ">javaEE 开发中 现在最成熟的框架之一应该就是spring了 spring框架最强大的地方就是实现了依赖注入 也叫控制反转 最近的一个项目中用的就是 spring框架 spring框架是工厂模式的应用结合了ＭＶＣ的设计思想 大家可以看到在spring框 [更多]
Java 基础知识之 依赖注入（Dependency Injection）
李斯维的博客空间
07-05 1432
本文介绍了在 Java 开发中常用的 依赖注入 设计模式的基本概念，并演示了使用和不使用依赖注入时代码的区别及影响，详细说明了依赖注入的4种方式，最后介绍了几个常用的依赖注入框架。
JAVA的依赖注入--搞不定的方式
06-20 691
依赖注入是 Java 后端开发的基础技术之一，有助于构建针对现代软件需求量身定制的弹性和可扩展应用程序。DI 用于通过将依赖项外部化类本身、简化代码维护、促进模块化和增强可测试性来简化依赖项管理。为什么这种技术对 Java 开发人员至关重要？它如何有效解决常见的痛点？在本文中，我将向您介绍依赖注入的实际好处、基本实践和实际应用。让我们来探讨一下 Java 后端应用程...
Java依赖注入
weixin_30455067的博客
02-21 84
Java依赖注入设计原则允许我们移除硬编码依赖和让我们的应用低耦合，可扩展和可维护。我们可以通过在Java中实现依赖注入将依赖关系从编译时移到运行时来解析。 Java依赖注入似乎很难通过理论来掌握。所以我将通过一些简单的例子，然后我们将会看到如何在应用里使用依赖注入模式来实现低耦合和可扩展性。 一个不使用依赖注入实现的应用案例 假如说我们有一个通过调用EmailService类来发送邮...
轻松理解 Java开发中的依赖注入(DI)和控制反转(IOC)
peterxiaoq的专栏
01-17 1924
轻松理解 Java开发中的依赖注入(DI)和控制反转(IOC) 前言 关于这个话题, 网上有很多文章,这里, 我希望通过最简单的话语与大家分享. 依赖注入和控制反转两个概念让很多初学这迷惑, 觉得玄之又玄,高深莫测. 这里想先说明两点: 依赖注入和控制反转不是高级的,很初级,也很简单.在JAVA世界,这两个概念像空气一样无所不在,彻底理解很有必要. 第一节 依赖
Java依赖注入(Dependency Injection,DI )
modige_hm的博客
08-19 1381
DI
【Java万花筒】解析Java依赖注入：从Spring到CDI的全方位比较
记录我的学习历程
02-13 1510
本文将介绍Java中几种常用的依赖注入框架，包括Spring IoC、Google Guice、PicoContainer、Dagger、HK2和CDI。首先，我们会深入了解每种框架的核心概念、特点和使用方法，然后通过具体的示例代码演示如何在实际项目中应用这些框架。最后，我们会对这些框架进行比较和总结，帮助读者更好地理解和选择合适的依赖注入框架。
依赖注入的方法
lbllol365的博客
03-26 94
依赖注入的方法 通过构造器注入 官方文档： Core Technologies 通过有参构造器注入。 使用： 假设有一个人，有一条狗和一只猫，狗有名字和年龄。 package com.lbl.pojo; public class User { private Cat cat; private Dog dog; pu...
Java设计模式深度解析与实战教程
- **自定义Spring的IOC功能**：Spring框架是Java开发中广泛使用的IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）容器。通过分析和实践Spring的源码，可以深入理解如何在实际项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值