7.4 Java开发利器

在Java开发中，有很多成熟的开源工具库供大家选用，覆盖了很多常见的但JDK中没有提供的功能和使用场景。学习并熟练使用这些类库，能让你在编码过程中少走很多弯路，并且也能学习到很多漂亮的编码方式和风格。比较常用的有以下几个：

  • Apache Commons：Apache开源的Java相关工具库，囊括了编码、文本、网络等等一系列工具类。

  • Guava：Google贡献的一个服务于Java6、7的类库，囊括了集合、字符串、缓存等一系列工具类。

  • Joda Time: 为了弥补JDK自带日期类使用上的不方便而创造的一个日期时间工具库，已经得到了广泛运用。

  • FastJson: 阿里开源的JSON序列化、反序列化类库，使用比较方便，性能也比较好。

  • Orika: 简单快速高效的Java Bean映射、复制框架。

  • MapDB: 专为Java设计的高性能的数据库，可以被用作多级缓存。

  • FastUtils：扩充了Java的集合类，提供了很多快速、压缩、支持基本数据类型的集合类以及大规模集合。

  • JCTools: 提供很多并发集合类，适用于高并发的业务场景。

  • Relections：org.relections提供了一系列对于运行时元数据的查询接口，大大简化了Java自带反射API的使用。

  • Lombok：一个简化开发工作的开发工具，能够节省很多重复、繁琐代码的编写。使用@Data可以省去编写getter、setter、hashCode、equals、toString等，使用@Slf4j自动生成Slf4j log对象。其原理是JDK中注解的编译时解析机制，javac会在执行的时候去调用实现了相关API（Pluggable Annotation Processing API）的程序，从而可以对编译器做一些增强。

此外，还有其他大厂出品的工具类库如：Twitter的commons、Linkedin的linkedin-utils等，基本上也都是对一些常用工具的封装。

还需要说明的是，前文提到过的Spring框架中也提供了很多可用的工具，如StringUtils、StopWatch、ReflectionUtils、ResourceUtils等，在Spring应用中完全可以拿来用。

本章主要讲述其中最为常用的Apache Commons、Google Guava、Joda Time、FastJson、Orika以及MapDB。

7.4.1 Apache Commons

Apache Commons是Apache开源的一个可复用Java组件库。包含了多达50个子项目。其中开发中常用的有以下几个：

  • BeanUtils: 提供了对于Java Bean进行各种操作，克隆对象、属性。

  • Codec: 处理常用的编码解码方法的工具类包等。

  • Collections: 扩展Java集合框架的操作。

  • IO: 输入输出工具的封装。

  • Lang: Java基本对象（java.lang）方法的工具类包。

  • HttpClient: 低层次对HTTP协议操作的封装, 提供HTTP客户端与服务器的各种通讯操作。

BeanUtils

BeanUtils基于JDK的java.beans，提供了一系列对Java Bean的操作：读取（get）和设置（set）Bean属性值、动态定义和访问bean属性等。

先讲述一下Java Bean的定义，符合Bean规范的Java类需要符合以下要求：

  • 类必须是public访问权限，且需要有一个public的无参构造方法，方便利用Java的反射动态创建对象实例。

  • Bean的属性都是私有字段。

  • Bean的属性值只能通过setter方法设置。

  • 读取Bean的属性需要通过getter方法。

对于Bean的操作，主要是BeanUtils这个类。

BeanUtils将property分成simple（简单类型:String、int）、indexed（索引类型：数组、ArrayLsit）以及Maped（Map类型）三种类型，可以直接get和set Java Bean中的一个属性的值。

这里需要注意的是，此类其实最终是调用的BeanUtilsBean，但是BeanUtilsBean2继承BeanUtilsBean并做了升级，提供了任何类型到字符串的转换。因此，使用的时候建议直接使用BeanUtilsBean2。

BeanUtilsBean beanUtilsBean = new BeanUtilsBean2();
beanUtilsBean.getConvertUtils().register(false, false, 0);//错误不抛出异常、不使用Null做默认值，数组的默认大小为0
    
User user = new User();
beanUtilsBean.setProperty(user, "name", "testName");//设置属性的值
beanUtilsBean.getProperty(user,"name");//获取属性的值

