1. E Gas Sly Injection Software Developers

Play Video

GAS TURBINE FUEL CONVERSION CAPABILITY SOLUTIONS

I’m assuming here you mean “ how soon following an environmental exposure with an open (or puncture) wound should you seek medical attention, especially for risk of tetanus?” After exposure, you are given primarily an antitoxin to immediately cou.

The flexibility to operate reliably and efficiently on lower-cost fuels—saving customers money.

For more than 50 years, GE has cultivated close relationships with owners, operators, and fuel suppliers, so we can understand new fuel trends, expand our capability for existing turbine fuels, qualify new fuels, and actively invest in new combustion technologies. As a result, we have the broadest experience to reliably convert the full spectrum of fuels to mechanical, electrical, and thermal energy. Over the last decade, GE experts have performed over 20,000 hours of combustion testing to validate our technology as well as develop new technologies and expanded fuel capabilities.

Modern gas turbines can operate on a wide variety of fuels, which helps power generation in industrial and utility-scale applications where natural gas or light distillate fuels are not available. This fuel flex capability could play an increasing role in a future low- or zero-carbon energy ecosystem.

GE has more than 400 gas turbine fuel and combustion experts that are leading the industry in developing solutions for expanded fuels capability. Our experts can test nearly any fuel used in gas turbines at our world-class facilities, like the Greenville Combustion Lab.

E Gas Sly Injection Software Developers

GE offers combustion technologies, hardware, and controls to help our customers utilize a broad range of gas turbine fuels and solutions. Our Dry Low NOx (DLN) combustion systems are continuously evolving to meet new customer challenges. GE's range of combustion systems have accrued over 190 million fired hours combined.

GE has the broadest experience reliably converting fuels to mechanical, electrical, and thermal energy, giving us the capabilities to deliver solutions to meet our customers’ fuel needs.

DECARBONIZING POWER GEN: HYDROGEN-FUELED GAS TURBINES

One path towards a reduced carbon energy system being discussed is the use of hydrogen as a gas turbine fuel. Hydrogen-fueled gas turbines could potentially allow both new and existing power plants to continue operating for decades to come while reducing their carbon emissions. GE’s gas turbines have nearly 30 years of experience operating on a variety of fuels that contain hydrogen totaling over 4 million operating hours with hydrogen concentrations ranging from 5% to 95% (by volume).

FUEL TOOLS TO HELP YOU GET STARTED

GE’s gas turbines operate on a wide variety of gaseous and liquid fuels, and the process of choosing the right fuel for electrical power generation can be a complex task, influenced by factors like fuel price and availability.

Could using an alternative fuel save you money? Let’s crunch some numbers.

• View Profile

Fuels Capability: Case Studies

Jeffrey Goldmeer, Ph.D., is an accomplished leader in the energy and power generation industries with more than 20 years of expertise in combustion and fuels. In his current role, Jeffrey is responsible for the strategic development of new combustion technologies and expanding gas turbine product capabilities for emerging fuel applications.

Download Jeff’s published case study on the application of Arabian Super Light (ASL) Crude Oil, and a new case study 'Enabling ethane as a primary gas turbine fuel: an economic benefit from the growth of shale gas.'

GE is the first OEM in the world to operate F-class gas turbines on Arabian Super Light (ASL) Crude Oil

GE POWER'S VARIETY OF FUELS

• Arabian Extra Light Crude Oil (AXL)
• Arabian Super Light (ASL)
• Biodiesel Condensate or Natural Gas Liquids (NGL)
• Dimethyl Ether (DME)
• Distillate Oil #2 (DO2)
• Ethane (C2)
• Heavy Crude Oil
• Heavy Fuel Oil (HFO)
• High H2
• Hydrogen Blends
• Kerosene (Jet A or Jet A-1)

• Lean Methane
• Light Crude Oil (LCO)
• Liquid Natural Gas (LNG)
• Liquefied Propane Gas (LPG)
• Medium Crude Oil
• Methanol / Ethanol (Alcohol)
• Naphtha
• Natural Gas (NG)
• Sour Gas (H2S)
• Steel Mill Gases
• Syngas

