jaxb_Java XML绑定的JAXB教程–最终指南（PDF下载）

最新推荐文章于 2021-02-05 07:37:47 发布
最新推荐文章于 2021-02-05 07:37:47 发布
阅读量364 收藏 1
点赞数
文章标签： python java 编程语言 linux 大数据
原文链接：https://www.javacodegeeks.com/2014/12/jaxb-tutorial-xml-binding.html
版权
jaxb

jaxb

在本文中，我们提供了一个全面的Java XML绑定JAXB教程。 Java提供了几种用于处理XML结构和文件的选项。 JAXB是最常用和最常用的一种。 JAXB代表用于XML绑定的Java体系结构。 它提供了将Java对象转换为XML结构以及其他方法的可能性。 自JRE 1.6的第一个版本以来，JAXB附带了JRE标准包。

JAXB的第一个规范于2003年3月完成，其工作过程在Java Specification Request 31中进行了跟踪： https : //jcp.org/en/jsr/detail?id= 31。 在此规范要求中，您可以找到许多有关JAXB的使用寿命以及所做的所有改进的信息。

如前所述，自1.6版更新以来，JAX包中已包含JAXB。

在此之前，有必要将它们的库包含在特定的Java项目中才能使用它。

在JAXB可用之前(很久以前)，Java处理XML文档的方式就是DOM： http : //www.w3.org/DOM/ 。 这不是一个很好的方法，因为几乎没有从XML节点到Java对象的抽象，并且所有值类型都被推断为字符串。 JAXB提供了许多好处，例如与XML节点和属性有关的面向对象方法，类型化的值，注释以及我们将在本文中解释的其他好处。

本教程中的所有示例均已使用以下软件版本实现：用于32b的JRE 1.8.0。 使用的IDE是Eclipse SDK版本：Luna(4.4)。 但是，任何其他包含JAXB API和IDE的Java版本都可以正常工作，因为所有代码都是标准的Java 8。

目录

1.映射 2.元帅 3.取消编组 4.适配器 5. XSD 6.注释 7.工具 8.最佳做法 9.总结 10.资源 11.下载

1.映射

可以通过使用某些注释和遵循特定规则将Java对象绑定到XML结构。 这就是我们所谓的映射。 在本教程中，我们将解释以下几点，提供示例，资源和其他信息：

  • 我们将展示一些有关如何将Java对象转换为XML结构的示例，这称为封送处理。 我们将展示如何使用适配器处理基本类型，集合和更复杂的类型。
  • 我们还将解释如何执行补充操作，称为非编组，即将XML文件转换为Java对象。
  • 所有这些操作都是使用Java注释完成的，我们将列出并解释JAXB中使用的最重要的注释。
  • 我们还将提供用于验证的XSD(XML模式)的介绍，这是JAXB支持的功能强大的工具。 我们还将看到XSD也可以用于编组。
  • 最后，我们将列出几种可以与JAXB结合使用的工具，这些工具可以以不同的方式帮助程序员。

2.元帅

在本章中，我们将了解如何将Java对象转换为XML文件，以及在执行此操作时应考虑的因素。 这通常称为封送处理。

首先，我们向JAXB指出业务模型中的java元素对应于XML节点。 

@XmlType( propOrder = { "name", "capital", "foundation", "continent" , "population"} )
@XmlRootElement( name = "Country" )
public class Country
{
    
    @XmlElement (name = "Country_Population")
    public void setPopulation( int population )
    {
        this.population = population;
    }


    @XmlElement( name = "Country_Name" )
    public void setName( String name )
    {
        this.name = name;
    }

    @XmlElement( name = "Country_Capital" )
    public void setCapital( String capital )
    {
        this.capital = capital;
    }
    @XmlAttribute( name = "importance", required = true )
    public void setImportance( int importance )
    {
        this.importance = importance;
    }
...

上面的类包含一些JAXB注释，这些注释使我们能够指示要生成的XML节点。 为此，我们使用注释