这里需要注意的是，如果类型是indexed，那么属性名[index]可以直接获取某个元素的值，而对于Maped类型，属性名（key值）可以获取某一个key对应的value。

此外，还提供了复制以及克隆Bean的功能。

User user = new User();
user.setName("test");
User user2 = new User();
    
beanUtilsBean.copyProperties(user2,user);
User user3= (User)beanUtilsBean.cloneBean(user);

但这里的复制是浅复制，2个Bean的同一个属性可能拥有同一个对象的引用。

还有Map和Bean之间的转换。

Map<String,Object> map = beanUtilsBean.describe(user);//bean->map
beanUtilsBean.populate(user, map) //map->bean

此外，还有一个PropertyUtils和BeanUtils功能几乎一致。不同的是BeanUtils在对Bean赋值是会进行自动类型转化，只要属性名相同，类型会尝试转换，而PropertyUtils则会报错。

Codec

常用的解码、编码方法封装，包括Base64、MD5、Sha1、URL。

  1. Base64

    Base64.encodeBase64String(byte[] binaryData);
Base64.decodeBase64(String base64String);

  2. MD5

    DigestUtils.md5Hex(final byte[] data);

  3. Sha1

    DigestUtils.sha1Hex(final byte[] data);

  4. URL

    URLCodec.encode(final String str);
URLCodec.decode(final String str);

Collections

Collections为JDK的集合类提供了更为丰富的工具类、接口以及实现。最新的版本4，包名修改为：org.apache.commons.collections4。

  1. CollectionUtils: 提供了一些方面的操作方法，如判断集合非空、对集合的并集、交集、差集的操作。

    List<String> list = getList();
List<String> list2 = getList2();

if(CollectionUtils.isNotEmpty(list)){ //判断非空
    CollectionUtils.union(list,list2)//并集
    CollectionUtils.subtract(list,list2)//差集
    CollectionUtils.retainAll(list,list2)//交集
}

  2. 提供了一些新的集合类型。

    //得到集合里按顺序存放的key之后的某一Key
OrderedMap map = new LinkedMap();  
map.put("1", "1");  
map.put("2", "1");  
map.put("3", "1");  
map.firstKey(); // returns "1"
map.nextKey("1"); // returns "2" 

//双向map
BidiMap bidi = new TreeBidiMap();
bidi.put("6", "6");  
bidi.get("6");  // returns "6"  
bidi.getKey("6");  // returns "6"

IO

提供了一些IO工具类, 是对java.io的扩展，操作文件非常方便。

  1. IOUtils：对IO stream操作的封装。

    InputStream is = new URL( "http://baidu.cim" ).openStream(); 
try{
    IOUtils.toString(is, "utf-8");
    IOUtils.readLines(is, "utf-8");
}finally {  
    IOUtils.closeQuietly(is);  
}

  2. FileUtils：对文件操作的封装。

    File file = new File("/data/data.txt");  
List lines = FileUtils.readLines(file, "UTF-8"); //读取成字符串集合
byte[] fileBytes = FileUtils.readFileToByteArray(file); //读取成字节数组
FileUtils.writeByteArrayToFile(file,fileBytes); //字节写入文件
FileUtils.writeStringToFile(file, "test"); //字符串写入文件

  3. FileSystemUtils：对文件系统的操作封装。

    FileSystemUtils.freeSpaceKb("/data"); //查看相应路径的剩余空间

Lang

一些公共的工具集合，涵盖了字符串操作、字符操作、 JVM交互操作、归类、异常和位域校验等等。现在最新的版本为3, 包名改成了org.apache.commons.lang3。

  1. StringUtils && StringEscapeUtils

    StringUtils继承自Object，是null safe的，即遇到null的String对象，会把它处理掉不会抛出异常；StringEscapeUtils是对字符串做转义的工具类，包括HTML、JS、XML等等。

    String str = ...;

StringUtils.isEmpty(str); //判断字符串为空，多个连续空格不为空
StringUtils.isBlank(str); //判断字符串为空，多个连续空格为空

StringUtils.trim(str);//以strip开头的方法都是trim方法的扩展，不过可以自定义stripChars，不局限于空白符。

StringUtils.equals(str,"test");//支持null

