openfire二次开发：使用Annotation注解VO转换xml文档

最新推荐文章于 2023-03-15 16:19:16 发布
最新推荐文章于 2023-03-15 16:19:16 发布
阅读量1k 收藏 1
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blademainer/article/details/9138019
版权

IQElementMapping是一个注解类，用于映射实体类与xml对象


/**
 * openfire_src
 */
package com.kingray.openfire.plugin.packet;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * IQ映射注解，用于注解实体类的字段，帮助转换器转换为xml对象
 * @author KRXiongYingqi
 * @version 2013-6-17 上午10:44:44
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.TYPE})
public @interface IQElementMapping {
	public String value();
}


VO接口，所有实体类的超类

package com.kingray.openfire.plugin.vo;

import java.io.Serializable;
/**
 * VO类，所有实体类的超类
 * @author KRXiongYingqi
 * @version 2013-6-20 下午4:02:49
 */
public interface VO extends Serializable{

}


消息实体，使用IQElementMapping注解 

package com.kingray.openfire.plugin.vo;

import java.util.Date;

import com.kingray.openfire.plugin.packet.IQElementMapping;
import com.xiongyingqi.util.DateHelper;

/**
 * 消息实体，用于存储传递时用到的查询条件或返回结果
 * @author KRXiongYingqi
 * @version 2013-6-20 下午2:14:47
 */
@IQElementMapping("message")
public class MessageVO implements VO {
	@IQElementMapping("messageId")
	private long messageId;
	
	@IQElementMapping("sendMessageId")
	private String sendMessageId;
	
	@IQElementMapping("messageFrom")
	private String messageFrom;
	
	@IQElementMapping("messageTo")
	private String messageTo;
	
	@IQElementMapping("messageSubject")
	private String messageSubject;
	
	@IQElementMapping("messageBody")
	private String messageBody;
	
	@IQElementMapping("messageDateTime")
	private Date messageDateTime;
	
	@IQElementMapping("messageDateTimeStr")
	private String messageDateTimeStr;
	
	@IQElementMapping("messageType")
	private String messageType;
	
	public MessageVO(){
	}
	public MessageVO(long messageId, String sendMessageId, String messageFrom, String messageTo, String messageBody){
		this.messageId = messageId;
		this.sendMessageId = sendMessageId;
		this.messageFrom = messageFrom;
		this.messageTo = messageTo;
		this.messageBody = messageBody;
	}
	/**
	 * @return the messageType
	 */
	public String getMessageType() {
		return messageType;
	}
	/**
	 * @param messageType the messageType to set
	 */
	public void setMessageType(String messageType) {
		this.messageType = messageType;
	}
	/**
	 * @return the messageSubject
	 */
	public String getMessageSubject() {
		return messageSubject;
	}
	/**
	 * @param messageSubject the messageSubject to set
	 */
	public void setMessageSubject(String messageSubject) {
		this.messageSubject = messageSubject;
	}
	/**
	 * @return the messageId
	 */
	public long getMessageId() {
		return messageId;
	}
	/**
	 * @param messageId the messageId to set
	 */
	public void setMessageId(long messageId) {
		this.messageId = messageId;
	}
	/**
	 * @return the sendMessageId
	 */
	public String getSendMessageId() {
		return sendMessageId;
	}
	/**
	 * @param sendMessageId the sendMessageId to set
	 */
	public void setSendMessageId(String sendMessageId) {
		this.sendMessageId = sendMessageId;
	}
	/**
	 * @return the messageFrom
	 */
	public String getMessageFrom() {
		return messageFrom;
	}
	/**
	 * @param messageFrom the messageFrom to set
	 */
	public void setMessageFrom(String messageFrom) {
		if(messageFrom == null) messageFrom = "";
		this.messageFrom = messageFrom;
	}
	/**
	 * @return the messageTo
	 */
	public String getMessageTo() {
		return messageTo;
	}
	/**
	 * @param messageTo the messageTo to set
	 */
	public void setMessageTo(String messageTo) {
		if(messageTo == null) messageTo = "";
		this.messageTo = messageTo;
	}
	/**
	 * @return the messageBody
	 */
	public String getMessageBody() {
		return messageBody;
	}
	/**
	 * @param messageBody the messageBody to set
	 */
	public void setMessageBody(String messageBody) {
		this.messageBody = messageBody;
	}
	/**
	 * @return the messageDateTime
	 */
	public Date getMessageDateTime() {
		return messageDateTime;
	}
	/**
	 * @param messageDateTime the messageDateTime to set
	 */
	public void setMessageDateTime(Date messageDateTime) {
		this.messageDateTimeStr = DateHelper.FORMATTER_LONG.format(messageDateTime);
		this.messageDateTime = messageDateTime;
	}
	/**
	 * @return the messageDateTimeStr
	 */
	public String getMessageDateTimeStr() {
		return messageDateTimeStr;
	}
	/**
	 * @param messageDateTimeStr the messageDateTimeStr to set
	 */
	public void setMessageDateTimeStr(String messageDateTimeStr) {
		this.messageDateTime = DateHelper.strToDateLong(messageDateTimeStr);
		this.messageDateTimeStr = messageDateTimeStr;
	}
	@Override
	public String toString() {
		return this.getClass() + "@" + hashCode() + ": messageId: " + messageId + ", sendMessageId: " 
				+ sendMessageId + ", messageFrom: " + messageFrom + ", messageTo: " + messageTo + ", messageBody: " 
				+ messageBody + ", messageDateTime: " + messageDateTime;
	}
}

