jaxb相关

最新推荐文章于 2024-10-06 20:29:51 发布
最新推荐文章于 2024-10-06 20:29:51 发布
阅读量1.9k 收藏 2
点赞数
文章标签： jaxb javadoc documentation java schema xml

原帖地址：http://manyuewushuang.iteye.com/blog/684285

http://manyuewushuang.iteye.com/blog/684379

http://manyuewushuang.iteye.com/blog/684391

http://manyuewushuang.iteye.com/blog/685910

 http://java.sun.com/javaee/5/docs/tutorial/doc/bnazf.html

https://jaxb.dev.java.net/guide/  （详细学习）

 

Jaxb中两个重要的过程：

1. 编组 Marshal（java 2 xml） 则是指将一个内存对象以XML文档形式进行编组处理的过程。

编组是把一些 Java 对象转化成一个（或多个） XML 文档。

 

2. 解组 Unmarshaller（xml 2 java）与编组相反是一个将XML文档解析为内存对象的过程。

 

 

JAXB数据绑定步骤：

l Generate classes: 使用JAXB Binding Compiler（xjc命令）根据XML Schema生成Java代码。

l Compile classes: 编译所有生成的Java源代码。

l Unmarshal: 将XML文档内容解组到内存中。

l Generate content tree: 解组过程产生由JAXB生成的一系列classes的数据对象的实例的content tree。这个content tree代表了这个XML文档的结构以及内容。

l Validate (optional): 解组过程中带有的可选的校验过程，包括在生成content tree之前校验xml文档。

l Process content: 应用程序可以通过JAXB生成的一系列content tree修改xml文档内容。

l Marshal: 处理过的content tree 的内容编组到xml文档中，在这之前可能进行过校验。

 

 

JAXB将XML Schema表示为Java对象：

l 根据Schema中定义的xml elements生成的一系列类文件；

l 一个ObjectFactory类，用于产生绑定的Java类的实例的工厂。

 

<!--EndFragment-->

 

 

 

2010 - 06 - 04

JAXB入门学习（二）

文章分类:Java编程

一个Schema中的类型定义：

l 基本类型

l 集合类型

l Predicate（？？谓语？？）

 

Schema-to-Java Mapping(here list the mapping of XML data types to java data types in JAXB):



 <!--EndFragment-->

JAXBElement Object：

当xml element不能用Java表示时，此时提供一个JAXBElement，用于getting/setting object name 和object value .

 

Java-to-Schema Mapping（here list the mapping of Java classes to XML data types）：

在Java EE5 中的JAXB注解元素在 javax.xml.bind.annotation包中。 



 

<!--EndFragment-->
  1. standalone = "yes" ?>   
  3. <project basedir="." default="compile">  
  4. <!-- 设置jwsdp主目录 -->  
  5.     <property name="jwsdp.home" value="D:/Java/Sun/jwsdp-2.0" />  
  6.     <property name="classes.home" value="target/classes" />  
  7.     <property name="generate.code.home" value="src/primer" />  
  8.        
  9.   <path id="classpath">  
  10.     <pathelement path="src" />  
  11.     <pathelement path="${classes.home}" />  
  12.     <!--for use with bundled ant-->  
  13.     <fileset dir="${jwsdp.home}" includes="jaxb/lib/*.jar" />  
  14.     <fileset dir="${jwsdp.home}" includes="sjsxp/lib/*.jar" />  
  15.     <fileset dir="${jwsdp.home}" includes="jwsdp-shared/lib/activation.jar" />  
  16.     <fileset dir="${jwsdp.home}" includes="jwsdp-shared/lib/resolver.jar" />  
  17.   </path>  
  18. <!-- 定义xjc任务 -->  
  19.   <taskdef name="xjc" classname="com.sun.tools.xjc.XJCTask">  
  20.     <classpath refid="classpath" />  
  21.   </taskdef>  
  22.   
  23.      <target name="generate-code" >  
  24.         <echo message="Compiling the schema..." />  
  25. <!-- 使用xjc任务根据xsd文件生成Java代码 -->  
  26.         <xjc schema="po.xsd" package="primer.po" destdir="src">  
  27.           <produces dir="src/primer.po" includes="**/*.java" />  
  28.         </xjc>  
  29.           
  30.       </target>  
  31.        
  32.   <!--compile Java source files-->  
  33.   <target name="compile" depends="generate-code" description="Compile all Java source files">  
  34.        
  35.     <echo message="Compiling the java source files..." />  
  36.     <mkdir dir="${classes.home}"/>  
  37.     <javac destdir="${classes.home}" debug="on">  
  38.       <src path="src" />  
  39.       <classpath refid="classpath" />  
  40.     </javac>  
  41.   </target>  
  42.   
  43.   <target name="clean" description="删除生成的class文件及由xsd生成的Java代码">  
  44.     <delete dir="${classes.home}" />  
  45.     <delete deleteonexit="true" dir="${generate.code.home}" />  
  46.   </target>  
  47. </project>  

 

