apache-commons家族的八兄弟（上）

       Apache Commons包含了很多开源的工具，用于解决平时编程经常会遇到的问题，减少重复劳动。篇幅很长所以拆分为两篇。

老大：commons-beanUtils

Commons BeanUtils一共包括如下5个包：

org.apache.commons.beanutils – 核心包，定义一组 Utils 类和需要用到的接口规范

org.apache.commons.beanutils.converters – 转换 String 到需要类型的类，实现 Converter 接口

org.apache.commons.beanutils.locale –beanutils 的 locale 敏感版本

org.apache.commons.beanutils.locale.converters– converters 的 locale 敏感版本

org.apache.commons.collections – beanutils 使用到的 Collection 类

其中需要我们特别关注的是这个org.apache.commons.beanutils包，其他包都是起辅助作用的。接下来我们就仔细看一看这个包都有些什么东东：

    4个接口

1.Converter

该接口定义了如下方法：

public java.lang.Object convert(java.lang.Class type, java.lang.Object value);

只要实现了这个Converter接口并注册到ConvertUtils类即可被我们的BeanUtils包所使用，它的主要目的是提供将给定的Object实例转换为目标类型的算法。我们可以在beanutils.converters包中找到相当多的已经实现的转换器。

2.DynaBean

该接口定义的是一个动态的JavaBean，它的属性类型、名称和值都是可以动态改变的。

3.DynaClass

该接口定义的是针对实现了DynaBean接口的类的java.lang.Class对象，提供如getName()、newInstance()等方法。

4.MutableDynaClass

该接口是对DynaClass的扩展，使得动态bean的属性可以动态增加或删除。

    24个类

       只要把握好BeanUtils本身要完成的事，就不难理解这些类存在的道理。我们不妨把BeanUtils的基础应用分解成：访问JavaBean的属性、设定JavaBean的属性、以及创建和使用DynaBeans。

    代码示例

假定我们有如下两个标准的JavaBean：

//地址类
public class Address {
    private String zipCode;
    private String addr;
    private String city;
    private String country;
    public Address() {}
    public Address(String zipCode, String addr,String city, String country) {
        this .zipCode = zipCode;
        this .addr = addr;
        this .city = city;
        this .country = country;
    }
   //get-set method
}

//顾客类
public class Customer {
    private long id;
    private String name;
    private Address[] addresses;
    public Customer() {
    }
    public Customer( long id, String name, Address[]addresses) {
        this .id = id;
        this .name = name;
        this .addresses = addresses;
    }
   //get-set method
}

我们来看看通常我们是怎样利用Commons BeanUtils来完成一些基本的JavaBean和DynaBean操作：