xml转换工具，使用反射机制

/**
 * openfire_src
 */
package com.xiongyingqi.convert;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Iterator;

import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import com.kingray.openfire.plugin.packet.KingrayNameSpace;
import com.kingray.openfire.plugin.vo.VO;
import com.xiongyingqi.util.StringHelper;

/**
 * Xml转换工具
 * @author KRXiongYingqi
 * @version 2013-6-17 下午4:44:03
 */
public class XmlConvert {
	private Class annotationClass;
	
	public XmlConvert(Class annotationClass){
		this.annotationClass = annotationClass;
	}
	
	/**
	 * 由Collection<? extends VO>转换为xml，被转换的类必须由有注解类注解
	 * <br>2013-6-17 下午4:44:45
	 * @param collection 消息集合
	 * @return org.dom4j.Element
	 */
	public Element convertVOs(Collection<? extends VO> collection){
		Element element = DocumentHelper.createElement(KingrayNameSpace.QUERY_MESSAGE.getKey());
		for (Iterator iterator = collection.iterator(); iterator.hasNext();) { // 遍历集合
			Object instance =  iterator.next();
			Class instanceClass = instance.getClass();
			
			String elementName = null; 
			if(instanceClass.isAnnotationPresent(annotationClass)){ // 判断VO类是否包含了annotationClass的注解
				Annotation annotation = instanceClass.getAnnotation(annotationClass); // 获取annotationClass的注解
				Method[] methods = annotationClass.getMethods(); // 获取annotationClass的所有方法
				if(methods.length > 1){ // 如果有多个注解
					for (int i = 0; i < methods.length; i++) {
						Method method = methods[i];
						String methodName = method.getName(); // 注解方法的方法名
						
						if("value".equals(methodName)){ // 是否为value方法
							try {
								elementName = (String) method.invoke(annotation);
							} catch (IllegalArgumentException e) {
								e.printStackTrace();
							} catch (IllegalAccessException e) {
								e.printStackTrace();
							} catch (InvocationTargetException e) {
								e.printStackTrace();
							}
							break;
						}
					}
				} else if(methods.length == 1){
					Method method = methods[0];
					String methodName = method.getName(); // 注解方法的方法名
					
					if("value".equals(methodName)){ // 是否为value方法
						try {
							elementName = (String) method.invoke(annotation);
						} catch (IllegalArgumentException e) {
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							e.printStackTrace();
						} catch (InvocationTargetException e) {
							e.printStackTrace();
						}
					}
				}
				
			}
			if(StringHelper.nullOrEmpty(elementName)){
				elementName = instance.getClass().getSimpleName();
			}
			Element messageElement = DocumentHelper.createElement(elementName); // 创建节点
			
//			Class clazz = IQElementMapping.class;
			Field[] fields = instance.getClass().getDeclaredFields();
			for (int i = 0; i < fields.length; i++) { // 遍历每个字段
				Field field = fields[i];
				if(field.isAnnotationPresent(annotationClass)){ // 检测是否为IQElementMapping的注解类型
					Annotation annotation = field.getAnnotation(annotationClass);
					Method[] methods = annotationClass.getDeclaredMethods(); // 获取注解类的所有方法
					for (int j = 0; j < methods.length; j++) {
						Method annoutationMethod = methods[j];
						String fieldName = null;
						try {
							fieldName = annoutationMethod.invoke(annotation) + ""; // 获取注解方法的返回值
						} catch (IllegalArgumentException e1) {
							e1.printStackTrace();
						} catch (IllegalAccessException e1) {
							e1.printStackTrace();
						} catch (InvocationTargetException e1) {
							e1.printStackTrace();
						}
//						annotation.value();
						String fieldValue = null; // 被注解的字段的值
						try {
							String methodName = "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1); // 使用bean的方法
							Method method = instance.getClass().getDeclaredMethod(methodName);
							Object returnObject = method.invoke(instance);
							if(returnObject != null){
								fieldValue = returnObject + "";
							}
//						fieldValue = (String) field.get(messageVO);
						} catch (IllegalArgumentException e) {
							e.printStackTrace();
						} catch (IllegalAccessException e) {
							e.printStackTrace();
						} catch (SecurityException e) {
							e.printStackTrace();
						} catch (NoSuchMethodException e) {
							e.printStackTrace();
						} catch (InvocationTargetException e) {
							e.printStackTrace();
						}
						if(StringHelper.notNullAndNotEmpty(fieldValue)){
							messageElement.addAttribute(fieldName, fieldValue);  // 为每个字段设置属性
						}
					}
				}
			}
			element.add(messageElement);
		}
		return element;
	}
}


