Java中Jackson快速入门

Java生态圈中有很多处理JSON和XML格式化的类库,Jackson是其中比较著名的一个。虽然JDK自带了XML处理类库,但是相对来说比较低级,使用本文介绍的Jackson等高级类库处理起来会方便很多。

引入类库

由于Jackson相关类库按照功能分为几个相对独立的,所以需要同时引入多个类库,为了方便我将版本号单独提取出来设置,相关Gradle配置如下。

ext {
  jacksonVersion = '2.9.5'
}

dependencies {
  compile group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: jacksonVersion
  compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: jacksonVersion
  compile group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: jacksonVersion
  // 引入XML功能
  compile group: 'com.fasterxml.jackson.dataformat', name: 'jackson-dataformat-xml', version: jacksonVersion
  // 比JDK自带XML实现更高效的类库
  compile group: 'com.fasterxml.woodstox', name: 'woodstox-core', version: '5.1.0'
  // Java 8 新功能
  compile group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-jsr310', version: jacksonVersion
  compile group: 'com.fasterxml.jackson.module', name: 'jackson-module-parameter-names', version: jacksonVersion
  compile group: 'com.fasterxml.jackson.datatype', name: 'jackson-datatype-jdk8', version: jacksonVersion

  compileOnly group: 'org.projectlombok', name: 'lombok', version: '1.16.22'
}

Maven配置请去mvnrepository搜索。

Jackson注解

Jackson类库包含了很多注解,可以让我们快速建立Java类与JSON之间的关系。详细文档可以参考Jackson-Annotations。下面介绍一下常用的。

属性命名

@JsonProperty注解指定一个属性用于JSON映射,默认情况下映射的JSON属性与注解的属性名称相同,不过可以使用该注解的value值修改JSON属性名,该注解还有一个index属性指定生成JSON属性的顺序,如果有必要的话。

属性包含

还有一些注解可以管理在映射JSON的时候包含或排除某些属性,下面介绍一下常用的几个。

@JsonIgnore注解用于排除某个属性,这样该属性就不会被Jackson序列化和反序列化。

@JsonIgnoreProperties注解是类注解。在序列化为JSON的时候,@JsonIgnoreProperties({"prop1", "prop2"})会忽略pro1和pro2两个属性。在从JSON反序列化为Java类的时候,@JsonIgnoreProperties(ignoreUnknown=true)会忽略所有没有Getter和Setter的属性。该注解在Java类和JSON不完全匹配的时候很有用。

@JsonIgnoreType也是类注解,会排除所有指定类型的属性。

序列化相关

@JsonPropertyOrder和@JsonProperty的index属性类似,指定属性序列化时的顺序。

@JsonRootName注解用于指定JSON根属性的名称。

处理JSON

简单映射

我们用Lombok设置一个简单的Java类。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Friend {
  private String nickname;
  private int age;
}

然后就可以处理JSON数据了。首先需要一个ObjectMapper对象,序列化和反序列化都需要它。

    ObjectMapper mapper = new ObjectMapper();
    Friend friend = new Friend("yitian", 25);

    // 写为字符串
    String text = mapper.writeValueAsString(friend);
    // 写为文件
    mapper.writeValue(new File("friend.json"), friend);
    // 写为字节流
    byte[] bytes = mapper.writeValueAsBytes(friend);
    System.out.println(text);
    // 从字符串中读取
    Friend newFriend = mapper.readValue(text, Friend.class);
    // 从字节流中读取
    newFriend = mapper.readValue(bytes, Friend.class);
    // 从文件中读取
    newFriend = mapper.readValue(new File("friend.json"), Friend.class);
    System.out.println(newFriend);

程序结果如下。可以看到生成的JSON属性和Java类中定义的一致。

{"nickname":"yitian","age":25}
Friend(nickname=yitian, age=25)

集合的映射