StringUtils.contains("str","test"); //子字符串匹配

StringUtils.split(str,";"); //根据字符/字符串分隔字符串
StringUtils.join(new String[]{"1","2"},"-"); //根据字符连接字符串

StringEscapeUtils.escapeHtml4(str); //对字符串中的html标签做转义

    这里需要注意的是其split方法，相比字符串自带的split方法使用正则，此方法直接使用了完整的字符串来做匹配，且会丢弃空字符串。

  2. ArrayUtils

    ArrayUtils是一个对数组进行特殊处理的类。ArrayUtils扩展了JDK中的Arrays，提供了更多的功能。

    String[] strs = new String[]{"1", "4", "2"};

ArrayUtils.nullToEmpty(strs); //如果数组为null，则返回长度为0的数组
ArrayUtils.reverse(strs); //反转数组

ArrayUtils.addAll(strs,"3"); //数组添加元素

    需要注意：使用addAll添加元素，是需要数组拷贝的，慎用。

  3. RandomUtils && RandomStringUtils

    提供了生成随机数、字符串的操作封装。

    RandomUtils.nextInt(0,10); //随机一个整数，从0到10，不包括10。
RandomStringUtils.random(3); //随机三个字母的字符串出来。

    这里需要注意的是这俩类都使用了Random这个类，但其是伪随机的，在要求严格的环境下，尽量不要使用这俩类，去使用SecureRandom。

  4. NumberUtils

    为数字提供了一些操作封装, 是null safe的。

    String numberStr = "123";
long n = NumberUtils.toLong(numberStr); //将字符串转化为long, 如果字符串格式不对或者为Null，则返回0，并不会抛出异常
long max = NumberUtils.max(new Long[]{1L,5L,10L}); //计算数组最大值

  5. DateUtils && DateFormatUtils

    是对日期时间操作的封装。

    DateUtils提供了很多日期计算。

    DateUtils.addDays(new Date(),3); //计算三天后的时间
DateUtils.addHours(new Date(),3); //三个小时候的时间

DateUtils.truncate(new Date(), Calendar.HOUR); //截断日期到小时，后面的分、秒都为0

    DateFormatUtils提供了Date到字符串表示的操作。

    DateFormatUtils.format(new Date(),"yyyyMMdd"); //以yyyyMMdd的格式输出日期

  6. MethodUtils

    通过此工具类可以调用类的方法，实现原理基于反射。

    MethodUtils.invokeStaticMethod(StringUtils.class,"isNotBlank","test"); //调用静态方法
MethodUtils.invokeMethod(user,"getName"); //调动实例方法

  7. StopWatch

    StopWatch是一个秒表类。

    StopWatch stopWatch = new StopWatch();
stopWatch.start(); //开始计时
stopWatch.split(); //截断每一次的分段计时
stopWatch.getSplitTime(); //获取分段计时
stopWatch.suspend(); //暂停秒表
stopWatch.resume(); //恢复计时
stopWatch.stop(); //停止秒表
stopWatch.getTime(); //获得总共计时

  8. ImmutablePair && ImmutableTriple

    这俩类都是不可变的，经常是用在返回值是两个或者三个的场景下，是对多返回值的通用封装。

    ImmutablePair pair = ImmutablePair.of(user,user1);
pair.getLeft();
pair.getRight();
ImmutableTriple triple = ImmutableTriple.of(user,user1,user2);
triple.getLeft();
triple.getMiddle();
triple.getRight();

HttpClient

提供HTTP客户端与服务器的各种通讯操作, 包括支持各种HTTP Method、SSL连接、Cookie、Session保持等。此工具类现在已经从Apache Commons移到Apache HttpComponents中。包名改为：org.apache.http。

  1. 连接池

    HttpClient提供了HTTP连接池的支持，连接池依赖HTTP 1.1的keep alive机制，对HTTP 1.0需要做兼容配置。此外，也支持HTTPS请求。需要注意的是使用连接池能够减少频繁创建、销毁连接的消耗提高性能，但是由于连接池是有锁的，为了提升并发性能，最好对于每一个服务都创建一个连接池。

    RegistryBuilder<ConnectionSocketFactory> schemeRegistry = RegistryBuilder.create();
