精华内容
下载资源
问答
  • java生成xsd,xml示例

    热门讨论 2014-04-17 10:20:29
    java生成xsd,xml示例
  • xsd 生成 java 类In last few posts, we learned about Java JAXB and how to generate java class from XSD. Today we will learn how to generate XSD from java classes. 在最近的几篇文章中,我们了解了Java ...

    xsd 生成 java 类

    In last few posts, we learned about Java JAXB and how to generate java class from XSD. Today we will learn how to generate XSD from java classes.

    在最近的几篇文章中,我们了解了Java JAXB以及如何从XSD生成Java类 。 今天,我们将学习如何从Java类生成XSD。

    从Java类生成XSD (Generate XSD from Java Class)

    We will use JAXB-2 Maven Plugin in a maven project to generate XSD from java classes.

    我们将在maven项目中使用JAXB-2 Maven插件从Java类生成XSD。

    • JAXB2 Maven Plugin uses JAXB SchemaGenerator utility to generate XSD from java classes.

      JAXB2 Maven插件使用JAXB SchemaGenerator实用程序从Java类生成XSD。
    • Java classes should have JAXB annotations to be used by this plugin.

      Java类应具有此插件要使用的JAXB批注。
    • Minimum java version required is Java 5

      所需的最低Java版本是Java 5

    First create a new maven project, you can give any name, group id and artifact id you want. Once we will build our project, it will generate XSD classes in target/generated-resources/schemagen directory.

    首先创建一个新的Maven项目,您可以提供所需的任何名称,组ID和工件ID。 构建项目后,它将在target/generated-resources/schemagen目录中生成XSD类。

    After build, our project structure will look like below image.

    构建后,我们的项目结构将如下图所示。

    Here is the final pom.xml file we have:

    这是我们拥有的最终pom.xml文件:

    <project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>jaxb-schemagen</groupId>
    	<artifactId>jaxb-schemagen</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<dependencies>
    		<dependency>
    			<groupId>javax.xml.bind</groupId>
    			<artifactId>jaxb-api</artifactId>
    			<version>2.1</version>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<pluginManagement>
    			<plugins>
    				<plugin>
    					<groupId>org.apache.maven.plugins</groupId>
    					<artifactId>maven-compiler-plugin</artifactId>
    					<version>2.5.1</version>
    				</plugin>
    			</plugins>
    		</pluginManagement>
    
    		<plugins>
    			<plugin>
    				<groupId>org.codehaus.mojo</groupId>
    				<artifactId>jaxb2-maven-plugin</artifactId>
    				<version>1.5</version>
    				<executions>
    					<execution>
    						<id>schemagen</id>
    						<goals>
    							<goal>schemagen</goal>
    						</goals>
    					</execution>
    				</executions>
    
    				<configuration>
    					<transformSchemas>
    						<transformSchema>
    							<uri>https://www.example.org/employee</uri>
    							<toPrefix>empns</toPrefix>
    							<toFile>employee.xsd</toFile>
    						</transformSchema>
    						<transformSchema>
    							<uri>https://www.example.org/address</uri>
    							<toPrefix>addrns</toPrefix>
    							<toFile>address.xsd</toFile>
    						</transformSchema>
    					</transformSchemas>
    					<includes>
    						<include>com/journaldev/bean/*</include>
    					</includes>
    					<verbose>true</verbose>
    
    				</configuration>
    			</plugin>
    		</plugins>
    	</build>
    </project>

    Few things to notice are jaxb dependency, schemagen execution goal and transformSchema configuration. transformSchema configuration is used to specify the XSD file name generated and namespace prefix to be used in the XSD file.

    很少注意的是jaxb依赖关系, schemagen执行目标和transformSchema配置。 transformSchema配置用于指定生成的XSD文件名和要在XSD文件中使用的名称空间前缀。

    Here are the java classes we have that will be used to generate XSD.

    这是我们将用于生成XSD的Java类。

    Employee.java

    Employee.java

    package com.journaldev.bean;
    
    
    import javax.xml.bind.annotation.XmlAttribute;
    import javax.xml.bind.annotation.XmlType;
    
    @XmlType(namespace = "https://www.example.org/employee")
    public class Employee {
        private String name;
        private int id;
        private String role;
        private Address address;
    
    
        public String getName() {
            return name;
        }
    
    
        public void setName(String name) {
            this.name = name;
        }
    
    
        @XmlAttribute
        public int getId() {
            return id;
        }
    
    
        public void setId(int id) {
            this.id = id;
        }
    
    
        public String getRole() {
            return role;
        }
    
    
        public void setRole(String role) {
            this.role = role;
        }
    
    
        public Address getAddress() {
            return address;
        }
    
    
        public void setAddress(Address address) {
            this.address = address;
        }
    }

    Notice the XmlType annotation with namespace used for the class and XmlAttribute for the field id. This class will generate employee.xsd schema once we build the project.

    请注意, XmlType批注带有用于类的名称空间,而XmlAttribute用于字段ID。 一旦我们构建项目,该类将生成employee.xsd模式。

    As you can see that it has a field Address that is another custom class, so we need to annotate this class also for successful schema generation.

    如您所见,它的字段Address是另一个自定义类,因此为了成功生成模式,我们还需要注释该类。

    Here is the address class with jaxb annotations.

    这是带有jaxb批注的地址类。

    Address.java

    Address.java

    package com.journaldev.bean;
    
    import javax.xml.bind.annotation.XmlType;
    
    @XmlType(namespace = "https://www.example.org/address")
    public class Address {
        private String city;
        private int zip;
        private String addressLine1;
        private String addressLine2;
        public String getCity() {
            return city;
        }
        public void setCity(String city) {
            this.city = city;
        }
        public int getZip() {
            return zip;
        }
        public void setZip(int zip) {
            this.zip = zip;
        }
        public String getAddressLine1() {
            return addressLine1;
        }
        public void setAddressLine1(String addressLine1) {
            this.addressLine1 = addressLine1;
        }
        public String getAddressLine2() {
            return addressLine2;
        }
        public void setAddressLine2(String addressLine2) {
            this.addressLine2 = addressLine2;
        }
        
    }

    This class will generate address.xsd because it’s name is matched in transformSchema in pom.xml file.

    此类将生成address.xsd,因为其名称在pom.xml文件的transformSchema中匹配。

    Our project setup is ready, just build the project using command mvn clean install and the XSD files will be generated. For my project, generated XSD files are as below.

    我们的项目设置已准备就绪,只需使用命令mvn clean install构建项目,然后将生成XSD文件。 对于我的项目,生成的XSD文件如下。

    employee.xsd

    employee.xsd

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="https://www.w3.org/2001/XMLSchema" xmlns:addrns="https://www.example.org/address" targetNamespace="https://www.example.org/employee" version="1.0">
    
      <xs:import namespace="https://www.example.org/address" schemaLocation="address.xsd"/>
    
      <xs:complexType name="employee">
        <xs:sequence>
          <xs:element minOccurs="0" name="address" type="ns1:address"/>
          <xs:element minOccurs="0" name="name" type="xs:string"/>
          <xs:element minOccurs="0" name="role" type="xs:string"/>
        </xs:sequence>
        <xs:attribute name="id" type="xs:int" use="required"/>
      </xs:complexType>
    </xs:schema>

    address.xsd

    address.xsd

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <xs:schema xmlns:xs="https://www.w3.org/2001/XMLSchema" targetNamespace="https://www.example.org/address" version="1.0">
    
      <xs:complexType name="address">
        <xs:sequence>
          <xs:element minOccurs="0" name="addressLine1" type="xs:string"/>
          <xs:element minOccurs="0" name="addressLine2" type="xs:string"/>
          <xs:element minOccurs="0" name="city" type="xs:string"/>
          <xs:element name="zip" type="xs:int"/>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>

    That’s all for generating XSD from java class. It’s very simple and great way for java class to XSD generation. I hope you will find it useful and easy to understand.

    这就是从java类生成XSD的全部。 这是将Java类生成XSD的非常简单且绝佳的方法。 我希望您会发现它有用且易于理解。

    翻译自: https://www.journaldev.com/1316/generate-xsd-from-java-class

    xsd 生成 java 类

    展开全文
  • java 生成XSD

    千次阅读 2014-04-11 10:57:42
    import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; import org.dom4j.Document; import

    复合类型封装:

    package org.tbyf;
    
    /**
     * 复合类型封装
     * 
     * @author 杨虹昌
     */
    public class ElementNode {
    	private String name;// 元素名
    	private String type="xs:string";// 类型名
    
    	
    	public ElementNode(String name) {
    		this.name = name;
    	}
    
    	public ElementNode() {
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getType() {
    		return type;
    	}
    
    	public void setType(String type) {
    		this.type = type;
    	}
    
    	public ElementNode(String name, String type) {
    		super();
    		this.name = name;
    		this.type = type;
    	}
    
    }
    

    XSD生成类封装:

    package org.tbyf;
    
    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.util.List;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    
    /**
     * xsd 生成
     * @author YHC
     */
    public class XSDGenerate {
    	//文档对象
    	private Document document;
        private Element header;
        private Element body;
        private Element request;
        private Element root;
        
        
    	/**
    	 * 初始化XSD
    	 */
    	public XSDGenerate() {
    		document= DocumentHelper.createDocument();
    		root=initRootElement();
    		request=createRequest();
    	}
    	
    	/**
    	 * 初始化头部信息
    	 * @return
    	 */
    	private Element initRootElement(){
    		Element root = document.addElement("xs:schema");
    		root.addNamespace("xs", "http://www.w3.org/2001/XMLSchema");
    		root.addAttribute("elementFormDefault", "qualified");
    		root.addAttribute("attributeFormDefault", "unqualified");
    		return root;
    	}
    	
    	/**
    	 * 构造头部
    	 */
    	private Element createHeader(){
    		 Element header = request.addElement("xs:element");
    		 header.addAttribute("name", "Header");
    		return header;
    	}
    	
    	/**
    	 * 构造Body
    	 */
    	private Element createBody(){
    		 Element body = request.addElement("xs:element");
    		 body.addAttribute("name", "Body");
    		return body;
    	}
    	
    	/**
    	 * 构造Body
    	 */
    	private Element createRequest(){
    		 Element request = root.addElement("xs:element");
    		 request.addAttribute("name", "Request");
    		 //
    		 Element complexType=request.addElement("xs:complexType");
    		 Element sqeuence=complexType.addElement("xs:sequence");
    		 //
    		 header=sqeuence.addElement("xs:element");
    		 header.addAttribute("name", "Header");
    		 //
    		 body=sqeuence.addElement("xs:element");
    		 body.addAttribute("name", "Body");
    		 
    		return request;
    	}
    
    	/**
    	 * 新增复合元素
    	 * @param typeName 元素名
    	 * @param elementNodes  元素节点名
    	 * @return
    	 */
    	public void addComplexType(String typeName,List<ElementNode> elementNodes){
    		Element complexType=root.addElement("xs:complexType");
    		complexType.addAttribute("name", typeName);
    		Element sqeuence=complexType.addElement("xs:sequence");
    		//添加元素
    		for (int i = 0; i < elementNodes.size(); i++) {
    			Element ele=sqeuence.addElement("xs:element");
    			ele.addAttribute("name", elementNodes.get(i).getName());
    			ele.addAttribute("type", elementNodes.get(i).getType());
    		}
    	}
    	
    	
    	//=======================================getter setter
    	/**
    	 * 获取头部
    	 * @param complexTypeName 复合类型名称
    	 * @return
    	 */
    	private Element initHeader(String complexTypeName) {
    		 header.addAttribute("type", complexTypeName);
    		 List list=root.selectNodes("./xs:complexType[@name='"+complexTypeName+"']");
    		 if(list.size()==0){
    			 throw new RuntimeException("不存在复合类型\""+complexTypeName+"\"请选择正确的复合类型名.");
    		 }
    		 return header;
    	}
    
    	/**
    	 * 获得Body元素
    	 * @param complexTypeName 复合类型名称
    	 * @return
    	 */
    	private Element initBody(String complexTypeName) {
    		 body.addAttribute("type", complexTypeName);
    		 List list=root.selectNodes("./xs:complexType[@name='"+complexTypeName+"']");
    		 if(list.size()==0){
    			 throw new RuntimeException("不存在复合类型\""+complexTypeName+"\"请选择正确的复合类型名.");
    		 }
    		 return body;
    	}
    	
    	/**
    	 * 初始化Header与Body
    	 * @param headerComplexTypeName 头部复合名称
    	 * @param bodyComplexTypeName   body复合名称
    	 */
    	public void initHeaderBody(String headerComplexTypeName,String bodyComplexTypeName){
    		initHeader(headerComplexTypeName);
    		initBody(bodyComplexTypeName);
    	}
    	
    	
    	/**
    	 * 改变元素复合类型名称
    	 * @param xPathQuery
    	 * @param complexTypeName
    	 */
    	public void changeElementTypeName(String xPathQuery,String complexTypeName){
    		List list=root.selectNodes(xPathQuery);
    		if(list.size()==0){
    			 throw new RuntimeException("没有搜索到"+xPathQuery+"路径下的任何元素.");
    		}
    		
    		if(list.size()>1){
    			 throw new RuntimeException("在此路径下"+xPathQuery+"搜索到多个元素.");
    		}
    		Element element=(Element) list.get(0);
    		element.addAttribute("type", complexTypeName);
    	}
    	
    	/***
    	 * 写出
    	 */
    	public void writeToDisk(){
    		try {
    			OutputFormat format = OutputFormat.createPrettyPrint();   
    			XMLWriter writer = new XMLWriter(new FileWriter(
    					new File("test.xsd")),format);
    			writer.write(document);
    			writer.close();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }
    




    调用代码示例:

     XSDGenerate generate=new XSDGenerate();
            generate.addComplexType("User", Arrays.asList(new ElementNode("id"),new ElementNode("name"),new ElementNode("role","Role")));
            generate.addComplexType("Role", Arrays.asList(new ElementNode("id"),new ElementNode("roleName")));
            generate.addComplexType("Organization", Arrays.asList(new ElementNode("id"),new ElementNode("orgName")));
            generate.initHeaderBody("User", "Organization");
    //        generate.changeElementTypeName("./xs:complexType[@name='User']/xs:sequence/xs:element[@name='role']", "Role");
            generate.writeToDisk();


    生成结果:

    <?xml version="1.0" encoding="UTF-8"?>
    
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
      <xs:element name="Request">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="Header" type="User"/>
            <xs:element name="Body" type="Organization"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
      <xs:complexType name="User">
        <xs:sequence>
          <xs:element name="id" type="xs:string"/>
          <xs:element name="name" type="xs:string"/>
          <xs:element name="role" type="Role"/>
        </xs:sequence>
      </xs:complexType>
      <xs:complexType name="Role">
        <xs:sequence>
          <xs:element name="id" type="xs:string"/>
          <xs:element name="roleName" type="xs:string"/>
        </xs:sequence>
      </xs:complexType>
      <xs:complexType name="Organization">
        <xs:sequence>
          <xs:element name="id" type="xs:string"/>
          <xs:element name="orgName" type="xs:string"/>
        </xs:sequence>
      </xs:complexType>
    </xs:schema>
    






    展开全文
  • 生成Xsd工具

    热门讨论 2012-11-29 16:14:42
    由xml生成xsd工具,简单易用。
  • java根据xml生成schema_xsd_生成javabean
  • xml生成xsd

    2017-11-30 16:30:13
    可以通过xml生成想要的xsd文件。减少开发人员的时间浪费,
  • xml生成xsd工具

    热门讨论 2013-11-07 23:05:41
    xml生成xsd 使用方法:java -jar trang.jar EchoRequest.xml EchoRequest.xsd
  • xsd生成javaBean

    2018-12-13 16:37:22
    根据xsd文件一键生成javaBean,无需引用任何其他配置,所有依赖jar包已经完整提供
  • 使用jaxb根据xsd生成xml文档

    热门讨论 2012-02-21 16:51:24
    使用jaxb根据xsd生成xml文档,不要积分的,赶快下载
  • JAXB 利用xsd文件生成java

    热门讨论 2014-02-08 13:19:07
    编写xsd文件,利用jaxb生成java类。
  • 根据xsd批量生成java

    2014-03-20 16:18:53
    根据xsd批量生成java类,觉得很方便也很酷。但是有时候xsd生成java类中含有汉字,结果总是有些问题。 可是xjc命令参数又没有encoding参数之类的。在网上搜了一通,忽然发现了一个好东东:xjc是由...
  • xsd2java gradle 插件 用于从 xsd 模式生成 java 的 Gradle 插件 问题 如果您对插件有任何问题,请在 github 上提交问题, 贡献 只要他们是理智的,就欢迎贡献。 贡献者 尼尔斯·拉尔斯格德, 马茨·福格利, 托本·...
  • 3.1 单个xsd文件转换为Java对象 3.2 N个xsd文件转换为Java对象 1 什么是XSD(XML Schema Definition)? 定义(来自百度百科) XML Schema Definition 缩写.可扩展标记语言架构是以可扩展标记语言(标准通用标记...

    目录

     

    1 什么是XSD(XML Schema Definition)?

    2 xjc命令

    3 实战

    3.1 单个xsd文件转换为Java对象

    3.2 N个xsd文件转换为Java对象


    1 什么是XSD(XML Schema Definition)?

    定义(来自百度百科)

    XML Schema Definition 缩写.可扩展标记语言架构是以可扩展标记语言(标准通用标记语言的子集)为基础的,它用于可替代文档类型定义(外语缩写:DTD);一份XML schema文件描述了可扩展标记语言文档的结构。

    它的作用是定义一份XML文档的合法组件群,就像文档类型定义(外语缩写:DTD)的作用一样,一份XML Schema定义了:

    • 可以出现在文档里的元素;

    • 可以出现在文档里的属性;

    • 哪些元素是子元素;

    • 子元素的顺序;

    • 子元素的数量;

    • 一个元素应是否能包含文本,或应该是空的;

    • 元素和属性的数据类型;

    • 元素和属性的默认值和固定值。

    2 xjc命令

    xjc属于jdk 的命令行工具,用于将schema文件生成java实体类。关于详细命令介绍,可参考该网站相关文档

    演示的是最简单的命令,使用了很多默认参数,实际上xjc支持的参数非常多,列举常用的几个参数及其含义。

    参数取值含义
    -bfile/dir指定其他的binding 文件 或文件夹
    -ddir,默认为generated生成的文件存放在该文件夹下
    -ppkg,默认为generated生成的Java文件使用的包名
    -xmlschema默认指定输入为W3C XML Schema
    -relaxng 指定输入为 RELAX NG
    -relaxng-compact 指定输入为 RELAX NG compact
    dtd 指定输入为 XML DTD
    -version 查看 xjc 的版本
    1. 指定生成的 java 文件的包名: xjc -p com.traing.bean book.xsd 可以在生成的文件E:/JAXB/com/traing/book/Book.java中发现指定的包名。 package com.traing.bean;

    2. 指定生成的 java 文件路径: xjc book.xsd -d e:\JAXB\com 可以发现生成的文件位于E:/JAXB/com/Book.java,值得注意的是,这里的e:\JAXB\com必须是一个存在的文件夹,否则不成功,错误提示拒绝写入不存在的目录 "e:\JAXB\com"
    3. 将其他格式的 schema 转化为Java对象: xjc student.dtd -dtd 可以发现生成的文件E:/JAXB/generated/Student.java,此外还有其他的一些文件。 
    4. 一次性指定多个需要转换 schema 文件: xjc student.xsd grade.xsd 不用一个个转换了,可以指定多个schema文件,不过两个 schema 文件不能有重复的属性。

    3 实战

    3.1 单个xsd文件转换为Java对象

    在cmd窗口,进入到xsd文件所在目录,执行如下命令,转换的java对象默认会生成到当前文件夹下。

    xjc mytest.xsd -p com.bighuan.app.xmlschema.mytest -encoding UTF-8

    一些说明:com.bighuan.app.xmlschema.mytest是生成Java类的包名,其他配置都是默认。

    3.2 N个xsd文件转换为Java对象

    N个xsd文件转换到对应的Java对象比较麻烦,自己网上查了一些资料,通过代码实现对应的转换。

    准备工作:首先将所有需要转换的xsd文件放置到一个文件夹(eg:C:\\Users\\Administrator\\IdeaProjects\\xxxx\\xsd)下,并且在该文件夹先创建一个Test.java类

    Test类源码如下,注释里有对应的说明。

    /**
     *
     * @author: bighuan
     * @version: 1.0
     * @date: 2020/7/23
     * @time: 17:32
     * @description: 描述
     */
    public class Test {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            String path = "C:\\Users\\Administrator\\IdeaProjects\\xxxx\\xsd";
            File file = new File(path);
            File[] files = file.listFiles();
            System.out.println(files.length);
            for (File currFile:files) {
               // list.add("文件名:"+currFile.getName());
                System.out.println("文件名:"+currFile.getName());
    
                try {
                    // String cmdStr = "cmd /c rd/s/q e:\\test" ;
                    
                    String name = currFile.getName(); // pcac.ries.052.xsd
                    if(name.equals("Test.java")){
                        continue;
                    }
                    // 去掉.xsd后缀,并将文件名中的.替换为_,最终作为包名的一部分,看自己需求做改动
                    String packname=name.substring(0,name.length()-4).replace(".","_");
                    System.out.println("packname:"+packname);
                    // 很重要的一步:就是拼接xjc转换xsd文件为Java类的命令,然后通过循环实现批量
                    // XSD文件转换为Java类
                    String cmdStr = "cmd /c xjc "+name+" -p com.bighuan.app.xmlschema."+packname+" -encoding UTF-8" ;
                    // 原理:java的Runtime.getRuntime().exec("cmd命令")可以调用执行cmd指令。 
                    Runtime.getRuntime().exec(cmdStr);
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
    
        }
    }

    关于Java调用windows的cmd.exe命令,可以参考该博客

    接下来,就是执行Test的main方法了。进入Test所在文件夹下,分别执行命令如下(ps:感觉回到了刚学Java的时候):

    javac Test.java 

    java Test

    最终就实现了批量xsd文件转java的功能,如果xsd文件很多,一条命令一条命令来执行转换就太劳民伤财了。

    展开全文
  • 使用JAXB从XSD生成XML

    2020-05-01 18:55:39
    Mohamed解释了如何使用JAXB从给定的XSD生成XML 。 (注意:对原始帖子进行了少量编辑以提高可读性) 我们可以使用JAXB使用给定的Schema将Java对象编组为XML,反之亦然。 可以以DTD , XSD或其他格式指定XML模式。...
    这是最初由JCG合作伙伴 Experiences UnlimitedMohamed Sanaulla发表的帖子。 Mohamed解释了如何使用JAXB从给定的XSD生成XML

    (注意:对原始帖子进行了少量编辑以提高可读性)

    我们可以使用JAXB使用给定的Schema将Java对象编组为XML,反之亦然。 可以以DTDXSD或其他格式指定XML模式。

    工具“ xjc”可用于从XSD架构生成带注释的Java类。 可以下载Java Web服务开发人员包(WSDP) ,其中包括所需的JAXB实现工具。 在这里,我将阐明如何动态生成XML。

    使用的样本XSD是:

    – Expense.xsd

    <?xml version="1.0"?>
    <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="expenseReport" type="ExpenseT" />
    <xs:complexType name="ExpenseT">
        <xs:sequence>
            <xs:element name="user" type="UserT"/>
            <xs:element name="items" type="ItemListT"/>
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="UserT">
        <xs:sequence>
            <xs:element name="userName" type="xs:string" />
        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ItemListT">
         <xs:sequence>
             <xs:element name="item" type="ItemT" maxOccurs="unbounded"/>
         </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ItemT">
         <xs:sequence>
             <xs:element name="itemName" type="xs:string" />
             <xs:element name="purchasedOn" type="xs:string" />
             <xs:element name="amount" type="xs:decimal" />
         </xs:sequence>
    </xs:complexType>
    </xs:schema>

    现在,我们使用xjc工具生成相应的Java类。 对生成的Java类进行适当的注释。 我不会详细介绍类的注释,因为这会使事情变得复杂。

    xjc.exe费用.xsd

    默认情况下,该命令在名为“ generated”的目录中生成Java类。 有很多可以与xjc一起使用的选项,并且可以看看使用

    xjc-帮助

    下面的Main类使用生成的类来创建XML。

    – Main.java

    package generated;
     
    import javax.xml.bind.JAXBContext;
    import javax.xml.bind.JAXBElement;
    import javax.xml.bind.JAXBException;
    import javax.xml.bind.Marshaller;
    import java.math.BigDecimal;
     
    public class Main
     
    {
        public static void main(String[] args) throws JAXBException
        {
     
            ObjectFactory factory = new ObjectFactory();
     
            UserT user = factory.createUserT();
            user.setUserName("Sanaulla");
            ItemT item = factory.createItemT();
            item.setItemName("Seagate External HDD");
            item.setPurchasedOn("August 24, 2010");
            item.setAmount(new BigDecimal("6776.5"));
     
            ItemListT itemList = factory.createItemListT();
            itemList.getItem().add(item);
     
            ExpenseT expense = factory.createExpenseT();
            expense.setUser(user);
            expense.setItems(itemList);
     
            JAXBContext context = JAXBContext.newInstance("generated");
            JAXBElement<ExpenseT> element = factory.createExpenseReport(expense);
            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty("jaxb.formatted.output",Boolean.TRUE);
            marshaller.marshal(element,System.out);
        }
     
    }

    在上面的XSD中,我们看到很少声明复杂类型。 这些复杂的类型会生成Java类。 子元素和属性成为该类的属性,并且为它们提供了getter和setter。 不能直接创建此类的实例,即不能对其进行调用。 每当我们编译XSD时,都会生成一个ObjectFactory类–这是用于创建XSD Complex类型的实例的工厂(上述Java类中的Lines-17,19,24,27)。

    一旦获得实例,便使用该类提供的设置器将相应的数据填充到属性中。 还要注意,复杂元素可以具有许多复杂元素作为类的成员。 在那种情况下,我们使用工厂获取复杂元素的实例,然后使用外部复杂元素的setter。

    例如:在上面的XSD中,ExpenseT是一个复杂类型,它由UserT和ItemT列表(ItemListT)组成。 在上面的Java类(第27、28、29行)中,我们正在创建ExpenseT的实例,然后使用设置器设置UserT和ItemListT的值。 通过为工厂调用createExpenseReport()创建RootElement。 方法的名称受根元素的名称影响,并且方法的返回类型和参数类型与根元素的类型相同。

    一旦我们为XML中的不同元素(属性)设置了值,现在就可以实际生成XML。 我们必须有一个Marshaller (从Java对象获取XML)或一个Unmarshaller (从XML对象获取Java)。

    我们需要一个Marshaller –可以从JAXBContext实例获得。 第31,32行获取Marshaller的实例。 可以为marshaller设置不同的属性,在上面的代码中,我们将jaxb.formatted.output设置为true,这意味着所获得的XML格式正确,使用户可读。

    支持的不同属性是:

    • jaxb.encoding
    • jaxb.formatted.output
    • jaxb.schema位置
    • jaxb.noNamespaceSchemaLocation
    • jaxb片段

    <instance_of_marshaller> .marshal()是用于生成XML的方法。 它被重载以接受以下输出机制:

    生成的XML如下所示:

    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
      <expenseReport>
        <user>
          <userName>Sanaulla</userName>
       </user>
       <items>
         <item>
           <itemName>Seagate External HDD</itemName>
           <purchasedOn>August 24, 2010</purchasedOn>
           <amount>6776.5</amount>
         </item>
       </items>
    </expenseReport>

    相关文章:


    翻译自: https://www.javacodegeeks.com/2011/02/jaxb-generate-xml-xsd.html

    展开全文
  • xsd 生成java 对象

    2017-01-18 17:24:27
    xsd 生成java 对象 -XautoNameResolution 自动处理命名冲突
  • 根据XML生成xsd

    2017-11-16 19:03:03
    XML生成XSD xml生成xsd 生成xsd工具 工具 使用方法: java -jar trang.jar xml文件绝对路径 要生成的xsd文件绝对路径 例如在当前目录有文件aaa.xml,需要生成xsd文件名为aaa,并存放在当前目录: java -jar trang....
  • 执行java -jar trang.jar a.xml a.xsd即可生成需要发的xsd校验文件
  • java -jar trang.jar users.xml users.xsd 执行完上述命令后会在当前文件生成users.xsd,然后执行如下命令,其中-p后com.bean是包名,-d后是要生成到哪的文件目录 xjc -p com.bean users.xsd -d F:\
  • XSD根据xml生成schema文件
  • Java Bean以及xsd相互生成

    千次阅读 2016-12-20 11:37:00
    1.先定义一个Java bean -- Student.java [java] view plain copy import java.util.List;  public class Student {   private String name;   private String number;   pri
  • 根据xml生成xsd trang

    2018-08-09 20:31:00
    Trang 是一种命令行的可以XML生成XSD的工具,生成XML文件对应的XSD文件只需要3个简单的步骤: 第一步 下载Trang 第二步 解压zip 将trang-version.zip解压到某个目录,比如d:\trang 第三步 生成XSD 假设在 d:\ ...
  • Jaxb JAXB官网:http://jaxb.java.net/ API链接 :http://jaxb.java.net/nonav/2.2.5/docs/api/ 文档 :...Trang 是一种命令行的可以XML生成XSD的工具,生成XML文件对应的XSD文件只需要3个简单的步...
  • 根据xsd文件逆向生成java

    千次阅读 2018-04-17 10:28:53
    由于工作需要,笔者需要将xsd文件解析成java代码,网上查了相关资料,整理了下面的生成步骤: 1、首先是配置好java的环境变量,将java安装目录下bin文件夹下的xjc.exe配到classpath下 2、进入到你的xsd的文件夹...
  • 二、使用sxd文件生成Java类 此步操作通过Windows系统cmd操作即可完成: // 使用win操作系统,来到xsd文件所在目录,启动cmd xjc TrnMessage.xsd -p com.xha.mode // 路径中不要有汉字 // com.xha.mode为生成的包...
  • xsd.exe 可用于根据 XML 文件...下载xsd.exe文件,命令行进入文件所在目录执行以下命令即可生成Java类文件(如下表示xml文件与xsd.exe在同一目录) 1)xsd.exe fileName.xml 2)xjc -d . -p packageName ./fileName.xsd
  • 2019独角兽企业重金招聘Python工程师标准>>> ...webservice xsd.exe根据xml生成xsd。然后根据xsd生成java bean 转载于:https://my.oschina.net/u/2357525/blog/743493
  • c:\Program Files\Java\jdk1.8.0_101\bin>xjc.exe -p "io.xsd.xml" -encoding "UTF-8" ".\xsdTOxml\MyField.xsd" -d ".\xsdTOxml" Picked up JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8 -Duser.language=e...
  • JAXB(Java Architecture for XML Binding)是JDK的一部分,用于Object XML的转换(有点类似于.NET中的XML序列化)。...可以使用任何工具生成XSD工具,比如XMLSPY。eclipse也提供了相关的jaxb插件,
  • 准备标准xsd文件 选择此文件 准备创建生成bean的文件包名 点击菜单栏的Tools目录 如下图 填入准备好的包路径名。 接着就可以去包中找到根据xsd生成的bean了 对于生成的需要时间格式的字段类型为:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 85,566
精华内容 34,226
关键字:

java生成xsd

java 订阅