除了使用Java类进行映射之外,我们还可以直接使用Map和List等Java集合组织JSON数据,在需要的时候可以使用readTree方法直接读取JSON中的某个属性值。需要注意的是从JSON转换为Map对象的时候,由于Java的类型擦除,所以类型需要我们手动用new TypeReference<T>给出。

    ObjectMapper mapper = new ObjectMapper();

    Map<String, Object> map = new HashMap<>();
    map.put("age", 25);
    map.put("name", "yitian");
    map.put("interests", new String[]{"pc games", "music"});

    String text = mapper.writeValueAsString(map);
    System.out.println(text);

    Map<String, Object> map2 = mapper.readValue(text, new TypeReference<Map<String, Object>>() {
    });
    System.out.println(map2);

    JsonNode root = mapper.readTree(text);
    String name = root.get("name").asText();
    int age = root.get("age").asInt();

    System.out.println("name:" + name + " age:" + age);

程序结果如下。

{"name":"yitian","interests":["pc games","music"],"age":25}
{name=yitian, interests=[pc games, music], age=25}
name:yitian age:25

Jackson配置

Jackson预定义了一些配置,我们通过启用和禁用某些属性可以修改Jackson运行的某些行为。详细文档参考JacksonFeatures。下面我简单翻译一下Jackson README上列出的一些属性。

// 美化输出
mapper.enable(SerializationFeature.INDENT_OUTPUT);
// 允许序列化空的POJO类
// (否则会抛出异常)
mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
// 把java.util.Date, Calendar输出为数字(时间戳)
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

// 在遇到未知属性的时候不抛出异常
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 强制JSON 空字符串("")转换为null对象值:
mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);

// 在JSON中允许C/C++ 样式的注释(非标准,默认禁用)
mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
// 允许没有引号的字段名(非标准)
mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
// 允许单引号(非标准)
mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
// 强制转义非ASCII字符
mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true);
// 将内容包裹为一个JSON属性,属性名由@JsonRootName注解指定
mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);

这里有三个方法,configure方法接受配置名和要设置的值,Jackson 2.5版本新加的enable和disable方法则直接启用和禁用相应属性,我推荐使用后面两个方法。

用注解管理映射

前面介绍了一些Jackson注解,下面来应用一下这些注解。首先来看看使用了注解的Java类。

@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonRootName("FriendDetail")
@JsonIgnoreProperties({"uselessProp1", "uselessProp3"})
public class FriendDetail {
  @JsonProperty("NickName")
  private String name;
  @JsonProperty("Age")
  private int age;
  private String uselessProp1;
  @JsonIgnore
  private int uselessProp2;
  private String uselessProp3;
}

然后看看代码。需要注意的是,由于设置了排除的属性,所以生成的JSON和Java类并不是完全对应关系,所以禁用DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES是必要的。

    ObjectMapper mapper = new ObjectMapper();
    //mapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    FriendDetail fd = new FriendDetail("yitian", 25, "", 0, "");
    String text = mapper.writeValueAsString(fd);
    System.out.println(text);

    FriendDetail fd2 = mapper.readValue(text, FriendDetail.class);
    System.out.println(fd2);

运行结果如下。可以看到生成JSON的时候忽略了我们制定的值,而且在转换为Java类的时候对应的属性为空。

{"NickName":"yitian","Age":25}
FriendDetail(name=yitian, age=25, uselessProp1=null, uselessProp2=0, uselessProp3=null)

然后取消注释代码中的那行,也就是启用WRAP_ROOT_VALUE功能,再运行一下程序,运行结果如下。可以看到生成的JSON结果发生了变化,而且由于JSON结果变化,所以Java类转换失败(所有字段值全为空)。WRAP_ROOT_VALUE这个功能在有些时候比较有用,因为有些JSON文件需要这种结构。

{"FriendDetail":{"NickName":"yitian","Age":25}}
FriendDetail(name=null, age=0, uselessProp1=null, uselessProp2=0, uselessProp3=null)

Java8日期时间类支持

