2017 年你不能错过的 Java 类库

各位读者好,

这些开源库非常棒,我已经将它们整理成参考清单,附上简短的功能清单连同案例一同分享。Guice
Guice是谷歌开发的一个轻量级的依赖注入框架,支持 java 6 及以上版本。

下面是2017年你不应该错过的Java库包清单:
GuiceGuice是一个Java 6以上支持依赖注入框架。由谷歌提供。# Typical
dependency injectionpublic class DatabaseTransactionLogProvider
implements Provider<TransactionLog> {@Inject Connection
connection;public TransactionLog get() {return new
DatabaseTransactionLog(connection);}}# FactoryModuleBuilder generates
factory using your interface****public interface
PaymentFactory {Payment create(Date startDate, Money amount);}

这篇文章是在我看过 Andres
Almiray 的一篇介绍文后,整理出来的。

# Typical dependency injectionpublic class DatabaseTransactionLogProvider implements ProviderTransactionLog { @Inject Connection connection; public TransactionLog get() { return new DatabaseTransactionLog(connection); }}

# FactoryModuleBuilder generates factory using your interfacepublic interface PaymentFactory { Payment create(Date startDate, Money amount); }

OkHttpHTTP是现代网络的通讯方式。决定我们如何交换数据和媒体。
如果有效地执行HTTP通讯会使您的内容加载更快,并且节省带宽。OkHttp是一个HTTP客户端,高效是其特点:(1)在HTTP
/
2情况下支持对同一主机的所有请求能够共享同一个socket。(2)通过连接池降低请求延迟(如果HTTP
/
2不可用)。(3)透明GZIP压缩下载大小。(4)对响应进行缓存,可以完全避免重复请求的网络。OkHttpClient
client = new OkHttpClient();String run(String url) throws
IOException {Request request = new
Request.Builder().url(url).build();Response response =
client.newCall(request).execute();return response.body().string();}

因为内容非常好,我便将它整理成参考列表分享给大家,
同时附上各个库的特性简介和示例。

OkHttpHTTP
是现代应用程序实现互联的机制。数据和媒体的交互都基于此。高效的 http
机制能提升你的下载速度和节约带宽。OkHttp
作为一个HTTP客户端,默认:HTTP/2
服务默认发往同一台主机的所有请求共用一个套接字。连接池减少请求的延迟。gzip
压缩下载大小可见。通过响应缓存完全避免了网络的重复请求。

Retrofit用于Android的类型安全的HTTP客户端,能够将HTTP
API转为Java接口。public interface GitHubService
{@GET(“users/{user}/repos”
)Call<List<Repo>listRepos(@Path(
“user”
) String user);}

请欣赏!

OkHttpClient client = new OkHttpClient();String run(String url) throws IOException { Request request = new Request.Builder() .url(url) .build(); Response response = client.newCall(request).execute(); return response.body().string();}

Retrofit会产生上面GitHubService的实现类:Retrofit retrofit = new
Retrofit.Builder().baseUrl(“https://api.github.com/”
).build();GitHubService service =
retrofit.create(GitHubService.class);

Guice

Guice (发音同 ‘juice’) ,是一个 Google 开发的轻量级依赖性注入框架,适合
Java 6 以上的版本。

# Typical dependency injection
public class DatabaseTransactionLogProvider implements Provider<TransactionLog> {
  @Inject Connection connection;

  public TransactionLog get() {
    return new DatabaseTransactionLog(connection);
  }
}
# FactoryModuleBuilder generates factory using your interface
public interface PaymentFactory {
   Payment create(Date startDate, Money amount);
 }

GitHub, JavaDoc, 使用指南, FactoryModuleBuilder

Retrofit 来自 Square 公司的 HTTP 客户端,类型案例,可用于 Android 和
Java。Retrofit 会按照 HTTP API 生成 Java 接口。

每个对创建的GitHubService类调用将对远程服务器产生一个同步或异步的Http请求。Call<List<Repo>>
repos = service.listRepos(“octocat”
);