Fuel Profiles

These 23 comprehensive gas turbine fuel types outline the recommended fuel conditioning processes, provide fuel attributes and baseline fuel comparisons, and details GE’s experience and gas turbine options by class.

Fuel Conditioning

Due to varying compositions and contaminant levels, all gas turbine fuels require some level of conditioning for safe and reliable operation in a gas turbine. GE's Fuel Conditioning Appendix provides additional details on our fuel conditioning processes.

System Schematics

These Fuel System Schematics help illustrate where the fuel conditioning processes are applied along the liquid and gas fuel systems; from the point of fuel delivery, to gas turbine operation, and prior to heat recovery steam generator emission.

Impacts Matrix

Some turbine engine fuel conditioning processes have nominal impacts, while others can have significant impacts on CapEx, OpEx, and performance (output and efficiency). This matrix indicates the degree of impact for each process.

Featured Videos

Take an in-depth look at our products, solutions, and how we work with customers just like you.

Unmatched in the Industry

The flexibility to operate reliably and efficiently on lower-cost fuels—saving customers money

Fuel Science: Heating

A little heat can make some difficult-to-use fuels easier to turn into power. Tune in.. learn more!

Aug 14, 2019  Matrix-nake is a revolutionary game for TI-83+. Unlike other snake games, your aim is to avoid the dots instead of hitting them and you are not killed if you hit a wall or hit the snake itself. You just don't have one or two lives. You have 50 lives, but don't think that the game is far to easy. This TI-83 Plus and TI-84 Plus game is a a plain ordinary version of the classic snake game. Includes 5 speeds and support for external levels. Ti 84 calculator games snake ex2 2.

Fuels 101

Gas or liquid, natural or man-made - learn the basics of what fuels our turbines.

In software engineering, dependency injection is a technique whereby one object supplies the dependencies of another object. A 'dependency' is an object that can be used, for example as a service. Instead of a client specifying which service it will use, something tells the client what service to use. The 'injection' refers to the passing of a dependency (a service) into the object (a client) that would use it. The service is made part of the client's state.^[1] Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.

The intent behind dependency injection is to achieve Separation of Concerns of construction and use of objects. This can increase readability and code reuse.

Dependency injection is one form of the broader technique of inversion of control. The client delegates the responsibility of providing its dependencies to external code (the injector). The client is not allowed to call the injector code;^[2] it is the injecting code that constructs the services and calls the client to inject them. This means the client code does not need to know about the injecting code, how to construct the services or even which actual services it is using; the client only needs to know about the intrinsic interfaces of the services because these define how the client may use the services. This separates the responsibilities of use and construction.

• 2Overview
• 3Structure
• 4Examples
  • 4.2Types of dependency injection

Intent[edit]

Dependency Injection solves problems such as:^[3]

• How can an application or class be independent of how its objects are created?
• How can the way objects are created be specified in separate configuration files?
• How can an application support different configurations?

Creating objects directly within the class that requires the objects is inflexiblebecause it commits the class to particular objects and makes it impossible to change the instantiation later independently from (without having to change) the class.It stops the class from being reusable if other objects are required,and it makes the class hard to test because real objects can't be replaced with mock objects.

A class is no longer responsible for creating the objects it requires, and it doesn't have to delegate instantiation to a factory object as in the Abstract Factory^[4] design pattern.
See also the UML class and sequence diagram below.

Overview[edit]

Dependency injection for five-year-olds

When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn't want you to have. You might even be looking for something we don't even have or which has expired.

What you should be doing is stating a need, 'I need something to drink with lunch,' and then we will make sure you have something when you sit down to eat.

John Munsch, 28 October 2009.^[5][6][7]

Dependency injection separates the creation of a client's dependencies from the client's behavior, which allows program designs to be looselycoupled^[8] and to follow the dependency inversion and single responsibility principles.^[5][9] It directly contrasts with the service locator pattern, which allows clients to know about the system they use to find dependencies.