public class BeanUtilsUsage {
    public static void main(String[] args) throws Exception {
        demoNormalJavaBeans();
        demoDynaBeans();
    }
    public static void demoNormalJavaBeans() throws Exception {
        System.out.println(StringUtils.center( " demoNormalJavaBeans " , 40, "=" ));
        // data setup
        Address addr1 = new Address( "CA1234" , "xxx" , "Los Angeles" , "USA" );
        Address addr2 = new Address( "100000" , "xxx" , "Beijing" , "China" );
        Address[] addrs = new Address[2];
        addrs[0] = addr1;
        addrs[1] = addr2;
        Customer cust = new Customer(123, "John Smith" , addrs);
        // accessing the city of first address
        String cityPattern = "addresses[0].city" ;
        String name =        (String)PropertyUtils.getSimpleProperty(cust, "name" );
        String city = (String)PropertyUtils.getProperty(cust, cityPattern);
        Object[] rawOutput1 = new Object[] { "The city of customer " ,name,
                "'sfirst address is " , city, "." };
        System.out.println(StringUtils.join(rawOutput1));
        // setting the zipcode of customer'ssecond address
        String zipPattern = "addresses[1].zipCode" ;
        if (PropertyUtils.isWriteable(cust, zipPattern)){
            System.out.println( "Setting zipcode ..." );
            PropertyUtils.setProperty(cust,zipPattern, "200000" );
        }
        String zip = (String)PropertyUtils.getProperty(cust, zipPattern);
        Object[] rawOutput2 = new Object[] { "The zipcode of customer " ,name,
                "'ssecond address is now " , zip, "." };
        System.out.println(StringUtils.join(rawOutput2));
        System.out.println();
    }
    public static void demoDynaBeans() throws Exception {
        System.out.println(StringUtils.center( " demoDynaBeans " , 40, "=" ));
        // creating a DynaBean
        DynaProperty[] dynaBeanProperties = new DynaProperty[] {
                new DynaProperty( "name" , String.class),
                new DynaProperty( "inPrice" , Double.class), 
                new DynaProperty( "outPrice" , Double.class),
        };
        BasicDynaClass cargoClass = new BasicDynaClass( "Cargo" ,BasicDynaBean.class, dynaBeanProperties);
        DynaBean cargo =cargoClass.newInstance();
        // accessing a DynaBean
        cargo.set( "name" , "Instant Noodles" );
        cargo.set( "inPrice" ,new Double(21.3));
        cargo.set( "outPrice" ,new Double(23.8));
        System.out.println( "name: " + cargo.get( "name" ));
        System.out.println( "inPrice: " + cargo.get( "inPrice" ));
        System.out.println( "outPrice: " + cargo.get( "outPrice" ));
        System.out.println();
    }
}

运行结果：

=========demoNormalJavaBeans ==========
The city of customerJohn Smith's first address is Los Angeles.
Setting zipcode ...
The zipcode ofcustomer John Smith's second address is now 200000.
============demoDynaBeans =============
name: InstantNoodles
inPrice: 21.3
outPrice: 23.8

老2：commons-codec

       commons-codec是Apache开源组织提供的用于摘要运算、编码的包。在该包中主要分为四类加密：BinaryEncoders、DigestEncoders、LanguageEncoders、NetworkEncoders。

为大家介绍一下如何用commons-codec包完成常见的编码、摘要运算。

    base64

@Test
public void testBase64(){
    System.out.println("==============Base64================");
    byte[] data = "imooc".getBytes();
    Base64 base64 = new Base64();
    String encode = base64.encodeAsString(data);
    System.out.println(encode);
    System.out.println(new String(base64.decode(encode)));
}

运行结果：

==============Base64================
amlhbmdndWppbg==
imooc

    MD5

@Test
public void testMD5(){
    System.out.println("==============MD5================");
    String result = DigestUtils.md5Hex("imooc");
    System.out.println(result);
}

运行结果：

acab4efdfd3b8efcdec37fe160d7be0e

SHA等摘要运算和MD5类似。

    URLCode

@Test
public void testURLCodec() throws Exception{
    System.out.println("==============URLCodec================");
    URLCodec codec = new URLCodec();
    String data = "imooc";
    String encode = codec.encode(data, "UTF-8");
    System.out.println(encode);
    System.out.println(codec.decode(encode, "UTF-8"));
}

运行结果：

==============URLCodec================
%E8%92%8B%E5%9B%BA%E9%87%91
imooc

老三：commons-collections

        Commons Collections，又是一个重量级的东西，为Java标准的Collections API提供了相当好的补充。Collections当然有它存在的道理，能够把常用的数据结构归纳起来，以通用的方式去维护和访问，这应该说是一种进步，但是用起来似乎不够友好。这个时候我就会想，如果Java比现在做得更好用些，或者有一套第三方的API把我的这些需求抽象出来，实现了，该多好。Commons Collections就是这样一套API。

      用过Java Collections API的朋友大概或多或少会同意我如下的划分：在Java的Collections API中，不狭义的区分语法上的接口和类，把它们都看作是类的话，大致我们可以发现三种主要的类别：