澳门新葡萄京官网注册 ,OKHttp

HTTP是现代应用程序实现网络连接的途径,也是我们进行数据和媒体交换的工具。高效使用HTTP能使你的东西加载更快,并节省带宽。

OkHttp是一个非常高效的HTTP客户端,默认情况下:

  • 支持HTTP/2,允许对同一主机的请求共用一个套接字。
  • 如果HTTP/2 不可用,连接池会减少请求延迟。
  • 透明的GZIP可以减少下载流量。
  • 响应的缓存避免了重复的网络请求。

OkHttpClient client = new OkHttpClient();

String run(String url) throws IOException {
  Request request = new Request.Builder()
      .url(url)
      .build();

  Response response = client.newCall(request).execute();
  return response.body().string();
}

GitHub, Website

public interface GitHubService { @GET("users/{user}/repos") CallListRepolistRepos(@Path("user") String user);}

JDeferredJava的Deferred/Promise库类似于JQuery:Deferred对象和PromisePromise回调:
.then(…), .done(…), .fail(…), .progress(…), .always(…)多个promises –
.when(p1, p2, p3, …).then(…)Callable 和 Runnable – wrappers.when(new
Runnable() {…})使用Executor ServiceJava范型支持: Deferred<Integer,
Exception, Doubledeferred;, deferred.resolve(10);, deferred.reject(new
Exception());,deferred.notify(0.80);,Android支持Java 8
Lambda友好RxJavaRxJava – JVM的反应式扩展Reactive Extension
-使用可观察序列来组合异步和基于事件的程序。它扩展了观察者模式以支持数据/事件序列,并添加操作符,允许您以声明方式组合序列,同时抽象出对低级线程,同步,线程安全和并发数据结构等问题的关注。RxJava的一个常见用例是在后台线程上运行一些计算,比如网络请求,并在UI线程上显示结果(或错误):Flowable.fromCallable(()
-{Thread.sleep(1000);// imitate expensive computation
return
“Done”
;}).subscribeOn(Schedulers.io()).observeOn(Schedulers.single()).subscribe(System.out::println,
Throwable::printStackTrace);Thread.sleep(2000);
// <— wait for the flow to finish

Retrofit

Retrofit 是 Square 下的类型安全的 HTTP 客户端,支持 Android 和 Java
等,它能将你的 HTTP API 转换为 Java 接口。

Retrofit 将 HTTP API 转换为 Java 接口:

public interface GitHubService {
    @GET("users/{user}/repos")
    Call<List<Repo>listRepos(@Path("user") String user);
}
Retrofit 类实现 GitHubService 接口:

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

来自 GitHubService 的每个 Call 都能产生为远程 Web 服务产生一个异步或同步
HTTP 请求:

Call<List<Repo>> repos = service.listRepos("octocat");

GitHub, Website

Retrofit 类实现 GitHubService 接口。

MBassadorMBassador是一种轻量级,高性能的事件总线,实现发布订阅模式。它为易于使用而设计,功能丰富且可扩展,同时保持资源效率和高性能。MBassador的高性能核心是一个专门的数据结构,提供非阻塞读取器,并最大限度地减少写争夺的锁争用,使并发读/写访问的性能降低最小。注释驱动递送一切,尊重类型层次结构同步和异步消息传递可配置的引用类型消息过滤包装消息处理程序优先级自定义错误处理可扩展性//
Define your listener

class SimpleFileListener{@Handlerpublic void handle(File
msg){
// do something with the file
}}
// somewhere else in your code
MBassador bus = new MBassador();Object listener = new
SimpleFileListener();bus.subscribe (listener);bus.post(new File(
“/tmp/smallfile.csv”
)).now();bus.post(new File(
“/tmp/bigfile.csv”
)).asynchronously();

JDeferred