运行ant文件后（运行默认任务即可），运行Main类，可在控制台打印修改原xml文档后的内容，并可在project目录下生成一个newpo.xml文件：

Java代码 复制代码  收藏代码
  1. package modifymarshal;   
  2.   
  3. import java.io.File;   
  4. import java.io.FileInputStream;   
  5. import java.io.FileOutputStream;   
  6. import java.io.IOException;   
  7. import java.math.BigDecimal;   
  8. import java.math.BigInteger;   
  9. import java.util.Date;   
  10. import java.util.GregorianCalendar;   
  11. import java.util.List;   
  12. import java.util.Locale;   
  13. import java.util.TimeZone;   
  14.   
  15. import javax.xml.bind.JAXBContext;   
  16. import javax.xml.bind.JAXBElement;   
  17. import javax.xml.bind.JAXBException;   
  18. import javax.xml.bind.Marshaller;   
  19. import javax.xml.bind.Unmarshaller;   
  20. import javax.xml.datatype.Duration;   
  21. import javax.xml.datatype.XMLGregorianCalendar;   
  22. import javax.xml.namespace.QName;   
  23.   
  24. import com.sun.org.apache.bcel.internal.generic.GETSTATIC;   
  25. import com.sun.org.apache.xerces.internal.jaxp.datatype.XMLGregorianCalendarImpl;   
  26.   
  27. // import java content classes generated by binding compiler   
  28. import primer.po.*;   
  29. import primer.po.Items.Item;   
  30.   
  31.   
  32. /**  
  33.  *   
  34.  * @author liu_yming  
  35.  *  
  36.  */  
  37. public class Main {   
  38.     // This sample application demonstrates how to modify a java content   
  39.     // tree and marshal it back to a xml data   
  40.     public static void main(String[] args) {   
  41.         try {   
  42.             // 创建一个 JAXBContext 的实例处理生成的primer.po包底下的类   
  43.             JAXBContext jc = JAXBContext.newInstance("primer.po");   
  44.   
  45.             // create an Unmarshaller   
  46.             Unmarshaller u = jc.createUnmarshaller();   
  47.                
  48.             // 已经废弃的setValidating方法   
  49.             // u.setValidating(true);   
  50.   
  51.             // 读取xml文档并unmarshal(xml2java 解组)至content tree   
  52.             JAXBElement poe = (JAXBElement) u.unmarshal(   
  53.                         new FileInputStream("po.xml"));   
  54.             PurchaseOrderType po = (PurchaseOrderType) poe.getValue();   
  55.             // 输出po.xml文档中的内容   
  56.             USAddress shipTo = po.getShipTo();   
  57.             System.out.println("shipTo name: " + shipTo.getName());   
  58.             System.out.println("shipto country: " + shipTo.getCountry());   
  59.             System.out.println("**********************************");   
  60.             USAddress billTo = po.getBillTo();   
  61.             System.out.println("billTo name: " + billTo.getName());   
  62.             System.out.println("billTo country: " + billTo.getCountry());   
  63.             System.out.println("**********************************");   
  64.             Items items = po.getItems();   
  65.             List<Item> itemList = items.getItem();   
  66.             for (Item item:itemList) {   
  67.                 System.out.println("item attribute partNum : " + item.getPartNum());   
  68.                 System.out.println("item element comment : " + item.getComment());   
  69.                 System.out.println("item element ProductName : " + item.getProductName());   
  70.                 System.out.println("item element Quantity : " + item.getQuantity());   
  71.                 System.out.println("item element ShipDate : " + item.getShipDate());   
  72.                 System.out.println("-----------------------------");   
  73.             }   
  74.             System.out.println("**********************************");   
  75.                
  76.   
  77.             // change the billto address   
  78.             USAddress newBillTo = po.getBillTo();   
  79.             newBillTo.setCountry("CN");   
  80.             newBillTo.setName("Kevin Liu");   
  81.             newBillTo.setStreet("XueYuan road 388");   
  82.             newBillTo.setCity("KunShan");   
  83.             newBillTo.setState("JiangSu");   
  84.             newBillTo.setZip(new BigDecimal("258311"));   
  85.                
  86.             // change the first item   
  87.             Item newItem = itemList.get(0);   
  88.             newItem.setPartNum("444-CN");   
  89.             newItem.setComment("水泥杀手");   
  90.             newItem.setProductName("安踏");   
  91.             newItem.setShipDate(XMLGregorianCalendarImpl.parse("20100603"));   
  92.             newItem.setQuantity(BigInteger.valueOf(3));   
  93.   
  94.             // 创建一个Marshaller 并marshal(编组 java2xml)只newpo.xml文件并在控制台打印输出   
  95.             Marshaller m = jc.createMarshaller();   
  96.             m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);   
  97.                
  98.             // 输出的控制台   
  99.             m.marshal(poe, System.out);   
  100.             // 输出到新的文件   
  101.             //m.marshal(poe, new FileOutputStream(new File("newpo.xml")));   
  102.         } catch (JAXBException je) {   
  103.             je.printStackTrace();   
  104.         } catch (IOException ioe) {   
  105.             ioe.printStackTrace();   
  106.         }    
  107.     }   
  108. }  

 

