Difference Betwixt Dependency Injection As Well As Manufacturing Works Life Designing Inwards Java

TL;DR Main departure betwixt dependency injection too manufactory pattern is that inwards the instance of quondam dependency is provided past times the 3rd political party (framework or container) field inwards the instance of afterwards dependency is acquired past times customer flat itself. Another substitution departure betwixt them is that operate of dependency injection outcome inwards loosely coupled design but the operate of manufactory pattern create a tight coupling betwixt manufactory too classes which are subject on the production created past times the factory. Though both Dependency Injection too Factory pattern hold off similar inwards a feel that both creates an instance of a class, too also promotes interface driven programming rather than hard coding implementation class; But, at that topographic point are around subtle differences betwixt Factory pattern too dependency injection pattern.

In the instance of manufactory blueprint pattern, customer flat is responsible for calling getInstance() of manufactory flat to create an instance of products, it also agency that customer flat is straight coupled alongside manufactory too can't last unit of measurement tested without manufactory flat existence available.

On the other manus inwards Dependency Injection, customer flat has no clue nigh how his dependencies are created too managed. It exclusively knows nigh dependencies. Mostly dependencies are injected past times framework e.g. edible bean flat exists without whatever hard-coded dependency, equally those are injected past times IOC container e.g. Spring.

If yous are serious nigh learning blueprint patterns too principles, I advise yous accept a hold off at Head First Object Oriented Analysis too design book. This mass is overshadowed past times its pop cousin Head First Design Pattern but it's i of the books to primary object-oriented blueprint principles too patterns.

You tin move also operate points discussed hither to reply questions similar departure betwixt Spring IOC too Factory pattern because Spring IOC is zip but an implementation of dependency injection pattern.

Factory Pattern vs Dependency Injection

To empathize departure betwixt manufactory pattern too dependency injection improve let's run across examples of how both DI too Factory blueprint pattern are used :

In Factory Pattern

public class CashRegister {      private PriceCalculator figurer = PriceCalculatorFactory.getInstance();      public void add(Transaction tx) {           int toll = calcualtor.getPrice(tx);           add(price);     }  }

In this instance subject class, CashRegister is directly coupled alongside PriceCalculatorFactory because its calling static getInstance() method from PriceCalculatorFactory to satisfy its dependency. In gild to seek CashRegister, yous must involve a PriceCalculatorFactory, which is non practiced for unit of measurement testing of this class.

On the other hand, if yous operate Dependency injection, too hence dependencies are added past times framework e.g. Spring framework or DI container similar Google Guice because yous contrary the responsibleness of acquiring dependencies.

Now it's the responsibleness of IOC container to inject dependency than the subject flat fending for himself. In the instance of dependency injection whatever flat merely looks similar a POJO.

In Dependency Injection 

public class CashRegister {      private PriceCalculator calculator;      public CashRegister(PriceCalculator calculator){         this.calculator = calculator;     }      public void add(Transaction tx) {           int toll = calcualtor.getPrice(tx);           add(price);     }      public void setCalcuator(PriceCalculator calc){         this.calculator = calc;     }  }

You tin move run across that dependency for CashRegister, which is PriceCalculator is supplied via a constructor, this is known equally constructor dependency injection. There is around other shape of DI equally good e.g. setter injection, inwards which dependency is provided using setter method.

For example, setCalcuator(PriceCalcuator) is facilitating setter injection there. You should operate constructor injection to inject mandatory dependencies too setter injection for optional, practiced to guide keep dependencies. You tin move also run across when to operate Setter vs Constructor injection for to a greater extent than guidelines.

Difference betwixt Factory Pattern vs Dependency Injection

Based on our noesis of both of these patterns, yous tin move easily deduce next substitution differences betwixt them :

1) Factory pattern adds coupling betwixt object, factory, too dependency. Object non exclusively needs a subject object to piece of work properly but also a Factory object. While inwards instance of dependency injection, Object merely knows the dependency, it doesn't know anything nigh container or factory