schemeRegistry.register("http", PlainConnectionSocketFactory.getSocketFactory());

//对https的支持
SSLContext sslcontext = SSLContext.getInstance("TLS");
sslcontext.init(new KeyManager[0], new TrustManager[]{new SimpleTrustManager()}, null);
SSLConnectionSocketFactory sf = new SSLConnectionSocketFactory(sslcontext);
schemeRegistry.register("https", sf);

//连接池配置
PoolingHttpClientConnectionManager pool = new PoolingHttpClientConnectionManager(schemeRegistry.build());
pool.setMaxTotal(1000); //最大连接数支持
pool.setDefaultMaxPerRoute(100); //每一个路由的最大连接数
pool.setDefaultSocketConfig(SocketConfig.custom().setSoTimeout(5000).build());

  2. HttpRequestBase

    HttpClient支持HTTP的各种方法, 都是HttpRequestBase的子类。

    • HttpGet

    • HttpPost

    • HttpPut

    • HttpDelet

    以上类都有一个参数为URL字符串的构造方法。此外，对post、put这种需要传递数据的方法，HttpClient是使用HttpEntity来实现的。常用的几个HttpEntity如下：

    • UrlEncodedFormEntity：最常见的表单提交，Content-type为application/x-www-form-urlencoded。

    • MultipartFormEntity: 提交文件时常用的方式，Content-type为multipart/form-data

    • StringEntiry：自包含的Entity, 传递JSON数据时可以使用。

    StringEntity entity = new StringEntity("{\"name\";\"test\"}", "UTF-8");
entity.setContentType("application/json")    

HttpPost method = new HttpPost(url);
method.setEntity(entity);

  3. Cookie

    Cookie的支持需要依赖CookieStore。HttpClientUtil内置了BasicCookieStore。

    CookieStore cookieStore = new BasicCookieStore()
cookieStore.addCookie(Cookie cookie);
List<Cookie> cookies = cookieStore.getCookies();

  4. HttpClientBuilder

    HttpClient的创建依赖于HttpClientBuilder, 能够对HttpClient的Cookie以及Connect Timeout、Socket Timout、Keep Alive的策略进行配置。

    HttpClientBuilder httpClientBuilder = HttpClients.custom().setDefaultCookieStore(cookieStore);//cookie支持
httpClientBuilder.setConnectionManager(pool); //设置连接池
httpClientBuilder.setDefaultSocketConfig(pool.getDefaultSocketConfig());
httpClientBuilder.setDefaultRequestConfig(
        RequestConfig.custom()
                .setConnectTimeout(3000)
                .setSocketTimeout(5000)
                .build());
                
//对keep alive的策略配置
httpClientBuilder.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
                    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
                        HeaderElementIterator it = new BasicHeaderElementIterator(response
                                .headerIterator(HTTP.CONN_KEEP_ALIVE));
                        while (it.hasNext()) {
                            HeaderElement he = it.nextElement();
                            String param = he.getName();
                            String value = he.getValue();
                            if (value != null && param.equalsIgnoreCase("timeout")) {
                                try {
                                    return Long.parseLong(value) * 1000;
                                } catch (NumberFormatException ignore) {
                                }
                            }
                        }
                        // 否则保持活动5秒
                        return 5 * 1000;
                    }
                });

HttpClient httpClient = httpClientBuilder.build()；

  5. 使用

    method.setProtocolVersion(HttpVersion.HTTP_1_1); //设置使用http 1.1
request.addHeader("User-Agent", agentHeader); //设置ua
request.addHeader("Connection", "keep-alive"); //为了keepalive支持http 1.0

HttpResponse res = httpClient.execute(request);

byte[] byteResult = EntityUtils.toByteArray(res.getEntity());

    最终可以通过返回的HttResponse拿到接口返回的body、header等信息。

此外，Apache HttpComponents还提供了AsyncHttpClient用于异步通讯场景, 使用流程和HttpClient类似。不同之处如下：

  1. 连接池管理器多了IO线程的配置且连接的Registry也不同。

    Registry<SchemeIOSessionStrategy> sessionStrategyRegistry = RegistryBuilder
      .<SchemeIOSessionStrategy>create()
      .register("http", NoopIOSessionStrategy.INSTANCE)
      .register("https", new SSLIOSessionStrategy(SSLContexts.createDefault()))
      .build();