  • @XmlRootElement作为根元素。
  • @XmlElement与setter方法结合使用。
  • @XmlAttribute将属性传递到XML节点。 这些属性可以具有是否需要的属性。
  • @XmlType表示特殊选项，例如XML中的出现顺序。

在下一章中，我们将更详细地解释这些注释和其他注释。 目前，我只想在这里提及它们。

下一步是从Java对象生成XML文件。 为此，我们使用JAXBContext及其封送功能创建一个简单的测试程序：

Country spain = new Country();
            spain.setName( "Spain" );
            spain.setCapital( "Madrid" );
            spain.setContinent( "Europe" );
            spain.setImportance( 1 );
            spain.setFoundation( LocalDate.of( 1469, 10, 19 ) );
            spain.setPopulation( 45000000 );

            /* init jaxb marshaler */
            JAXBContext jaxbContext = JAXBContext.newInstance( Country.class );
            Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

            /* set this flag to true to format the output */
            jaxbMarshaller.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, true );

            /* marshaling of java objects in xml (output to file and standard output) */
            jaxbMarshaller.marshal( spain, new File( "country.xml" ) );
            jaxbMarshaller.marshal( spain, System.out );

基本上，这里最重要的部分是使用类javax.xml.bind.JAXBContext 。 此类提供了一个框架，用于验证XML到Java对象中以及从Java对象中对XML进行编组和取消编组，它是JAXB API的入口点。 可以在以下位置找到有关此类的更多信息： https : //docs.oracle.com/javase/7/docs/api/javax/xml/bind/JAXBContext.html 。

在我们的小示例中，我们只是使用此类来创建JAXB上下文，该上下文允许我们封送作为参数传递的类型的对象。 正是在这里完成的： 

JAXBContext jaxbContext = JAXBContext.newInstance( Country.class );
Marshaller jaxbMarshaller = jaxbContext.createMarshaller();

主程序的结果将是： 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Country importance="1">
 <Country_Name>Spain</Country_Name>
 <Country_Capital>Madrid</Country_Capital>
 <Country_Foundation_Date></Country_Foundation_Date>
 <Country_Continent>Europe</Country_Continent>
 <Country_Population>45000000</Country_Population>
</Country>

在上面显示的JAXB应用程序中，我们只是将容器类中存在的简单类型(字符串和整数)转换为XML节点。 例如，我们可以看到缺少基于日期的属性(如基础日期)，稍后我们将说明如何解决复杂类型的问题。

这看起来很简单。 JAXB支持各种Java对象，例如其他原始类型，集合，日期范围等。

如果我们想将元素列表映射到XML中，可以编写： 

@XmlRootElement( name = "Countries" )
public class Countries
{
    List countries;
    
    /**
     * element that is going to be marshaled in the xml
     */
    @XmlElement( name = "Country" )
    public void setCountries( List countries )
    {
        this.countries = countries;
    }

我们可以在上面的代码段中看到需要一个新的容器类，以指示JAXB存在包含列表的类。 与上面显示的程序类似的结果是： 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Countries>
	<Country importance="1">
		<Country_Name>Spain</Country_Name>
		<Country_Capital>Madrid</Country_Capital>
		<Country_Foundation_Date></Country_Foundation_Date>
		<Country_Continent>Europe</Country_Continent>
		<Country_Population>0</Country_Population>
	</Country>
	<Country importance="0">
		<Country_Name>USA</Country_Name>
		<Country_Capital>Washington</Country_Capital>
		<Country_Foundation_Date></Country_Foundation_Date>
		<Country_Continent>America</Country_Continent>
		<Country_Population>0</Country_Population>
	</Country>
</Countries>

处理集合时有几种选择：

