ToStringBuilder、HashCodeBuilder、EqualsBuilder、ToStringStyle、ReflectionToStringBuilder等学习...

        无论你在开发哪中 Java 应用程序，都免不了要写很多工具类/工具函数。你可知道，有很多现成的工具类可用，并且代码质量都很不错，不用你写，不用你调试，只要你发现。

        在 Apache Jakarta Common 中， Lang 这个 Java 工具包是所有 Apache Jakarta Common 项目中被使用最广泛的，几乎你所知道的名气比较大的软件里面都有用到它，包括 Tomcat, Weblogic, Websphere, Eclipse 等等。我们就从这个包开始介绍整个 common 项目。

Lang 中工具类比较多，这里介绍几个主要的：
　　ClassUtils：  getShortClassName，这个函数应该在 java.lang.Class 类中有的，我看到很多人自己写这个函数。getAllInterfaces，convertClassNamesToClasses，isAssignable，primitivesToWrappers，isInnerClass。
　　NumberUtils： 关于数字以及数字和字符串转换的类 stringToInt，toDouble，createNumber，isAllZeros， int compare(float lhs, float rhs)， isNumber(String str)，double min(double[] array)。
　　RandomUtils： 用于产生随机数的。
　　DateFormatUtils： 日期时间格式转换，以及本地时间和 UTC 时间转换。
　　DateUtils： 日期工具类。isSameDay，truncate，round，modify。

　　基于反射机制的几个类：
　　CompareToBuilder： 比较，用在算法、排序、比较的地方。reflectionCompare，append。
　　EqualsBuilder： 通过反射机制比较。reflectionEquals 很多项目中用到。
　　HashCodeBuilder： 可以通过反射生成 hash code，很多算法的地方涉及到 hash code，但是并不是每个人都知道一种 hash code 的生成方法。
　　ToStringBuilder： 当你需要重载 toString 函数而不想写代码把当前类的所有成员信息列出来，可以用这个函数。

 

一、简介与引入
   1、ToStringBuilder、HashCodeBuilder、EqualsBuilder、ToStringStyle、ReflectionToStringBuilder、CompareToBuilder等这些类都是位于commons-lang3.jar下面的，所以要使用这些类一定要导入commons-lang3.jar。
   2、为什么要使用ToStringBuilder？
     系统中一般都要打印日志的，因为所有实体的toString()方法 都用的是简单的"+"，因为每"＋" 一个就会 new 一个 String 对象，这样如果系统内存小的话会暴内存（前提系统实体比较多）。使用ToStringBuilder就可以避免暴内存这种问题的。

二、示例学习
  1、ToStringBuilder的append方法
     ToStringBuilder类主要用于类的格式化输出。ToStringBuilder中append方法可以向该类添加基本类型、数组、和对象，只有添加的方法才会被toString输出。如：
class TaxReturn {
  private String ssn;
  private int year;
  private String lastName;
  private BigDecimal taxableIncome;
  // get/set方法省略
  public TaxReturn() {
  }
 public TaxReturn(String pSsn, int pYear, String pLastName, BigDecimal pTaxableIncome) { 
    setSsn(pSsn); 
    setYear(pYear); 
    setLastName(pLastName); 
    setTaxableIncome(pTaxableIncome); 
  } 
  public String toString() {
    return new ToStringBuilder(this).append("ssn", ssn).append("year", year).append("lastName",
        lastName).toString();
  }

  public int hashCode() {
    return new HashCodeBuilder(3, 7).append(ssn).append(year).toHashCode();
  }

  public boolean equals(Object pObject) {
    boolean equals = false;
    if (pObject instanceof TaxReturn) {
      TaxReturn bean = (TaxReturn) pObject;
      equals = (new EqualsBuilder().append(ssn, bean.ssn).append(year, bean.year)).isEquals();
    }
    return equals;
  }

  public int compareTo(Object pObject) {
    return CompareToBuilder.reflectionCompare(this, pObject);
  }

}

public class MainClass {

  public static void main(String[] pArgs) throws Exception {
     TaxReturn return1 = new TaxReturn("012-68-3242", 1998, "O'Brien", new BigDecimal(43000.00));
     TaxReturn return2 = new TaxReturn("012-68-3242", 1999, "O'Brien", new BigDecimal(45000.00));
     TaxReturn return3 = new TaxReturn("012-68-3242", 1999, "O'Brien", new BigDecimal(53222.00));
     System.out.println("ToStringBuilder: " + return1.toString());
  }
}
运行结果如下：
   ToStringBuilder: TaxReturn@1503a3[ssn=012-68-3242,year=1998,lastName=O'Brien]


2、ToStringBuilder的reflectionToString方法

     该方法主要是把类对应的基本属性和值输出来。如：
public class MainClass {
    public static void main(String[] args) {
        MyClass one = new MyClass("Becker", 35);
        MyClass two = new MyClass("Becker", 35);
        MyClass three = new MyClass("Agassi", 33);

        System.out.println("One>>>" + one);
        System.out.println("Two>>>" + two);
        System.out.println("Three>>>" + three);

        System.out.println("one equals two? " + one.equals(two));
        System.out.println("one equals three? " + one.equals(three));

        System.out.println("One HashCode>>> " + one.hashCode());
        System.out.println("Two HashCode>>> " + two.hashCode());
        System.out.println("Three HashCode>>> " + three.hashCode());
    }
}

class MyClass {
    private String name = null;
    private int age = 0;

    public MyClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public boolean equals(Object obj) {
        return EqualsBuilder.reflectionEquals(this, obj);
    }

    public String toString() {
        return ToStringBuilder.reflectionToString(this,
            ToStringStyle.MULTI_LINE_STYLE);
    }

    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }
}
运行结果如下：

