XML解析与反射机制的结合使用 （2）- 优化（实现调用指定类的指定方法）

xml文档

<?xml version="1.0" encoding="UTF-8"?>
<funs>
	<fun class = "com.mec.test.IntAdd" method = "add">
		<para type = "int" value = "54"></para>
		<para type = "int" value = "24"></para>
	</fun>
	<fun class = "com.mec.test.IntSub" method = "sub">
		<para type = "int" value = "54"></para>
		<para type = "int" value = "24"></para>
	</fun>
</funs>

指定类与指定方法

package com.mec.test;

public class IntAdd {
	
	public int add(int a,int b) {
		int c;
		c = a + b;
		System.out.println("a + b = " + c);
		return c;
	}

}

package com.mec.test;

public class IntSub {
	public IntSub() {
	}
	
	public int sub(int a,int b) {
		int c = a-b;
		System.out.println("a - b = " + c);
		
		return c;
	}
}

分析

• ClassBeanFactory类功能：对xml文档进行解析、调用xml文档信息中的指定类的指定方法
• Para类功能：处理参数类类型、对应类类型值的转换
• ClassDefinition功能：存储和处理从xml文档解析出来的一个fun标签的内容（类、方法、参数类型等等）

代码实现

• ClassBeanFactory类

package com.mec.parserAndReflect.core;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import org.w3c.dom.Element;

import com.mec.util.parser.XMLParser;

public class ClassBeanFactory {
	public static final Map<String,ClassDefinition> classMap = new HashMap<>();
	
	public ClassBeanFactory() {
	}
	
	public static void xmlParser(String path) {
		try {
			new XMLParser() {
				
				@Override
				public void dealElement(Element element, int index) {
					ClassDefinition classDefinition  = new ClassDefinition();
					
					String className = element.getAttribute("class");
					classDefinition.setKlass(className);
					String methodName = element.getAttribute("method");					
					new XMLParser() {
						
						@Override
						public void dealElement(Element element, int index) {
							String paraStr = element.getAttribute("type");
							String paraValueStr = element.getAttribute("value");
							classDefinition.addPara(paraStr, paraValueStr);
						}
					}.parse(element, "para");
					classDefinition.setMethod(methodName);
					try {
						classDefinition.getMethod().invoke(classDefinition.getObject(), classDefinition.getValues());
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					} catch (IllegalArgumentException e) {
						e.printStackTrace();
					} catch (InvocationTargetException e) {
						e.printStackTrace();
					}
					classMap.put(className, classDefinition);
				}
			}.parse(XMLParser.loadXML(path),"fun");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public void showMap() {
		for(String key : classMap.keySet()) {
			ClassDefinition cl = classMap.get(key);
			System.out.println("key   " + key);
			System.out.println(cl);
		}
	}
	
}

• ClassDefinition

package com.mec.parserAndReflect.core;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ClassDefinition {
	private Class<?> klass;
	private Method method;
	private List<Para> paras;
	private Object object;
	
	public ClassDefinition() {
		paras = new ArrayList<>();
	}

	public Class<?> getKlass() {
		return klass;
	}

	public void setKlass(String classname) {
		try {
			this.klass = Class.forName(classname);
			this.object = klass.newInstance();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

	public Method getMethod() {
		return method;
	}

	public void setMethod(String method) {
		try {
			this.method = this.klass.getMethod(method,getTypes());
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
	}
	
	private Class<?>[] getTypes() {
		if(paras.isEmpty()) {
			return new Class<?>[] {};
		}
		Class<?>[] types = new Class<?>[paras.size()];
		int i = 0;
		for(Para para : paras) {
			types[i++] = para.getParaklass();
		}
		return types;
	}
	
	public Object[] getValues() {
		if(paras.isEmpty()) {
			return new Object[] {};
		}
		
		Object[] values = new Object[paras.size()];
		int i = 0;
		for(Para para : paras) {
			values[i++] = para.getValue();
		}
		return values; 
	}
	
	public void addPara(String paraTypeStr,String paraValueStr) {
		Para para = new Para();
		para.setParaName(paraTypeStr);
		para.setParaklass(paraTypeStr);
		para.setValue(paraValueStr);
		
		this.paras.add(para);
	}
	
	public List<Para> getParas() {
		return paras;
	}

	public void setParas(List<Para> paras) {
		this.paras = paras;
	}

	public Object getValue() {
		return object;
	}

	public void setValue(Object value) {
		this.object = value;
	}

	public Object getObject() {
		return object;
	}

	public void setObject(Object object) {
		this.object = object;
	}

	@Override
	public String toString() {
		return "klass=" + klass + ", method=" + method + ", paras=" + paras + ", object=" + object;
	}
	
}

• Para类

package com.mec.parserAndReflect.core;

import java.util.HashMap;
import java.util.Map;

public class Para {
	public static final Map<String , Class<?>> StrClassMap = new HashMap<>();
	
	static {
		StrClassMap.put("int",int.class);
		StrClassMap.put("string", String.class);
		StrClassMap.put("byte", byte.class);
		StrClassMap.put("char", char.class);
		StrClassMap.put("short", short.class);
		StrClassMap.put("long", long.class);
		StrClassMap.put("float", float.class);
		StrClassMap.put("double", double.class);
		StrClassMap.put("boolean", boolean.class);	
	}
	
	private Class<?> paraklass;
	private String paraName;
	private Object value;
	
	public Para() {
		paraName = "";
		value = new Object();
	}

	public Class<?> getParaklass() {
		return paraklass;
	}

	public void setParaklass(String paraName) {
		Class<?> klass = StrClassMap.get(paraName);
		if(paraName == null) {
			try {
				klass = Class.forName(paraName);
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
		}
		this.paraklass = klass;
	}

	public String getParaName() {
		return paraName;
	}

	public void setParaName(String paraName) {
		this.paraName = paraName;
	}

	public Object getValue() {
		return value;
	}

	public void setValue(String valueStr) {
		this.value = setParaValue(valueStr);
	}

	public static Map<String, Class<?>> getStrclassmap() {
		return StrClassMap;
	}
	
	private Object setParaValue(String valueStr) {
		Object result = null;
		
		if(paraklass.equals(int.class)) {
			result = Integer.valueOf(valueStr);
		}
		if(paraklass.equals(double.class)) {
			result = Double.valueOf(valueStr);
		}
		if(paraklass.equals(String.class)) {
			result = String.valueOf(valueStr);
		}
		if(paraklass.equals(float.class)) {
			result = Float.valueOf(valueStr);
		}
		if(paraklass.equals(boolean.class)) {
			result = Boolean.valueOf(valueStr);
		}
		if(paraklass.equals(byte.class)) {
			result = Byte.valueOf(valueStr);
		}
		return result;
	}
	
	public void showMap() {
		for(String key : StrClassMap.keySet()) {
			Class<?> klass = StrClassMap.get(key);
			System.out.println("key: " + key + " class: " + klass);
		}
	}

	@Override
	public String toString() {
		return "paraklass=" + paraklass + ", paraName=" + paraName + ", value=" + value;
	}
}

测试

package com.mec.parserAndReflect.test;

import com.mec.parserAndReflect.core.ClassBeanFactory;

public class Test {
	public static void main(String[] args) {
		ClassBeanFactory.xmlParser("/fun.xml");
	}
}

运行结果

a + b = 78
a - b = 30