  • 我们可以使用包装器注释：注释javax.xml.bind.annotation.XMLElementWrapper提供了围绕XML表示形式创建包装器的可能性。 该包装器可以包含元素的集合。
  • 我们可以使用基于集合的注释，例如javax.xml.bind.annotation.XMLElements或javax.xml.bind.annotation.XMLRefs ，它们提供集合功能但灵活性较低。
  • 我们可以使用容器进行收集。 一种容器类( Countries其具有类型的成员在我们的例子) java.util.Collection ( Country在我们的例子)。 这是我最喜欢的方法，因为它提供了更大的灵活性。 这是之前显示的方法。

3.取消编组

在本章中，我们将看到如何执行补充操作：将XML文件解组到Java对象中，以及在执行此操作时应考虑的因素。

首先，我们创建要取消编组的XML结构： 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Countries>
	<Country>
		<Country_Name>Spain</Country_Name>
		<Country_Capital>Madrid</Country_Capital>
		<Country_Continent>Europe</Country_Continent>
	</Country>
	<Country>
		<Country_Name>USA</Country_Name>
		<Country_Capital>Washington</Country_Capital>
		<Country_Continent>America</Country_Continent>
	</Country>
	<Country>
		<Country_Name>Japan</Country_Name>
		<Country_Capital>Tokyo</Country_Capital>
		<Country_Continent>Asia</Country_Continent>
	</Country>
</Countries>

值得一提的是，我们删除了成立日期。 如果存在这些，由于JAXB不知道如何解组它们，我们将得到一个错误。 以后我们将看到如何解决这个问题。

之后，我们可以创建一个程序来“读取”该XML文件并将其解析为适当的Java对象：

File file = new File( "countries.xml" );
      JAXBContext jaxbContext = JAXBContext.newInstance( Countries.class );

      /**
      * the only difference with the marshaling operation is here
      */
      Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
      Countries countres = (Countries)jaxbUnmarshaller.unmarshal( file );
      System.out.println( countres );

我们可以看到，上面的代码与上一章中有关编组操作的代码相差无几。 我们还使用类javax.xml.bind.JAXBContext但是在这种情况下，使用的方法是createUnmarshaller()一个，它负责提供类型为javax.xml.bind.Unmarshaller的对象。 此对象负责随后解组XML。

该程序使用带注释的类Country 。 看起来像： 

@XmlType( propOrder = { "name", "capital", "foundation", "continent" , "population"} )
@XmlRootElement( name = "Country" )
public class Country
{
    
    @XmlElement (name = "Country_Population")
    public void setPopulation( int population )
    {
        this.population = population;
    }


    @XmlElement( name = "Country_Name" )
    public void setName( String name )
    {
        this.name = name;
    }

    @XmlElement( name = "Country_Capital" )
    public void setCapital( String capital )
    {
        this.capital = capital;
    }
    @XmlAttribute( name = "importance", required = true )
    public void setImportance( int importance )
    {
        this.importance = importance;
    }
...

我们不能理解与上一章中使用的类有太多差异，使用了相同的批注。

这是程序在标准控制台中产生的输出： 

Name: Spain
Capital: Madrid
Europe
Name: USA
Capital: Washington
America
Name: Japan
Capital: Tokyo
Asia

此处适用于编组操作的解释说明。 可以取消编组对象或其他原始类型，例如数字对象。 也可以取消对诸如列表或集合之类的基于集合的元素进行编组，并且可能性是相同的。

正如我们在上一章和上一章中提供的结果中所看到的，类型java.time.LocalDate的属性尚未转换。 发生这种情况是因为JAXB不知道该怎么做。 也可以使用适配器来处理像这样的复杂类型。 我们将在下一章中看到。

4.适配器

当处理JAXB中可能不直接可用的复杂类型时，我们需要编写一个适配器来指示JAXB如何管理特定类型。

我们将通过对java.time.LocalDate类型的元素使用封送处理(和取消封送处理)的示例进行说明。 

public class DateAdapter extends XmlAdapter
{

    public LocalDate unmarshal( String date ) throws Exception
    {
        return LocalDate.parse( date );
    }