2010 - 06 - 07

JAXB入门学习（四）

文章分类:Java编程

定制JAXB绑定：

l 在XML Schema中使用JAXB注解，使用<xsd:appinfo>内嵌于<xsd:annotation>中，在<xsd:appinfo>中使用<jxb:xx>标签定义各元素与class的对应关系。

l 直接使用XML Schema 配合自定义JAXB的.xjb文件

inline绑定：

Xml代码 复制代码  收藏代码
  1. <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
  2.             xmlns:jxb="http://java.sun.com/xml/ns/jaxb"  
  3.             jxb:version="1.0">  
  4.   <xsd:annotation>  
  5.     <xsd:documentation>  
  6.        文件描述   
  7.     </xsd:documentation>  
  8.     <xsd:appinfo>  
  9.       <jxb:globalBindings  
  10.           fixedAttributeAsConstantProperty="false"  
  11.           collectionType="java.util.Vector"  
  12.           typesafeEnumBase="xsd:NCName"  
  13.           choiceContentProperty="false"  
  14.           typesafeEnumMemberName="generateError"  
  15.           enableFailFastCheck="false"      
  16.           generateIsSetMethod="false"  
  17.           underscoreBinding="asCharInWord"/>  
  18.       <jxb:schemaBindings>  
  19.         <jxb:package name="primer.myPo"><!-- 生成Java代码时候的包路径 -->  
  20.           <jxb:javadoc>  
  21.             <![CDATA[<body> Package level documentation for generated package primer.myPo.</body>]]>  
  22.           </jxb:javadoc>  
  23.         </jxb:package>  
  24.         <jxb:nameXmlTransform>  
  25.           <jxb:elementName suffix="Element"/>  
  26.         </jxb:nameXmlTransform>    
  27.       </jxb:schemaBindings>  
  28.     </xsd:appinfo>  
  29.   </xsd:annotation>  
  30. <xsd:element name="purchaseOrder" type="PurchaseOrderType"/>  
  31. <xsd:element name="comment" type="xsd:string"/><!-- 映射为普通的String类型元素 -->  
  32. <xsd:complexType name="PurchaseOrderType">  
  33.   <xsd:annotation>  
  34.     <xsd:appinfo>  
  35.       <jxb:class name="POType">  
  36.         <jxb:javadoc>  
  37.         </jxb:javadoc>  
  38.       </jxb:class>  
  39.     </xsd:appinfo>  
  40.   </xsd:annotation>  
  41.   
  42.   <xsd:sequence>  
  43.     <xsd:element name="shipTo" type="USAddress"/>  
  44.     <xsd:element name="billTo" type="USAddress"/>  
  45.     <xsd:element ref="comment" minOccurs="0"/>  
  46.     <xsd:element name="items" type="Items"/>  
  47.   </xsd:sequence>  
  48.   <xsd:attribute name="orderDate" type="xsd:date"/>  
  49. </xsd:complexType>  
  50.   
  51.   
  52. <!-- Stock Keeping Unit, a code for identifying products -->  
  53. <xsd:simpleType name="SKU">  
  54.   <xsd:restriction base="xsd:string">  
  55.     <xsd:pattern value="/d{3}-[A-Z]{2}"/>  
  56.   </xsd:restriction>  
  57. </xsd:simpleType>  
  58.   
  59.   
  60.   
  61. <xsd:simpleType name="ZipCodeType">  
  62.   <xsd:annotation>    
  63.         <xsd:appinfo><!-- 使用自定义类型转换器 -->    
  64.       <jxb:javaType name="int"    
  65.            parseMethod="inlinecustomize.primer.MyDatatypeConverter.parseIntegerToInt"    
  66.            printMethod="inlinecustomize.primer.MyDatatypeConverter.printIntToInteger" />  
  67.     </xsd:appinfo>  
  68.   </xsd:annotation>     
  69.   <xsd:restriction base="xsd:integer">  
  70.     <xsd:minInclusive value="10000"/>  
  71.     <xsd:maxInclusive value="99999"/>  
  72.   </xsd:restriction>  
  73. </xsd:simpleType>  
  74. </xsd:schema>  

 external 绑定需要一个标准的xsd文件以及一个外部的xjb格式文件：