与JQuery类似的Java Deferred/Promise类库

  • Deferred 对象和 Promise
  • Promise
    回调:.then(…).done(…).fail(…).progress(…).always(…)
  • 支持多个promises – .when(p1, p2, p3, …).then(…)
  • Callable 和 Runnable – wrappers.when(new Runnable() {…})
  • 使用 Executor
    服务
  • 支持Java
    泛型: Deferred<Integer, Exception, Doubledeferred;deferred.resolve(10);deferred.reject(new Exception());,deferred.notify(0.80);,
  • 支持Android
  • Java 8 Lambda的友好支持

GitHu链接,官方网站链接

Retrofit retrofit = new Retrofit.Builder() .baseUrl("") .build(); GitHubService service = retrofit.create(GitHubService.class);

Lombok使用注释来减少Java中的重复代码,例如getters setters,not
null检查,生成Builder等。val – 不会产生麻烦的final局部变量。@NonNull –
或者:我怎么学会停止担心和喜欢上了NullPointerException。@Cleanup –
自动资源管理:安全地调用您的close()方法,没有麻烦。@Getter / @Setter –
不要再写public int getFoo(){return foo;}。@ToString –

RxJava

RxJava – JVM的响应式编程扩展 –
是一个为Java虚拟机编写的使用可观察序列的构建异步的基于事件的程序的类库。

它基于观察者模式实现对数据/事件的序列的支持,并添加了一些操作符,允许你以声明式构建序列, 使得开发者无需关心底层的线程、同步、线程安全和并发数据结构。

RxJava最常见的一个用法就是在后台线程运行一些计算和网络请求,而在UI线程显示结果(或者错误):

Flowable.fromCallable(() -{
     Thread.sleep(1000); //  imitate expensive computation
     return "Done";
 })
   .subscribeOn(Schedulers.io())
   .observeOn(Schedulers.single())
   .subscribe(System.out::println, Throwable::printStackTrace);

 Thread.sleep(2000); // <--- wait for the flow to finish

GitHub, Wiki

来自 GitHubService 的每个 Call 都会向远端 Web 服务器发送一个同步或异步的
HTTP 请求。

无需启动调试器来查看您的字段:只需让Lombok为您生成一个toString!@EqualsAndHashCode

从对象的字段中生成hashCode和equals实现。@NoArgsConstructor,@RequiredArgsConstructor和@AllArgsConstructor

  • 按顺序构造的构造函数:生成不带参数,每个final
    /非空字段有一个参数或每个字段有一个参数的构造函数。@Data –
    现所有字段上都有@ToString,@EqualsAndHashCode,@Getter的快捷方式,所有非final字段的@Setter和@RequiredArgsConstructor!@Value
  • 编写不可变的类非常容易。@Builder –
    没有麻烦的花哨的API对象创建!@SneakyThrows –
    大胆地引发检查异常,在没有触发他们之前!@同步 –
    同步:不要暴露你的锁。@Getter(lazy =
    true)懒惰是一种美德!SLF4jSimple Logging Facade for Java
    (SLF4J)用作各种日志框架(例如java.util.logging,logback,log4j)的简单封装管理抽象,允许最终用户在部署时插入所需的日志框架。简而言之,嵌入式库或组件应该考虑SLF4J的作为日志记录需求,因为该库不会强加最终用户选择哪个日志框架。
    另一方面,对于独立应用程序使用SLF4J并不一定有意义。独立应用程序可以直接调用他们选择的日志框架。
    JUnitParams与标准JUnit的主要区别:更明确 –
    params是在测试方法参数中,而不是类字段更少的代码 –
    你不需要一个构造函数来设置参数您可以在一个类中混合使用非参数方法的参数参数可以作为CSV字符串或参数提供程序类传递参数提供程序类可以具有任意多个提供所需方法的参数,以便可以对不同的案例进行分组你可以有一个提供参数的测试方法(不再有外部类或静态)您可以在IDE中查看实际的参数值(在JUnit的Parametrised中,它只是连续的参数数量):@Test@Parameters({“17,
    false”
    ,
    “22, true”
    })public void personIsAdult(int age, boolean valid)
    throws Exception {assertThat(new Person(age).isAdult(), is(valid));}