    public String marshal( LocalDate date ) throws Exception
    {
        return date.toString();
    }

}

上面的代码片段显示了接口javax.xml.bind.annotation.adapters.XmlAdapter的编组和解编方法的实现，以及正确的类型和结果，然后，我们使用注解@XmlJavaTypeAdapter指示JAXB在哪里使用它@XmlJavaTypeAdapter ：

...
@XmlElement( name = "Country_Foundation_Date" )
@XmlJavaTypeAdapter( DateAdapter.class )
public void setFoundation( LocalDate foundation )
{
    this.foundation = foundation;
}
...

本教程中显示的第一个程序的结果XML将类似于： 

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Country importance="1">
	<Country_Name>Spain</Country_Name>
	<Country_Capital>Madrid</Country_Capital>
	<Country_Foundation_Date>1469-10-19</Country_Foundation_Date>
	<Country_Continent>Europe</Country_Continent>
	<Country_Population>45000000</Country_Population>
</Country>

这可以应用于我们希望在XML结构中没有JAXB直接支持的任何其他复杂类型。 我们只需要实现接口javax.xml.bind.annotation.adapters.XmlAdapter并实现其方法javax.xml.bind.annotation.adapters.XmlAdapter.unmarshal(ValueType)和javax.xml.bind.annotation.adapters.XmlAdapter.marshal(BoundType) 。

5. XSD

XSD是XML模式。 它包含有关XML文件和结构的信息以及应遵循的规则和约束。 这些规则可以应用于XML的结构，也可以应用于内容。 可以将规则连接起来，并可以使用所有类型的结构创建非常复杂的规则，在本文中，我们将展示有关如何使用XSD进行验证和编组的主要概念。

这是可用于本教程中的Country类的XML Schema的示例： 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="Country">
	<xs:complexType>
		<xs:sequence>
			<xs:element name="Country_Name" type="xs:string" />
			<xs:element name="Country_Capital" type="xs:string" />
			<xs:element name="Country_Foundation_Date" type="xs:string" />
			<xs:element name="Country_Continent" type="xs:string" />
			<xs:element name="Country_Population" type="xs:integer" />
		</xs:sequence>
	</xs:complexType>
</xs:element>
</xs:schema>

使用XSD进行验证

XSD可以用于XML验证。 JAXB使用XSD来验证XML并确保对象和XML结构遵循预期的规则集。 为了针对XSD验证对象，我们需要首先创建XSD，例如： 

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
	<xs:simpleType name="continentType">
		<xs:restriction base="xs:string">
			<xs:pattern value="Asia|Europe|America|Africa|Oceania"/>
		</xs:restriction>
	</xs:simpleType>
 
<xs:element name="Country">
	<xs:complexType>
		<xs:sequence>
			<xs:element name="Country_Name" type="xs:string" minOccurs='1' />
			<xs:element name="Country_Capital" type="xs:string" minOccurs='1' />
			<xs:element name="Country_Foundation_Date" type="xs:string" minOccurs='1' />
			<xs:element name="Country_Continent" type="continentType" minOccurs='1' />
			<xs:element name="Country_Population" type="xs:integer" />
		</xs:sequence>
	</xs:complexType>
</xs:element>
</xs:schema>

我们可以在程序中使用它来指示JAXB，我们希望在代码中使用什么XSD。 我们可以通过创建类javax.xml.validation.Schema的实例并通过以下方式初始化其验证来做到这一点： 

/**
* schema is created
*/
SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI );
Schema schema = sf.newSchema( new File( "countries_validation.xsd" ) );

验证需要一个可以处理错误的错误处理程序。 这是通过实现org.xml.sax.ErrorHandler接口及其错误方法来完成的： 

public class MyErrorHandler implements ErrorHandler
{

    @Override
    public void warning( SAXParseException exception ) throws SAXException
    {
        throw exception;

    }
   ...

之后，可以使用验证来验证类javax.xml.bind.util.JAXBSource实例：

/**
         * context is created and used to create sources for each country
         */
        JAXBContext jaxbContext = JAXBContext.newInstance( Country.class );
        JAXBSource sourceSpain = new JAXBSource( jaxbContext, spain );
        JAXBSource sourceAustralia = new JAXBSource( jaxbContext, australia );

这是完整的程序：

/**
         * error will be thrown because continent is mandatory
         */
        Country spain = new Country();
        spain.setName( "Spain" );
        spain.setCapital( "Madrid" );
        spain.setFoundation( LocalDate.of( 1469, 10, 19 ) );
        spain.setImportance( 1 );


