Jackson学习

最新推荐文章于 2024-07-01 16:24:15 发布
最新推荐文章于 2024-07-01 16:24:15 发布
阅读量1.6k 收藏
点赞数 1
文章标签： Json Jackson
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xtsylc/article/details/51980154
版权

Jackson是基于Java平台的一套数据处理工具，被称为“最好的Java Json解析器”。使用Json需要添加三个核心类库：

jackson-core-x.x.x.jar、jackson-annotations-x.x.x.jar和jackson-databind-bind-x.x.x.jar。


Jackson提供了三种可选的Json处理方法：流式API(Streaming API) 、树模型(Tree Model)、数据绑定(Data Binding)。从使用角度来看，比较一下这三种处理Json的方式的特性：

Streaming API：是效率最高的处理方式(开销低、读写速度快，但程序编写复杂度高)
Tree Model：是最灵活的处理方式
Data Binding：是最常用的处理方式。

下面介绍一下Jackson常用注解内容，并且例子中采用DataBinding处理Json：

  1. @JsonIgnore：作用在字段或者方法上，用来完全忽略被注解的字段以及方法对应的属性。不管@JsonIgnore注解在setters上还是getters上都会忽略对应的属性。示例代码如下：
    <pre name="code" class="java">public class TestPOJO{  
    private int id;  
    @JsonIgnore  
    private String name;  
    private int count;  
  
    public int getId() {  
        return id;  
    }  
  
    public void setId(int id) {  
        this.id = id;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public int getCount() {  
        return count;  
    }  
    @JsonIgnore  
    public void setCount(int count) {  
        this.count = count;  
    }

	@Override
	public String toString() {
		return "TestPOJO [id=" + id + ", name=" + name + ", count=" + count + "]";
	}   
}
    //测试类
    public class jsonIgnoreTest {

	 @Test  
	 public void jsonIgnoreTest() throws Exception {  
	     TestPOJO testPOJO = new TestPOJO();  
	     testPOJO.setId(111);  
	     testPOJO.setName("myName");  
	     testPOJO.setCount(22);  
	   
	     ObjectMapper objectMapper = new ObjectMapper();  
	     String jsonStr = objectMapper.writeValueAsString(testPOJO);  
	     Assert.assertEquals("{\"id\":111}",jsonStr);  
	     System.out.println(jsonStr);
	     String jsonStr2 = "{\"id\":111,\"name\":\"myName\",\"count\":22}";  
	     TestPOJO testPOJO2 = objectMapper.readValue(jsonStr2, TestPOJO.class);  
	     System.out.println(testPOJO2);
	     Assert.assertEquals(111,testPOJO2.getId());  
	     Assert.assertNull(testPOJO2.getName());  
	     Assert.assertEquals(0,testPOJO2.getCount());  
	 }
}
     
  2. @JsonProperty：作用在字段或方法上，用来对属性的序列化/反序列化，可以用来避免遗漏属性，同时提供对属性名称重命名。示例代码如下：
    public class TestPOJOJsonProperty {
	@JsonProperty//注意这里必须得有该注解，因为没有提供对应的getId和setId函数，而是其他的getter和setter，防止遗漏该属性  
    private int id;  
    

	@JsonProperty("first_name")  
    private String firstName;  
  
    public int wahaha() {  
        return id;  
    }  
  
    public void wahaha(int id) {  
        this.id = id;  
    }  
  
    public String getFirstName() {  
        return firstName;  
    }  
  
    public void setFirstName(String firstName) {  
        this.firstName = firstName;  
    }  
}<pre name="code" class="java">public class JsonPropertyTest {
	@Test  
	public void jsonPropertyTest() throws Exception {  
		TestPOJOJsonProperty testPOJO = new TestPOJOJsonProperty();  
	    testPOJO.wahaha(111);  
	    testPOJO.setFirstName("myName");  
	  
	    ObjectMapper objectMapper = new ObjectMapper();  
	    String jsonStr = objectMapper.writeValueAsString(testPOJO);
	    System.out.println(jsonStr);
	    Assert.assertEquals("{\"id\":111,\"first_name\":\"myName\"}",jsonStr);  
	  
	    String jsonStr2 = "{\"id\":111,\"first_name\":\"myName\"}";  
	    TestPOJOJsonProperty testPOJO2 = objectMapper.readValue(jsonStr2, TestPOJOJsonProperty.class);  
	    Assert.assertEquals(111, testPOJO2.wahaha());  
	    Assert.assertEquals("myName", testPOJO2.getFirstName());  
	}
}
     
     
  3. @JsonIgnoreProperties：作用在类上，用来说明有些属性在序列化/反序列化时需要忽略掉，可以将它看做是@JsonIgnore的批量操作，但它的功能比@JsonIgnore要强，比如一个类是代理类，我们无法将将@JsonIgnore标记在属性或方法上，此时便可用@JsonIgnoreProperties标注在类声明上，
     它还有一个重要的功能是作用在反序列化时解析字段时过滤一些未知的属性，
     否则通常情况下解析到我们定义的类不认识的属性便会抛出异常。
     可以注明是想要忽略的属性列表如@JsonIgnoreProperties({"name","age","title"})，
     也可以注明过滤掉未知的属性如@JsonIgnoreProperties(ignoreUnknown=true)。示例代码如下：
    @JsonIgnoreProperties({"name","age","title"})
public class TestPOJOJsonIgnoreProperties {
	private int id;  
    private String name;  
    private int age;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}
//测试类
public class JsonIgnorePropertiesTest {

	@Test()  
	public void JsonIgnoreProperties() throws Exception {  
		TestPOJOJsonIgnoreProperties testPOJO = new TestPOJOJsonIgnoreProperties();  
	    testPOJO.setId(111);  
	    testPOJO.setName("myName");  
	    testPOJO.setAge(22);  
	    ObjectMapper objectMapper = new ObjectMapper();  
	    String jsonStr = objectMapper.writeValueAsString(testPOJO);  
	    Assert.assertEquals("{\"id\":111}",jsonStr);//name和age被忽略掉了  
	  
	    String jsonStr2 = "{\"id\":111,\"name\":\"myName\",\"age\":22,\"title\":\"myTitle\"}";  
	    TestPOJOJsonIgnoreProperties testPOJO2 = objectMapper.readValue(jsonStr2, TestPOJOJsonIgnoreProperties.class);  
	    Assert.assertEquals(111, testPOJO2.getId());  
	    Assert.assertNull(testPOJO2.getName());  
	    Assert.assertEquals(0,testPOJO2.getAge());  
	    String jsonStr3 = "{\"id\":111,\"name\":\"myName\",\"count\":33}";//这里有个未知的count属性，反序列化会报错  
	    objectMapper.readValue(jsonStr3, TestPOJOJsonIgnoreProperties.class);  
	} 
	
}

     
  4. @JsonUnwrapped作用在属性或方法上，用来将子Json对象的属性添加到封闭的Json对象，来个例子一目了然。
    @Test  
public void jsonUnwrapped() throws Exception {  
    TestPOJO testPOJO = new TestPOJO();  
    testPOJO.setId(111);  
    TestName testName = new TestName();  
    testName.setFirstName("张");  
    testName.setSecondName("三");  
    testPOJO.setName(testName);  
    ObjectMapper objectMapper = new ObjectMapper();  
    String jsonStr = objectMapper.writeValueAsString(testPOJO);  
    //如果没有@JsonUnwrapped，序列化后将为{"id":111,"name":{"firstName":"张","secondName":"三"}}  
    //因为在name属性上加了@JsonUnwrapped，所以name的子属性firstName和secondName将不会包含在name中。  
    Assert.assertEquals("{\"id\":111,\"firstName\":\"张\",\"secondName\":\"三\"}",jsonStr);  
    String jsonStr2 = "{\"id\":111,\"firstName\":\"张\",\"secondName\":\"三\"}";  
    TestPOJO testPOJO2 = objectMapper.readValue(jsonStr2,TestPOJO.class);  
    Assert.assertEquals(111,testPOJO2.getId());  
    Assert.assertEquals("张",testPOJO2.getName().getFirstName());  
    Assert.assertEquals("三",testPOJO2.getName().getSecondName());  
}  
  
public static class TestPOJO{  
    private int id;  
    @JsonUnwrapped  
    private TestName name;  
      //getters、setters省略  
} public static class TestName{  
    private String firstName;  
    private String secondName;  
  
    //getters、setters省略  
} 

     
  5. @JsonIdentityInfo作用于类或者属性上，被用来在序列化/反序列化时为该对象或字段添加一个对象识别码，通常用来解决循环嵌套问题。对象识别码可以是虚拟的，即
 

 
 存在在JSON中，但不是POJO的一部分，这种情况下我们可以这样使用注解：（没有该注释的话，对象转Json会因为循环嵌套报错） 

 

 
 @JsonIdentityInfo(generator = ObjectIdGenerators.IntSequenceGenerator.class,property = "@id")
  

 

 
 对象识别码也可以是真实存在的，即以对象的属性为识别码，通常这种情况下我们一般以id属性为识别码，使用如下： 

 

 
 @JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class,property = "id")
  

 

 
 举例如下： 
 