An injection, the basic unit of dependency injection, is not a new or a custom mechanism. It works in the same way that 'parameter passing' works.^[10] Referring to 'parameter passing' as an injection carries the added implication that it's being done to isolate the client from details.

An injection is also about what is in control of the passing (never the client) and is independent of how the passing is accomplished, whether by passing a reference or a value.

Dependency injection involves four roles:

• the service object(s) to be used
• the client object that is depending on the service(s) it uses
• the interfaces that define how the client may use the services
• the injector, which is responsible for constructing the services and injecting them into the client

As an analogy,

• service - an electric, gas, hybrid, or diesel car
• client - a driver who uses the car the same way regardless of the engine
• interface - automatic, ensures driver doesn't have to understand engine details like gears
• injector - the parent who bought the kid the car and decided which kind

Any object that may be used can be considered a service. Any object that uses other objects can be considered a client. The names have nothing to do with what the objects are for and everything to do with the role the objects play in any one injection.

The interfaces are the types the client expects its dependencies to be. An issue is what they make accessible. They may truly be interface types implemented by the services but also may be abstract classes or even the concrete services themselves, though this last would violate DIP^[11] and sacrifice the dynamic decoupling that enables testing. It's only required that the client does not know which they are and therefore never treats them as concrete, say by constructing or extending them.

The client should have no concrete knowledge of the specific implementation of its dependencies. It should only know the interface's name and API. As a result, the client won't need to change even if what is behind the interface changes. However, if the interface is refactored from being a class to an interface type (or vice versa) the client will need to be recompiled.^[12] This is significant if the client and services are published separately. This unfortunate coupling is one that dependency injection cannot resolve.

The injector introduces the services into the client. Often, it also constructs the client. An injector may connect together a very complex object graph by treating an object like a client and later as a service for another client. The injector may actually be many objects working together but may not be the client. The injector may be referred to by other names such as: assembler, provider, container, factory, builder, spring, construction code, or main.

Dependency injection can be applied as a discipline, one that asks that all objects separate construction and behavior. Relying on a DI framework to perform construction can lead to forbidding the use of the new keyword, or, less strictly, only allowing direct construction of value objects.^{[13][14][15][16]}

Taxonomy[edit]

Inversion of control (IoC) is more general than DI. Put simply, IoC means letting other code call you rather than insisting on doing the calling. An example of IoC without DI is the template method pattern. Here, polymorphism is achieved through subclassing, that is, inheritance.^[17]

Dependency injection implements IoC through composition so is often identical to that of the strategy pattern, but while the strategy pattern is intended for dependencies to be interchangeable throughout an object's lifetime, in dependency injection it may be that only a single instance of a dependency is used.^[18] This still achieves polymorphism, but through delegation and composition.

Dependency injection frameworks[edit]

Application frameworks such as CDI and its implementation Weld, Spring, Guice, Play framework, Salta, Glassfish HK2, Dagger, and Managed Extensibility Framework (MEF) support dependency injection but are not required to do dependency injection.^[19][20]

Advantages[edit]

• Dependency injection allows a client the flexibility of being configurable. Only the client's behavior is fixed. The client may act on anything that supports the intrinsic interface the client expects.^{[citation needed]}
• Dependency injection can be used to externalize a system's configuration details into configuration files, allowing the system to be reconfigured without recompilation. Separate configurations can be written for different situations that require different implementations of components. This includes, but is not limited to, testing.^{[citation needed]}
• Because dependency injection doesn't require any change in code behavior it can be applied to legacy code as a refactoring. The result is clients that are more independent and that are easier to unit test in isolation using stubs or mock objects that simulate other objects not under test. This ease of testing is often the first benefit noticed when using dependency injection.^{[citation needed]}
• Dependency injection allows a client to remove all knowledge of a concrete implementation that it needs to use. This helps isolate the client from the impact of design changes and defects. It promotes reusability, testability and maintainability.^[21]
• Reduction of boilerplate code in the application objects, since all work to initialize or set up dependencies is handled by a provider component.^[21]
• Dependency injection allows concurrent or independent development. Two developers can independently develop classes that use each other, while only needing to know the interface the classes will communicate through. Plugins are often developed by third party shops that never even talk to the developers who created the product that uses the plugins.^{[citation needed]}
• Dependency Injection decreases coupling between a class and its dependency.^[22][23]