Java8增加了一套全新的日期时间类,Jackson对此也有支持。这些支持是以Jackson模块形式提供的,所以首先就是注册这些模块。

    ObjectMapper mapper = new ObjectMapper()
        .registerModule(new JavaTimeModule())
        .registerModule(new ParameterNamesModule())
        .registerModule(new Jdk8Module());

导入类库之后,Jackson也可以自动搜索所有模块,不需要我们手动注册。

mapper.findAndRegisterModules();

我们新建一个带有LocalDate字段的Java类。

@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonRootName("Person")
public class Person {
  @JsonProperty("Name")
  private String name;
  @JsonProperty("NickName")
  private String nickname;
  @JsonProperty("Age")
  private int age;
  @JsonProperty("IdentityCode")
  private String identityCode;
  @JsonProperty
  @JsonFormat(pattern = "yyyy-MM-DD")
  private LocalDate birthday;

}

然后来看看代码。

  static void java8DateTime() throws IOException {
    Person p1 = new Person("yitian", "易天", 25, "10000", LocalDate.of(1994, 1, 1));
    ObjectMapper mapper = new ObjectMapper()
        .registerModule(new JavaTimeModule());
    //mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    String text = mapper.writeValueAsString(p1);
    System.out.println(text);

    Person p2 = mapper.readValue(text, Person.class);
    System.out.println(p2);
  }

运行结果如下。可以看到,生成的JSON日期变成了[1994,1,1]这样的时间戳形式,一般情况下不符合我们的要求。

{"birthday":[1994,1,1],"Name":"yitian","NickName":"易天","Age":25,"IdentityCode":"10000"}
Person(name=yitian, nickname=易天, age=25, identityCode=10000, birthday=1994-01-01)

取消注释那行代码,程序运行结果如下。这样一来就变成了我们一般使用的形式了。如果有格式需要的话,可以使用@JsonFormat(pattern = "yyyy-MM-DD")注解格式化日期显示。

{"birthday":"1994-01-01","Name":"yitian","NickName":"易天","Age":25,"IdentityCode":"10000"}
Person(name=yitian, nickname=易天, age=25, identityCode=10000, birthday=1994-01-01)

处理XML

Jackson是一个处理JSON的类库,不过它也通过jackson-dataformat-xml包提供了处理XML的功能。Jackson建议我们在处理XML的时候使用woodstox-core包,它是一个XML的实现,比JDK自带XML实现更加高效,也更加安全。

这里有个注意事项,如果你正在使用Java 9以上的JDK,可能会出现java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException异常,这是因为Java 9实现了JDK的模块化,将原本和JDK打包在一起的JAXB实现分隔出来。所以这时候需要我们手动添加JAXB的实现。在Gradle中添加下面的代码即可。

compile group: 'javax.xml.bind', name: 'jaxb-api', version: '2.3.0'

注解

Jackson XML除了使用Jackson JSON和JDK JAXB的一些注解之外,自己也定义了一些注解。下面简单介绍一下几个常用注解。

@JacksonXmlProperty注解有三个属性,namespace和localname属性用于指定XML命名空间的名称,isAttribute指定该属性作为XML的属性()还是作为子标签().

@JacksonXmlRootElement注解有两个属性,namespace和localname属性用于指定XML根元素命名空间的名称。

@JacksonXmlText注解将属性直接作为未被标签包裹的普通文本表现。

@JacksonXmlCData将属性包裹在CDATA标签中。

XML映射

新建如下一个Java类。

@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonRootName("Person")
public class Person {
  @JsonProperty("Name")
  private String name;
  @JsonProperty("NickName")
  //@JacksonXmlText
  private String nickname;
  @JsonProperty("Age")
  private int age;
  @JsonProperty("IdentityCode")
  @JacksonXmlCData
  private String identityCode;
  @JsonProperty("Birthday")
  //@JacksonXmlProperty(isAttribute = true)
  @JsonFormat(pattern = "yyyy/MM/DD")
  private LocalDate birthday;

}