@Test  
public void jsonIdentityInfo() throws Exception {  
    Parent parent = new Parent();  
    parent.setName("jack");  
    Child child = new Child();  
    child.setName("mike");  
    Child[] children = new Child[]{child};  
    parent.setChildren(children);  
    child.setParent(parent);  
    ObjectMapper objectMapper = new ObjectMapper();  
    String jsonStr = objectMapper.writeValueAsString(parent);  
    Assert.assertEquals("{\"@id\":1,\"name\":\"jack\",\"children\":[{\"name\":\"mike\",\"parent\":1}]}",jsonStr);  
}  
  
@JsonIdentityInfo(generator = ObjectIdGenerators.IntSequenceGenerator.class,property = "@id")  
public static class Parent{  
    private String name;  
    private Child[] children;  
  
    //getters、setters省略  
}  
  
public static class Child{  
    private String name;  
    private Parent parent;  
  
    //getters、setters省略  
}
 

 

 
 6.@JsonNaming作用：它可以让你定制属性命名策略，作用和前面提到的@JsonProperty的重命名属性名称相同。 

 

 
 比如你有一个JSON串{"in_reply_to_user_id":"abc123"}，需要反序列化为POJO，POJO一般情况下则需要如此写 
 
public class TestPOJO{  
  
    private String in_reply_to_user_id;  
  