Disadvantages[edit]

• Dependency injection creates clients that demand configuration details be supplied by construction code. This can be onerous when obvious defaults are available.^{[citation needed]}
• Dependency injection can make code difficult to trace (read) because it separates behavior from construction. This means developers must refer to more files to follow how a system performs.^{[citation needed]}
• Dependency injection frameworks are implemented with reflection or dynamic programming. This can hinder use of IDE automation, such as 'find references', 'show call hierarchy' and safe refactorings.^{[citation needed]}
• Dependency injection typically requires more upfront development effort since one can not summon into being something right when and where it is needed but must ask that it be injected and then ensure that it has been injected.^{[citation needed]}
• Dependency injection forces complexity to move out of classes and into the linkages between classes which might not always be desirable or easily managed.^[24]
• Dependency injection can encourage dependence on a dependency injection framework.^[24][25][26]

Structure[edit]

UML class and sequence diagram[edit]

In the above UMLclass diagram, the Client class that requires ServiceA and ServiceB objects doesn't instantiate the ServiceA1 and ServiceB1 classes directly.Instead, an Injector class creates the objects and injects theminto the Client, which makes the Client independent of how the objects are created (which concrete classes are instantiated).
The UMLsequence diagram shows the run-time interactions: The Injector object creates the ServiceA1 and ServiceB1 objects.Thereafter, the Injector creates the Client objectand injects the ServiceA1 and ServiceB1 objects.

Examples[edit]

Without dependency injection[edit]

In the following Java example, the Client class contains a Service member variable that is initialized by the Client constructor. The client controls which implementation of service is used and controls its construction. In this situation, the client is said to have a hard-coded dependency on ExampleService.

Dependency injection is an alternative technique to initialize the member variable rather than explicitly creating a service object as shown above.

Types of dependency injection[edit]

There are at least three ways a client object can receive a reference to an external module:^[28]

• constructor injection: the dependencies are provided through a client's class constructor.
• setter injection: the client exposes a setter method that the injector uses to inject the dependency.
• interface injection: the dependency's interface provides an injector method that will inject the dependency into any client passed to it. Clients must implement an interface that exposes a setter method that accepts the dependency.

Other types[edit]

It is possible for DI frameworks to have other types of injection beyond those presented above.^[29]

Testing frameworks may also use other types. Some modern testing frameworks do not even require that clients actively accept dependency injection thus making legacy code testable. In particular, in the Java language it is possible to use reflection to make private attributes public when testing and thus accept injections by assignment.^[30]

Some attempts at Inversion of Control do not provide full removal of dependency but instead simply substitute one form of dependency for another. As a rule of thumb, if a programmer can look at nothing but the client code and tell what framework is being used, then the client has a hard-coded dependency on the framework.

Constructor injection[edit]

This method requires the client to provide a parameter in a constructor for the dependency.

Setter injection[edit]

This method requires the client to provide a setter method for the dependency.

Interface injection[edit]

This is simply the client publishing a role interface to the setter methods of the client's dependencies. It can be used to establish how the injector should talk to the client when injecting dependencies.

Constructor injection comparison[edit]

Preferred when all dependencies can be constructed first because it can be used to ensure the client object is always in a valid state, as opposed to having some of its dependency references be null (not be set). However, on its own, it lacks the flexibility to have its dependencies changed later. This can be a first step towards making the client immutable and therefore thread safe.

Setter injection comparison[edit]

Requires the client to provide a setter method for each dependency. This gives the freedom to manipulate the state of the dependency references at any time. This offers flexibility, but if there is more than one dependency to be injected, it is difficult for the client to ensure that all dependencies are injected before the client could be provided for use.