Xml代码 复制代码  收藏代码
  1. <jxb:bindings version="1.0"  
  2.                xmlns:jxb="http://java.sun.com/xml/ns/jaxb"  
  3.                xmlns:xs="http://www.w3.org/2001/XMLSchema">  
  4.   <jxb:bindings schemaLocation="po.xsd" node="/xs:schema">  
  5.     <jxb:globalBindings  
  6.          fixedAttributeAsConstantProperty="false"  
  7.          collectionType="java.util.Vector"  
  8.          typesafeEnumBase="xs:NCName"  
  9.          choiceContentProperty="false"  
  10.          typesafeEnumMemberName="generateError"  
  11.          enableFailFastCheck="false"      
  12.          generateIsSetMethod="false"  
  13.          underscoreBinding="asCharInWord"/>  
  14.     <jxb:schemaBindings>  
  15.       <jxb:package name="primer.myPo">  
  16.         <jxb:javadoc><![CDATA[<body>Package level documentation for generated package primer.myPo.</body>]]>  
  17. </jxb:javadoc>  
  18.       </jxb:package>  
  19.       <jxb:nameXmlTransform>  
  20.         <jxb:elementName suffix="Element"/>  
  21.       </jxb:nameXmlTransform>  
  22.     </jxb:schemaBindings>  
  23.   
  24.     <jxb:bindings node="//xs:complexType[@name='PurchaseOrderType']">  
  25.       <jxb:class name="POType">  
  26.         <jxb:javadoc>A &lt;b>Purchase Order&lt;/b> consists of addresses and items.</jxb:javadoc>  
  27.       </jxb:class>  
  28.     </jxb:bindings>  
  29.   
  30.     <jxb:bindings node="//xs:complexType[@name='USAddress']">  
  31.       <jxb:class>  
  32.         <jxb:javadoc><![CDATA[First line of documentation for a <b>USAddress</b>.]]></jxb:javadoc>  
  33.       </jxb:class>  
  34.        
  35.       <jxb:bindings node=".//xs:element[@name='name']">  
  36.         <jxb:property name="toName"/>  
  37.       </jxb:bindings>  
  38.   
  39.       <jxb:bindings node=".//xs:element[@name='zip']">  
  40.          <jxb:property name="zipCode"/>  
  41.       </jxb:bindings>  
  42.     </jxb:bindings> <!-- node="//xs:complexType[@name='USAddress']" -->  
  43.   
  44.     <jxb:bindings node="//xs:complexType[@name='Items']">  
  45.       <jxb:bindings node=".//xs:element[@name='item']//xs:element[@name='quantity']">  
  46.         <jxb:property generateIsSetMethod="true"/>  
  47.   
  48.   
  49.   
  50.       <jxb:bindings node=".//xs:attribute[@name='partNum']">  
  51.         <jxb:property name="partNumber"/>  
  52.       </jxb:bindings>  
  53.     </jxb:bindings>  
  54.   
  55.     <jxb:bindings node="//xs:simpleType[@name='ZipCodeType']">  
  56.       <jxb:javaType name="int"        
  57.                     parseMethod="javax.xml.bind.DatatypeConverter.parseInt"    
  58.                     printMethod="javax.xml.bind.DatatypeConverter.printInt"/>  
  59.     </jxb:bindings>  
  60.   </jxb:bindings> <!-- schemaLocation="po.xsd" node="/xs:schema" -->  
  61.   
  62. </jxb:bindings>  

  

 