IQ处理器，用于处理客户端发送的查询IQ

package com.kingray.openfire.plugin.handler;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.jivesoftware.openfire.IQHandlerInfo;
import org.jivesoftware.openfire.IQRouter;
import org.jivesoftware.openfire.XMPPServer;
import org.jivesoftware.openfire.auth.UnauthorizedException;
import org.jivesoftware.openfire.disco.ServerFeaturesProvider;
import org.jivesoftware.openfire.handler.IQHandler;
import org.jivesoftware.openfire.session.ClientSession;
import org.xmpp.packet.IQ;
import org.xmpp.packet.JID;
import org.xmpp.packet.PacketError;

import com.kingray.openfire.plugin.dao.MessageDAO;
import com.kingray.openfire.plugin.dao.impl.MessageDAOImpl;
import com.kingray.openfire.plugin.packet.IQElementMapping;
import com.kingray.openfire.plugin.packet.KingrayNameSpace;
import com.kingray.openfire.plugin.packet.MessageHistoryIQ;
import com.kingray.openfire.plugin.vo.MessageVO;
import com.xiongyingqi.convert.XmlConvert;
import com.xiongyingqi.util.CalendarHelper;
import com.xiongyingqi.util.DateHelper;
import com.xiongyingqi.util.StringHelper;

/**
 * 服务类，用于处理客户端的数据查询等请求
 * @author XiongYingqi
 * 
 */
public class KingrayMessageHistoryIQHandler extends IQHandler implements ServerFeaturesProvider {
	private static final KingrayNameSpace QUERY_MESSAGE = KingrayNameSpace.QUERY_MESSAGE; // 命名空间
	private MessageDAO messageDAO;
	private XmlConvert convert;
	
	private IQHandlerInfo info;
	
	private String serverString;
	
	public KingrayMessageHistoryIQHandler() {
		super(QUERY_MESSAGE.getKey()); // 取一个处理器名
		messageDAO = new MessageDAOImpl();
		convert = new XmlConvert(IQElementMapping.class);
		info = new IQHandlerInfo(QUERY_MESSAGE.getKey(), QUERY_MESSAGE.getValue());
		
		XMPPServer server = XMPPServer.getInstance();
		serverString = server.getServerInfo().getXMPPDomain();
		
		// 注册IQ处理服务
		IQRouter iqRouter = server.getIQRouter();
		iqRouter.addHandler(this);
		
//		server.getServerFeaturesProviders().add(this);
//		server.getIQDiscoInfoHandler().addServerFeature(QUERY_MESSAGE.getValue());
		
	}

	@Override
	public IQ handleIQ(IQ packet) throws UnauthorizedException {
		System.out.println("packet.toXML() =========== " + packet.toXML());
		IQ response = handleMessageHistory(packet);
		
		response.setType(IQ.Type.result);
		response.setFrom(serverString);
		JID fromJid = packet.getFrom();
		ClientSession session = XMPPServer.getInstance().getSessionManager().getSession(fromJid);
		if(session == null){ // 
			response.setChildElement(packet.getChildElement().createCopy());
			response.setError(PacketError.Condition.not_authorized);
		}
//		session.process(response);
//		deliverer.deliver(response);
		
		System.out.println(this.getClass() + " handleIQ ====== " + response.toXML());
//		response = null;
		return response;
	}
	