Because these injections happen independently there is no way to tell when the injector is finished wiring the client. A dependency can be left null simply by the injector failing to call its setter. This forces the check that injection was completed from when the client is assembled to whenever it is used.

Interface injection comparison[edit]

The advantage of interface injection is that dependencies can be completely ignorant of their clients yet can still receive a reference to a new client and, using it, send a reference-to-self back to the client. In this way, the dependencies become injectors. The key is that the injecting method (which could just be a classic setter method) is provided through an interface.

An assembler is still needed to introduce the client and its dependencies. The assembler would take a reference to the client, cast it to the setter interface that sets that dependency, and pass it to that dependency object which would turn around and pass a reference-to-self back to the client.

For interface injection to have value, the dependency must do something in addition to simply passing back a reference to itself. This could be acting as a factory or sub-assembler to resolve other dependencies, thus abstracting some details from the main assembler. It could be reference-counting so that the dependency knows how many clients are using it. If the dependency maintains a collection of clients, it could later inject them all with a different instance of itself.

Assembling examples[edit]

Manually assembling in main by hand is one way of implementing dependency injection.

The example above constructs the object graph manually and then invokes it at one point to start it working. Important to note is that this injector is not pure. It uses one of the objects it constructs. It has a purely construction-only relationship with ExampleService but mixes construction and using of Client. This should not be common. It is, however, unavoidable. Just like object oriented software needs a non-object oriented static method like main() to get started, a dependency injected object graph needs at least one (preferably only one) entry point to get the whole thing started.

Manual construction in the main method may not be this straight forward and may involve calling builders, factories, or other construction patterns as well. This can be fairly advanced and abstract. The line is crossed from manual dependency injection to framework dependency injection once the constructing code is no longer custom to the application and is instead universal.^[31]

Frameworks like Spring can construct these same objects and wire them together before returning a reference to client. All mention of the concrete ExampleService can be moved from the code to the configuration data.

Frameworks like Spring allow assembly details to be externalized in configuration files.This code (above) constructs objects and wires them together according to Beans.xml (below). ExampleService is still constructed even though it's only mentioned below. A long and complex object graph can be defined this way and the only class mentioned in code would be the one with the entry point method, which in this case is greet().

In the example above Client and Service have not had to undergo any changes to be provided by spring. They are allowed to remain simple POJOs.^[32][33][34] This shows how spring can connect services and clients that are completely ignorant of its existence. This could not be said if spring annotations are added to the classes. By keeping spring specific annotations and calls from spreading out among many classes, the system stays only loosely dependent on spring.^[25] This can be important if the system intends to outlive spring.

The choice to keep POJOs pure doesn't come without cost. Rather than spending the effort to develop and maintain complex configuration files it is possible to simply use annotations to mark classes and let spring do the rest of the work. Resolving dependencies can be simple if they follow a convention such as matching by type or by name. This is choosing convention over configuration.^[35] It is also arguable that, when refactoring to another framework, removing framework specific annotations would be a trivial part of the task^[36] and many injection annotations are now standardized.^[37][38]

Assembly comparison[edit]

The different injector implementations (factories, service locators, and dependency injection containers) are not that different as far as dependency injection is concerned. What makes all the difference is where they are allowed to be used. Move calls to a factory or a service locator out of the client and into main and suddenly main makes a fairly good dependency injection container.

By moving all knowledge of the injector out, a clean client, free of knowledge of the outside world, is left behind. However, any object that uses other objects can be considered a client. The object that contains main is no exception. This main object is not using dependency injection. It's actually using the service locator pattern. This can't be avoided because the choice of service implementations must be made somewhere.

Externalizing the dependencies into configuration files doesn't change this fact. What makes this reality part of a good design is that the service locator is not spread throughout the code base. It's confined to one place per application. This leaves the rest of the code base free to use dependency injection to make clean clients.

Dependency Injection Pattern[edit]