Java-to-Schema：

@XmlAccessorOrder  @XmlType.propOrder 用于指明xml schema元素的顺序

使用@XmlAccessorOrder：

包括XmlAccessorOrder.UNDEFINED  XmlAccessorOrder.ALPHABETICAL两个值，默认为UNDEFINED（无序），XmlAccessorOrder.ALPHABETICAL是指按属性的字母顺序排序。

当@XmlAccessorOrder定义在一个package之上时候（Package annotations must be in file package-info.java），此包下的所有类都遵守@XmlAccessorOrder定义的规则；当它定义在类之上时，只有该类的内容遵守规则。

就近原则：如果出现在package之上使用@XmlAccessorOrder并且在该包下的某个类又使用了@XmlAccessorOrder，那在该类上定义的@XmlAccessorOrder规则才起作用，如在package上声明@XmlAccessorOrder(XmlAccessOrder.ALPHABETICAL)，而在某类上声明为UNDEFINED，则该类遵守的规则为UNDEFINED。

使用@XmlType.propOrder：

propOrder可以定义class中字段出现在xml中的顺序，class中所有public的字段必须列的propOrder的参数列表中，如果不想将某public字段列在列表中，可在字段上使用@XmlTransient or @XmlAttribute注解标识。

默认的内容顺序为@XmlType.propOrder is {} or {""}（not active 可认为无序？），在这种情况下，@XmlAccessorOrder 注解具有优先权。当@XmlAccessorOrder 与@XmlType.propOrder同时出现时，propOrder总是具有优先权（最终起作用）。

XmlAdapter 接口和 @XmlJavaTypeAdapter 注解：

使用这两个主要是为了那种 xml data type无法映射为Java object而准备的，比如Collection和Map及实现类等。

例：@XmlJavaTypeAdapter(AdapterPurchaseListToHashMap.class)// 使用自定义的实现 XmlAdapter 接口的适配器 for custom marshaling.

@XmlAttribute：

@XmlType：

@XmlRootElement：