        /**
         * ok
         */
        Country australia = new Country();
        australia.setName( "Australia" );
        australia.setCapital( "Camberra" );
        australia.setFoundation( LocalDate.of( 1788, 01, 26 ) );
        australia.setContinent( "Oceania" );
        australia.setImportance( 1 );


        /**
         * schema is created
         */
        SchemaFactory sf = SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI );
        Schema schema = sf.newSchema( new File( "countries_validation.xsd" ) );

        /**
         * context is created and used to create sources for each country
         */
        JAXBContext jaxbContext = JAXBContext.newInstance( Country.class );
        JAXBSource sourceSpain = new JAXBSource( jaxbContext, spain );
        JAXBSource sourceAustralia = new JAXBSource( jaxbContext, australia );

        /**
         * validator is initialized
         */
        Validator validator = schema.newValidator();
        validator.setErrorHandler( new MyErrorHandler() );

        //validator is used
        try
        {
            validator.validate( sourceSpain );
            System.out.println( "spain has no problems" );
        }
        catch( SAXException ex )
        {
            ex.printStackTrace();
            System.out.println( "spain has problems" );
        }
        try
        {
            validator.validate( sourceAustralia );
            System.out.println( "australia has no problems" );
        }
        catch( SAXException ex )
        {
            ex.printStackTrace();
            System.out.println( "australia has problems" );
        }

及其输出： 

org.xml.sax.SAXParseException
	at javax.xml.bind.util.JAXBSource$1.parse(JAXBSource.java:248)
	at javax.xml.bind.util.JAXBSource$1.parse(JAXBSource.java:232)
	at com.sun.org.apache.xerces.internal.jaxp.validation.ValidatorHandlerImpl.validate(
...
spain has problems
australia has no problems

我们可以看到，澳大利亚没有问题，但是西班牙有……

使用XSD封送处理

XSD还用于从XML文件绑定和生成Java类，反之亦然。 我们将在这里看到如何通过编组示例使用它。

采用，我们将wriite是初始化程序前显示的相同的XML模式javax.xml.validation.Schema使用给定的XSD和javax.xml.bind.JAXBContext的类，我们要元帅( Country )。 该程序将使用javax.xml.bind.Marshaller来执行所需的操作：

/**
         * validation will fail because continent is mandatory
         */
        Country spain = new Country();
        spain.setName( "Spain" );
        spain.setCapital( "Madrid" );
        spain.setFoundation( LocalDate.of( 1469, 10, 19 ) );

        SchemaFactory sf = SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI );
        Schema schema = sf.newSchema( new File( "countries_validation.xsd" ) );

        JAXBContext jaxbContext = JAXBContext.newInstance( Country.class );

        Marshaller marshaller = jaxbContext.createMarshaller();
        marshaller.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, true );
        marshaller.setSchema( schema );
        //the schema uses a validation handler for validate the objects
        marshaller.setEventHandler( new MyValidationEventHandler() );
        try
        {
            marshaller.marshal( spain, System.out );
        }
        catch( JAXBException ex )
        {
            ex.printStackTrace();
        }

        /**
         * continent is wrong and validation will fail
         */
        Country australia = new Country();
        australia.setName( "Australia" );
        australia.setCapital( "Camberra" );
        australia.setFoundation( LocalDate.of( 1788, 01, 26 ) );
        australia.setContinent( "Australia" );

        try
        {
            marshaller.marshal( australia, System.out );
        }
        catch( JAXBException ex )
        {
            ex.printStackTrace();
        }

        /**
         * finally everything ok
         */
        australia = new Country();
        australia.setName( "Australia" );
        australia.setCapital( "Camberra" );
        australia.setFoundation( LocalDate.of( 1788, 01, 26 ) );
        australia.setContinent( "Oceania" );


        try
        {
            marshaller.marshal( australia, System.out );
        }
        catch( JAXBException ex )
        {
            ex.printStackTrace();
        }