	/**
	 * 处理消息记录
	 * <br>2013-6-18 上午9:49:27
	 * @param packet
	 * @return
	 */
	public IQ handleMessageHistory(IQ packet){
		IQ response = IQ.createResultIQ(packet);
		
		String userName = packet.getFrom().getNode();
		
		// 读取根节点数据
		Element element = packet.getChildElement();
		String relationUserName = element.attributeValue("relationUserName");
		String actionType = element.attributeValue("actionType");
		String messageDateTimeStr = element.attributeValue("messageDateTime");
		
		Date messageDateTime = null;
		if(StringHelper.notNullAndNotEmpty(messageDateTimeStr)){
			try {
				messageDateTime = DateHelper.strToDate(messageDateTimeStr);
			} catch (Exception e) {
			}
		}
		
		//读取<message节点数据>
		Collection<Long> messageIds = new HashSet<Long>();
		Collection<String> sendMessageIds = new HashSet<String>();
		
		List messageElements = element.elements();
		for (Iterator iterator = messageElements.iterator(); iterator.hasNext();) {
			Element messageElement = (Element) iterator.next();
			String messageIdStr = messageElement.attributeValue("messageId"); // 优先读取messageId
			if(StringHelper.notNullAndNotEmpty(messageIdStr)){
				Long messageId = Long.parseLong(messageIdStr);
				messageIds.add(messageId);
			} else { // 如果不存在messageId属性，则读取sendMessageId
				String sendMessageId = messageElement.attributeValue("sendMessageId");
				if(StringHelper.notNullAndNotEmpty(sendMessageId)){
					sendMessageIds.add(sendMessageId);
				}
			}
		}
		
		if(!StringHelper.notNullAndNotEmpty(actionType)){ // 判断是否指定actionType，如果没有指定，则默认使用QUERY_COUNT
			actionType = MessageHistoryIQ.MessageHistoryActionType.QUERY_COUNT.toString();
		} 
		Element resultElement = null;
		
		if(actionType.equals(MessageHistoryIQ.MessageHistoryActionType.QUERY_COUNT.toString())){ // 查询条数
			int messageHistoryCount = messageDAO.getMessageHistoryCountByUserName(userName, relationUserName, messageDateTime);
			resultElement = handleMessageHistoryCountResponseIQ(response, messageHistoryCount, relationUserName, messageDateTime);
		} else if(actionType.equals(MessageHistoryIQ.MessageHistoryActionType.QUERY_SUMMARY.toString())){ // 查询预览
			Collection<MessageVO> messageVOs = messageDAO.getMessageHistorySummaryByUserName(userName, relationUserName, messageDateTime);
			resultElement = convert.convertVOs(messageVOs); // 将获取的数据转换为xml
		} else if(actionType.equals(MessageHistoryIQ.MessageHistoryActionType.QUERY_DETAIL.toString())){ // 查询详细消息
			Collection<MessageVO> messageVOs = null;
			// 检查查询条件，如果查询条件不足，那么就返回错误
			if(messageIds != null && messageIds.size() > 0){
				messageVOs = messageDAO.getMessageHistoryDetailByMessageIds(messageIds);
			} else if(sendMessageIds != null && sendMessageIds.size() > 0){
				messageVOs = messageDAO.getMessageHistoryDetailBySendMessageIds(sendMessageIds);
			} else if(StringHelper.notNullAndNotEmpty(userName)){
				messageVOs = messageDAO.getMessageHistoryDetailByUserName(userName, relationUserName, messageDateTime);
			} else { // 查询条件不足，返回错误
				response.setChildElement(packet.getChildElement().createCopy());
				response.setError(PacketError.Condition.bad_request);
				return response;
			}
			
			if(messageVOs != null){
				resultElement = convert.convertVOs(messageVOs); // 将获取的数据转换为xml
			}
		}
		System.out.println("resultElement ======== " + resultElement);
		resultElement.addAttribute("actionType", actionType); // 加入actionType
		resultElement.addNamespace("", QUERY_MESSAGE.getValue()); // 加入命名空间
		response.setChildElement(resultElement);
		
		return response;
	}
	/**
	 * 返回总消息数的IQ
	 * <br>2013-6-17 下午3:26:22
	 * @param packet
	 * @param messageCount
	 * @param relationUserName
	 * @param messageDateTime
	 * @return
	 */
	public Element handleMessageHistoryCountResponseIQ(IQ packet, int messageHistoryCount, String relationUserName, Date messageDateTime){
		Element element = DocumentHelper.createElement(QUERY_MESSAGE.getKey());
//		Element messageHistoryCountElement = DocumentHelper.createElement("messageHistoryCount");
//		messageHistoryCountElement.setData(messageHistoryCount);
//		element.add(messageHistoryCountElement);
		element.addAttribute("messageHistoryCount", messageHistoryCount + "");
		if(StringHelper.notNullAndNotEmpty(relationUserName)){
			element.addAttribute("relationUserName", relationUserName);
		}
		if(messageDateTime != null){
			element.addAttribute("messageDateTime", DateHelper.dateToStr(messageDateTime));
		}
		element.addNamespace("", QUERY_MESSAGE.getValue()); // 加入命名空间
//		packet.setChildElement(element);
		return element;
	}
	
