org.apache.commons.lang.builder——ReflectionToStringBuilder类

bjghzly

　　先看一下常见的用法：

//本示例来自Jakarta Commons Cookbook
public class PoliticalCandidate {
private String lastName;
private String firstName;
private Date dateOfBirth;
private BigDecimal moneyRaised;
private State homeState;

// get/set methods 省略

public void toString( ) {
ReflectionToStringBuilder.toString( this );
}
}
// Create a State
State va = new State( "VA", "Virginia");
// Create a Birth Date
Calendar calendar = new GregorianCalendar( );
calendar.set( Calendar.YEAR, 1743 );
calendar.set( Calendar.MONTH, Calendar.APRIL );
calendar.set( Calendar.DAY_OF_MONTH, 13 );
Date dob = calendar.getTime( );

BigDecimal moneyRaised = new BigDecimal( 293829292.93 );        

// Create a Political Candidate
PoliticalCandidate candidate =
new PoliticalCandidate( "Jefferson", "Thomas", dob, moneyRaised, va );

System.out.println( candidate );
//输出结果
com.discursive.jccook.lang.builders.PoliticalCandidate@187aeca
[lastName=Jefferson,\firstName=Thomas,
dateOfBirth=Sat Apr 13 22:38:42 CST 1743,
moneyRaised=\293829292.930000007152557373046875,
state=\com.discursive.jccook.lang.builders.State@87816d
[abbreviation=VA,name=Virginia]]

　　这个类其实就是ToStringBuilder类的一个简单实现，真正toString的生成工作全部委托给了ToStringBuilder类去完成。下面看一下这个类的源码，简单的方法就不在说了。