// 配置io线程
IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
      .setIoThreadCount(Runtime.getRuntime().availableProcessors())
      .build();

// 设置连接池
ConnectingIOReactor ioReactor;
ioReactor = new DefaultConnectingIOReactor(ioReactorConfig);
PoolingNHttpClientConnectionManager conMgr = new PoolingNHttpClientConnectionManager(
      ioReactor, null, sessionStrategyRegistry, null);
conMgr.setMaxTotal(100);
conMgr.setDefaultMaxPerRoute(100);

// 连接配置：忽略传输错误，默认编码使用utf-8
ConnectionConfig connectionConfig = ConnectionConfig.custom()
      .setMalformedInputAction(CodingErrorAction.IGNORE)
      .setUnmappableInputAction(CodingErrorAction.IGNORE)
      .setCharset(Consts.UTF_8).build();
conMgr.setDefaultConnectionConfig(connectionConfig);

  2. 使用CloseableHttpAsyncClient。

    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(3000)
            .setSocketTimeout(1000).build();

CloseableHttpAsyncClient asyncClient = HttpAsyncClients.custom().setConnectionManager(conMgr)
    .setDefaultCookieStore(new BasicCookieStore())
    .setDefaultRequestConfig(requestConfig)
    .build();

  3. 使用时，需要先启动Client，并且提供了回调使用方式。

    asyncClient.start(); //需要先启动Client

// 通过future获取结果
HttpGet httpGet = new HttpGet("http://www.baidu.com");
Future<HttpResponse> responseFuture = asyncClient.execute(httpGet, null);
try {
    HttpResponse httpResponse = responseFuture.get();
    HttpEntity httpEntity = httpResponse.getEntity();
    ...
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

// 回调方式获取结果   
final HttpGet httpGet2 = new HttpGet("http://www.baidu.com"); 
asyncClient.execute(httpGet2, new FutureCallback<HttpResponse>() {
    @Override
    public void completed(HttpResponse httpResponse) {
        HttpEntity httpEntity = httpResponse.getEntity();
        ...
    }

    @Override
    public void failed(Exception e) {
    
    }

    @Override
    public void cancelled() {
    
    }
});

...

asyncClient.close();

    需要注意的是，无论是HttpClient还是AsyncHttpClient, 连接池都是有锁的。虽然支持对每一个route设置最大连接数，但如果是高并发场景，最好对于每一个服务都创建一个单独的HttpClient实例，使用不同的连接池。

    还需要提到的是，如果想要使用Http缓存提高请求的性能，可以使用Apache HttpComponents提供的httpclient-cache中的CachingHttpClient。

7.4.2 Guava

Guava是Google开源的一个涵盖了字符串处理、缓存、并发库、事件总线、IO等常用操作的Java核心库，也是Google自己很多Java项目依赖的工具库。其中的Guava Cache缓存已经在4.3.1讲过。

  1. Preconditions

    对条件做前置判断，经常用在方法的最前面，来对参数进行校验，不符合则抛出异常。

    Preconditions.checkArgument(user != null,"user null error"); //user为null则抛出IllegalArgumentException
Preconditions.checkNotNull(user); //user为null则抛出NullPointerException

  2. Optional

    使用Optional表示可能为null的T类型引用，能够显著地降低代码抛出NullPointerException的可能。其中其of方法和fromNullable，前者传入的值不能为空，后者则可以传入null值，表示引用缺失。提供了isPresent()方法判断是否引用缺失，在调用get之前务必先调用isPresent()。但Optional不能乱用，建议仅仅用在对外的API和接口的返回值上。

    String str = ...;
Optional<String> optional = Optional.fromNullable(str);
if(optional.isPresent()){
    String tmp = optional.get();
}

str = optional.or("default string");
str = optional.or(new Supplier<String>() {
    @Override
    public String get() {
        return "default string";
    }
});
str = optional.orNull();

// 对optional中的value做转换操作
optional.transform(new Function<String, Object>() {
    @Override
    public Object apply(String input) {
        return "transformed string";
    }
});

  3. Objects && MoreObjects

    是对Java中Object的操作的扩展，后者是对前者的升级,都是null safe的。包括非空判断、相等判断、空值处理、hashcode计算等。

    User user = new User();
User user1 = new User();  
...  

Objects.equal(user,user1); //equal判断
Objects.hashCode(user); //获取对象实例的哈希值
MoreObjects.toStringHelper(user).add("name","testName").toString(); //辅助编写类的toString方法
MoreObjects.firstNonNull(user,new User()); //取第一个非空的实例，可以用来在设置第一个元素为null时的默认值。

  4. ComparisonChain

    提供了链式的比较器，执行比较操作直至发现非零的结果, 之后的比较将被忽略。

    ComparisonChain.start()
            .compare(user.getName(),user1.getName())
            .compare(user.getAge(),user1.getAge())
            .result();

  5. Strings && Joiner && Splitter && CaseFormat

    这几个类都是对字符串的操作，包括分割、连接、格式转换等。

    Strings.nullToEmpty(str); //如果字符串为null，则转换为空字符串
Strings.repeat(str,3); //重复字符串成新的字符串

Joiner joiner = Joiner.on(";").skipNulls(); 
joiner.join("1", null, "2", "3","4"); //使用;拼接字符串

Splitter.on(';')
        .trimResults()
        .omitEmptyStrings()
        .split("1;2;3;4"); //分隔字符串

CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "user_name"); // 将字符串从low underscore命名格式转换为low camel命名。

    其中的命名格式转换还支持LOWER_HYPHEN、UPPER_CAMEL以及UPPER_UNDERSCORE。

  6. ImmutableList && Multiset && Multimap

    这些是Guava实现的新的集合类型。

    ImmutableList是不可变集合（保证线程绝对安全）的一种。除此之外，还有ImmutablesSet、ImmutableMap，用法都类似。

    ImmutableList<String> list = ImmutableList.of("1","2","3");

    Multiset可以多次添加相等的元素,主要统计给定元素的个数。

    Multiset<String> set = HashMultiset.create();