    public String getIn_reply_to_user_id() {  
        return in_reply_to_user_id;  
    }  
  
    public void setIn_reply_to_user_id(String in_reply_to_user_id) {  
        this.in_reply_to_user_id = in_reply_to_user_id;  
    }  
}
 
 
 但这显然不符合JAVA的编码规范，你可以用@JsonProperty，比如 
 
public class TestPOJO{  
  
    @JsonProperty("in_reply_to_user_id")  
    private String inReplyToUserId;  
  
    public String getInReplyToUserId() {  
        return inReplyToUserId;  
    }  
  
    public void setInReplyToUserId(String inReplyToUserId) {  
        this.inReplyToUserId = inReplyToUserId;  
    }  
}
 
 
 这样就符合规范了，可是如果POJO里有很多属性，给每个属性都要加上@JsonProperty是多么繁重的工作，这里就需要用到@JsonNaming了， 

 

 
 它不仅能制定统一的命名规则，还能任意按自己想要的方式定制 
 
@Test  
public void jsonNaming() throws Exception{  
    String jsonStr = "{\"in_reply_to_user_id\":\"abc123\"}";  
    ObjectMapper objectMapper = new ObjectMapper();  
    TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);  
    Assert.assertEquals("abc123",testPOJO.getInReplyToUserId());  
  
    TestPOJO testPOJO2 = new TestPOJO();  
    testPOJO2.setInReplyToUserId("abc123");  
    String jsonStr2 = objectMapper.writeValueAsString(testPOJO2);  
    Assert.assertEquals(jsonStr,jsonStr2);  
}  
  
@JsonNaming(PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy.class)  
public static class TestPOJO{  
  
    private String inReplyToUserId;  
  
    public String getInReplyToUserId() {  
        return inReplyToUserId;  
    }  
  