下面是代码示例,基本上和JSON的API非常相似,XmlMapper实际上就是ObjectMapper的子类。

    Person p1 = new Person("yitian", "易天", 25, "10000", LocalDate.of(1994, 1, 1));
    XmlMapper mapper = new XmlMapper();
    mapper.findAndRegisterModules();
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    String text = mapper.writeValueAsString(p1);
    System.out.println(text);

    Person p2 = mapper.readValue(text, Person.class);
    System.out.println(p2);

运行结果如下。

<Person>
 <Name>yitian</Name>
 <NickName>易天</NickName>
 <Age>25</Age>
 <IdentityCode><![CDATA[10000]]></IdentityCode>
 <Birthday>1994/01/01</Birthday>
</Person>

Person(name=yitian, nickname=易天, age=25, identityCode=10000, birthday=1994-01-01)

如果取消那两行注释,那么运行结果如下。可以看到Jackson XML注解对生成的XML的控制效果。

<Person birthday="1994/01/01">
 <Name>yitian</Name>易天
 <Age>25</Age>
 <IdentityCode><![CDATA[10000]]></IdentityCode>
</Person>

Person(name=yitian, nickname=null, age=25, identityCode=10000, birthday=1994-01-01)

Spring Boot集成

自动配置

Spring Boot对Jackson的支持非常完善,只要我们引入相应类库,Spring Boot就可以自动配置开箱即用的Bean。Spring自动配置的ObjectMapper(或者XmlMapper)作了如下配置,基本上可以适应大部分情况。

  • 禁用了MapperFeature.DEFAULT_VIEW_INCLUSION
  • 禁用了DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES
  • 禁用了SerializationFeature.WRITE_DATES_AS_TIMESTAMPS

如果需要修改自动配置的ObjectMapper属性也非常简单,Spring Boot提供了一组环境变量,直接在application.properties文件中修改即可。

|Jackson枚举|Spring环境变量|
|—–|—–|
com.fasterxml.jackson.databind.DeserializationFeature|spring.jackson.deserialization.=true|false
com.fasterxml.jackson.core.JsonGenerator.Feature|spring.jackson.generator.=true|false
com.fasterxml.jackson.databind.MapperFeature|spring.jackson.mapper.=true|false
com.fasterxml.jackson.core.JsonParser.Feature|spring.jackson.parser.=true|false
com.fasterxml.jackson.databind.SerializationFeature|spring.jackson.serialization.=true|false
com.fasterxml.jackson.annotation.JsonInclude.Include|spring.jackson.default-property-inclusion=always|non_null|non_absent|non_default|non_empty

由于Spring会同时配置相应的HttpMessageConverters,所以我们其实要做的很简单,用Jackson注解标注好要映射的Java类,然后直接让控制器返回对象即可!下面是一个Java类。

@JsonRootName("person")
public class Person {
  @JsonProperty
  private String name;
  @JsonProperty
  private int id;
  @JsonFormat(pattern = "yyyy-MM-DD")
  private LocalDate birthday;

  public Person(String name, int id, LocalDate birthday) {
    this.name = name;
    this.id = id;
    this.birthday = birthday;
  }
}

然后是控制器代码。在整个过程中我们只需要引入Jackson类库,然后编写业务代码就好了。关于如何配置Jackson类库,我们完全不需要管,这就是Spring Boot的方便之处。

@Controller
public class MainController {
  private Person person = new Person("yitian", 10000, LocalDate.of(1994, 1, 1));

  @RequestMapping("/")
  public String index() {
    return "index";
  }

  @RequestMapping(value = "/json", produces = "application/json")
  @ResponseBody
  public Person json() {
    return person;
  }
}

进入localhost:8080/xml就可以看到对应结果了。

手动配置

Spring Boot自动配置非常方便,但不是万能的。在必要的时候,我们需要手动配置Bean来替代自动配置的Bean。