One>>>MyClass@743399[
  name=Becker
  age=35
]
Two>>>MyClass@1d8957f[
  name=Becker
  age=35
]
Three>>>MyClass@3ee284[
  name=Agassi
  age=33
]
one equals two? true
one equals three? false
One HashCode>>> 462213092
Two HashCode>>> 462213092
Three HashCode>>> -530629296

ToStringStyle参数说明：
1. DEFAULT_STYLE
   com.entity.Person@182f0db[name=John Doe,age=33,smoker=false]
2. MULTI_LINE_STYLE
    com.entity.Person@182f0db[
   name=John Doe
   age=33
   smoker=false
]
3. NO_FIELD_NAMES_STYLE
   com.entity.Person@182f0db[John Doe,33,false]
4. SHORT_PREFIX_STYLE   （即截去了包名）
  Person[name=John Doe,age=33,smoker=false]
5. SIMPLE_STYLE
   John Doe,33,false

 

两种方法用法优缺点及一个问题

研究ApacheCommon源码, 先从一个最简单的开始,即围绕Object类里的toString方法自动化实现的一系列类.
   
    怎么来自动化地实现toString方法, 有两种:反射和手动设置.这两种方法在上一篇博客中都有体现,这里就不再赘述了.下面列举下其优缺点.

    用反射方法的优点:
        1. 代码简洁, 不需要有什么配置的.
        2, 若Model属性有变化时不必再手动更改toString方法的实现.

    缺点:
        1, 有些属性并不想让toString给输入出来, (可能是没用, 也有可能是出于密码方面考虑),但用反射时所有属性值都给输了出来. (这个已有解决,见下面,不过虽说解决了,但还是不如另一种方式灵活.)
        2, 安全方面的考虑. 一般来说,一个java类是的属性都是private的,这样用反射来构建toString方法时,就得绕过private的限制. 于是 If your system is running under a restrictive SecurityManager , you may need to alter your configuration to allow Commons Lang to bypass these security restrictions.对Java安全性问题还没有体会,现在写在这里,以作备案,提醒以后注意.

    相比于这个反射, 直接用ToStringBuilder来配置就灵活多了.

    下面说下,弥补用反射方法不够灵活的一个扩展. 由于这个是我第一次见,就放在这里,作为备案.假设一个类里有名为password这样的属性,一般情况下,是不想让toString输入的, 但用反射默认情况下是会输出的. 这怎么办呢?看ReflectionToStringBuilder源码里文档时,发现这么一个扩展: 通过子类,覆盖其accept方法来加以筛选.具体如下所示:

public String toString() {
      return (new ReflectionToStringBuilder(this) {
// 注意这里为了表达上的简洁用了匿名内部类.
      protected boolean accept(Field f) {
        return super.accept(f) && !f.getName().equals("password");
          }
      }).toString();
}
这样在toString时, 就会跳过名为password的属性.

    上面记录了两种方法的优缺点和反射时的扩展, 其实研究完这个ToStringBuilder后,有三个收获,上面只是第一个,第三个相对来说比较大,只能放在下一篇了,这里介绍下第二个收获.

    说是收获,其实是一个问题,不过问题往往是新收获的开始. 问题是这样的: 一个private的静态内部类,它有一个同样是private的方法,名为readResolve(详见ToStringStyle的内部类 DefaultToStringStyle),那这个方法有什么用? 不用反射这个方法是不可能被调用的. 看对这个方法的描述,说是"Ensure Singleton after serialization".看不出来是什么意思? 怎么以前一直没见过呢?这个问题,先放在这里.

    两个小收获写完了, 下一篇中将介绍研究ToStringBuilder带给我的最大收获: abstract与设计模式.

readResolve()方法与序列化

在ToStringBuilder学习（一）中提到一个问题,即 readResolve方法是干啥的? 当时也没多想, 只是列在那里, 今天忙里偷闲地把搜点材料整理下这个问题.
原来这个方法跟对象的序列化相关(这样倒是解释了为什么 readResolve方法是private修饰的). ??? 怎么跟对象的序列化相关了?

下面我们先简要地回顾下对象的序列化. 一般来说, 一个类实现了 Serializable接口, 我们就可以把它往内存地写再从内存里读出而"组装"成一个跟原来一模一样的对象. 不过当序列化遇到单例时,这里边就有了个问题: 从内存读出而组装的对象破坏了单例的规则. 单例是要求一个JVM中只有一个类对象的, 而现在通过反序列化,一个新的对象克隆了出来.
如下例所示:
public final class MySingleton implements Serializable {
     private MySingleton() { }
     private static final MySingleton INSTANCE = new MySingleton();
     public static MySingleton getInstance() { return INSTANCE; }
}

当把 MySingleton对象(通过getInstance方法获得的那个单例对象)序列化后再从内存中读出时, 就有一个全新但跟原来一样的MySingleton对象存在了. 那怎么来维护单例模式呢?这就要用到readResolve方法了. 如下所示:
public final class MySingleton implements Serializable{
    private MySingleton() { }
    private static final MySingleton INSTANCE = new MySingleton();
    public static MySingleton getInstance() { return INSTANCE; }
    private Object readResolve() throws ObjectStreamException {
       // instead of the object we're on,
       // return the class variable INSTANCE
      return INSTANCE;
   }
}
这样当JVM从内存中反序列化地"组装"一个新对象时,就会自动调用这个 readResolve方法来返回我们指定好的对象了, 单例规则也就得到了保证.

 

转载于:https://my.oschina.net/u/3213541/blog/878816