我们之前谈论的是与XSD相关的验证。 将对象编组为XML时也可以进行验证。 如果我们的对象不符合某些预期规则，尽管我们没有明确验证，但我们也会在这里遇到一些验证错误。 在这种情况下，我们没有使用实现org.xml.sax.ErrorHandler的错误处理程序，而是javax.xml.bind.ValidationEventHandler ： 

public class MyValidationEventHandler implements ValidationEventHandler
{

    @Override
    public boolean handleEvent( ValidationEvent event )
    {
        System.out.println( "Error catched!!" );
        System.out.println( "event.getSeverity():  " + event.getSeverity() );
        System.out.println( "event:  " + event.getMessage() );
        System.out.println( "event.getLinkedException():  " + event.getLinkedException() );
        //the locator contains much more information like line, column, etc.
        System.out.println( "event.getLocator().getObject():  " + event.getLocator().getObject() );
        return false;
    }

}

我们可以看到已经实现了javax.xml.bind.ValidationEventHandler.handleEvent(ValidationEvent)方法。输出将是： 

javax.xml.bind.MarshalException
 - with linked exception:
[org.xml.sax.SAXParseException; lineNumber: 0; columnNumber: 0; cvc-pattern-valid: Value 'Australia' is not facet-valid with respect to pattern 'Asia|Europe|America|Africa|Oceania' for type 'continentType'.]
	at com.sun.xml.internal.bind.v2.runtime.MarshallerImpl.write(MarshallerImpl.java:311)
	at ...
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Country>
<Country_Name>Australia</Country_Name>
<Country_Capital>Camberra</Country_Capital>
<Country_Foundation_Date>1788-01-26</Country_Foundation_Date>
<Country_Continent>Oceania</Country_Continent>
<Country_Population>0</Country_Population>
</Country>

显然，由于所有可能的规则星座及其应用非常庞大，因此关于XSD的解释还很多。 但是，这超出了本教程的范围。 如果您需要有关如何在JAXB中使用XML模式的更多信息，可以访问以下链接，我发现它们非常有趣：

6.注释

在本教程中，我们一直在使用JAXB中用于XML封送和取消封送操作的几个批注。 我们将在这里列出最重要的一些：

这是一个庞大的列表，但是这些并不是所有可用的JAXB相关注释。 有关带有所有JAXB可用注释的完整列表，请转到包摘要https://docs.oracle.com/javase/7/docs/api/javax/xml/bind/annotation/package-frame.html 。

7.工具

有许多工具可以帮助程序员在使用JAXB和XML Schema时使用。 我们将在本章中列出其中一些，并提供一些有用的资源：

  • schemagen ：代表模式生成器。 它用于从Java带注释的类或源生成JAXB Schema(它也适用于字节码)。 可以直接从命令行或使用Ant来使用。 有关更多信息，请访问Oracle页面https://docs.oracle.com/javase/7/docs/technotes/tools/share/schemagen.html或https://jaxb.java.net/2.2.4/docs/schemagen .html 。 它与JRE标准捆绑包一起提供，可以从bin目录中启动。
  • xjc ：这是JAXB绑定编译器。 它用于从XML模式(XSD)生成Java源(类)。 可以与Ant一起使用。 在执行XSD之前执行验证。 有关其用法和参数的更多信息，请访问https://jaxb.java.net/2.2.4/docs/xjc.html 。
  • Jsonix ：与JAXB无关，但是它是将XML转换为JSON的工具。 在使用JavaScript时，它非常有用。 这是官方链接http://confluence.highsource.org/display/JSNX/Jsonix 。
  • Hyperjaxb3 ：它为JAXB对象提供关系持久性。 它使用JAXB批注将对象持久存储在关系数据库中。 它可以与Hibernate(可能是最常用的Java持久性框架)一起使用。 您可以在链接http://confluence.highsource.org/display/HJ3/Home中找到更多文档和资源。
  • Maven JAXB2插件：Maven插件，提供了xjc工具的所有功能以及将XML Schema转换为Java类时的更多功能。 在以下链接中，您可以下载资源并查阅文档https://github.com/highsource/maven-jaxb2-plugin 。
  • JAXB Eclipse插件：有几个可用的Eclipse插件(也适用于其他IDE，例如NetBeans或IntelliJ)，可以将XML Schema编译为Java类，验证XML模式或生成模式。 它们全部包装并使用上述工具之一。 由于没有可被描述为标准插件的插件，我让您在网络上搜索并选择一个插件。