set.add("1");
set.add("1");
System.out.println(set.count("1"));

    Multimap是一个key映射多值的Map，类似于Map<K, List<V>>、Map<K, Set<V>>。主要是使用其两个子类：ListMultimap和SetMultimap，前者允许重复值，后者则不允许。

    Multimap<String,String> multimap = ArrayListMultimap.create();
multimap.put("test","1");
multimap.put("test","2");
multimap.get("test"); //["1","2"];

  7. Lists && Maps

    JDK默认提供了Collections作为集合工具类。Guava针对其没有提供的集合工具操作做了扩展和实现。Lists、Maps是List和Map的工具类。最大的一个特性是提供的静态工厂方法相比先创建ArrayList再添加元素或者设置参数的初始化方式要简单优雅很多。

    Lists.newArrayList("1", "2", "3");
Lists.newArrayListWithCapacity(100);

  8. ListenableFuture

    ListenableFuture继承了JDK concurrent包下的Future接口，可以大大简化并发逻辑的编写。可以注册回调方法，在运算（多线程执行）完成的时候进行调用, 或者在运算（多线程执行）完成后立即执行。

    ListeningExecutorService service  = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(10));
ListenableFuture future = service.submit(new Callable<String>() {
      @Override
      public String call() throws Exception {
          return "result";
      }
});
Futures.addCallback(future, new FutureCallback() {
      @Override
      public void onSuccess(Object result) {
          ...
      }
    
      @Override
      public void onFailure(Throwable t) {
        ...
      }
});

    还支持链式操作：

    Futures.transform(future, new AsyncFunction() {
     @Override
     public ListenableFuture apply(Object input) throws Exception {
         return ...;
     }
}, new Executor() {
     @Override
     public void execute(Runnable command) {
         
     }
});

  9. EventBus

    Guava实现的事件总线机制，为了替代通用型的发布-订阅模型，不适用于进程间通信。

    EventBus定义了事件生产者和事件监听者的角色，类似于生产者和消费者。

    • 事件生产者：管理和追踪监听者以及向监听者分发事件。

    • 事件监听者：注册到总线上，按照Event监听。只要以ChangeEvent为唯一参数创建方法，并用Subscribe注解标记即可实现一个监听者。register到EventBus上即可开始监听Event。

    class EventBusListener {
    @Subscribe
    public void recordCustomerChange(ChangeEvent e) {
        System.out.println(e.getSource());
    }
}