    public void setInReplyToUserId(String inReplyToUserId) {  
        this.inReplyToUserId = inReplyToUserId;  
    }  
}
 
 
 @JsonNaming使用了jackson已经实现的PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy，它可以将大写转换为小写并添加下划线。 

 

 
 你可以自定义，必须继承类PropertyNamingStrategy，建议继承PropertyNamingStrategyBase， 

 

 
 我们自己实现一个类似LowerCaseWithUnderscoresStrategy的策略，只是将下划线改为破折号 

 

 
  
 
@Test  
public void jsonNaming() throws Exception{  
    String jsonStr = "{\"in-reply-to-user-id\":\"abc123\"}";  
    ObjectMapper objectMapper = new ObjectMapper();  
    TestPOJO testPOJO = objectMapper.readValue(jsonStr,TestPOJO.class);  
    Assert.assertEquals("abc123", testPOJO.getInReplyToUserId());  
  
    TestPOJO testPOJO2 = new TestPOJO();  
    testPOJO2.setInReplyToUserId("abc123");  
    String jsonStr2 = objectMapper.writeValueAsString(testPOJO2);  
    Assert.assertEquals(jsonStr, jsonStr2);  
}  
  
@JsonNaming(MyPropertyNamingStrategy.class)  
public static class TestPOJO{  
  
    private String inReplyToUserId;  
  
    public String getInReplyToUserId() {  
        return inReplyToUserId;  
    }  
  
    public void setInReplyToUserId(String inReplyToUserId) {  
        this.inReplyToUserId = inReplyToUserId;  
    }  
}  
  
public static class MyPropertyNamingStrategy extends PropertyNamingStrategy.PropertyNamingStrategyBase {  
    @Override  
    public String translate(String input) {  
        if (input == null) return input; // garbage in, garbage out  
        int length = input.length();  
        StringBuilder result = new StringBuilder(length * 2);  
        int resultLength = 0;  
        boolean wasPrevTranslated = false;  
        for (int i = 0; i < length; i++)  
        {  
            char c = input.charAt(i);  
            if (i > 0 || c != '-') // skip first starting underscore  
            {  
                if (Character.isUpperCase(c))  
                {  
                    if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '-')  
                    {  
                        result.append('-');  
                        resultLength++;  
                    }  
                    c = Character.toLowerCase(c);  
                    wasPrevTranslated = true;  
                }  
                else  
                {  
                    wasPrevTranslated = false;  
                }  
                result.append(c);  
                resultLength++;  
            }  
        }  
        return resultLength > 0 ? result.toString() : input;  
    }  
} 
如果你想让自己定制的策略对所有解析都实现，除了对每个具体的实体类对应的位置加上@JsonNaming外你还可以如下做全局配置 
 
ObjectMapper objectMapper = new ObjectMapper();  
objectMapper.setPropertyNamingStrategy(new MyPropertyNamingStrategy());
 
 
 
 
 

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 

 
 
  

 


                

        

        

    




    

      

        

            

              
                
                  小木屑
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
如何在Jackson中使用PropertyNamingStrategy

				
			

			

				

					最佳 Java 编程
				

				

					05-15
					
					8991
					
				

			

		

		

			
				
Jackson api被广泛用于将json转换为Object并将Object转换为JSON。因此，如果您有json字符串并想在java对象中进行转换，请创建与json中的字段相同的bean的字段名。 Jackson在将json字段映射到Java对象字段时遵循标准bean约定，但是如果您有一个不遵循命名约定的json（对于以大写字母开头的ex字段），jackson将不知道如何将此字段与您的ja...

			
		

	



                

              
                



	

		

			

				
					
JackSon

				
			

			

				

					qq_44507798的博客
				

				

					04-26
					
					2541
					
				

			

		

		

			
				
前后端分离开发中常用到的数据交互方式就是json。本文主要讲解对jackson对json的相关操作。
jackson
基础篇
1、引入依赖：
<!--jackson--> 
<dependency> 
	<groupId>com.fasterxml.jackson.core</groupId> 
	<artifactId>jackson-databind</artifactId> 
</dependency>

2、、创建O

			
		

	



                


  
              

                


	

		

			

				
					
jackson自定义策略

				
			

			

				

					weixin_43831204的博客
				

				

					08-08
					
					2294
					
				

			

		

		

			
				
