依賴注入(di)模式
加載依賴項 java編程實現。Java Dependency Injection design pattern allows us to remove the hard-coded dependencies and make our application loosely coupled, extendable and maintainable. We can implement dependency injection in java to move the dependency resolution from compile-time to runtime.
Java Dependency Injection設計模式允許我們刪除硬編碼的依賴關系，并使我們的應用程序松散耦合，可擴展和可維護。 我們可以在Java中實現依賴注入，以將依賴解析從編譯時移至運行時。
ioc注入。Java Dependency injection seems hard to grasp with theory, so I would take a simple example and then we will see how to use dependency injection pattern to achieve loose coupling and extendability in the application.
Java依賴注入似乎很難用理論來理解，因此我將舉一個簡單的例子，然后我們將看到如何使用依賴注入模式來實現應用程序中的松散耦合和可擴展性。
ioc依賴注入的三種方式、Let’s say we have an application where we consume EmailService to send emails. Normally we would implement this like below.
假設我們有一個應用程序，我們在其中使用EmailService發送電子郵件。 通常我們會像下面這樣實現。
package com.journaldev.java.legacy;public class EmailService {public void sendEmail(String message, String receiver){//logic to send emailSystem.out.println("Email sent to "+receiver+ " with Message="+message);}
}EmailService class holds the logic to send an email message to the recipient email address. Our application code will be like below.
EmailService類包含將電子郵件消息發送到收件人電子郵件地址的邏輯。 我們的應用程序代碼如下所示。
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 etcthis.email.sendEmail(msg, rec);}
}Our client code that will use MyApplication class to send email messages will be like below.
我們的客戶端代碼將使用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");}}At first look, there seems nothing wrong with the above implementation. But above code logic has certain limitations.
乍一看，上述實現似乎沒有錯。 但是以上代碼邏輯有一定的局限性。
MyApplication class is responsible to initialize the email service and then use it. This leads to hard-coded dependency. If we want to switch to some other advanced email service in the future, it will require code changes in MyApplication class. This makes our application hard to extend and if email service is used in multiple classes then that would be even harder. MyApplication類負責初始化電子郵件服務，然后使用它。 這導致硬編碼的依賴性。 如果將來想切換到其他高級電子郵件服務，則需要在MyApplication類中更改代碼。 這使我們的應用程序難以擴展，如果在多個類中使用電子郵件服務，則將更加困難。 One can argue that we can remove the email service instance creation from MyApplication class by having a constructor that requires email service as an argument.
可以說，我們可以通過使用需要電子郵件服務作為參數的構造函數來從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 etcthis.email.sendEmail(msg, rec);}
}But in this case, we are asking client applications or test classes to initializing the email service that is not a good design decision.
但是在這種情況下，我們要求客戶端應用程序或測試類初始化電子郵件服務，這不是一個好的設計決定。
Now let’s see how we can apply java dependency injection pattern to solve all the problems with the above implementation. Dependency Injection in java requires at least the following:
現在，讓我們看看如何應用Java依賴注入模式來解決上述實現的所有問題。 Java中的依賴注入至少需要滿足以下條件：
For our case, we can have MessageService that will declare the contract for service implementations.
對于我們的情況，我們可以使用MessageService來聲明服務實現的合同。
package com.journaldev.java.dependencyinjection.service;public interface MessageService {void sendMessage(String msg, String rec);
}Now let’s say we have Email and SMS services that implement the above interfaces.
現在，我們有實現上述接口的電子郵件和SMS服務。
package com.journaldev.java.dependencyinjection.service;public class EmailServiceImpl implements MessageService {@Overridepublic void sendMessage(String msg, String rec) {//logic to send emailSystem.out.println("Email sent to "+rec+ " with Message="+msg);}}package com.journaldev.java.dependencyinjection.service;public class SMSServiceImpl implements MessageService {@Overridepublic void sendMessage(String msg, String rec) {//logic to send SMSSystem.out.println("SMS sent to "+rec+ " with Message="+msg);}}Our dependency injection java services are ready and now we can write our consumer class.
我們的依賴項注入Java服務已準備就緒，現在我們可以編寫我們的使用者類。
We are not required to have base interfaces for consumer classes but I will have a Consumer interface declaring contract for consumer classes.
我們不需要具有用于消費者類的基本接口，但是我將具有一個用于聲明消費者類合同的Consumer接口。
package com.journaldev.java.dependencyinjection.consumer;public interface Consumer {void processMessages(String msg, String rec);
}My consumer class implementation is like below.
我的消費者類實現如下。
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;}@Overridepublic void processMessages(String msg, String rec){//do some msg validation, manipulation logic etcthis.service.sendMessage(msg, rec);}}Notice that our application class is just using the service. It does not initialize the service that leads to better “separation of concerns“. Also use of service interface allows us to easily test the application by mocking the MessageService and bind the services at runtime rather than compile time.
請注意，我們的應用程序類僅在使用服務。 它不會初始化導致更好的“ 關注點分離 ”的服務。 服務接口的使用還使我們能夠通過模擬MessageService輕松測試應用程序，并在運行時（而不是在編譯時）綁定服務。
Now we are ready to write java dependency injector classes that will initialize the service and also consumer classes.
現在，我們準備編寫java依賴注入程序類 ， 該類將初始化服務以及使用者類。
Let’s have an interface MessageServiceInjector with method declaration that returns the Consumer class.
讓我們有一個帶有方法聲明的MessageServiceInjector接口，該方法聲明返回Consumer類。
package com.journaldev.java.dependencyinjection.injector;import com.journaldev.java.dependencyinjection.consumer.Consumer;public interface MessageServiceInjector {public Consumer getConsumer();
}Now for every service, we will have to create injector classes like below.
現在，對于每項服務，我們將必須創建如下所示的噴射器類。
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 {@Overridepublic 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 {@Overridepublic Consumer getConsumer() {return new MyDIApplication(new SMSServiceImpl());}}Now let’s see how our client applications will use the application with a simple program.
現在，讓我們看看我們的客戶端應用程序將如何通過一個簡單的程序使用該應用程序。
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 emailinjector = new EmailServiceInjector();app = injector.getConsumer();app.processMessages(msg, email);//Send SMSinjector = new SMSServiceInjector();app = injector.getConsumer();app.processMessages(msg, phone);}}As you can see that our application classes are responsible only for using the service. Service classes are created in injectors. Also if we have to further extend our application to allow facebook messaging, we will have to write Service classes and injector classes only.
如您所見，我們的應用程序類僅負責使用服務。 服務類別是在注射器中創建的。 同樣，如果我們必須進一步擴展我們的應用程序以允許Facebook消息傳遞，我們將只必須編寫Service類和注射器類。
So dependency injection implementation solved the problem with hard-coded dependency and helped us in making our application flexible and easy to extend. Now let’s see how easily we can test our application class by mocking the injector and service classes.
因此，依賴項注入實現解決了具有硬編碼依賴項的問題，并幫助我們使應用程序靈活且易于擴展。 現在，讓我們看看通過模擬注入器和服務類來測試應用程序類有多么容易。
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;@Beforepublic void setUp(){//mock the injector with anonymous classinjector = new MessageServiceInjector() {@Overridepublic Consumer getConsumer() {//mock the message servicereturn new MyDIApplication(new MessageService() {@Overridepublic void sendMessage(String msg, String rec) {System.out.println("Mock Message Service implementation");}});}};}@Testpublic void test() {Consumer consumer = injector.getConsumer();consumer.processMessages("Hi Pankaj", "pankaj@abc.com");}@Afterpublic void tear(){injector = null;}}As you can see that I am using anonymous classes to mock the injector and service classes and I can easily test my application methods. I am using JUnit 4 for the above test class, so make sure it’s in your project build path if you are running above test class.
如您所見，我正在使用匿名類 模擬注入器和服務類，并且可以輕松測試我的應用程序方法。 我在上述測試類中使用的是JUnit 4，因此，如果您在測試類之上運行，請確保它在您的項目構建路徑中。
We have used constructors to inject the dependencies in the application classes, another way is to use a setter method to inject dependencies in application classes. For setter method dependency injection, our application class will be implemented like below.
我們使用構造函數將依賴項注入應用程序類中，另一種方法是使用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;}@Overridepublic void processMessages(String msg, String rec){//do some msg validation, manipulation logic etcthis.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 {@Overridepublic Consumer getConsumer() {MyDIApplication app = new MyDIApplication();app.setService(new EmailServiceImpl());return app;}}One of the best example of setter dependency injection is Struts2 Servlet API Aware interfaces.
設置程序依賴項注入的最佳示例之一是Struts2 Servlet API Aware接口 。
Whether to use Constructor based dependency injection or setter based is a design decision and depends on your requirements. For example, if my application can’t work at all without the service class then I would prefer constructor based DI or else I would go for setter method based DI to use it only when it’s really needed.
使用基于構造函數的依賴項注入還是基于setter是設計決策，取決于您的要求。 例如，如果我的應用程序如果沒有服務類就無法工作，那么我會更喜歡基于構造函數的DI，否則我會選擇基于setter方法的DI來僅在確實需要它時才使用它。
Dependency Injection in Java is a way to achieve Inversion of control (IoC) in our application by moving objects binding from compile time to runtime. We can achieve IoC through Factory Pattern, Template Method Design Pattern, Strategy Pattern and Service Locator pattern too.
Java中的依賴注入是一種通過將對象綁定從編譯時移到運行時來在我們的應用程序中實現控制反轉 （ IoC ）的方法。 我們也可以通過工廠模式 ， 模板方法設計模式 ， 策略模式和服務定位器模式來實現IoC。
Spring Dependency Injection, Google Guice and Java EE CDI frameworks facilitate the process of dependency injection through use of Java Reflection API and java annotations. All we need is to annotate the field, constructor or setter method and configure them in configuration xml files or classes.
Spring Dependency Injection ， Google Guice和Java EE CDI框架通過使用Java Reflection API和Java注釋簡化了依賴項注入的過程。 我們所需要做的就是注釋字段，構造函數或設置方法，并在配置xml文件或類中對其進行配置。
Some of the benefits of using Dependency Injection in Java are:
在Java中使用依賴注入的一些好處是：
Java Dependency injection has some disadvantages too:
Java依賴注入也有一些缺點：
That’s all for dependency injection pattern in java. It’s good to know and use it when we are in control of the services.
這就是java中依賴注入模式的全部內容。 當我們控制服務時，很高興知道并使用它。
翻譯自: https://www.journaldev.com/2394/java-dependency-injection-design-pattern-example-tutorial
依賴注入(di)模式
版权声明：本站所有资料均为网友推荐收集整理而来,仅供学习和研究交流使用。
工作时间：8:00-18:00
客服电话
电子邮件
admin@qq.com
扫码二维码
获取最新动态