	/**
	 * 必须实现该方法，否则openfire将无法实例化本处理器
	 */
	@Override
	public IQHandlerInfo getInfo() {
		return info;
	}


	/**
	 * <br>2013-6-19 下午5:56:05
	 * @see org.jivesoftware.openfire.disco.ServerFeaturesProvider#getFeatures()
	 */
	@Override
	public Iterator<String> getFeatures() {
		ArrayList<String> features = new ArrayList<String>();
        features.add(QUERY_MESSAGE.getValue());
        return features.iterator();
	}

}


blademainer
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何将java对象转换成xml
03-17
NULL 博文链接：https://hfkiss44.iteye.com/blog/567137
Android XMPP 即时通讯 Openfire二次开发资料，非常齐
10-21
Android XMPP 即时通讯 Openfire 二次开发是基于 XMPP 协议的即时通讯解决方案，使用 Openfire 作为服务器端，Spark 作为客户端，Smack 作为 XMPP 传输协议的实现。XMPP 协议是一个基于 XML 的消息传递协议，...
VO对象通过groovy模板映射XML文件
iteye_13605的博客
07-10 149
介绍 之前写过JAVA+XSLT相关的技术博客，最近研究了一个开源工具包org.codehaus.groovy，处理VO对象和XML文件映射非常方便。简言之：将VO对象中的属性（包括Collection, Map），通过groovy模板，映射XML文件。 Maven pom.xml &lt;dependency&gt; &lt;groupId&gt;org.codeha...
asMapper 数据解析工具总算完成了第一步,能实现vo和xml和相互转换
dengxiao9180的博客
11-15 183
asMapper是本人写的一个actionscript的数据解析框架。能实体vo/po/pojo和xml的互相转换，方便跟服务端的交互。如果没用过vo模式开发的，大可无视此工具。 xml和vo互转的工具早就写过，不过一直没想过更快的方式。最近写java用上xscream，发现原来把vo绑定到框架里面再进行一次性解析这么方便。于是，我开始把我utils的xml工具分出个单独lib项目。一...
VO to XML converter
dream8062的专栏
05-05 649
 Actionscript代码 private function convertToXML():void  {  var product:ProductVO = new ProductVO();  product.id = 12;  product.name = ‘test product’;  product.description = ‘test des
基于JAXB实现将vo对象转化为xml字符串
lomo1122的专栏
09-09 802
package com.wtkj.zwxt.util;import java.io.StringWriter;import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBException; import javax.xml.bind.Marshaller;import com.wttech.ep.msgws.model.AuthIn
openfire_src:openfire java服务器二次开发源码-服务器
03-24
4. **二次开发**：Openfire的源码开放，允许开发者根据实际需求进行定制和扩展。例如，可以通过编写插件来增加新功能，如集成其他业务系统、添加特定的认证方式或者定制特定的消息处理逻辑。 5. **数据库支持**：...
spark+openfire二次开发含截图和详细说明
最新发布
07-21
### Spark + Openfire 二次开发知识点详解 #### 一、准备工作 在进行Spark与Openfire的二次开发前，首先需要准备必要的软件包和资源。官方推荐的版本为Openfire 3.6.4以及Spark 2.5.8。需要注意的是，Spark 2.5.8...
openfire二次开发资料整理
01-22
### Openfire二次开发资料知识点梳理 #### 一、XMPP协议概述 - **XMPP**（Extensible Messaging and Presence Protocol）是一种基于XML的即时通信协议。该协议的主要特点是使用XML作为消息格式，使得消息能够携带...
openfire二次开发
11-19
Openfire二次开发是一个深入理解并定制开源即时通讯服务器Openfire的过程。Openfire是一款基于XMPP协议的实时协作服务器，它提供了强大的聊天、会议和文件传输功能。本资料旨在指导开发者如何进行Openfire的定制和...
2017XML字符串转对象Object 实现工具
11-03
实现 XML字符串转VO对象的实现 1.0：标签读取，属性读取，List类型标签实现 以下是 测试说明 原XML： <?xml version="1.0" encoding="UTF-8"?> <HEADER NAME="HEADERname" name_cn="头名称">标签text值 版本号 时间 地址 </HEADER> <BODY> 红豆 10元 芋头 100元 </BODY> 转换为对象 xmlToObject.vo.Request（自定义） 里面还包含其他对象。 转成的对象 已JSON格式后台输出 {"body":{"class":"xmlToObject.vo.ReqBody","list":[{"class":"xmlToObject.vo.Foot","name":"红豆","rmb":"10元"},{"class":"xmlToObject.vo.Foot","name":"芋头","rmb":"100元"}]},"class":"xmlToObject.vo.Request","header":{"address":"地址","bbh":"版本号","class":"xmlToObject.vo.ReqHeader","name":"HEADERname","name_cn":"头名称","text":"标签text值\n\t\t\n\t\t\n\t\t\n\t","time":"时间"}}
xml与实体类转换工具
09-28
XML与实体类的相互转换工具，util是工具类，MyTest包含实体类转xml字符串以及XML字符串转实体类的方法，需要引入外部依赖或jar包，亲测可用
xml和java对象互相转换的两种方法
05-01
里面是xml转换成为java对象的两种方法，
xml和实体对象相互转换 一步到位
04-10
NULL 博文链接：https://crawler.iteye.com/blog/1671936
创建Vo和相应的hbm.xml
weixin_44619313的博客
04-28 392
开发工具与关键技术：MyEclipse 10、java 作者：梁添荣 撰写时间：2020-04-28 有时候我们需要一个vo类返回给页面，是结合其它实体类属性的vo，因为是查询，所有我们必须要相应的hbm.xml，如果每次去手动创建，配置，就很麻烦的，所以，做了个工具，直接生成！ package com.gx.util; import java.io.File; import java.io.F...
xml 转 VO
i心灵鸡汤you的专栏
03-24 807
package com.linzl.cn.xmlToVo; import java.io.StringReader; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import org.w3c.dom.Document; import org.w3c.dom
Java开发中利用JAXBContext 和 Unmarshaller、Marshaller 实现xml和javabean实体类之间的相互转换
u010741112的博客
10-26 1954
1.xml转javabean 1.1 xml格式如下，只有一层的： <?xml version='1.0' encoding='UTF-8'?> <root> <company>10000</company> <descr>公司</descr> <descrshort>公司简称</descrshort> <country>国家</country> <phone>电话</p
java--- xml和对象之间的互相转换
m0_56076357的博客
03-15 9004
使用定制的适配器（即扩展抽象类XmlAdapter并覆盖marshal()和unmarshal()方法），以序列化Java类为XML。，对于数组或集合（即包含多个元素的成员变量），生成一个包装该数组或集合的XML元素（称为包装器）。converter主要用于将某些字段进行复杂的转换，转换过程写在一个类中。此xstream实例，为线程安全的，可以供多个线程进行调用，共享使用。文件反序列化的时候，不需要其它辅助类和映射文件，使得。需要指定bean中的属性和xml的属性一一对应。或反序列化，使用非常方便。
caffe-ssd 训练自己的VOC数据集(一):转换VOC xml数据为lmdb格式
热门推荐
jiang_ming_的博客
07-16 1万+
假设你已经做好了VOC数据标签，也就是xml文件，并且已经配置好了caffe-ssd的环境 第一步，在caffe-ssd/data目录下本身自带有如下文件夹： 然后在caffe-ssd/data目录下新建一个文件夹命名为VOCdevkit: 然后data目录下有： 进入VOCdevkit目录内，新建VOC2007文件夹，然后再进入VOC2007文件夹内新建Annotations,I...
Openfire二次开发：打造定制化XMPP即时通讯系统
"openfire二次开发涉及XMPP协议、Openfire服务器、Spark客户端以及Smack库的使用，强调通过插件开发进行系统扩展" 在开放源码的世界里，Openfire是一个基于XMPP（Extensible Messaging and Presence Protocol）协议...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值