Mockito单元测试框架://你可以模拟具体的类,而不仅仅是接口
LinkedList mockedList = mock(LinkedList.class);
//stubbing
when(mockedList.get(0)).thenReturn(
“first”
);when(mockedList.get(1)).thenThrow(new RuntimeException());
//将打印 “first”
System.out.println(mockedList.get(0));
//将抛出runtime exception
System.out.println(mockedList.get(1));
//将打印 “null” 因为get(999)没有被stubbed
System.out.println(mockedList.get(999));
//Although it is possible to verify a stubbed invocation, usually it’s
just redundant

//If your code cares what get(0) returns, then something else breaks
(often even before verify() gets executed).

//If your code doesn’t care what get(0) returns, then it should not be
stubbed. Not convinced? See here.

verify(mockedList).get(0);

Jukito集合 JUnit, Guice, 和
Mockito优点:通过自动化,大大减少了样板,导致更容易阅读测试引入对测试对象中的API更改更有弹性的测试用@Inject注释的字段会自动注入使得将对象连接在一起变得容易,因此您可以将单元测试缩放为部分集成测试@RunWith(JukitoRunner.class)public
class EmailSystemTest {@Inject EmailSystemImpl emailSystem;Email
dummyEmail;@Beforepublic void setupMocks(IncomingEmails
incomingEmails,EmailFactory factory) {dummyEmail =
factory.createDummy();when(incomingEmails.count()).thenReturn(1);when(incomingEmails.get(0)).thenReturn(dummyEmail);}@Testpublic
void shouldFetchEmailWhenStarting(EmailView emailView) {// WHEN
emailSystem.start();
// THEN
verify(emailView).addEmail(dummyEmail);}}

AwaitilityAwaitility是一种用于同步异步操作的小型Java
DSL。测试异步系统很困难。
它不仅需要处理线程,超时和并发问题,但测试代码的意图可能被所有这些细节模糊。
Awaitility是一种DSL,允许您以简洁易读的方式表达异步系统的期望。@Testpublic
void updatesCustomerStatus() throws Exception {// Publish an
asynchronous event:

publishEvent(updateCustomerStatusEvent);
// Awaitility让你等待异步操作完成
await().atMost(5, SECONDS).until(customerStatusIsUpdated());…}

Spock为企业准备的测试和规范框架。class HelloSpockSpec
extends spock.lang.Specification {def”length of Spock’s and his
friends’ names”
() {expect:name.size() == lengthwhere:name | length
“Spock”
| 5
“Kirk”
| 4
“Scotty”
| 6}}

WireMock模拟HTTP服务的工具:HTTP响应stubbing存根,匹配HTTP的URL、头部和正文内容请求验证在单元测试中运行,作为独立进程或作为WAR应用程序运行可通过流畅的Java
API,JSON文件和通过HTTP的JSON进行配置记录/回放存根故障注入每次请求的条件代理浏览器代理请求检查和替换状态行为模拟可配置的响应延迟{“request”
: {
“method”
:
“GET”
,
“url”
:
“/some/thing”
},
“response”
: {
“status”
: 200,
“statusMessage”
:
“Everything was just fine!”
}}

MBassador

MBassador是一个实现了发布-订阅模式的轻量级的,高性能的事件总线。它易于使用,并力求功能丰富,易于扩展,而同时又保证资源的高效利用和高性能。

MBassador的高性能的核心是一个专业的数据结构,它提供了非阻塞的读取器,并最小化写入器的锁争用,因此并发读写访问的性能衰减会是最小的。

  • 注解驱动的
  • 提供任何东西,慎重对待类型层次结构
  • 同步和异步的消息传递
  • 可配置的引用类型
  • 消息过滤
  • 封装的消息
  • 处理器的优先级
  • 自定义错误处理
  • 可扩展性

// Define your listener
class SimpleFileListener{
    @Handler
    public void handle(File msg){
      // do something with the file
    }
}

