javahtml字符串 解析 java解析字符串中的标签

在日常的工作中，我们经常需要处理xml格式的字符串，比如：调用第三方接口返回xml信息，需要解析xml获取相应的结果信息，之前自己写过一个利用 Java反射解析XML字符串，并封装到指定的JavaBean中的方法，最近的工作中又使用到了第三方接口，需要处理接口返回的XML字符串信息，对解 析XML的工具方法做了重新的优化，这里记录总结一下。

首先， 我们看下面xml格式的字符串：

//这里随便在网上搜索的xml字符串，简单做了修改
firstXmlStr = "<?xml  version=\"1.0\" encoding=\"GBK\"?>" +
"" +
"" +
"1001     " +
"Realfighter   " +
"81        " +
"1001号   " +
"" +
"";
假设现在我们需要获取到其中的结果信息，拿到用户的相关信息，并封装到指定的UserBean中，如下：
/**
* xml中需要的信息封装到User
* 这里继承BaseObject用于第二个解析xml的方法
* 注意：User的属性名必须与xml字符串中的标签一致
*/
class User extends BaseObject {
String users_id;//用户ID
String users_name;//用户名
String users_group;//用户分组
String users_address;//用户地址
public String getUsers_id() {
return users_id;
}
public void setUsers_id(String users_id) {
this.users_id = users_id;
}
public String getUsers_name() {
return users_name;
}
public void setUsers_name(String users_name) {
this.users_name = users_name;
}
public String getUsers_group() {
return users_group;
}
public void setUsers_group(String users_group) {
this.users_group = users_group;
}
public String getUsers_address() {
return users_address;
}
public void setUsers_address(String users_address) {
this.users_address = users_address;
}
@Override
public String toString() {
return "User{" +
"users_id=" + users_id +
", users_name='" + users_name + '\'' +
", users_group=" + users_group +
", users_address='" + users_address + '\'' +
'}';
}
}
我们通过以下方法解析xml并封装到指定对象，如下：
/**
* 封装xml信息到指定的Object
*
* @param returnXml
* @param obj
* @return Object
* @throws
* @Title: packReturnByXml
* @author Realfighter
*/
public static Object packReturnByXml(String returnXml, Object obj) {
Field[] fields = obj.getClass().getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
String fieldname = field.getName();
try {
Pattern p = Pattern.compile(".*?"
+ fieldname + ">");
//匹配类似：1001     的字符
Matcher matcher = p.matcher(returnXml);
while (matcher.find()) {
Pattern p1 = Pattern.compile(">([^<>]*)
//匹配类似：>1001     
Matcher m1 = p1.matcher(matcher.group(0).trim());
if (m1.find()) {
String value = m1.group(1).trim().equals("") ? null
: m1.group(1).trim();
Class> beanType = field.getType();
String setMethodName = "set"
+ fieldname.substring(0, 1).toUpperCase()
+ fieldname.substring(1);
Method m = obj.getClass().getMethod(setMethodName,
beanType);
m.invoke(obj, value);
}
}
} catch (Exception e) {
continue;
}
}
return obj;
}
测试如下：
@Test
public void testFirstXmlStr() {
User user = (User) packReturnByXml(firstXmlStr, new User());
System.out.println(user.toString());
//执行结果：
//User{users_id=1001, users_name='Realfighter', users_group=81, users_address='1001号'}
}
但是如果我们获取到的xml字符串是以下的类型，上面的方法就存在问题了，因为我们匹配到的不止是一条记录，我们需要的也是多个对象，如下：
secondXmlStr = "<?xml  version=\"1.0\" encoding=\"GBK\"?>" +
"" +
"" +
"1001     " +
"Realfighter   " +
"81        " +
"1001号   " +
"" +
"" +
"1002     " +
"Realfighter2   " +
"82        " +
"1002号   " +
"" +
"";
这时候，我们就需要改进一下上面的packReturnByXml方法，对其中匹配到的对象放入数组返回，如下：
/**
* 解析xml,封装成returnbean数组
*
* @param returnXml
* @param obj
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
* @throws SecurityException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
public static BaseObject[] packReturnArrayByXml(String returnXml, BaseObject obj)
throws IllegalArgumentException, IllegalAccessException,
SecurityException, NoSuchMethodException, InvocationTargetException {
Field[] fields = obj.getClass().getDeclaredFields();
List objs = new ArrayList();
int count = 0;//临时变量，用于计算可匹配到的对象数目
for (Field field : fields) {
field.setAccessible(true);
String fieldname = field.getName();
Pattern p = Pattern.compile(".*?"
+ fieldname + ">");
Matcher matcher = p.matcher(returnXml);
while (matcher.find()) {
//对象的复制方法
Object _obj = obj.clone();
objs.add(_obj);
count++;
}
if (count > 0) {
//一旦获取到对象数组，结束循环
break;
}
}
BaseObject[] objs2 = new BaseObject[count];
for (int i = 0; i 
Object obj1 = objs.get(i);
for (Field field : fields) {
field.setAccessible(true);
String fieldname = field.getName();
try {
Pattern p = Pattern.compile(".*?"
+ fieldname + ">");
Matcher matcher = p.matcher(returnXml);
int num = 0;
while (matcher.find()) {
if (num == i) {
Pattern p1 = Pattern.compile(">([^<>]*)
Matcher m1 = p1.matcher(matcher.group(0).trim());
if (m1.find()) {
String value = m1.group(1).trim().equals("") ? null
: m1.group(1).trim();
Class> beanType = field.getType();
String setMethodName = "set"
+ fieldname.substring(0, 1)
.toUpperCase()
+ fieldname.substring(1);
Method m = obj1.getClass().getMethod(
setMethodName, beanType);
m.invoke(obj1, value);
}
}
num++;
}
} catch (NullPointerException e) {
continue;
}
}
objs2[i] = (BaseObject) obj1;
}
return objs2;
}
这里需要传入的是一个BaseObject对象，实现Cloneable接口的一个基类，实际的User对象需要继承此对象，以实现clone()，如下：
/**
* 基础的Object对象，实现Cloneable接口，用于调用clone()
*/
class BaseObject implements Cloneable {
@Override
public Object clone() {
Object obj = null;
try {
obj = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
测试如下：
@Test
public void testSecondXmlStr() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
BaseObject[] objs = packReturnArrayByXml(secondXmlStr, new User());
for (BaseObject base : objs) {
System.out.println(((User) base).toString());
}
//执行结果：
//User{users_id=1001, users_name='Realfighter', users_group=81, users_address='1001号'}
//User{users_id=1002, users_name='Realfighter2', users_group=82, users_address='1002号'}
}

总结：在XML信息比较简单的时候，不需要封装多个对象信息的时候，我们可以调用第一个方法：packReturnByXml解析xml封装到指定的对象 中，但是当xml信息比较复杂的时候，需要封装多个对象信息的时候，我们就需要将封装的对象继承BaseObject，通过调用 packReturnArrayByXml返回BaseObject数组，通过遍历数组拿到需要的相关信息。