Java usa jaxb para analisar XML (incluindo geração automática de classes de entidade com base em xml)

Exemplos de arquivo users.xml

<?xml version="1.0" encoding="UTF-8"?>
<users>
    <user id="1">
        <name>张三</name>
        <age>18</age>
    </user>
    <user id="2">
        <name>李四</name>
        <age>19</age>
    </user>    
</users>

Gerar xsd de XML

Coloque trang.jar e o xml a ser analisado no mesmo diretório, execute o seguinte comando no arquivo atual, onde users.xsd é o nome do arquivo xsd a ser gerado

java -jar trang.jar users.xml users.xsd

 

endereço de download do trang.jar: https://download.csdn.net/download/zheng_chang_wei/10617086

Gerar Bean de acordo com xsd

Depois de executar o comando acima, users.xsd será gerado no arquivo atual e, em seguida, execute o seguinte comando, onde com.bean após -p é o nome do pacote e após -d é o diretório do arquivo a ser gerado
 

  xjc -p com.bean users.xsd -d f:

Depois de executar o comando acima, a classe de entidade será gerada no diretório F: \ com \ bean

função principal

	public static void main(String[] args)  {
		String path = "users.xml";
		try {
			//解析
			Users users = (Users) JaxbUtil.unmarshaller(ObjectFactory.class, path);
			//序列化
			JaxbUtil.marshall(ObjectFactory.class, users, "users2.xml");
		}catch (Exception e) {
			e.printStackTrace();
		}
		
	}

Classe de ferramenta JaxbUtil

import java.io.File;
import java.io.FileNotFoundException;

import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import javax.xml.validation.Validator;

public class JaxbUtil {

	public static boolean validate(final String xmlPath, final String xsdPath) {
		boolean result = true;
		try {
			final String language = XMLConstants.W3C_XML_SCHEMA_NS_URI;
			final SchemaFactory factory = SchemaFactory.newInstance(language);
			final Schema schema = factory.newSchema(new File(xsdPath));
			final Validator validator = schema.newValidator();
			validator.validate(new StreamSource(xmlPath));
		} catch (final Exception e) {
			result = false;
		}
		return result;
	}

	/**
	 * 序列化
	 * @param clazz
	 * @param object
	 * @param path
	 * @throws JAXBException
	 */
	public static void marshall(final Class<?> clazz, final Object object, final String path) throws JAXBException {
		// 通过映射的类创建XMLContext上下文对象，其中参数为映射的类。
		JAXBContext jaxbContext = JAXBContext.newInstance(clazz);
		// 通过JAXBComtext上下文对象的createMarshaller()方法，创建一个对象java格式转化成XML的格式
		Marshaller marshaller = jaxbContext.createMarshaller();
		marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
		// 最后，将JAVA对象转换到制定的输出位置，其中的object为java对象。
		marshaller.marshal(object, new File(path));
	}

	/**
	 * 解析
	 * @param clazz
	 * @param path
	 * @return
	 * @throws Exception
	 */
	public static Object unmarshaller(final Class<?> clazz, final String path) throws Exception {
		if (path == null || !new File(path).exists()) {
			throw new FileNotFoundException();
		}
		// 通过映射的类创建XMLComtext上下文对象，其中参数为映射的类。
		JAXBContext jaxbContext = JAXBContext.newInstance(clazz);
		// 通过JAXBContext上下文对象创建createUnmarshaller()方法，创建XML转换成JAVA对象的格式。
		Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
		// 最后，将XML转换成对映的类，转换后需要强制性转换成映射的类
		Object object = unmarshaller.unmarshal(new File(path));
		return object;
	}
}

Resumindo

Use este método quando o xml for mais complexo para evitar escrever classes de entidade complexas sozinho.