Jackson支持在处理数据的时候，使用不同于对象字段名的JSON名称（Jackson内部使用），来代替原来的字段名进行序列化和反序列化。
主要有几种实现方式：

使用@JsonProperty指定固定的名称进行名称映射；
使用预定义的命名策略PropertyNamingStrategy，设置全局或单个类的命名策略；
扩展PropertyNamingStrategy，实现自定义命名策略，读和写支持使用不同的命名策略。

一.属性名称@JsonProperty
对于需要修改名称的字段，可以在字段或getter

			
		

	





	

		

			

				
					
Jackson使用详解

					
最新发布

				
			

			

				

					长河的博客
				

				

					07-01
					
					699
					
				

			

		

		

			
				
Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架。Jackson 社区相对比较活跃，更新速度也比较快， 从 Github 中的统计来看，Jackson 是最流行的 json 解析器之一。Spring MVC 的默认 json 解析器便是 Jackson。Jackson 优点很多。Jackson 所依赖的 jar 包较少 ，简单易用。与其他 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比较快；

			
		

	



		

			
		



	

		

			

				
					
spring jack 使用自定义的objectMapper。或者在xml配置objectMapper参数

				
			

			

				

					layman1024的博客
				

				

					06-08
					
					5993
					
				

			

		

		

			
				
在spring-servlet.xml中配置json的转换器：


[html] 
view plain 
copy 
print?


bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">                    property name

			
		

	





	

		

			

				
					
Jackson修改字段名和自定义命名

				
			

			

				

					LOOPY_Y的博客
				

				

					03-26
					
					1663
					
				

			

		

		

			
				
jackson修改字段名和自定义命名：
使用@JsonProperty指定固定的名称进行名称映射；
使用预定义的命名策略PropertyNamingStrategy
扩展PropertyNamingStrategy，实现自定义命名策略。

			
		

	





	

		

			

				
					
ObjectMapper序列化和反序列化特性

				
			

			

				

					zzztimes的博客
				

				

					12-14
					
					832
					
				

			

		

		

			
				
【代码】ObjectMapper序列化和反序列化特性。

			
		

	





	

		

			

				
					
jackson学习之二：jackson-core

				
			

			

				

					qdwd888的博客
				

				

					05-04
					
					498
					
				

			

		

		

			
				
增加一个Pojo，对应的是一条推特消息：