EventBus eventBus = new EventBus(); //还可以使用AsyncEventBus异步发送event
eventBus.register(new EventBusListener());

eventBus.post(new ChangeEvent("test event"));

  10. RateLimiter

    使用令牌桶的速率限制器，经常用于限制对一些物理资源或者逻辑资源的访问速率。与JDK中的Semaphore相比，Semaphore 限制了并发访问的数量而不是使用速率。

    final RateLimiter rateLimiter = RateLimiter.create(2.0); //桶容量为2且每秒新增2个令牌

Executor executo = Executors.newFixedThreadPool(10);

for (Runnable task : tasks) {
        rateLimiter.acquire(); // 也许需要等待直到有令牌可用
        executor.execute(task);
    }
}

    需要注意的是RateLimiter并不提供公平性的保证，没有先来先得的概念。此外，其请求的许可数不会影响到请求本身的限制，但会影响下一次请求的限制（高开销的任务下一个请求会经历额外的限制，从而来偿付高开销任务）。如：acquire(1) 和acquire(1000)的限制效果一样，但后者的下一次请求会受到额外限制。

此外，Guava还提供了散列、函数式风格、IO、区间、数学运算、Service框架、BloomFilter 等等许多非常有用的工具类，都大大提高了开发效率和代码质量。其中，Guava的Optional、Objects这些由于用的非常广泛，Java8都吸收并做了类似的实现。

7.4.3 Joda Time

JDK自带的Date、Calendar类使用起来非常麻烦，并且日期与字符串之间的转换很慢且非线程安全。Joda Time就是为了解决这些问题而创造的日期时间库，使用起来非常简单方便。和之前Apache Commons提供的DateUtils相比，如果想继续使用Java日期，可以选择DateUtils；如果想彻底改变的话就可以使用Joda Time。

  1. 初始化时间

    DateTime dateTime=new DateTime(2017, 6, 21, 18, 00,0); //2017.06.21 18:00:00

  2. 输出格式化字符串

    dateTime.toString("yyyy-MM-dd");

  3. 解析时间字符串

    DateTimeFormatter format = DateTimeFormat .forPattern("yyyy-MM-dd");         
DateTime dateTime = DateTime.parse("2017-06-21", format);

  4. 时间计算

    dateTime.plusDays(1) // 增加天      
           .plusYears(1)// 增加年      
           .plusMonths(1)// 增加月      
           .plusWeeks(1)// 增加星期      
           .minusMillis(1)// 减分钟      
           .minusHours(1)// 减小时      
           .minusSeconds(1);// 减秒数 

DateTime.Property month = dateTime.monthOfYear();      
month.isLeap(); //判断是否是闰月

  5. 与Java Date转换

    dateTime = new DateTime(new Date());
dateTime = new DateTime(Calendar.getInstance());
Date date = dateTime.toDate();

7.4.4 FastJson

FastJson是阿里巴巴开源的JSON处理器，官方测试称性能超过MappingJackson。使用起来比较简单方便。

  1. 序列化

    User user = new User();
user.setName("testUser");
user.setGender("M");
Strign userJson = JSON.toJSONString(user);

  2. 反序列化

    user = JSON.parseObject(str,User.class);
JSONObject jo = JSON.parseObject("{\"name\":\"test\"}");

  3. 构造JSONObject以及取值

    JSONObject jo = new JSONObject();
jo.put("name","test");
jo.getString("name");
jo.getString("nickName"); //返回为null, 不会抛异常

  4. 属性名称转化

    很多时候会遇到JSON字符串中的属性和Java Bean中的属性名称不一致的情况。这时候如果直接调用，则会出错，需要做名称转换，可以使用@JSONField注解配置别名：

    @JSONField(name = "nick")
private String nickName;

    此外，FastJson默认提供了JSON属性Low Underscore到Java Bean字段Low Camel命名的转化。如果想要实现序列化的时候到Low Camel的转换除了可以使用@JSONField，还可以使用SerializeConfig, 设置其PropertyNamingStrategy。同样的，ParseConfig也能设置此策略。

    SerializeConfig config = new SerializeConfig();
