Java利用反射和读取xml实现迷你容器

由于需要框架能实现多态，达到控制反转解耦。所以容器还是需要的，容器的存在可以简化对象获取工作，但是容器也不是万能的。合理使用即可，Spring对我来说太庞大了，用不着，为此给框架写一个迷你版容器。

容器配置还是继承以前用spring.net的容器配置，名称为ObjConfig.xml放在程序根目录供容器初始化

<objects xmlns='http://www.springframework.net' default-autowire="byType">
  
  
  
  <object id="LisMianDbFactory" type="LIS.Dal.Base.PostgreSqlBase,LIS.Dal.Base"  singleton="false">
  object>
 
objects>
1
2
3
4
5
6
7
8
9

容器实现

package LIS.Core.Context;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.lang.reflect.Type;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.List;
import java.util.HashMap;
import java.util.*;

//一个迷你版容器，供ORM等控制反转使用
public class ObjectContainer {

    ///用来存类型
    private static List<Class> classList=new ArrayList<Class>();

    ///存类的查找关系
    private static HashMap<String, Integer> classIndexMap = new HashMap<String, Integer>();

    /// 

    /// 按类型返回强类型的对象,一般用接口获得实现类
    /// 
    /// 对象类型
    /// 返回的对象
    public static <T> T GetObject()
    {
        Type type = ObjectContainer.class.getClass().getGenericSuperclass();
        Class c=type.getClass();
        Class<?> parent=c.getSuperclass();
        String cName=c.getName();
        if(classIndexMap.containsKey(cName))
        {
            //创建对象
            Object o = GetObject(cName);
            return (T)o;
        }
        if(parent!=null)
        {
            String parentName=parent.getName();
            if(classIndexMap.containsKey(parentName))
            {
                //创建对象
                Object o = GetObject(parentName);
                return (T)o;
            }
        }
        Class<?> interfaceArr[]=c.getInterfaces();
        if(interfaceArr!=null&&interfaceArr.length>0)
        {
            for(int j=0;j<interfaceArr.length;j++)
            {
                String interfaceName=interfaceArr[j].getName();
                if(classIndexMap.containsKey(interfaceName))
                {
                    //创建对象
                    Object o = GetObject(interfaceName);
                    return (T)o;
                }
            }
        }
        return null;
    }

    /// 

    /// 按名称返回强类型的对象
    /// 
    /// 对象类型
    /// 对象名称
    /// 返回的对象
    public static <T> T GetTypeObject(String name)
    {
        Object o=GetObject(name);
        return (T)o;
    }

    /// 

    /// 按名称返回对象
    /// 
    /// 对象名称
    /// 返回对象
    public static Object GetObject(String name)
    {
        if(classIndexMap.containsKey(name))
        {
            try {
            int index=classIndexMap.get(name);
            Class c=classList.get(index);
            //创建对象
            Object o = c.newInstance();
            return o;
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
        }
        return null;
    }


    /// 

    /// 用类型全名和程序集全名获得类型
    /// 
    /// 类型全名
    /// 程序集名
    /// 
    private static Class GetType(String typeName, String assemblyName)
    {
        try {
            //得到根路径
            Class<?> clazz = ObjectContainer.class;
            ClassLoader classLoader = clazz.getClassLoader();
            URL resourceURL1 = classLoader.getResource("");
            String bashePath = resourceURL1.getFile();
            //组装成jar包路径
            String jarPath=bashePath+assemblyName+".jar";
            File file = new File(jarPath);
            if (!file.exists()) {
                throw new Exception("未能找到"+jarPath+"的文件");
            }
            //反射得到类型
            //自己生成jar包路径
            URL url = file.toURI().toURL();
            URL[] urls = new URL[]{url};
            //加载程序集
            URLClassLoader loader = new URLClassLoader(urls);
            //加载类
            Class c = loader.loadClass(typeName);
            if(c!=null)
            {
                return  c;
            }
            else
            {
                throw new Exception("未能构建类型"+typeName);
            }
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
        return  null;
    }

    /// 

    /// 从根目录的ObjConfig初始化IOC容器，还是按Spring.Net的配置格式
    /// 
    public static void InitIoc() {
        try {
            //得到根路径
            Class<?> clazz = ObjectContainer.class;
            ClassLoader classLoader = clazz.getClassLoader();
            URL resourceURL = classLoader.getResource("resources/ObjConfig.xml");
            String IocPath = resourceURL.getFile();
            //判断配置是否存在
            File file = new File(IocPath);
            if (!file.exists()) {
                System.out.println("resources/ObjConfig.xml文件不存在,请确认!");
                return;
            }
            //解析xml
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = factory.newDocumentBuilder();
            Document document = builder.parse(file);
            // 获得根节点
            Element rootElement = document.getDocumentElement();
            // 获得根节点下的所有子节点
            NodeList students = rootElement.getChildNodes();
            for (int i = 0; i < students.getLength(); i++) {
                // 由于节点多种类型，而一般我们需要处理的是元素节点
                Node childNode = students.item(i);
                // 元素节点就是非空的子节点，也就是还有孩子的子节点
                if (childNode.getNodeType() == Node.ELEMENT_NODE) {
                    Element childElement = (Element) childNode;
                    //不是对象配置元素就忽略
                    if(childElement.getNodeName()!= "object")
                    {
                        continue;
                    }
                    //解析类型配置
                    String type=childElement.getAttribute("type");
                    //是否单例
                    String singleton=childElement.getAttribute("singleton");
                    //取对象id
                    String id=childElement.getAttribute("id");
                    //分割类全面和包名
                    String [] arr=type.split(",");
                    //反射得到类型
                    Class c=GetType(arr[0],arr[1]);
                    //添加到类型列表
                    classList.add(c);
                    //存储索引
                    int index=classList.size()-1;
                    Class<?> parent=c.getSuperclass();
                    //有id就存id映射
                    if(id!=null&&id!="")
                    {
                        if(classIndexMap.containsKey(id))
                        {
                            throw new Exception("已经包含了id为:"+id+"的类型");
                        }
                        classIndexMap.put(id,index);
                    }
                    //有父类就存父类映射
                    if(parent!=null)
                    {
                        String parentName=parent.getName();
                        if(!classIndexMap.containsKey(parentName))
                        {
                            classIndexMap.put(parentName,index);
                        }
                    }
                    //得到所有实现的接口
                    Class<?> interfaceArr[]=c.getInterfaces();
                    //循环存接口映射
                    if(interfaceArr!=null&&interfaceArr.length>0)
                    {
                        for(int j=0;j<interfaceArr.length;j++)
                        {
                            String interfaceName=interfaceArr[j].getName();
                            if(!classIndexMap.containsKey(interfaceName)) {
                                classIndexMap.put(interfaceName, index);
                            }
                        }
                    }
                }
            }

        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

使用容器

运行测试，成功取到PG数据库的数据

经过下午两小时的努力，LIS.Core的一个核心小功能实现了