// somewhere else in your code
MBassador bus = new MBassador();
Object listener = new SimpleFileListener();
bus.subscribe (listener);
bus.post(new File("/tmp/smallfile.csv")).now();
bus.post(new File("/tmp/bigfile.csv")).asynchronously();

GitHub, Javadoc

CallListRepo repos = service.listRepos("octocat");

Lombok项目

使用注解来减少Java中的重复代码,比如getter,setters,非空检查,生成的Builder等。

  • val – 总算有了!无忧的final本地变量。
  • @NonNull –
    或:我如何学会不再担心并爱上了非空异常(NullPointerException)。
  • @Cleanup – 自动的资源管理:安全调用你的close() 方法,无需任何麻烦。
  • @Getter / @Setter –
    再也不用写 public int getFoo() {return foo;}了
  • @ToString –
    无需启动调试器来检查你的字段:就让Lombok来为你生成一个toString方法吧!
  • @EqualsAndHashCode –
    实现相等的判断变得容易了:它会从你的对象的字段里为你生成hashCode和equals方法的实现。
  • @NoArgsConstructor, @RequiredArgsConstructor and
    @AllArgsConstructor –
    定做构造函数:为你生成各种各样的构造函数,包括无参的,每一个final或非空的字段作为一个参数的,或者每一个字段都作为参数的。
  • @Data –
    所有的都同时生成:这是一个快捷方式,可以为所有字段生成@ToString@EqualsAndHashCode@Getter注解,以及为所有非final的字段生成``@Setter注解,以及生成@RequiredArgsConstructor!
  • @Value – 声明一个不可变类变得非常容易。
  • @Builder – … 而且鲍伯是你叔叔:创建对象的无争议且奢华的接口!
  • @SneakyThrows – 在以前没有人抛出检查型异常的地方大胆的抛出吧!
  • @Synchronized – 正确的实现同步:不要暴露你的锁。
  • @Getter(lazy=true) 懒惰是一种美德!
  • @Log – 船长日志,星历24435.7: “那一行又是什么呢?”

GitHub, Website

JDeferred Java 的 Deferred/Promise 库,与 JQuery 的 Deferred/Promise
相似Deferred 和 Promise 对象Promise 回调:.then(…), .done(…), .fail(…),
.progress(…), .always(…)同时处理多个 Promise – .when(p1, p2, p3,
…).then(…)Callable 和 Runnable – wrappers.when(new Runnable()
{…})使用执行服务(ExecutorService)Java Generics 支持: DeferredInteger,
Exception, Doubledeferred;, deferred.resolve(10);, deferred.reject(new
Exception());,deferred.notify(0.80);,支持 Android可以使用 Java 8
LambdaRxJava RxJava – JVM 的 Reactive Extensions (响应式扩展) –
一个用于 Java VM
的库,它通过可观测序列构成异步及基于事件的程序。它扩展了观察者模式以支持数据/事件流,并添加了操作符,使你能以申明的方式组合处理序列,对一些事情进行抽象,比如低级线程、同步、线程安全和并发数据结构。RxJava
常见的应用是在后台线程运行一些计算或网络请求,并在 UI
线程显示结果(或错误):

Java简单日志门面(SLF4J)

Java简单日志门面 (SLF4J)
为不同的日志框架(比如java.util.logginglogbacklog4j)提供了简单的门面或者抽象的实现,允许最终用户在部署时能够接入自己想要使用的日志框架。

简言之,类库和其他嵌入式的组件都应该考虑采用SLF4J作为他们的日志需求,因为类库无法将它们对日志框架的选择强加给最终用户。另一方面,对于独立的应用来说,就不一定需要使用SLF4J。独立应用可以直接调用他们自己选择的日志框架。而对于logback来说,这个问题是没有意义的,因为logback是通过SLF4J来暴露其日志接口的。

Website, GitHub, FAQ