1.容器类：如Collection、List、Map等，用于存放对象和进行简单操作的；

2.操作类：如Collections、Arrays等，用于对容器类的实例进行相对复杂操作如排序等；

3.辅助类：如Iterator、Comparator等，用于辅助操作类以及外部调用代码实现对容器类的操作，所谓辅助，概括而通俗的来讲，就是这些类提供一种算法，你给它一个对象或者一组对象，或者仅仅是按一定的规则调用它，它给你一个运算后的答案，帮助你正确处理容器对象。比如Iterator会告诉你容器中下一个对象有没有、是什么，而Comparator将对象大小/先后次序的算法逻辑独立出来。

       list包中的方法Commons Collections在java.util.Map的基础上扩展了很多接口和类，比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似，Commons Collections也提供了一个MapUtils。

       所谓BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。

所谓MultiMap，就是说一个key不在是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。

       所谓LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建，这样的解释初听上去是不是有点不可思议？这样的LazyMap有用吗？我们这样来理解：我们需要一个Map，但是由于创建成员的方法很“重”（比如数据库访问），或者我们只有在调用get()时才知道如何创建，或者Map中出现的可能性很多很多，我们无法在get()之前添加所有可能出现的键/值对，或者任何其它解释得通的原因，我们觉得没有必要去初始化一个Map而又希望它可以在必要时自动处理数据生成的话，LazyMap就变得很有用了。

       Collection包下的方法中首先就是这个TypedCollection，它实际上的作用就是提供一个decorate方法，我们传进去一个Collection和需要的类型甄别信息java.lang.Class，它给我们创建一个全新的强类型的Collection。我们其实在bag、buffer、list、map、set这些子包中都可以找到分别对应Bag、Buffer、List、Map、Set接口的TypedXxxx版本。

       Bag是在org.apache.commons.collections包中定义的接口，它extends java.util.Collection，而它的实现类都被放在下面的bag包中。之所以有这样一组类型，是因为我们有时候需要在Collection中存放多个相同对象的拷贝，并且需要很方便的取得该对象拷贝的个数。需要注意的一点是它虽然extends Collection，但是如果真把它完全当作java.util.Collection来用会遇到语义上的问题，详细信息参考Javadoc。

       HashBag是Bag接口的一个标准实现。而BagUtils提供一组static的方法让调用者获取经过不同装饰后的Bag实例。

       Buffer是定义在org.apache.commons.collections包下面的接口，用于表示按一定顺序除去成员对象的collection如队列等。具体的实现类在org.apache.commons.collections.buffer包下可以找到。

       BufferUtils提供很多静态/工具方法装饰现有的Buffer实例，如将其装饰成BlockingBuffer、执行类型检查的TypedBuffer、或者不可改变的UnmodifiableBuffer等等。

       最简单直接的Buffer实现类是UnboundedFifoBuffer，提供先进先出的大小可变的队列。而BoundedFifoBuffer则是对其大小进行了限制，是固定大小的先进先出队列。BlockingBuffer要在多线程的环境中才能体现出它的价值，尤其是当我们需要实现某种流水线时这个BlockingBuffer很有用：每个流水线上的组件从上游的BlockingBuffer获取数据，处理后放到下一个BlockingBuffer中依次传递。BlockingBuffer的核心特色通俗点说就是如果你向它要东西，而它暂时还没有的话，你可以一直等待直至拿到为止。PriorityBuffer则提供比一般的先进先出Buffer更强的控制力：我们可以自定义Comparator给它，告诉它怎么判定它的成员的先后顺序，优先级最高的最先走。

        Comparator包已经明确定了一个java.util.Comparator接口，只是有很多人并不了解，Commons Collections也只是扩展了这个接口而已。这个java.util.Comparator定义如下核心方法：