The examples until now have been overly simple examples about constructing a string. However, the dependency injection pattern is most useful when constructing an object graph where objects communicate via messages. Objects constructed in main will last for the life of the program. The typical pattern is to construct the graph and then call one method on one object to send the flow of control into the object graph. Just as main is the entry point to the static code, this one method is the entry point to the applications non-static code.

AngularJS example[edit]

In the AngularJS framework, there are only three ways a component (object or function) can directly access its dependencies:

1. The component can create the dependency, typically using the new operator.
2. The component can look up the dependency, by referring to a global variable.
3. The component can have the dependency passed to it where it is needed.

The first two options of creating or looking up dependencies are not optimal because they hard code the dependency to the component. This makes it difficult, if not impossible, to modify the dependencies. This is especially problematic in tests, where it is often desirable to provide mock dependencies for test isolation.

The third option is the most viable, since it removes the responsibility of locating the dependency from the component. The dependency is simply handed to the component.

In the above example SomeClass is not concerned with creating or locating the greeter dependency, it is simply handed the greeter when it is instantiated.

This is desirable, but it puts the responsibility of getting hold of the dependency on the code that constructs SomeClass.

To manage the responsibility of dependency creation, each AngularJS application has an injector. The injector is a service locator that is responsible for construction and look-up of dependencies.

Here is an example of using the injector service:

Create a new injector that can provide components defined in the myModule module and request our greeter service from the injector. (This is usually done automatically by the AngularJS bootstrap).

Asking for dependencies solves the issue of hard coding, but it also means that the injector needs to be passed throughout the application. Passing the injector breaks the Law of Demeter. To remedy this, we use a declarative notation in our HTML templates, to hand the responsibility of creating components over to the injector, as in this example:

When AngularJS compiles the HTML, it processes the ng-controller directive, which in turn asks the injector to create an instance of the controller and its dependencies.

This is all done behind the scenes. Because the ng-controller defers to the injector to instantiate the class, it can satisfy all of the dependencies of MyController without the controller ever knowing about the injector. The application code simply declares the dependencies it needs, without having to deal with the injector. This setup does not break the Law of Demeter.

See also[edit]

References[edit]