Flowable.fromCallable(() -{ Thread.sleep(1000); // imitate expensive computation return "Done";}) .subscribeOn(Schedulers.io()) .observeOn(Schedulers.single()) .subscribe(System.out::println, Throwable::printStackTrace); Thread.sleep(2000); // --- wait for the flow to finish

JUnitParams

对测试进行参数化,还不错

       @Test
       @Parameters({"17, false", 
                    "22, true" })
       public void personIsAdult(int age, boolean valid) throws Exception {
         assertThat(new Person(age).isAdult(), is(valid));
       }

与标准的JUnit 参数化运行器的区别如下:

  • 更明确 – 参数实在测试方法的参数中,而不是在类的字段中
  • 更少的代码 – 你不需要用构造函数来设置参数
  • 你可以在同一个类混合使用参数化和非参数化的方法。
  • 参数可以通过一个CSV字符串或者一个参数提供类传入。
  • 参数提供类可以拥有尽可能多的参数提供方法,这样你可以给不同的用例进行分类。
  • 你可以拥有可以提供参数的测试方法 (再也不需要外部类或者静态类了)
  • 你可以在你的集成开发工具中看到实际的参数值(而在JUnit的Parametrised里,只有连续数目的参数)

官方网站,GitHub,快速入门

MBassador MBassador
是一个轻量级、高性能的事件总线,它实现了发布/订阅模式。它的设计目的是易用、功能丰富和可扩展,同时保持资源的高效利用和良好性能。MBassador
高性能的核心在于一个专用的数据结构,这个数据结构提供了非阻塞读功能以及在写时最小化锁竞争,因此它将并行读/写访问造成的性能损耗降到最低。注解驱动分发的所有东西都会考虑类型层级同步和异步的消息分发可配置的引用类型消息过滤封装消息多级优先层次处理自定义错误处理

Mockito

Java里单元测试的非常棒(tasty)的模拟框架:

 //你可以模拟具体的类,而不只是接口
 LinkedList mockedList = mock(LinkedList.class);

 //打桩
 when(mockedList.get(0)).thenReturn("first");
 when(mockedList.get(1)).thenThrow(new RuntimeException());

 //以下代码打印出"first"字符串
 System.out.println(mockedList.get(0));

 //以下代码抛出运行时异
 System.out.println(mockedList.get(1));

 //以下代码打印出"null",因为get(999)没有被打桩
 System.out.println(mockedList.get(999));

 //尽管是可以验证一个打过桩的调用,但通常是多余的
 //如果你的代码关心get(0)返回值的内容,那么其他东西就会中断(往往在verify()执行之前就发生了)。
 //如果你的代码不关心get(0)返回值的内容,那么它就不应该被打桩。不相信吗?看看这里。
 verify(mockedList).get(0);

官方网站, GitHub, 文档

// Define your listenerclass SimpleFileListener{ @Handler public void handle(File msg){ // do something with the file }}// somewhere else in your codeMBassador bus = new MBassador();Object listener = new SimpleFileListener();bus.subscribe (listener);bus.post(new File("/tmp/smallfile.csv")).now();bus.post(new File("/tmp/bigfile.csv")).asynchronously();

Jukito

它结合了JUnit、Guice和Mockito的能力。 而且它还听起来像一门很酷的武术。

  • 极大的减少了诸如自动mock的样板,从而使测试更加易读。
  • 可以使得测试能够根据被测试的对象上的API的改变而弹性变化。
  • 标有@Inject注解的字段会被自动注入,不需要担心会遗忘掉它们
  • 使得将对象连接在一起变得容易,因此你可以将一个单元测试变成集成测试的一部分

    @RunWith(JukitoRunner.class)
    public class EmailSystemTest {

    @Inject EmailSystemImpl emailSystem;
    Email dummyEmail;

    @Before
    public void setupMocks(

      IncomingEmails incomingEmails,
      EmailFactory factory) {
    dummyEmail = factory.createDummy();
    when(incomingEmails.count()).thenReturn(1);
    when(incomingEmails.get(0)).thenReturn(dummyEmail);
    

    }

    @Test
    public void shouldFetchEmailWhenStarting(

      EmailView emailView) {
    // WHEN
    emailSystem.start();
    
    // THEN
    verify(emailView).addEmail(dummyEmail);
    

    }
    }

GitHub, Website

Project Lombok 通过注解来减少 Java 中的重复性代码,比如 getter 和
setter、非空检查、生成 Builder 等。val – 终级解决方案!简化 final
局部变量定义。@NonNull – 或者:了解我是怎样停止担心并爱上
NullPointerException 的。@Cleanup – 怎么资源管理:方便而安全地调用
close() 方法。@Getter / @Setter – 不再需要写像 public int getFoo()
{return foo;} 这样的代码。@ToString – 不用启动调试器就能观察字段值:让
Lombok 为你生成 toString!@EqualsAndHashCode –
让等值比较变得容易:在项目中由字段实现 hashCode 和
equals。@NoArgsConstructor, @RequiredArgsConstructor and
@AllArgsConstructor – 定制构造器:生成无参构造函数,对每个 final/非空
字段产生构造器,对每个字段产生构造器。@Data –
它合并所有注解:相当于对所有字段应用
@ToString、@EqualsAndHashCode、@Getter,并对所有非 final 字段应用
@Setter,以及应用 @RequiredArgsConstructor!@Value –
简单创意不可变类。@Builder – … 一切都很简单:简单直接地创建对象的
API!@SneakyThrows – 大胆的抛出以前不能轻易抛出的异常!@Synchronized –
正确的同步:不要暴露你的锁。@Getter(lazy=true) 懒加载是种美德!@Log –
舰长日志,星历 24435.7: “这是什么行?”Simple Logging Facade for
Java
Simple Logging Facade for
Java是对各种日志框架的简单门面或者抽象,它让用户可以在开发时使用喜欢的日志框架。简单地说,库和其它嵌入式组件考虑使用
SLF4J
来记录日志,因为它们不能把自己选用的日志框架强加给用户。另一方面,独立的应用程序就不必在意是否使用
SLF4J。独立的应用程序可以直接使用自己选用的日志框架。在使用 logback
的时候会有一个争议,因为它是使用 SLF4J 来提供日志 API
的。JUnitParams参数化测试

Awaitility

Awaitility是一个小型的Java领域专用语言(DSL),用于对异步的操作进行同步。

测试异步的系统是比较困难的。不仅需要处理线程、超时和并发问题,而且测试代码的本来意图也有可能被这些细节所蒙蔽。Awaitility是一个领域专用语言,可以允许你以一种简洁且易读的方式来表达异步系统的各种期望结果。

@Test
public void updatesCustomerStatus() throws Exception {
    // Publish an asynchronous event:
    publishEvent(updateCustomerStatusEvent);
    // Awaitility lets you wait until the asynchronous operation completes:
    await().atMost(5, SECONDS).until(customerStatusIsUpdated());
    ...
}

 GitHub,入门, 用户指南

@Test@Parameters({"17, false", "22, true" })public void personIsAdult(int age, boolean valid) throws Exception { assertThat(new Person(age).isAdult(), is(valid));}

Spock

企业级的测试和规范框架。

class HelloSpockSpec extends spock.lang.Specification {
  def "length of Spock's and his friends' names"() {
    expect:
    name.size() == length

    where:
    name     | length
    "Spock"  | 5
    "Kirk"   | 4
    "Scotty" | 6
  }
}

GitHub, Website

与标准 JUnit Parametrised 运行器的主要区别:更明确 –
参数是测试方法的参数,而不是类中定义的字段更少代码 –
不需要通过构造器来设置参数可以在一个类里混合参数化或非参数化的方法参数可以由
CSV
文本提供,也可以由专门的参数提供类提供参数提供类可以有任意多个参数提供方法,所以你可以对不同的情况分组可以由测试方法提供参数可以在
IDE 中看到实际的参数值Mockito Java 中不错的 mock 框架

WireMock

用于模拟HTTP服务的工具

  • 对HTTP响应进行打桩,可以匹配URL、header头信息和body内容的模式
  • 请求验证
  • 在单元测试里运行,但是是作为一个对立的进程或者一个WAR应用的形式
  • 可通过流畅的Java API、JSON文件和基于HTTP的JSON进行配置
  • 对stub的录制/回放
  • 故障注入
  • 针对每个请求的根据条件进行代理
  • 针对请求的检查和替换进行浏览器的代理
  • 有状态的行为模拟
  • 可配置的响应延迟

{
    "request": {
        "method": "GET",
        "url": "/some/thing"
    },
    "response": {
        "status": 200,
        "statusMessage": "Everything was just fine!"
    }
}

GitHub, Website

//You can mock concrete classes, not just interfacesLinkedList mockedList = mock(LinkedList.class);//stubbingwhen(mockedList.get(0)).thenReturn("first");when(mockedList.get(1)).thenThrow(new RuntimeException());//following prints "first"System.out.println(mockedList.get(0));//following throws runtime exceptionSystem.out.println(mockedList.get(1));//following prints "null" because get(999) was not stubbedSystem.out.println(mockedList.get(999));//Although it is possible to verify a stubbed invocation, usually it's just redundant//If your code cares what get(0) returns, then something else breaks (often even before verify() gets executed).//If your code doesn't care what get(0) returns, then it should not be stubbed. Not convinced? See here.verify(mockedList).get(0);

感谢

非常感谢阅读!

Jukito 结合了 JUnit、Guice 和 Mockito
的力量,听起来很有技术含量。大大降低了自动 mock
的古板,使阅读测试变得容易在测试对象的 API 变化时更有弹性通过 @Inject
注解的字段可以自动注入更容易将对象绑在一起,因此可以将单元测试扩展到部分集成测试

@RunWith(JukitoRunner.class)public class EmailSystemTest { @Inject EmailSystemImpl emailSystem; Email dummyEmail; @Before public void setupMocks( IncomingEmails incomingEmails, EmailFactory factory) { dummyEmail = factory.createDummy(); when(incomingEmails.count()).thenReturn(1); when(incomingEmails.get(0)).thenReturn(dummyEmail); } @Test public void shouldFetchEmailWhenStarting( EmailView emailView) { // WHEN emailSystem.start(); // THEN verify(emailView).addEmail(dummyEmail); }}

Awaitility Awaitility 是一个小型的
DSL,用于将异步操作同步化。测试异步系统是件难事,不仅需要处理线程、超时和并发问题,测试代码的意图还可能被这些细节所掩盖。Awaitility
是一个 DSL,它能以一个简洁易读的方式表达异步系统要做的事情。

@Testpublic void updatesCustomerStatus() throws Exception { // Publish an asynchronous event: publishEvent(updateCustomerStatusEvent); // Awaitility lets you wait until the asynchronous operation completes: await().atMost(5, SECONDS).until(customerStatusIsUpdated()); ...}

Spock 用于企业的测试和规范框架。

class HelloSpockSpec extends spock.lang.Specification { def "length of Spock's and his friends' names"() { expect: name.size() == length where: name | length "Spock" | 5 "Kirk" | 4 "Scotty" | 6 }}

WireMock模拟 HTTP 服务的工具HTTP 响应头,匹配
URL、标题和正文模式验证请求在单元测试中运行、独立运行或作为 WAR
应用运行通过 Java API、JSON 文件或者通过 HTTP 获取的 JSON
来进行配置录制/回放存根故障注入针对每个请求的条件代理浏览器代码用于注入请求或更换请求有状态的行为可配置响应延迟

{ "request": { "method": "GET", "url": "/some/thing" }, "response": { "status": 200, "statusMessage": "Everything was just fine!" }}

原文:Java libraries you can’t miss in 2017链接:译者:边城, Tocy, butta

发表评论

电子邮件地址不会被公开。 必填项已用*标注