package com.bolingcavalry.jacksondemo.beans;
/**


@Description: 推特消息bean


@author: willzhao E-mail: zq2599@gmail.com


@date: 2020/7/4 16:24


*/
public class TwitterEntry {
/**

推特消息id

*/
long id;
/**

消息内容

*/
String text;    /*.

			
		

	





	

		

			

				
					
Jackson学习实例

				
			

			

				

					08-12
				

			

		

		

			
				
在本"Jackson学习实例"中，我们将深入探讨Jackson库的核心概念、主要功能以及如何在实际项目中应用。  一、Jackson简介 Jackson是由FasterXML团队开发的开源库，它的全名是com.fasterxml.jackson.databind，是Java...

			
		

	





	

		

			

				
					
Jackson注解学习参考

				
			

			

				

					04-15
				

			

		

		

			
				
这篇“Jackson注解学习参考”文档很可能是对Jackson库中常用注解的一个详细讲解。在深入探讨之前，先了解JSON库在开发中的作用至关重要：它允许应用程序之间交换数据，特别是在Web服务和客户端之间。  Jackson库的...

			
		

	





	

		

			

				
					
jackson.zip|jackson.zip

				
			

			

				

					09-07
				

			

		

		

			
				
Jackson是Java领域中广泛使用的JSON处理库，由...总之，Jackson库以其高效、灵活和强大的特性，在Java世界中占据了重要的地位，对于理解和掌握JSON处理技术的开发者来说，深入学习和使用Jackson是非常有价值的。

			
		

	





	

		

			

				
					
jackson 全部jar包

				
			

			

				

					11-10
				

			

		

		

			
				
10. **社区支持和文档**：Jackson有着活跃的社区和详尽的文档，开发者可以在遇到问题时获取帮助，同时学习如何充分利用这个库。  综上所述，Jackson 2.6版本包含了全面的JSON处理功能，从基础的流式API到高级的数据...

			
		

	





	

		

			

				
					
Java的Jackson库的使用及其树模型的入门学习教程

				
			

			

				

					09-02
				

			

		

		

			
				
接下来，我们将通过一个具体的例子来学习如何使用Jackson库进行对象与JSON之间的转换。在这个例子中，我们有一个Student类，它有name和age两个属性。我们将创建一个JSON字符串表示这个学生的详细信息，然后使用...

			
		

	





	

		

			

				
					
Jackson使用PropertyNamingStrategy处理属性首字母为大写的情况

					
热门推荐

				
			

			

				

					岁月静好
				

				

					11-30
					
					1万+
					
				

			

		

		

			
				
最近在项目中调用.NET的服务时，Jackson在解析返回的json字符串时始终报错，纠结很久之后才找到原因，原来是由于json字符串中的字母都是首字母大写，导致jackson找不到相应的KEY。
可以使用PropertyNamingStrategy统一处理：ObjectMapper mapper = new ObjectMapper();
mapper.setPropertyNamingSt

			
		

	





	

		

			

				
					
map对象驼峰映射类型转换成下划线类型

				
			

			

				

					qi_ye_的博客
				

				

					12-30
					
					1495
					
				

			

		

		

			
				
map、object中key值驼峰映射转换为下划线类型

			
		

	





	

		

			

				
					
Jackson 注解及配置大全

				
			

			

				

					lizsy的博客
				

				

					04-19
					
					2685
					
				

			

		

		

			
				
注解应用于属性，反序列化时集合类型属性时，将Json中的元素与字段中的默认元素融合。

			
		

	





	

		

			

				
					
jackson-PropertyNamingStrategy.SNAKE_CASE 遇到的问题与解决方案

				
			

			

				

					RichardGeek的博客
				

				

					04-20
					
					5413
					
				

			

		

		

			
				
PropertyNamingStrategy.SNAKE_CASE

			
		

	





	

		

			

				
					
Spring Boot 统一设置Json数据返回风格（Java驼峰命名转下划线,解决数字转换缺陷）

				
			

			

				

					ccitSunshine的博客
				

				

					09-03
					
					2958
					
				

			

		

		

			
				
**Spring Boot 统一设置Json数据返回风格（Java驼峰命名转下划线,解决数字转换缺陷）
**
一般普通转化使用:
@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
/**
 * 统一输出风格
 */
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters

			
		

	





	

		

			

				
					
springboot jackson配置

				
			

			

				

					2401_84010865的博客
				

				

					04-03
					
					541
					
				

			

		

		

			
				
spring.jackson.joda-date-time-format指定Joda date/time的格式，比如yyyy-MM-ddHH:mm:ss). 如果没有配置的话，dateformat会作为backupspring.jackson.locale指定json使用的Locale.spring.jackson.mapper是否开启Jackson通用的特性.spring.jackson.parser是否开启jackson的parser特性.spring.jackson.property-naming-s

			
		

	





	

		

			

				
					
jackson这个jar包

				
			

			

				

					07-27
				

			

		

		

			
				
Jackson是一个用于处理JSON数据的Java库。它提供了一组功能强大的API，可以轻松地将Java对象转换为JSON格式，并将JSON格式转换为Java对象。在你提供的引用中，有三个与Jackson相关的jar包：jackson-core、jackson-databind。\[1\]\[2\]\[3\]

jackson-core是Jackson库的核心模块，它包含了处理JSON数据的基本功能。你可以使用它来解析和生成JSON数据。

jackson-databind是Jackson库的数据绑定模块，它提供了将Java对象与JSON数据进行相互转换的功能。你可以使用它来将Java对象序列化为JSON格式，或将JSON数据反序列化为Java对象。

如果你想在你的Java项目中使用Jackson库，你可以在项目的pom.xml文件中添加相应的依赖项，如你提供的引用所示。这样，你就可以使用Jackson库的功能来处理JSON数据了。
#### 引用[.reference_title]
-  *1* *2* *3* [Jackson学习笔记](https://blog.csdn.net/weixin_43304253/article/details/116898047)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值