@Configuration
public class JacksonConfig {
  @Bean
  @Primary
  @Qualifier("xml")
  public XmlMapper xmlMapper(Jackson2ObjectMapperBuilder builder) {
    XmlMapper mapper = builder.createXmlMapper(true)
        .build();
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    return mapper;
  }

  @Bean
  @Qualifier("json")
  public ObjectMapper jsonMapper(Jackson2ObjectMapperBuilder builder) {
    ObjectMapper mapper = builder.createXmlMapper(false)
        .build();
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    return mapper;
  }
}

然后在需要的地方进行依赖注入。需要注意为了区分ObjectMapper和XmlMapper,需要使用@Qualifier注解进行标记。

@Controller
public class MainController {
  private ObjectMapper jsonMapper;
  private XmlMapper xmlMapper;
  private Person person = new Person("yitian", 10000, LocalDate.of(1994, 1, 1));

  public MainController(@Autowired @Qualifier("json") ObjectMapper jsonMapper, @Autowired @Qualifier("xml") XmlMapper xmlMapper) {
    this.jsonMapper = jsonMapper;
    this.xmlMapper = xmlMapper;
  }

以上就是Jackson类库的一些介绍,希望对大家有所帮助。项目代码在我的Github,感兴趣的同学可以看看。

到此这篇关于Java中Jackson快速入门的文章就介绍到这了,更多相关Jackson快速入门内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Jackson的用法实例分析

    通俗的来说,Jackson是一个 Java 用来处理 JSON 格式数据的类库,其性能非常好.本文就来针对Jackson的用法做一个较为详细的实例分析.具体如下: 一.简介 Jackson具有比较高的序列化和反序列化效率,据测试,无论是哪种形式的转换,Jackson > Gson > Json-lib,而且Jackson的处理能力甚至高出Json-lib近10倍左右,且正确性也十分高.相比之下,Json-lib似乎已经停止更新,最新的版本也是基于JDK15,而Jackson的社区则较为活跃.

  • 关于Jackson的JSON工具类封装 JsonUtils用法

    直接上代码,都有注释,一看就懂,完全满足日常开发需求 import com.fasterxml.jackson.annotation.JsonInclude.Include; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.Deserializa

  • 浅谈JackSon的几种用法

    JackSon介绍 本文使用的JackSon版本为2.9.6. JackSon是解析JSON和XML的一个框架,优点是简单易用,性能较高. JackSon处理JSON的方式 JackSon提供了三种JSON的处理方式.分别是数据绑定,树模型,流式API.下面会分别介绍这三种方式. JackSon数据绑定 数据绑定用于JSON转化,可以将JSON与POJO对象进行转化.数据绑定有两种,简单数据绑定和完整数据绑定. 完整数据绑定 package com.xymxyg.json; import com

  • Java中Jackson快速入门

    Java生态圈中有很多处理JSON和XML格式化的类库,Jackson是其中比较著名的一个.虽然JDK自带了XML处理类库,但是相对来说比较低级,使用本文介绍的Jackson等高级类库处理起来会方便很多. 引入类库 由于Jackson相关类库按照功能分为几个相对独立的,所以需要同时引入多个类库,为了方便我将版本号单独提取出来设置,相关Gradle配置如下. ext { jacksonVersion = '2.9.5' } dependencies { compile group: 'com.fa

  • Java的JNI快速入门教程(推荐)

    1. JNI简介 JNI是Java Native Interface的英文缩写,意为Java本地接口. 问题来源:由于Java编写底层的应用较难实现,在一些实时性要求非常高的部分Java较难胜任(实时性要求高的地方目前还未涉及,实时性这类话题有待考究). 解决办法:Java使用JNI可以调用现有的本地库(C/C++开发任何和系统相关的程序和类库),极大地灵活Java的开发. 2. JNI快速学习教程 2.1 问题: 使用JNI写一段代码,实现string_Java_Test_helloworld

  • Java中如何快速构建项目脚手架的实现

    目录 1 前言 2 微服务项目准备 3 脚手架构建 3.1 项目正常启动 && 测试用例正常 3.2 在项目的根pom中加入以下maven插件配置 3.3 执行archetype插件 3.4 执行安装命令 3.5 将smilehappiness-project-template deploy到私服 4 基于脚手架生成新的项目 4.1 添加脚手架 4.2 创建新项目 4.3 命令行基于脚手架生成新的项目 1 前言 项目中,目前主流的当然是微服务项目.为了应对高并发,以及保证自己的服务比较稳定

  • 快速入门Java中的Lambda表达式

    Lambda简介 Lambda表达式是Java SE 8中一个重要的新特性.lambda表达式允许你通过表达式来代替功能接口. lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块). Lambda表达式还增强了集合库. Java SE 8添加了2个对集合数据进行批量操作的包: java.util.function 包以及 java.util.stream 包. 流(stream)就如同迭代器(iterator),但附加了许多