这些并不是与JAXB和XSD一起使用的用于将XML结构转换为Java类的所有工具。 还有更多。 我只是在这里列出了每个开发人员在其应用程序中使用JAXB时应考虑的最重要和最基本的内容。

8.最佳做法

尽管这不是最佳实践的完整列表，并且它是一个主观主题，但我想给出一些与JAXB相关的首选用法。

  • 尽量避免出现有问题的原始类型，例如float ， decimal或negativeInteger ； 这些在JAXB中没有相关类型。 在这些情况下，您可能可以使用其他“无问题”原始类型。
  • 使用注释@XMLSchemaType可以更明确地说明必须使用的类型，并且不要让JAXB来决定这一点。
  • 避免匿名类型和混合内容。
  • JAXB使用系统默认的语言环境和国家/地区来生成信息和错误消息。为了进行更改，您可以将以下JVM参数传递给应用程序： 
    -Duser.country=US -Duser.language=en -Duser.variant=Traditional_WIN

9.总结

这就是全部。 在本教程中，我们解释了什么是JAXB以及它可以用于什么。 JAXB代表用于XML绑定的Java体系结构，它基本上是用于以下目的的框架：

  • 将Java对象编组为XML结构。
  • 将XML文件取消编组为Java类。
  • 这些操作可以使用XSD(XML模式)来完成。
  • XSD对于验证目的也非常有用。

简而言之，JAXB可用于将XML转换为Java类，反之亦然。 我们解释了与所有这些相关的主要概念，并列出了JAXB使用中涉及的主要注释和类。

有几种工具可以与JAXB结合使用，以用于不同的目的，我们解释了如何使用它们以及可以对其中的某些工具进行处理。

10.资源

本教程包含有关JAXB及其将XML编组和解编为Java对象的用法的深入信息。 它还说明了在使用JAXB时如何使用XSD，以及一些最佳实践和技巧。 但是，如果您需要在使用JAXB进行应用程序编程方面迈出一步，那么访问以下资源可能会很有用：

11.下载Java XML绑定的JAXB教程源代码

这是Java XML绑定的JAXB教程。

下载 您可以在这里下载本教程的完整源代码： jaxb_ultimate 。

翻译自: https://www.javacodegeeks.com/2014/12/jaxb-tutorial-xml-binding.html

jaxb

