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>

容器实现

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();
        }
    }
}

使用容器

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

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