类的封装，HashMap的使用，Xml文件的读取并构建实例，参数类型的转化

package com.gxnu.study.bean;

import java.util.AbstractMap.SimpleEntry;
import java.util.HashMap;
import java.util.Map;

public class BeanValue {
private String className;//定义类名
private Map<String,SimpleEntry<String,String>> properTyAndVal;//三值Hash

{
this.properTyAndVal = new HashMap<>();//创建实例
}

public BeanValue() {
super();
// TODO Auto-generated constructor stub
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public Map<String, SimpleEntry<String, String>> getProperTyAndVal() {
return properTyAndVal;
}

public void setProperTyAndVal(Map<String, SimpleEntry<String, String>> properTyAndVal) {
this.properTyAndVal = properTyAndVal;
}
public void add(String name,String type,String value){
this.properTyAndVal.put(name, new SimpleEntry(type,value));//给定三个值，put到HashMap中
}
@Override
public String toString() {
return "BeanValue [className=" + className + ", properTyAndVal=" + properTyAndVal + "]";
}

}

 

 

//Student类

package com.gxnu.study.bean;

public class Student {
private String name;//定义姓名
private double height;//定义身高
private String sex;//定义性别
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, double height, String sex) {
super();
this.name = name;
this.height = height;
this.sex = sex;
}
@Override
public String toString() {
return "Student [name=" + name + ", height=" + height + ", sex=" + sex + "]";
}

}

 

 

 

 