@XmlSchemaType：使用该注解将字段映射到xml内置类型，如xs:date、xs:duration

@XmlType：使用该注解将一个class或一个enum映射成为一个 XML Schema type

JAXB Architectrual Overview:

 

 

A JAXB implementation consists of the following architectural components:

l Schema compiler: 将XML schema文件映射为相对应的Java元素。

l Schema generator: 与 Schema compiler反向的过程，将Java元素映射为schema。

l Binding runtime framework: 绑定运行时框架，即JAXB的编组及解组过程。

The JAXB Binding Proecss

zhoushuai3066
关注
JAXB注解相关技术
06-26
### JAXB注解相关技术 JAXB (Java Architecture for XML Binding) 是一种 Java 技术，它允许将 XML 数据与 Java 对象相互绑定。这使得开发人员能够更容易地处理 XML 数据，将其转换为 Java 对象，或者将 Java 对象...
JAXB.zip_jaxb
09-20
**xml-resources** 目录可能包含与XML相关的资源，如XSD（XML Schema Definition）文件，这些文件定义了XML文档的结构和约束，可以被JAXB用来验证生成的XML文档的合法性。 **test** 目录通常存放单元测试代码。在这...
jaxb api jar
06-08
虽然这个文件不是直接与JAXB相关的，但两者在Java EE环境中可能会共同发挥作用，比如在业务流程中根据XML数据触发某些规则。 总结来说，`jaxb-api-2.1.9.jar` 是Java开发中处理XML数据的重要工具，它提供了方便的...
java使用jaxb操作xml示例
09-04
关键在于创建 `JAXBContext` 实例，它是JAXB的核心，负责管理与特定Java包或类相关的元数据。然后，我们通过 `JAXBContext` 创建一个 `Marshaller` 实例，它负责实际的序列化过程。我们可以设置 `Marshaller` 的属性...
Jaxb webservice java调用
06-13
2. **导入所需的依赖库**：在Java项目中，你需要引入JAXB相关的库，例如`jaxb-api`、`jaxws-ri`等。这些库提供了实现JAXB和Web服务调用所需的功能。 3. **实例化服务代理**：生成的代码中会包含一个服务接口，你...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 884
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 286
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 490
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1001
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 631
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Springboot人才求职招聘系统源码（前台+后台）
最新发布
10-06 461
项目技术：springboot运行环境：jdk1.8+idea/eclipse+maven3+mysql5.6。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1499
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 825
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java中的break、continue和return语句
weixin_73230994的博客
10-05 354
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 935
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 184
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 402
记忆中，两个指针合并即可。
SpringBoot线程问题
juanmiao的专栏
10-04 493
程序，线程，线程池进程是资源分配最小单位，线程是程序执行的最小单位。计算机在执行程序时，会为程序创建相应的进程，进行资源分配时，是以进程为单位进行相应的分配，每个进程都有相应的线程，在执行程序是，实际上是执行相应的一系列线程。线程：程序执行流的最小执行单位，是行程中实际运作单位，经常容易和进程这个概念混淆简单来说，一个应用程序的运行就可以被看做是一个进程。是运行中实际的执行任务者，可以说，进程中包含了多个可以同时运行的线程。线程的生命周期。
Python并发编程(1)——Python并发编程的几种实现方式
一点
10-03 1060
Python 并发编程是指在 Python 中编写能够同时执行多个任务的程序。并发编程在任何一门语言当中都是比较难的，因为会涉及各种各样的问题，在Python当中也不例外。Python 提供了多种方式来实现并发，包括多线程（threading）、多进程（multiprocessing）、异步编程（asyncio），以及一些高级用法concurrent.futures和第三方库如gevent。
导入dom4j和JAXB相关的jar包。
06-10
<artifactId>jaxb-api <version>2.3.1 <groupId>com.sun.xml.bind</groupId> <artifactId>jaxb-core <version>2.3.0.1 <groupId>com.sun.xml.bind</groupId> <artifactId>jaxb-impl <version>2.3.2 ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值