|
Inversion of Control: A Mechanism for Highly Flexible Applications
by Samudra Gupta
Loose coupling is one of the critical elements in object-oriented software development. It allows you to change the implementations of two related objects without affecting the other object. Suppose you've got a situation in which making a change to the implementation details in component A forces you to make a change in component B (which uses component A). This is what is called a strong coupling, and it can make life more difficult when it comes to the scalability of an application. Inversion of Control (IoC) is one approach you can use to achieve loose coupling between several interacting components in an application.
What is IoC?
Inversion of Control, not surprisingly, is all about inverting the control. Or, how one object uses another object. Suppose class A wants to use class B. Traditionally, you would create and use an instance of class B within class A, like in the following example:
Class A {
private B b;
public A() {
b = new B();
}
public void doSomething(){
b.someMethod();
}
You can easily spot the problems in creating dependency between two objects using this traditional approach:
- The creation of object B relies upon the availability of a default constructor.
- Any change in the constructor implementation of class B will necessitate achange in the implementation of class A.
- Suppose class A wants to use class C instead of class B. Then class A needs to change. What happens if class B and class C are two separate implementations of same service and the application will need to switch over from one implementation to the other?
All three ofthe problems in the code example are due the strong coupling of class A and class B. Class A first needs to know that it must use an instance of class B and then it needs to know how to construct an instance of class B.
The solution to this problem is to eliminate the dependency from class A. What follows is a modified class A, where strong coupling is removed:
Class A {
private B b;
public A(B b) {
this.b = b;
}
public void doSomething(){
b.someMethod();
}
This example accepts an instance of class B via the constructor. This relieves class A from knowing how to instantiate class B. Now, in order to use class A, the caller class of A must also instantiate class B and pass it into class A. In this context, the caller class is also acting as an assembler of object A and object B. Object A does not explicitly look for B, but B is supplied to it. This is the Inversion of Control. The control of class B is taken out of class A and placed in the Assembler class.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
