Java链式编程
在使用jquery时肯定对它的链式编程惊艳到，慢慢的其它语言这种编程模式也逐渐增多。其本身并不复杂，在调用方法时，方法最后返回对象本身，以达到链式编程的效果。
链式编程比较简单，只要return this即可具有相应的编程模式，但是需要根据业务需求使用不同的方法方式进行实现。
简单的链式编程
既然使用return this可以实现链式模式，那就依次为方案，实现一个简单的例子。
public class Book {
private String bookId;
private String title;
private String cover;
public String getBookId() {
return bookId;
}
public Book setBookId(String bookId) {
this.bookId = bookId;
// 返回当前对象
return this;
}
public String getTitle() {
return title;
}
public Book setTitle(String title) {
this.title = title;
// 返回当前对象
return this;
}
public String getCover() {
return cover;
}
public Book setCover(String cover) {
this.cover = cover;
// 返回当前对象
return this;
}
@Override
public String toString() {
return "Book{" +
"bookId='" + bookId + '\'' +
", title='" + title + '\'' +
", cover='" + cover + '\'' +
'}';
}
}
代码比较简单，就是一个图书的模型，将三个字段的Set方法都返回了对象本身。看一下调用
public static void main(String[] args) {
Book book = new Book().setBookId("b.001").setTitle("庆余年").setCover("http://localhost/qyn.jpg");
System.out.println(book);
}
// Book{bookId='b.001', title='庆余年', cover='http://localhost/qyn.jpg'}
编码过程中，完成一个Set方法后按下.就会继续提醒其他方法，实现了链式编程的效果。并且最终结果也符合预期。
静态初始化方法of
目前Spring中有很多方法提供了静态of方法，可以更方便的创建对象，结合return this将更为实用的实现链式编程，算是一种比较不错得扩展措施。在这种模式中，大量的使用了of替代了构造函数。
public class Pageable {
// 页码，从1开始
private long page;
// 页大小
private int size;
// 结果命中数量
private long count;
private Pageable(long page, int size) {
this.page = page;
this.size = size;
}
private Pageable(long page, int size, long count) {
this(page, size);
this.count = count;
}
// PageRequest时使用
public static Pageable of(long page, int size) {
return of(page, size, 0);
}
// 返回结果时，具有命中数量及返回总页码计算使用
public static Pageable of(long page, int size, long count) {
return new Pageable(page, size, count);
}
// 分页时，获取偏移量
public long getOffset() {
return (page - 1) * size;
}
// 返回总页码
public long getPageCount() {
return (long) Math.ceil((double) count / size);
}
public long getPage() {
return this.page;
}
public int getSize() {
return this.size;
}
public long getCount() {
return this.count;
}
}
上面示例中的分页工具类，只实现了三个成员变量页码、页大小、条目数，并且未实现成员变量的Set方法；构造方法全部为私有，实现了静态的of方法来创建分页对象。在该对象中同时提供了获取分页偏移量的getOffset方法，以及计算出总页码的getPageCount方法。
该工具一般有两种使用场景:
- 数据库查询后，返回数据列表以及分页信息，此时需要页码、页大小、条目数三个信息，使用及实现都比较方便
- 内存分页时，可以提供一个分页偏移量的计算方法
public static void main(String[] args) {
Pageable pageable = Pageable.of(10, 10, 123);
System.out.println(pageable.getOffset());
System.out.println(pageable.getPageCount());
}
// 90
// 13
如果采用FastJson进行序列化，上述设计方式也能够满足返回JSON的需求，FastJson按照Get方法进行生成属性列表。
public static void main(String[] args) {
System.out.println(JSON.toJSONString(Pageable.of(10, 10, 123)));
}
// {"count":123,"offset":90,"page":10,"pageCount":13,"size":10}
Builder模式链式编程
Builder模式也是目前较为常用的一种链式编程方法，目前Spring中有大量的依据此模式进行的编码。以最为常见的ResponseEntity(或者Swagger模块也大量采用了此类方法)类来看，其内部定义了Builder接口，并默认实现了一个DefaultBuild内部类，内部方法采用return this实现链式模式，同时在ResponseEntity中提供了类似的Builder方法，如ok、status等静态方法。
从这些类的实现原理看，实现Builder模式也比较简单，一方面创建一个内部Builder类，实现相应信息的创建；同时在目标类中，实现一个静态的builder方法，用于创建Builder对象，并启动链式模式；最后再由内部类提供一个终止方法，该终止方法将完成目标类的创建。
public class ApiInfo {
private String name;
private String description;
private String url;
private Map<String, String> params;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Map<String, String> getParams() {
return params;
}
public void setParams(Map<String, String> params) {
this.params = params;
}
@Override
public String toString() {
return "ApiInfo{" +
"name='" + name + '\'' +
", description='" + description + '\'' +
", url='" + url + '\'' +
", params=" + params +
'}';
}
public static ApiBuilder builder() {
return new ApiBuilder();
}
// 内部Builder类
public static class ApiBuilder {
private String name;
private String description;
private String url;
private Map<String, String> params;
// name信息设置，链式
public ApiBuilder name(String name) {
this.name = name;
return this;
}
// 注释信息设置
public ApiBuilder description(String description) {
this.description = description;
return this;
}
public ApiBuilder url(String url) {
this.url = url;
return this;
}
// 参数信息设置
public ApiBuilder params(String name, String description) {
this.params = Optional.ofNullable(params).orElseGet(() -> Maps.newHashMap());
this.params.put(name, description);
return this;
}
// 创建ApiInfo对象
public ApiInfo build() {
ApiInfo apiInfo = new ApiInfo();
apiInfo.setName(this.name);
apiInfo.setDescription(this.description);
apiInfo.setUrl(this.url);
apiInfo.setParams(this.params);
return apiInfo;
}
}
}
上述示例采用Builder模式实现了一个Api接口信息的对象设计，主要是能够设置接口名、地址以及相应的参数。内部设计了一个ApiBuilder，可以实现链式属性设置，并最终提供一个build方法用于终止时创建目标实例。
public static void main(String[] args) {
ApiInfo apiInfo = ApiInfo.builder().name("获取资源信息")
.description("根据资源ID获取资源信息")
.url("/resource/:id")
.params("id", "资源唯一ID")
.params("token", "令牌")
.build();
System.out.println(apiInfo);
}
// ApiInfo{name='获取资源信息', description='根据资源ID获取资源信息', url='/resource/:id', params={id=资源唯一ID, token=令牌}}
lombok链式编程
链式编程比较简单，一般也就是return、静态of、Builder几种模式，可以直接编码实现，Spring以及一些开源项目Swagger等等都是这么做的。如果我们不是为了做一个通用的开源产品，只是业务性的编码，此时不需要通过大量的编码去实现链式编程，可以采用lombok进行实现，使用也比较简单。
使用lombok时，可以通过maven引入，也可以通过idea安装插件的方式引入。
return链式
仍然使用此前的例子Book类，进行改造，采用lombok注解进行编码。
lombok实现
return this链式，只需要在类添加注释@Accessors(chain = true)即可实现
@Getter
@Setter
@ToString
@Accessors(chain = true)
public class Book {
private String bookId;
private String title;
private String cover;
public static void main(String[] args) {
Book book = new Book().setBookId("b.001").setTitle("庆余年").setCover("http://localhost/qyn.jpg");
System.out.println(book);
}
}
如果在IDE中，查看类接口(ctrl+o)，可以发现属性的Set方法，返回类型为Book，和自己编码的方案一致。
public static void main(String[] args) {
Book book = new Book().setBookId("b.001").setTitle("庆余年").setCover("http://localhost/qyn.jpg");
System.out.println(book);
}
// Book{bookId='b.001', title='庆余年', cover='http://localhost/qyn.jpg'}
静态初始化方法
对Pageable类进行改造，使用lombok实现of方法。
静态
of方法的添加，需要通过lombok的构造函数注解进行添加，RequiredArgsConstructor可以实现必备参数列表的构造，并通过staticname指定静态方法为of；针对上例中的Pageable对象提供了两种静态构造方法，一种是只需要指定页码和页大小即可，还有一种是全部参数的构造函数，可以计算总页码；RequiredArgsConstructor可以实现必备参数的构造；AllArgsConstructor实现全部参数的构造函数，并指定staticName为of，通过lombok的注解组合，实现Pageable与上例自己编码同等效果。
@Getter
@ToString
@Accessors(chain = true)
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor(staticName = "of")
public class Pageable {
/**
* 页码，从1开始
*/
@NonNull
private long page;
/**
* 页大小
*/
@NonNull
private int size;
/**
* 结果命中数量
*/
private long count;
/**
* 分页时，获取偏移量
*
* @return
*/
public long getOffset() {
return (page - 1) * size;
}
/**
* 返回总页码
*
* @return
*/
public long getPageCount() {
return (long) Math.ceil((double) count / size);
}
}
通过组合注释实现了同样的效果，使用也和原有编码效果等同。
public static void main(String[] args) {
Pageable pageable = Pageable.of(10, 10);
System.out.println(pageable.getOffset());
// 全部构造
System.out.println(JSON.toJSONString(Pageable.of(10, 10, 123)));
}
// 90
// {"count":123,"offset":90,"page":10,"pageCount":13,"size":10}
Builder模式
对ApiInfo进行改造，使用lombok实现builder模式。
lombok实现Builder模式，只要添加
@Builder注解即可
@Getter
@Setter
@Builder
@ToString
public class ApiInfo {
private String name;
private String description;
private String url;
private Map<String, String> params;
}
使用上和之前的例子差不多，不过对于params默认只能是Set的形式。
public static void main(String[] args) {
ApiInfo apiInfo = ApiInfo.builder().name("获取资源信息")
.description("根据资源ID获取资源信息")
.url("/resource/:id")
.params(new HashMap<String, String>() {
{
put("id", "资源唯一ID");
put("token", "令牌");
}
})
.build();
System.out.println(apiInfo);
}
// ApiInfo(name=获取资源信息, description=根据资源ID获取资源信息, url=/resource/:id, params={id=资源唯一ID, token=令牌})
