Applying Java reflection to Ioc and AOP (1)

         JDK1.5 has introduced many useful features, including annotation and reflection. And now, IOC(Inversion of Control) and AOP(Aspect-oriented programming) would be the most popular words in the J2EE field. Today, I am not going to explain what is IOC and what is AOP. I just want to show two examples to present the technology of java reflection plays an important role in IOC and AOP.

        The first example would be a little bit different from the the concept of IOC, but the common thing is that both load the calss dynamically. In this example, I use properties file as the configuration file, but in a real application, we mostly use xml files.

//InjectionInterface.java 
//Firstly, we define a interface
public interface InjectionInterface{
       public void print();
}

//InjectionClass_1.java
//implements the InjectionInterface
public class InjectionClass_1 implements InjectionInterface{
       public void print(){
               //print out the name of the class the object belongs to
               System.out.println(“the print method of class InjectionClass_1″);
       }
}

//InjectionClass_2java
//implements the InjectionInterface
public class InjectionClass_2 implements InjectionInterface{
      public void print(){
              //print out the name of the class the object belongs to
              System.out.println(“the print method of class InjectionClass_2″);
     }
}

//Ioc.java-the testing class 
import java.util.Properties;
import java.io.*;

public class Ioc{
      private InjectionInterface injectionClass;

      //using setter injection
     public void setInjectionClass(InjectionInterface injectionClass)
    {
            this.injectionClass = injectionClass;
    } 

    public void print()
   {
            injectionClass.print();
    }

    public static void main(String[] args)
   {
            try{
                  Properties props = new Properties();
                  props.load(new FileInputStream(“injection.properties”));
                  String classname = props.getProperty(“iocclass”);
                 //dynamically load the class according to the class name
                  Class cls = Class.forName(classname);
                  Ioc ioc = new Ioc();
                 //get an instance of the loaded class
                  ioc.setInjectionClass((InjectionInterface)cls.newInstance());
                  ioc.print();
            }catch(Exception e){
                    e.printStackTrace();
            }
        }
}

//injection.properties – the properties file
iocclass=InjectionClass_1

The running result of the program is: the print method of class InjectionClass_1

Now, you can change the properties file: iocclass=InjectionClass_2. you don’t need to compile the java files again, and just run the class directly. you can see the result would be different.

        After reading the example, I hope you have a better understanding of IOC. And tomorrow, I will show the example about using the technology of reflection in AOP.

---

Possibly related posts: (automatically generated)

• DAO pattern for Hibernate!
• An example of JMock!
• Applying Java reflection to Ioc and AOP (2)