  • Java中Quartz高可用定时任务快速入门

    目录 定时任务使用指南 1.引入依赖 2.快速上手 3.手动触发定时任务 4.带参数任务 5.任务并发 6.持久化 定时任务使用指南 如果你想做定时任务,有高可用方面的需求,或者仅仅想入门快,上手简单,那么选用它准没错. 定时任务模块是对Quartz框架进一步封装,使用更加简洁. 1.引入依赖 <dependency> <groupId>xin.altitude.cms</groupId> <artifactId>ucode-cms-quartz</a

  • 快速入门介绍Java中强大的String.format()

    前言 从 Java 5.0 开始,String 类新增了一个强大的字符串格式化方法 format().这个方法到现在用的人还是不多,实在是一种浪费.本文带你快速过一遍这个方法的功能,将来你要用到格式化文本的时候,可能就不需要再借用第三方类库或自己去实现了. 首先看一个简单例子: String formatted = String.format("%s今年%d岁.", "小李", 30); // "小李今年30岁." 不用我多解释,你也可以看出:

  • java中Map、Set、List的简单使用教程(快速入门)

    Map.Set.List List的常用方法 1.创建 List<Integer> list = new ArrayList<>(); List<Integer> list = new LinkedList<>(); //同时可以作为链表用 List<List<Integer>> list = new ArrayList<>(); 2.遍历 //本质上其实是调用Iterator for(String s:list){ Sy

  • MongoDB快速入门笔记(八)之MongoDB的java驱动操作代码讲解

    MongoDB的Java驱动是线程安全的,对于一般的应用,只要一个Mongo实例即可,Mongo有个内置的连接池(池大小默认为10个). 下面代码给大家介绍MongoDB的java驱动操作,具体代码如下所示: import java.util.ArrayList; import java.util.List; import java.util.regex.Pattern; import org.bson.Document; import com.mongodb.MongoClient; impo

  • 快速入门HarmonyOS的Java UI框架的教程

    本文档适用于HarmonyOS应用开发的初学者.编写两个简单的页面,实现在第一个页面点击按钮跳转到第二个页面. 注意:运行Hello World在创建工程时,设备类型和模板分别以Wearable和Empty Feature Ability(Java)为例,本文档也基于相同的设备类型和模板进行说明. 编写第一个页面 在Java UI框架中,提供了两种编写布局的方式:在XML中声明UI布局和在代码中创建布局.这两种方式创建出的布局没有本质差别,为了熟悉两种方式,我们将通过XML的方式编写第一个页面,

  • 现代高效的java构建工具gradle的快速入门

    目录 和Maven一样,Gradle只是提供了构建项目的一个框架,真正起作用的是Plugin.Gradle在默认情况下为我们提供了许多常用的Plugin,其中包括有构建Java项目的Plugin,还有War,Ear等.与Maven不同的是,Gradle不提供内建的项目生命周期管理,只是java Plugin向Project中添加了许多Task,这些Task依次执行,为我们营造了一种如同Maven般项目构建周期.更多有关Maven的知识,读者可以访问Maven官网,或者可以参考笔者写的Maven学

随机推荐