cunfen3485
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAXB_Java Architecture For XML Binding
03-28
这些类包含了用于XML绑定的注解。 - **Java对象到XML**: 实例化Java对象并填充数据，然后使用`Marshaller`接口将对象转换为XML文档。 - **XML到Java对象**: 解析XML文档，使用`Unmarshaller`接口将其转换为Java对象...
使用JAXB（用于XML绑定的Java API）解决现实世界问题的7个步骤
04-11
JAXB（Java Architecture for XML Binding）是Java平台上的一个标准API，用于在Java对象和XML文档之间进行数据绑定。这个强大的工具使得开发人员能够轻松地处理XML数据，无需手动解析XML文档或创建复杂的序列化代码...
JAXB（一）初体验之实现XML和对象之间的映射
Calvin的博客
11-02 591
一、JAXB概述                 JAXB的全称是Java Architecture for XML Binding，是一项可以通过XML产生Java对象，也可以通过Java对象产生XML的技术。JDK中关于JAXB部分有几个比较重要的接口或类，如： Ø  JAXBContext：它是程序的入口类，提供了XML/Java绑定的操作，包括marshal、unmarshal等。 ...
JAXB教程–入门
sky198989的博客
02-05 145
转载：https://blog.csdn.net/dnc8371/article/details/106705657
jaxws,rest常用知识笔记
weixin_34126215的博客
10-16 145
2019独角兽企业重金招聘Python工程师标准>>> ...
jaxb的安装、使用和资源下载
jccmjl的专栏
08-14 561
今天运用到一个jaxb技术，简单来说就是给xml或者是xsd文件通过编译变为java实体对象，在中我觉得相对还是比较好用，我说说我的安装和使用：     首先在这个路径下下载一个安装下包（在这前提下要安装好jdk1.6,环境变量要配置好）:        jar包下载路径：http://download.csdn.net/detail/jccmjl/4498291       下载好以后接下...
javax/xml/bind/JAXBException异常
热门推荐
u012903200的博客
05-05 1万+
在使用jpa做Junit测试时，报错如下 Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactoryPrimary' defined in class path resource [com/sprucetec/mjyx/...
xml.rar_XML java_java xml_xml_xml 数据库
09-14
4. **Java XML绑定（JAXB）**：考虑到Java和XML之间的数据转换，JAXB也可能被用到，它能够自动将Java对象转换为XML，反之亦然，简化了数据的序列化和反序列化过程。 5. **数据库操作优化**：在大量数据操作时，可能...
xml.rar_java xml_java读写xml
最新发布
09-23
1. JAXB：JAXB允许我们将Java对象与XML文档之间进行绑定，实现对象到XML的自动序列化和反序列化。这种方式适合处理中等大小的数据，且数据量不频繁变化的情况。 2. DOM：DOM是W3C推荐的一种解析XML的标准，它将整个...
Java-xml.rar_XML java_java xml_javaXML.rar_javaxml.r_xml 网站
09-19
此外，"javaxml.r_xml"和"javaxml.r"标签可能指的是Java的JAXB框架，这是一个用于XML绑定的Java标准，可以自动将Java对象映射为XML文档，反之亦然。这大大简化了处理XML数据的过程，尤其是在构建Web服务或需要与XML...
jaxb2.1jar包
10-24
这个是jaxb2.1 jar包，这里提供下载，只要2个资源分哦，大家可以踊跃下载
jaxb jar包
01-23
jaxb jar(jaxb-api-2.2.7.jar) 针对xml和bean转化工具
JAXB的使用JAXB的使用
10-19
JAXB的使用JAXB的使用JAXB的使用JAXB的使用
jaxb2.2.jar
05-15
JAXB能够使用Jackson对JAXB注解的支持实现(jackson-module-jaxb-annotations)，既方便生成XML，也方便生成JSON，这样一来可以更好的标志可以转换为JSON对象的JAVA类。JAXB允许JAVA人员将JAVA类映射为XML表示方式
jaxb-xjc-2.1.13.jar
04-22
为了解决cxf webservice访问与jdk1.6版本之间不兼容问题
jaxb-api-2.2.12.jar
03-17
这是一个项目管理所需要的jar包
JAXB2 Webservice
03-01
NULL 博文链接：https://endeavor416.iteye.com/blog/270507
JAXB2基础教程
10-19
一个JAXB2的基础教程，教你快速运用JAXB通过XSD绑定XML和读写XML
java10运行springboot项目出现：Type javax.xml.bind.JAXBContext not present
弈凌
06-05 1万+
原因：java9模块化的概念使得JAXB默认没有加载； jaxb-api是存在jdk中的，只是默认没有加载而已，手动引入即可。 推荐方式：（作者采用的此方式，只想用java9、10一部分新特性） &amp;lt;!-- jaxb模块引用 - start --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;javax.xml.bind&amp;lt;/gro
Java和XML数据绑定技术指南
本书主要讲述了 Java 和 XML 绑定的相关知识，涵盖了 Sun Microsystems JAXB API 和流行的开源替代实现（Enhydra Zeus、Exolabs Castor 和 Quick）的所有特性。同时，本书还详细介绍了何时适合使用数据绑定，并提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值