public class ReflectionToStringBuilder extends ToStringBuilder {
public static String toString(Object object) {
return toString(object, null, false, false, null);
}
public static String toString(Object object, ToStringStyle style) {
return toString(object, style, false, false, null);
}
public static String toString(Object object, ToStringStyle style, boolean outputTransients) {
return toString(object, style, outputTransients, false, null);
}
public static String toString(Object object, ToStringStyle style, boolean outputTransients, boolean outputStatics) {
return toString(object, style, outputTransients, outputStatics, null);
}
//其他的toString方法都会调用这个toString
public static String toString(Object object, ToStringStyle style, boolean outputTransients, boolean outputStatics,
Class reflectUpToClass) {
//创建ReflectionToStringBuilder示例并调用toString方法
return new ReflectionToStringBuilder(object, style, null, reflectUpToClass, outputTransients, outputStatics)
.toString();
}
public static String toString(Object object, ToStringStyle style,
boolean outputTransients, Class reflectUpToClass)
{
return new ReflectionToStringBuilder(object, style, null, reflectUpToClass, outputTransients).toString();
}
//这个方法的作用就是不显示excludeFieldName参数做表示的字段
public static String toStringExclude(Object object, final String excludeFieldName) {
return toStringExclude(object, new String[]{excludeFieldName});
}
public static String toStringExclude(Object object, Collection /*String*/ excludeFieldNames) {
return toStringExclude(object, toNoNullStringArray(excludeFieldNames));
}
//检查数组是否为空，为空的话返回一个String类型的空数组
//EMPTY_STRING_ARRAY = new String[0]
static String[] toNoNullStringArray(Collection collection) {
if (collection == null) {
return ArrayUtils.EMPTY_STRING_ARRAY;
}
return toNoNullStringArray(collection.toArray());
}
//去除array数组中的null元素
static String[] toNoNullStringArray(Object[] array) {
ArrayList list = new ArrayList(array.length);
for (int i = 0; i < array.length; i++) {
Object e = array;
if (e != null) {
list.add(e.toString());
}
}
return (String[]) list.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
}
public static String toStringExclude(Object object, String[] excludeFieldNames) {
return new ReflectionToStringBuilder(object).setExcludeFieldNames(excludeFieldNames).toString();
}
//默认toString方法中不显示static字段，transient字段
private boolean appendStatics = false;
private boolean appendTransients = false;
private String[] excludeFieldNames;

private Class upToClass = null;
public ReflectionToStringBuilder(Object object) {
super(object);
}
public ReflectionToStringBuilder(Object object, ToStringStyle style) {
super(object, style);
}
public ReflectionToStringBuilder(Object object, ToStringStyle style, StringBuffer buffer) {
super(object, style, buffer);
}
//这里可以看到ReflectionToStringBuilder的构造函数只是简单的调用了父类的构造函数，并设置一些属性
public ReflectionToStringBuilder(Object object, ToStringStyle style, StringBuffer buffer, Class reflectUpToClass,
boolean outputTransients) {
super(object, style, buffer);
this.setUpToClass(reflectUpToClass);
this.setAppendTransients(outputTransients);
}
public ReflectionToStringBuilder(Object object, ToStringStyle style, StringBuffer buffer, Class reflectUpToClass,
boolean outputTransients, boolean outputStatics) {
super(object, style, buffer);
this.setUpToClass(reflectUpToClass);
this.setAppendTransients(outputTransients);
this.setAppendStatics(outputStatics);
}
//这个方法用于判断是否显示内部类，静态字段等
protected boolean accept(Field field) {
/*这里判断如果是内部类的话，就直接返回false，表示不显示。
INNER_CLASS_SEPARATOR_CHAR就是'$'，通过反射得到内部类的字段应该有困难，因为每个内部类都持有外部类实例的引用，所以这里只是简单的过滤掉内部类
*/
if (field.getName().indexOf(ClassUtils.INNER_CLASS_SEPARATOR_CHAR) != -1) {
// Reject field from inner class.
return false;
}
if (Modifier.isTransient(field.getModifiers()) && !this.isAppendTransients()) {
// Reject transient fields.
return false;
}
if (Modifier.isStatic(field.getModifiers()) && !this.isAppendStatics()) {
// Rject static fields.
return false;
}
if (this.getExcludeFieldNames() != null
&& Arrays.binarySearch(this.getExcludeFieldNames(), field.getName()) >= 0) {
// Reject fields from the getExcludeFieldNames list.
return false;
}
return true;
}
/*如果clazz是数组类型，则调用reflectionAppendArray方法进行处理。
否则就取得这个clazz表示的类的所有字段，并且把访问属性设置成可访问，这个意思就是说即使字段是private类型，也可以直接取值，而不用调用get方法。
但是注意这句话：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.
（参见Jakarta Commons Cookbook）
*/
protected void appendFieldsIn(Class clazz) {
if (clazz.isArray()) {
this.reflectionAppendArray(this.getObject());
return;
}
Field[] fields = clazz.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
for (int i = 0; i < fields.length; i++) {
Field field = fields;
String fieldName = field.getName();
if (this.accept(field)) {
try {
// Warning: Field.get(Object) creates wrappers objects
// for primitive types.
Object fieldValue = this.getValue(field);
this.append(fieldName, fieldValue);
} catch (IllegalAccessException ex) {
//this can't happen. Would get a Security exception
// instead
//throw a runtime exception in case the impossible
// happens.
throw new InternalError("Unexpected IllegalAccessException: " + ex.getMessage());
}
}
}
}
public String[] getExcludeFieldNames() {
return this.excludeFieldNames;
}
public Class getUpToClass() {
return this.upToClass;
}
protected Object getValue(Field field) throws IllegalArgumentException, IllegalAccessException {
return field.get(this.getObject());
}
public boolean isAppendStatics() {
return this.appendStatics;
}
public boolean isAppendTransients() {
return this.appendTransients;
}
public ToStringBuilder reflectionAppendArray(Object array) {
this.getStyle().reflectionAppendArrayDetail(this.getStringBuffer(), null, array);
return this;
}
public void setAppendStatics(boolean appendStatics) {
this.appendStatics = appendStatics;
}
public void setAppendTransients(boolean appendTransients) {
this.appendTransients = appendTransients;
}
public ReflectionToStringBuilder setExcludeFieldNames(String[] excludeFieldNamesParam) {
if (excludeFieldNamesParam == null) {
this.excludeFieldNames = null;
} else {
this.excludeFieldNames = toNoNullStringArray(excludeFieldNamesParam);
Arrays.sort(this.excludeFieldNames);
}
return this;
}
//设置可以自动查找到的最上层父类。也就是说，到这个类就不在向上查找字段了
public void setUpToClass(Class clazz) {
this.upToClass = clazz;
}
//真正的toString方法
public String toString() {
if (this.getObject() == null) {
//这里调用父类的getStyle方法，格式化字符串的工作由ToStringStyle类来处理
return this.getStyle().getNullText();
}
Class clazz = this.getObject().getClass();
this.appendFieldsIn(clazz);
//这里可以看到会自动附加上父类的字段，可以设置upToClass属性来阻止显示父类的字段
while (clazz.getSuperclass() != null && clazz != this.getUpToClass()) {
clazz = clazz.getSuperclass();
this.appendFieldsIn(clazz);
}
return super.toString();
}
}
　　通过源码可以看到，真正的工作是交由父类去处理的，而格式化字符串的工作又是由ToStringStyle类进行处理的