2) As compared to Factory pattern, Dependency injection makes unit of measurement testing easier. If yous operate the manufactory pattern, yous involve to create the object yous desire to test, the manufactory too the subject object, of course, yous constituent tin move render a mock object, but yous involve all this merely to outset alongside unit of measurement testing. On the other hand, if yous operate dependency injection, yous merely involve to mock the dependency too inject into an object yous desire to test, no clutter or boilerplate is needed.


3) Dependency injection is to a greater extent than flexible than manufactory pattern. You tin move fifty-fifty switch to dissimilar DI framework e.g. Spring IOC or Google Guice.


4) One of the drawbacks of Dependency injection equally compared to Factory pattern is that yous involve a container too configuration to inject the dependency, which is non required if yous operate manufactory blueprint pattern.

In truthful sense, it's non such a bad affair because yous guide keep i house to run across dependency of your flat too yous tin move command them, but yeah when yous compare DI to a manufactory method, this is the additional mensuration yous involve to do.


5) Due to depression coupling, DI results inwards much cleaner co than manufactory pattern. Your object looks similar POJO too yous also come upwards to know what is mandatory too what is an pick past times looking which type of dependency injection your flat is using.

If an object is injected using Setter injection, which agency it's optional too tin move last injected at whatever time, field dependencies which are injected using constructor injection agency they are mandatory too must last supplied inwards the gild they are declared.


6) Another tricky scenario alongside using DI is creating an object alongside likewise many dependencies too worse if those are injected using constructor injection. That code becomes hard to read. One solution to that occupation is to operate Facade pattern too inject dependencies past times encapsulating inwards around other object. For example, yous tin move innovate an object tell ApplicationSettings which tin move comprise DBSetting, FileSetting too other configuration settings required past times an object.


7) You should operate Dependency Injection Patterns to innovate loose coupling. Use Factory Patterns if yous involve to delegate the creation of objects. In short, dependency injection frees your application from manufactory pattern boilerplate code. All the piece of work which is required to implement a manufactory is already done past times IOC containers similar Spring too Google Guice.

That's all betwixt the difference betwixt Factory blueprint pattern too dependency injection inwards Java. Both patterns accept out the creation of dependencies from the subject flat too encourage the operate of interfaces for defining belongings e.g. hither nosotros are using PriceCalculator which is an interface hence that it tin move afterwards last replaced past times whatever suitable implementation without affecting whatever business office of code.

The existent departure betwixt manufactory too dependency injection lies on the fact that inwards the instance of a factory, your subject flat is nonetheless subject on factory, which is a novel shape of dependency field DI takes out the dependency completely. This agency dependency injection provides improve decoupling too unit of measurement testing of classes over Factory blueprint pattern.

If yous similar this article too interested inwards learning to a greater extent than nigh blueprint patterns too principles, yous may similar next ones equally good :

• What is the departure betwixt Adapter, Decorator, too Proxy blueprint patterns? (answer)
• How to implement Builder blueprint Pattern inwards Java? (solution)
• 10 Object Oriented Design Principle Every Programmer Should know (principles)
• What is Open Closed blueprint Principle inwards OOP? (answer)
• What is the departure betwixt Factory too Abstract Factory blueprint Patterns? (answer)
• 5 Reasons to operate Composition inwards house of Inheritance inwards Java? (answer)
• How to implement Strategy Design Pattern using Java Enum? (solution)
• What is the departure betwixt State too Strategy Pattern inwards Java? (answer)
• Top five Books to Learn Design Patterns too Principles (books)
• How to implement DAO blueprint Pattern inwards Java? (answer)
• Why implementing Singleton using Enum is improve than Class inwards Java? (answer)
• What is the departure betwixt Association, Aggregation, too Composition inwards OOP? (answer)
• What is the departure betwixt Singleton too Static Class inwards Java? (answer)
• Why should yous Interface for Coding inwards Java? (answer)
• Real life instance of Decorator Pattern inwards Java? (example)

Further Learning
Design Pattern Library
From 0 to 1: Design Patterns - 24 That Matter - In Java
Java Design Patterns - The Complete Masterclass