package com.gxnu.study.bean;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.AbstractMap.SimpleEntry;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XMLToBeanValue {
/**
* 传文件名参数，输出BeanValue
* @param fileName
* @return
*/
public static BeanValue readXml(String fileName) {

BeanValue beanValue = new BeanValue();//创建BeanValue实例
Document document = init(fileName);//调用下方的init方法，返回文档

// <student>
Element element = (Element) document.getChildNodes().item(0);//获取文档首个子节点
// System.out.println(element.getNodeName() + "\t" +
// element.getNodeValue());
String className = element.getAttribute("class");//获取当前子节点属性为class的值赋给类名
// System.out.println(className);
beanValue.setClassName(className);//给beanValue里边的className赋值

beanValue.setProperTyAndVal(getField( element));//调用下边的getField方法返回值作为参数给beanValue里边的类型和值赋值
return beanValue;//返回beanValue

}

/**
* getField方法，传入Element元素返回HashMap值
* @param element
* @return
*/
private static Map<String,SimpleEntry<String,String>> getField( Element element) {
Map<String,SimpleEntry<String,String>> map = new HashMap<>();//创建HashMap实例

NodeList childNodes = element.getChildNodes();//通过参数获取子节点
// System.out.println(childNodes.getLength());
for (int i = 0; i < childNodes.getLength(); i++) {//遍历结点
Node temp = childNodes.item(i);//接收结点
// System.out.println(temp);
// System.out.println(temp.getNodeType());
if (temp.getNodeType() == Node.ELEMENT_NODE) {//判断是否为Element结点
String nodeName = temp.getNodeName();//获取结点的名字作为属性
Element elementN = (Element) temp;//结点强制转为Element元素

String sValue = getVaOrTy(elementN, "value");//传入Element元素和子节点名，调用getVaOrTy方法，返回值
String sType = getVaOrTy(elementN, "type");
map.put(nodeName, new SimpleEntry(sType,sValue));//把获取到的值放到HashMap中
System.out.println(nodeName+"\t"+sType+"\t"+sValue);
}
}
return map;//返回值map
}

/**
* 传入Element元素和值或者类型，输出子节点的属性值
* @param elementN
* @param valOrTy
* @return
*/
private static String getVaOrTy(Element elementN, String valOrTy) {
String valueOrType = elementN.getAttribute(valOrTy);//获取属性（包括值和类型）的值
if (valueOrType == null || valueOrType.equals("")) {//判断属性是否为空
valueOrType = elementN.getElementsByTagName(valOrTy).item(0).getTextContent();//获取元素的子节点的值
// valueOrType = valueElm.getTextContent();
// System.out.println("dfjdkf:::"+valueOrType);
}
return valueOrType;//返回属性或子节点的值
}

/**
* 传入文件名返回Document类型的值
* @param filename
* @return
*/
private static Document init(String filename) {
Document document = null;

try {
// 工厂模式
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 构建模式
DocumentBuilder documentBuilder = factory.newDocumentBuilder();
// Class 里边的getResourceAsStream("/");如果以/开头，就到classPath中找这个文件
try (InputStream is = BeanValue.class.getClass().getResourceAsStream(filename);) {//自动关闭
document = documentBuilder.parse(is);//读取输入源
}
} catch (ParserConfigurationException | SAXException | IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

return document;//返回文档
}

/**
* 类型（字符串）转为Class类型
* @param name
* @return
*/
public static Class TpyeToClass(String name){
Class clz = null;
switch(name){//Stirng enum
case "double":
clz=double.class;
break;
case "float":
clz=float.class;
break;
case "char":
clz=char.class;
break;
case "byte":
clz=byte.class;
break;
case "short":
clz=short.class;
break;
case "int":
clz=int.class;
break;
case "long":
clz=long.class;
break;

case "boolean":
clz=boolean.class;
break;
default:
try {
clz=Class.forName(name);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
}
return clz;
}

/**
* 根据参数的类型，从而改变值的类型，返回对象值
* @param clas
* @param value
* @return
*/
public static Object ValueToObject(Class clas, String value){
Object obj = null;
if(clas == String.class){
obj = value;
}else if(clas == boolean.class || clas == Boolean.class){
obj = value;
}else if(clas == int.class){
obj = Integer.valueOf(value);
}else if(clas == long.class){
obj = Long.valueOf(value);
}else if(clas == short.class){
obj = Short.valueOf(value);
}else if(clas == byte.class){
obj = Byte.valueOf(value);
}else if(clas == char.class){
obj = value.charAt(0);
}else if(clas == float.class){
obj = Float.valueOf(value);
}else if(clas == double.class){
obj = Double.valueOf(value);
}
return obj;
}
}

 

 

 

 

 

package com.gxnu.study.trans;

import java.lang.reflect.Method;
import java.util.AbstractMap.SimpleEntry;
import java.util.Map;

import org.apache.commons.lang.StringUtils;

import com.gxnu.study.bean.BeanValue;
import com.gxnu.study.bean.Student;
import com.gxnu.study.bean.XMLToBeanValue;

public class BeanValueToStu {
/**
* 传入BeanValue转为Student类型
* @param beanValue
* @return
*/
public Student transform(BeanValue beanValue){
String className = beanValue.getClassName();//参数beanValue获取类名
Object target=null;
try {
Class<?> clazz = Class.forName(className);//加载类,赋给clazz
target = clazz.newInstance();//用此类创建一个实例，赋给target
this.implem(clazz,target,beanValue.getProperTyAndVal());//调用以下implem方法,传入类，实例，以及调用beanValue中的方法获取类型和值
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return (Student) target;
}

/**
* 传入类，实例对象和HashMap来实现方法名的实现，以及参数类型和值的转变
* @param clazz
* @param obj
* @param map
*/
public void implem(Class clazz,Object obj,Map<String,SimpleEntry<String,String>>map){
map.forEach((name,pair)->{
String methodName = this.MethodName(name);//map中的第一个值调用以下方法将属性转为set(name)的首字母大写得到set方法
Class paramClass=XMLToBeanValue.TpyeToClass(pair.getKey());//调用方法将参数类型字符串转为Class
try {
Method method = clazz.getMethod(methodName, paramClass);//传入方法名和参数类型调用系统的getMethod方法
//传入实例，值实现方法，值通过调用方法将String值转为指定类型的值
method.invoke(obj, XMLToBeanValue.ValueToObject(paramClass, pair.getValue()));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
});
}

/**
* 传入一个值，属性，将其变为set方法，并将其首字母变成大写字母
* @param field
* @return
*/
public String MethodName(String field){
return "set"+StringUtils.capitalise(field);//返回setField field的首字母大写
}
}

 

 

 

package com.gxnu.study.xml;

import java.util.AbstractMap.SimpleEntry;
import java.util.HashMap;
import java.util.Map;

import org.junit.Test;

import com.gxnu.study.bean.BeanValue;
import com.gxnu.study.bean.Student;
import com.gxnu.study.bean.XMLToBeanValue;
import com.gxnu.study.trans.BeanValueToStu;

public class XmlEx2 {

@Test
/**
* 测试BeanValueToStu
*/
public void testBeanValueToStu(){
BeanValueToStu bvts = new BeanValueToStu();//"/student.xml" 创建实例
//调用XMLToBeanValue中的readXml方法读取文件 作为参数值进而调用transform方法返回Student
Student stu = bvts.transform(XMLToBeanValue.readXml("/student.xml"));
System.out.println(stu);//返回stu
}
@Test
public void testXml(){
BeanValue readXml = XMLToBeanValue.readXml("/student.xml");//调用readXml方法
System.out.println(readXml);
}
@Test
public void testTriValue(){//测试Map（三个值）
String s1="name";
String t1= "java.lang.String";
String v1="zhangsan";

String s2="height";
String t2= "double";
String v2="167";

String s3="sex";
String t3= "boolean";
String v3="true";

String s4="ear";
String t4= "int";
String v4="2";

Map<String,SimpleEntry<String,String>> map = new HashMap<>();
for(int i=0;i<4;i++){

}
map.put(s1, new SimpleEntry(t1,v1));
map.put(s2, new SimpleEntry(t2,v3));
map.put(s3, new SimpleEntry(t3,v3));
map.put(s4, new SimpleEntry(t4,v4));

map.forEach((name,tyAndVal)->System.out.println(name+"\t"+tyAndVal.getKey()+"\t"+tyAndVal.getValue()));
}

}

 

 

 

<!-- 属性文件  -->

<?xml version="1.0" encoding="UTF-8"?>

<student class="com.gxnu.study.bean.Student">
<name value="zhangsan" type="java.lang.String"></name>
<height type="double">
<value>163</value>
</height>
<!-- 注释 -->
<!-- -->
<!-- [CDATA[<html><xiao>阿黄</xiao></html>]] -->
<sex>
<value>true</value>
<type>java.lang.String</type>
</sex>
</student>

转载于:https://www.cnblogs.com/jiminluo/p/9362730.html