public int compare(Object arg0, Object arg1)

        传给它两个对象，它要告诉我们这两个对象哪一个在特定的语义下更“大”，或者两者相等。如果arg0 > arg1，返回大于0的整数；如果arg0 = arg1，返回0；如果arg0 < arg2，返回小于0的整数。

        我们看看Commons Collections给我们提供了哪些Comparator的实现类（都在org.apache.commons.collections.comparators包下面）：

BooleanComparator – 用于排序一组 Boolean 对象，指明先 true 还是先 false ；

         ComparableComparator – 用于排序实现了 java.lang.Comparable 接口的对象（我们常用的 Java 类如 String 、 Integer、 Date 、 Double 、 File 、 Character 等等都实现了 Comparable 接口）；

ComparatorChain – 定义一组 Comparator 链，链中的 Comparator 对象会被依次执行；

FixedOrderComparator – 用于定义一个特殊的顺序，对一组对象按照这样的自定义顺序进行排序；

NullComparator – 让 null 值也可参与比较，可以设定为先 null 或者后 null ；

ReverseComparator – 将原有的 Comparator 效果反转；

TransformingComparator – 将一个 Comparator 装饰为具有 Transformer 效果的 Comparator 。

// 有关 Transformer 的内容会在以后的笔记中讲到。

       以上除了ComparatorChain之外，似乎都是实现一些很基本的比较方法，但是当我们用ComparatorChain将一组Comparator串起来之后，就可以实现非常灵活的比较操作。

       在Predicate包中Predicate是Commons Collections中定义的一个接口，可以在org.apache.commons.collections包中找到。其中定义的方法签名如下：

public boolean evaluate(Object object)

       它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。其实这个Predicate以及上一篇笔记提到的Comparator还有我们即将看到的Transformer和Closure等都有些类似C/C++中的函数指针，它们都只是提供简单而明确定义的函数功能而已。

       跟其他组类似，Commons Collections也提供了一组定义好的Predicate类供我们使用，这些类都放在org.apache.commons.collections.functors包中。当然，我们也可以自定义Predicate，只要实现这个Predicate接口即可。在Commons Collections中我们也可以很方便使用的一组预定义复合Predicate，我们提供2个或不定数量个Predicate，然后交给它，它可以帮我们处理额外的逻辑，如AndPredicate处理两个Predicate，只有当两者都返回true它才返回true；AnyPredicate处理多个Predicate，当其中一个满足就返回true，等等。

       而我们有时候需要将某个对象转换成另一个对象供另一组方法调用，而这两类对象的类型有可能并不是出于同一个继承体系的，或者说出了很基本的Object之外没有共同的父类，或者我们根本不关心他们是不是有其他继承关系，甚至就是同一个类的实例只是对我们而言无所谓，我们为了它能够被后续的调用者有意义的识别和处理，在这样的情形，我们就可以利用Transformer。除了基本的转型Transformer之外，Commons Collections还提供了Transformer链和带条件的Transformer，使得我们很方便的组装出有意义的转型逻辑。

       Closure这一组接口和类提供一个操作对象的execute方法，为我们在处理一系列对象时可以将处理逻辑分离出来。理论上讲，使用Transformer也可以达到类似的效果，只要输出对象和输入对象是同一个对象就好，但是Closure接口定义的execute方法返回void，并且从效果和功能区分上，Closure可以更好的诠释对象处理或执行的意思。而事实上，ClosureUtils中也提供了一个asClosure方法包装一个现成的Transformer。

       最后提到的java.util.Iterator接口定义了标准的Collection遍历方法，但是如果不做改变的使用它，我们得到的是从头到尾一次性的遍历。假如我们需要循环遍历，假如我们需要遍历某一段，假如我们需要遍历满足某些条件的元素，等等等等，我们就不能完全依赖于这个Iterator的标准实现了。除非我们宁可在此基础上在调用的代码中多加一些判断，不过这样的话代码就会显得混乱，时间长了就容易变得难以维护。Commons Collections的这一组Iterator为我们带来了便利。