1. ^I.T., Titanium. 'James Shore: Dependency Injection Demystified'. www.jamesshore.com. Retrieved 2015-07-18.
2. ^'HollywoodPrinciple'. c2.com. Retrieved 2015-07-19.
3. ^'The Dependency Injection design pattern - Problem, Solution, and Applicability'. w3sDesign.com. Retrieved 2017-08-12.
4. ^Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 87ff. ISBN0-201-63361-2.CS1 maint: multiple names: authors list (link)
5. ^ ^abSeeman, Mark (October 2011). Dependency Injection in .NET. Manning Publications. p. 4. ISBN9781935182504.
6. ^'Dependency Injection in NET'(PDF). philkildea.co.uk. p. 4. Retrieved 2015-07-18.
7. ^'How to explain dependency injection to a 5-year-old?'. stackoverflow.com. Retrieved 2015-07-18.
8. ^Seemann, Mark. 'Dependency Injection is Loose Coupling'. blog.ploeh.dk. Retrieved 2015-07-28.
9. ^Niko Schwarz, Mircea Lungu, Oscar Nierstrasz, “Seuss: Decoupling responsibilities from static methods for fine-grained configurability”, Journal of Object Technology, Volume 11, no. 1 (April 2012), pp. 3:1-23
10. ^'Passing Information to a Method or a Constructor (The Java™ Tutorials > Learning the Java Language > Classes and Objects)'. docs.oracle.com. Retrieved 2015-07-18.
11. ^'A curry of Dependency Inversion Principle (DIP), Inversion of Control (IoC), Dependency Injection (DI) and IoC Container - CodeProject'. www.codeproject.com. Retrieved 2015-08-08.
12. ^'How to force 'program to an interface' without using a java Interface in java 1.6'. programmers.stackexchange.com. Retrieved 2015-07-19.
13. ^'To 'new' or not to 'new'…'. Retrieved 2015-07-18.
14. ^'How to write testable code'. www.loosecouplings.com. Retrieved 2015-07-18.
15. ^'Writing Clean, Testable Code'. www.ethanresnick.com. Retrieved 2015-07-18.
16. ^Sironi, Giorgio. 'When to inject: the distinction between newables and injectables - Invisible to the eye'. www.giorgiosironi.com. Retrieved 2015-07-18.
17. ^'Inversion of Control vs Dependency Injection'. stackoverflow.com. Retrieved 2015-08-05.
18. ^'What is the difference between Strategy pattern and Dependency Injection?'. stackoverflow.com. Retrieved 2015-07-18.
19. ^'Dependency Injection != using a DI container'. www.loosecouplings.com. Retrieved 2015-07-18.
20. ^'Black Sheep » DIY-DI » Print'. blacksheep.parry.org. Archived from the original on 2015-06-27. Retrieved 2015-07-18.Cite uses deprecated parameter deadurl= (help)
21. ^ ^ab'The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 330'. jcp.org. Retrieved 2015-07-18.
22. ^'the urban canuk, eh: On Dependency Injection and Violating Encapsulation Concerns'. www.bryancook.net. Retrieved 2015-07-18.
23. ^'The Dependency Injection Design Pattern'. msdn.microsoft.com. Retrieved 2015-07-18.
24. ^ ^ab'What are the downsides to using Dependency Injection?'. stackoverflow.com. Retrieved 2015-07-18.
25. ^ ^ab'Dependency Injection Inversion - Clean Coder'. sites.google.com. Retrieved 2015-07-18.
26. ^'Decoupling Your Application From Your Dependency Injection Framework'. InfoQ. Retrieved 2015-07-18.
27. ^'The Dependency Injection design pattern - Structure and Collaboration'. w3sDesign.com. Retrieved 2017-08-12.
28. ^Martin Fowler (2004-01-23). 'Inversion of Control Containers and the Dependency Injection pattern - Forms of Dependency Injection'. Martinfowler.com. Retrieved 2014-03-22.
29. ^'Yan - Dependency Injection Types'. Yan.codehaus.org. Archived from the original on 2013-08-18. Retrieved 2013-12-11.Cite uses deprecated parameter deadurl= (help)
30. ^'AccessibleObject (Java Platform SE 7)'. docs.oracle.com. Retrieved 2015-07-18.
31. ^Riehle, Dirk (2000), Framework Design: A Role Modeling Approach(PDF), Swiss Federal Institute of Technology
32. ^'Spring Tips: A POJO with annotations is not Plain'. Archived from the original on 2015-07-15. Retrieved 2015-07-18.Cite uses deprecated parameter dead-url= (help)
33. ^'Annotations in POJO – a boon or a curse? Techtracer'. Retrieved 2015-07-18.
34. ^'Pro Spring Dynamic Modules for OSGi Service Platforms'. APress. Retrieved 2015-07-06.
35. ^'Captain Debug's Blog: Is 'Convention Over Configuration' Going Too Far?'. www.captaindebug.com. Retrieved 2015-07-18.
36. ^Decker, Colin. 'What's the issue with @Inject? Colin's Devlog'. blog.cgdecker.com. Retrieved 2015-07-18.
37. ^Morling, Gunnar (2012-11-18). 'Dagger - A new Java dependency injection framework'. Dagger - A new Java dependency injection framework - Musings of a Programming Addict. Retrieved 2015-07-18.
38. ^'The Java Community Process(SM) Program - JSRs: Java Specification Requests - detail JSR# 330'. www.jcp.org. Retrieved 2015-07-18.

External links[edit]

Wikimedia Commons has media related to Dependency injection.

• Dependency Injection & Testable Objects: Designing loosely coupled and testable objects - Jeremy Weiskotten; Dr. Dobb's Journal, May 2006.
• The Rich Engineering Heritage Behind Dependency Injection - Andrew McVeigh - A detailed history of dependency injection.
• What is Dependency Injection? - An alternative explanation - Jakob Jenkov