config.propertyNamingStrategy = PropertyNamingStrategy.SnakeCase;
String str = JSON.toJSONString(user, config);
System.out.println(str); // {\"nick_name\":\"testNick\"}

    PropertyNamingStrategy还支持KebabCase（短横线连接单词）、PascalCase（大写字母开头）以及CamelCase（驼峰）。

  5. JSONPath

    FastJson1.2.0之后提供了JSONPath，方便取值，类似于XPath。主要是为了简化取值逻辑，方便嵌套取值、过滤取值、获取集合长度等。

    String jsonStr = "{\"name\":\"testName\",\"interests\":[\"music\",\"basketball\"]," +
            "\"notes\":[{\"title\":\"note1\",\"contentLength\":200},{\"title\":\"note2\",\"contentLength\":100}]}";
JSONObject jsonObject1 = JSON.parseObject(jsonStr);
System.out.println(JSONPath.eval(jsonObject1, "$.interests.size()")); //集合长度
System.out.println(JSONPath.eval(jsonObject1, "$.interests[0]")); //集合取值
System.out.println(JSONPath.eval(jsonObject1, "$.notes[contentLength > 100].title")); //集合过滤取值
System.out.println(JSONPath.eval(jsonObject1, "$.notes['title']")); //只取某一个属性的值

使用FastJson时需要注意FastJson在序列化和反序列化默认是开启ASM的（安卓下不会开启）。可以通过下面的代码关闭：

SerializeConfig.getGlobalInstance().setAsmEnable(false); // 序列化的时候关闭ASM  
ParserConfig.getGlobalInstance().setAsmEnable(false); // 反序列化的时候关闭ASM

7.4.5 Orika

Orika是一个快速、高效的Java Bean映射框架，主要用于在VO、PO等各种Bean之间复制属性，并且是深复制。相比起7.4.1中提到的BeanUtils使用反射，Orika是使用代码生成进行复制的。因此其性能好于BeanUtils和Dozer（使用反射，对反射信息做了缓存）。

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
MapperFacade mapper = mapperFactory.getMapperFacade();

User user = new User();
user.setName("test");
User user1 = mapper.map(user, User.class);

不同类之间复制，如果属性名不一致，可以通过自定义映射来复制，属性名相同的直接可以复制。

MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
mapperFactory.classMap(User.class, TestUser.class)
      .field("name", "testName")
      .byDefault()
      .register();

MapperFacade mapper = mapperFactory.getMapperFacade();

User user = new User();
user.setName("test");
TestUser testUser = mapper.map(user, TestUser.class);

7.4.6 MapDB

MapDB将Java中常用的Maps, Sets, Lists, Queues等其他集合做了JVM堆外（堆外内存、磁盘）的存储实现。很多时候被用作多级缓存。如下：

DB db = DBMaker.memoryDB().make();

HTreeMap diskCache = db.hashMap("testCache")
      .expireStoreSize(10 * 1024)
      .expireMaxSize(1000)
      .expireAfterCreate(10, TimeUnit.SECONDS)
      .createOrOpen();

HTreeMap cache = db.hashMap("testCache")
      .expireMaxSize(100)
      .expireOverflow(diskCache)
      .createOrOpen();

需要注意的是，最新的MapDB使用的是Kotlin语言实现其主要逻辑。

7.4.7 使用Hystrix做熔断

除了HystrixBadRequestException异常之外，所有从run()方法抛出的异常都算作失败，并触发降级getFallback()和断路器逻辑。 HystrixBadRequestException用在非法参数或非系统故障异常等不应触发回退逻辑的场景。

请求缓存可以让(CommandKey/CommandGroup)相同的情况下,直接共享结果，降低依赖调用次数，在高并发和CacheKey碰撞率高场景下可以提升性能.

HystrixRequestContext context = HystrixRequestContext.initializeContext();

Servlet容器中，可以直接实用Filter机制Hystrix请求上下文

信号量隔离:SEMAPHORE 隔离本地代码或可快速返回远程调用(如memcached,redis)可以直接使用信号量隔离,降低线程隔离开销.

使用hystrix-javanica的Java注解

Previous7.3 Java并发编程Next7.5 Java新版本特性

Last updated