Apache-Commons家族的八兄弟（上）

港控/mmm° 2021-08-01 00:26 278阅读 0赞

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

![640][]

## ***老大：*****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

该接口定义了如下方法：

1`publicjava.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个类**

![640][640 1]

![640][640 2]

![640][640 3]

只要把握好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

## ***老二：*****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);
    }

**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。

![640][640 4]

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定义如下核心方法：

1`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包中找到。其中定义的方法签名如下：

1`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为我们带来了便利。

作者：皮县豆福脑

来源：慕课网

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

**推****荐****阅****读**

***1.***

***2. ***

***3.***

***4.***

![640?][640 5]

[640]: /images/20210731/a2ef8f25f24b4004aec7fca3b7776112.png
[640 1]: /images/20210731/af91446c800d4b18a91d3576e5ce0927.png
[640 2]: /images/20210731/3bee6476227949f0897f61033e63ca65.png
[640 3]: /images/20210731/cc9c7870d2734fd98db21cbc24ec3d7d.png
[640 4]: /images/20210731/c9913ed54a6845fe9930e1570d58ba92.png
[640 5]: /images/20210731/3e98ec1a72ae4913ba62770e54704f33.png?