手动实现IOC容器

IOC（Inversion of Control），即控制反转，它使你不需要再自己来实现对象的创建，而是把这些工作都交由容器来进行管理，增加了代码的可重用性。下面，便手动实现一个简单的IOC容器。

首先建立一个接口和这个接口的2个实现类：

 

Java代码  

1. package cn.cgw.ioc;  
2. public interface ReportGenerator {  
3.       
4.     public void generate(String[][] table);  
5. }  

 

Java代码  

1. <span style="white-space: normal;"><span style="white-space: pre;">package cn.cgw.ioc;</span></span>  
2. public class HtmlReportGenerator implements ReportGenerator {  
3.   
4.     public void generate(String[][] table) {  
5.         System.out.println("Generate HTML report...............");  
6.     }  
7. }  

 

Java代码  

1. package cn.cgw.ioc;  
2. public class PdfReportGenerator implements ReportGenerator {  
3.   
4.     public void generate(String[][] table) {  
5.         System.out.println("Generate PDF report..................");  
6.     }  
7. }  

 

 

然后，我们建立一个名为ReportService的类，在这个类中需要到ReportGenerator接口的实现类对象，我们不再手工创建它，而是由IOC容器来管理，在这个类中采用setter方法进行注入。

Java代码  

1. package cn.cgw.ioc;  
2.   
3. public class ReportService {  
4.   
5.     private ReportGenerator reportGenerator;  
6.       
7.     /** 
8.      * 采用setter注入 
9.      * @param reportGenerator 
10.      */  
11.     public void setReportGenerator(ReportGenerator reportGenerator) {  
12.         this.reportGenerator = reportGenerator;  
13.     }  
14.       
15.     public void generateAnnualReport(int year) {  
16.         String[][] statistics = null;  
17.         //  
18.         // Gather statistics for the year ...  
19.         //  
20.         reportGenerator.generate(statistics);  
21.     }  
22.   
23.     public void generateMonthlyReport(int year, int month) {  
24.         String[][] statistics = null;  
25.         //  
26.         // Gather statistics for the month ...  
27.         //  
28.         reportGenerator.generate(statistics);  
29.     }  
30.   
31.     public void generateDailyReport(int year, int month, int day) {  
32.         String[][] statistics = null;  
33.         //  
34.         // Gather statistics for the day ...  
35.         //  
36.         reportGenerator.generate(statistics);  
37.     }  
38. }  

 下面我们建立一个属性文件，在属性文件中，定义了属性与对应类的映射关系：

Java代码  

1. # Define a new component "reportGenerator"  
2. reportGenerator=cn.cgw.ioc.HtmlReportGenerator  
3.   
4. # Define a new component "reportService"  
5. reportService=cn.cgw.ioc.ReportService  
6. # Inject the component "reportGenerator" into property "reportGenerator"  
7. reportService.reportGenerator=reportGenerator  

 然后，我们实现IOC容器，在这个类中需要用到Apache的两个jar包。分别是common-logging和common-beanutils

Java代码  

1. package cn.cgw.ioc;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.HashMap;  
8. import java.util.Map;  
9. import java.util.Properties;  
10.   
11. import org.apache.commons.beanutils.PropertyUtils;  
12.   
13. public class Container {  
14.       
15.     private Map<String,Object> components;  
16.   
17.     public Container() {  
18.           
19.         components = new HashMap<String,Object>();  
20.           
21.         try {  
22.             Properties properties = new Properties();  
23.             //load properties file  
24.             InputStream istr = this.getClass().getResourceAsStream("components.properties");  
25.             properties.load(istr);  
26.               
27.             for(Map.Entry entry : properties.entrySet()) {  
28.                 String key = (String)entry.getKey();  
29.                 String value = (String)entry.getValue();  
30.                 processEntry(key,value);  
31.             }  
32.         } catch (FileNotFoundException e) {  
33.             e.printStackTrace();  
34.         } catch (IOException e) {  
35.             e.printStackTrace();  
36.         } catch (Exception e) {  
37.             e.printStackTrace();  
38.         }  
39.     }  
40.   
41.     private void processEntry(String key, String value) throws Exception{  
42.         String[] parts = key.split("\\.");  
43.         //new component definition  
44.         if(parts.length == 1) {  
45.             //reflection  
46.             Object component = Class.forName(value).newInstance();  
47.             components.put(parts[0], component);  
48.         } else {  
49.             // Dependency injection  
50.             Object component = components.get(parts[0]);  
51.             Object reference = components.get(value);  
52.             PropertyUtils.setProperty(component,parts[1],reference);  
53.         }     
54.     }  
55.       
56.     public Object getComponent(String id) {  
57.         return components.get(id);  
58.     }  
59. }  

 这样我们的工作就完成了，最后再写个测试方法来检验代码的正确性：

Java代码  

1. Container container = new Container();  
2. ReportService reportService = (ReportService)container.getComponent("reportService");  
3. reportService.generateAnnualReport(2009);  

 可以看到，输出的结果为：

 Generate HTML report...............

 如果，我们将属性文件中reportGenerator=的值改为PdfReportGenerator，则输出的结果为：

 Generate PDF report...............

 

通过以上结果我们可以清楚地认识到IOC的特性，我们并没有在ReportService类中创建ReportGenerator的任何实现类对象，这一切都是交由IOC容器进行管理的，通过属性文件的配置，我们可以轻松地更改想要使用的ReportGenerator实现类对象，它大大提高了代码的复用性。