ClassInfo.java
package com.gh.mygreen.xlsmapper.xml.bind;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import com.gh.mygreen.xlsmapper.util.ArgUtils;
import com.gh.mygreen.xlsmapper.util.Utils;
/**
* XMLのクラス情報を保持する。
* @version 1.1
* @since 0.5
* @author T.TSUCHIE
*
*/
public class ClassInfo implements Serializable {
/** serialVersionUID */
private static final long serialVersionUID = 1L;
private String className;
private boolean override;
private List<AnnotationInfo> annotationInfos = new ArrayList<>();
private List<MethodInfo> methodInfos = new ArrayList<>();
private List<FieldInfo> fieldInfos = new ArrayList<>();
/**
* ビルダクラスのインスタンスを取得する。
* @since 1.1
* @return
*/
public static Builder builder() {
return new Builder();
}
public ClassInfo() {
}
private ClassInfo(final Builder builder) {
this.className = builder.className;
this.override = builder.override;
setAnnotationInfos(builder.annotationInfos);
setMethodInfos(builder.methodInfos);
setFieldInfos(builder.fieldInfos);
}
@Override
public String toString() {
StringBuilder sb= new StringBuilder();
sb.append("ClassInfo:")
.append(String.format(" [name=%s]", getClassName()))
.append(String.format(" [override=%b]", isOverride()));
for(AnnotationInfo anno : annotationInfos) {
sb.append(" ").append(anno.toString());
}
for(MethodInfo method : methodInfos) {
sb.append(" ").append(method.toString());
}
for(FieldInfo field : fieldInfos) {
sb.append(" ").append(field.toString());
}
return sb.toString();
}
/**
* クラス名を取得する。
* @return FQCN（完全限定クラス名）を指定します。
*/
public String getClassName() {
return className;
}
/**
* クラス名を設定する。
* @param className FQCN（完全限定クラス名）を設定します。
* @throws IllegalArgumentException className is empty.
*/
@XmlAttribute(name="name", required=true)
public void setClassName(final String className) {
ArgUtils.notEmpty(className, "className");
this.className = className;
}
/**
* 既存のクラスの定義にあるアノテーションの設定をXMLの定義で上書きするかどうか。
* <p>ただし、XMLに定義していないアノテーションは、既存のクラスに定義にあるものを使用する。</p>
* @since 1.0
* @return true:XMLの定義で上書きする。
*/
public boolean isOverride() {
return override;
}
/**
* 既存のクラスの定義にあるアノテーションの設定をXMLの定義で上書きするかどうか設定する。
* <p>ただし、XMLに定義していないアノテーションは、既存のクラスに定義にあるものを使用する。
* @since 1.0
* @param override true:XMLの定義で上書きする。
*/
@XmlAttribute(name="override", required=false)
public void setOverride(final boolean override) {
this.override = override;
}
/**
* アノテーション情報を追加する。
* <p>ただし、既に同じアノテーションが存在する場合は、それと入れ替えされます。</p>
* @param annotationInfo アノテーション情報。
* @throws IllegalArgumentException annotationInfo is null.
*/
public void addAnnotationInfo(final AnnotationInfo annotationInfo) {
ArgUtils.notNull(annotationInfo, "annotationInfo");
removeAnnotationInfo(annotationInfo.getClassName());
this.annotationInfos.add(annotationInfo);
}
/**
* アノテーションのクラス名を指定してアノテーション情報を取得する。
* @param annotationClassName アノテーションのクラス名(FQCN)。
* @return 指定したクラスが存在しない場合は、nullを返す。
*/
public AnnotationInfo getAnnotationInfo(final String annotationClassName) {
for(AnnotationInfo item : annotationInfos) {
if(item.getClassName().equals( annotationClassName)) {
return item;
}
}
return null;
}
/**
* 指定したアノテーション情報を含むかどうか。
* @since 1.1
* @param annotationClassName アノテーションのクラス名(FQCN)。
* @return true:指定したクラスが存在する場合。
*/
public boolean containsAnnotationInfo(final String annotationClassName) {
return getAnnotationInfo(annotationClassName) != null;
}
/**
* 指定したアノテーション情報を削除します。
* @since 1.4.1
* @param annotationClassName アノテーションのクラス名(FQCN)。
* @return true:指定したアノテーション名を含み、それが削除できた場合。
*/
public boolean removeAnnotationInfo(final String annotationClassName) {
final AnnotationInfo existInfo = getAnnotationInfo(annotationClassName);
if(existInfo != null) {
this.annotationInfos.remove(existInfo);
return true;
}
return false;
}
/**
* メソッド情報を追加する。
* <p>ただし、既に同じメソッドが存在する場合は、それと入れ替えされます。</p>
* @param methodInfo メソッド情報。
* @throws IllegalArgumentException methodInfo is null.
*/
public void addMethodInfo(final MethodInfo methodInfo) {
ArgUtils.notNull(methodInfo, "methodInfo");
removeMethodInfo(methodInfo.getMethodName());
this.methodInfos.add(methodInfo);
}
/**
* メソッド名を指定してメソッド情報を取得する。
* @param methodName メソッド名。
* @return 指定したメソッド名が存在しない場合は、nullを返す。
*/
public MethodInfo getMethodInfo(final String methodName) {
for(MethodInfo item : methodInfos) {
if(item.getMethodName().equals(methodName)) {
return item;
}
}
return null;
}
/**
* 指定したメソッド情報を含むかどうか。
* @param methodName メソッド名。
* @return true: 指定したメソッド名が存在する場合。
*/
public boolean containsMethodInfo(final String methodName) {
return getMethodInfo(methodName) != null;
}
/**
* 指定したメソッド情報を削除します。
* @since 1.4.1
* @param methodName メソッド名。
* @return true:指定したメソッド名を含み、それが削除できた場合。
*/
public boolean removeMethodInfo(final String methodName) {
final MethodInfo existInfo = getMethodInfo(methodName);
if(existInfo != null) {
this.methodInfos.remove(existInfo);
return true;
}
return false;
}
/**
* フィールド情報を追加する。
* <p>ただし、既に同じフィールドが存在する場合は、それと入れ替えされます。</p>
* @param fieldInfo フィールド情報。
* @throws IllegalArgumentException fieldInfo is null.
*/
public void addFieldInfo(final FieldInfo fieldInfo) {
ArgUtils.notNull(fieldInfo, "fieldInfo");
removeFieldInfo(fieldInfo.getFieldName());
this.fieldInfos.add(fieldInfo);
}
/**
* フィールド名を指定してフィールド情報を取得する。
* @param fieldName フィールド名。
* @return 指定したフィールド名が存在しない場合は、nullを返す。
*/
public FieldInfo getFieldInfo(final String fieldName) {
for(FieldInfo item : fieldInfos) {
if(item.getFieldName().equals(fieldName)) {
return item;
}
}
return null;
}
/**
* 指定したフィールド情報を含むかどうか。
* @param fieldName フィールド名。
* @return true: 指定したフィールド名が存在する場合。
*/
public boolean containsFieldInfo(final String fieldName) {
return getFieldInfo(fieldName) != null;
}
/**
* 指定したフィールド情報を削除します。
* @since 1.4.1
* @param fieldName フィールドのクラス名(FQCN)。
* @return true:指定したフィールド名を含み、それが削除できた場合。
*/
public boolean removeFieldInfo(final String fieldName) {
final FieldInfo existInfo = getFieldInfo(fieldName);
if(existInfo != null) {
this.fieldInfos.remove(existInfo);
return true;
}
return false;
}
/**
* JAXB用のアノテーション情報を設定するメソッド。
* <p>XMLの読み込み時に呼ばれます。
* <br>ただし、Java8からはこのメソッドは呼ばれず、{@link #getAnnotationInfos()} で取得したインスタンスに対して要素が追加されます。
* </p>
* <p>既存の情報はクリアされます。
* @since 1.1
* @param annotationInfos アノテーション情報。
*/
@XmlElement(name="annotation")
public void setAnnotationInfos(final List<AnnotationInfo> annotationInfos) {
if(annotationInfos == this.annotationInfos) {
// Java7の場合、getterで取得したインスタンスをそのまま設定するため、スキップする。
return;
}
this.annotationInfos.clear();
for(AnnotationInfo item : annotationInfos) {
addAnnotationInfo(item);
}
}
/**
* JAXB用のアノテーション情報を全て取得するメソッド。
* <p>XMLの書き込み時に呼ばれます。
* <br>Java8から読み込み時に呼ばれるようになり、取得したインスタンスに対して、読み込んだ要素が呼ばれます。
* </p>
* @since 1.1
* @return アノテーション情報。
*/
public List<AnnotationInfo> getAnnotationInfos() {
return annotationInfos;
}
/**
* JAXB用のメソッド情報を設定するメソッド。
* <p>XMLの読み込み時に呼ばれます。
* <br>ただし、Java8からはこのメソッドは呼ばれず、{@link #getMethodInfos()} で取得したインスタンスに対して要素が追加されます。
* </p>
* <p>既存の情報はクリアされます。</p>
* @since 1.1
* @param methodInfos メソッド情報。
*/
@XmlElement(name="method")
public void setMethodInfos(final List<MethodInfo> methodInfos) {
if(methodInfos == this.methodInfos) {
// Java7の場合、getterで取得したインスタンスをそのまま設定するため、スキップする。
return;
}
this.methodInfos.clear();
for(MethodInfo item : methodInfos) {
addMethodInfo(item);
}
}
/**
* JAXB用のメソッド情報を全て取得するメソッド。
* <p>XMLの書き込み時に呼ばれます。
* <br>Java8から読み込み時に呼ばれるようになり、取得したインスタンスに対して、読み込んだ要素が呼ばれます。
* </p>
* @since 1.1
* @return メソッド情報。
*/
public List<MethodInfo> getMethodInfos() {
return methodInfos;
}
/**
* JAXB用のフィールド情報を設定するメソッド。
* <p>XMLの読み込み時に呼ばれます。
* <br>ただし、Java8からはこのメソッドは呼ばれず、{@link #getFieldInfos()} で取得したインスタンスに対して要素が追加されます。
* </p>
* <p>既存の情報はクリアされます。</p>
* @since 1.1
* @param fieldInfos フィールド情報。
*/
@XmlElement(name="field")
public void setFieldInfos(final List<FieldInfo> fieldInfos) {
if(fieldInfos == this.fieldInfos) {
// Java7の場合、getterで取得したインスタンスをそのまま設定するため、スキップする。
return;
}
this.fieldInfos.clear();
for(FieldInfo item : fieldInfos) {
addFieldInfo(item);
}
}
/**
* JAXB用のフィールド情報を全て取得するメソッド。
* <p>XMLの書き込み時に呼ばれます。
* <br>Java8から読み込み時に呼ばれるようになり、取得したインスタンスに対して、読み込んだ要素が呼ばれます。
* </p>
* @since 1.1
* @return フィールド情報。
*/
public List<FieldInfo> getFieldInfos() {
return fieldInfos;
}
/**
* {@link ClassInfo}を組み立てるためのクラス。
*
*/
public static final class Builder {
private String className;
private boolean override;
private List<AnnotationInfo> annotationInfos;
private List<MethodInfo> methodInfos;
private List<FieldInfo> fieldInfos;
private Builder() {
this.annotationInfos = new ArrayList<>();
this.methodInfos = new ArrayList<>();
this.fieldInfos = new ArrayList<>();
}
/**
* 組み立てた{@link ClassInfo}のインスタンスを取得する。
* @return
*/
public ClassInfo buildClass() {
if(Utils.isEmpty(className)) {
throw new IllegalStateException("class name is required.");
}
return new ClassInfo(this);
}
/**
* クラス名を設定する。
* @param className クラス名。FQCN（完全限定クラス名）を設定します。
* @return
* @throws IllegalArgumentException calssName is empty.
*/
public Builder name(final String className) {
ArgUtils.notEmpty(className, "className");
this.className = className;
return this;
}
/**
* クラス名を設定する。
* @param clazz クラス情報。
* @return
* @throws IllegalArgumentException clazz is null.
*/
public Builder name(final Class<?> clazz) {
ArgUtils.notNull(clazz, "clazz");
return name(clazz.getName());
}
/**
* 既存のクラスの定義にあるアノテーションの設定をXMLの定義で上書きするかどうか設定する。
* @param override true:XMLの定義で上書きする。
* @return
*/
public Builder override(final boolean override) {
this.override = override;
return this;
}
/**
* クラスに対するアノテーション情報を追加する。
* @param annotationInfo アノテーション情報
* @return
* @throws IllegalArgumentException annotationInfo is null.
*/
public Builder annotation(final AnnotationInfo annotationInfo) {
ArgUtils.notNull(annotationInfo, "annotationInfo");
this.annotationInfos.add(annotationInfo);
return this;
}
/**
* メソッド情報を追加する。
* @param methodInfo メソッド情報
* @return
* @throws IllegalArgumentException methodInfo is null.
*/
public Builder method(final MethodInfo methodInfo) {
ArgUtils.notNull(methodInfo, "methodInfo");
this.methodInfos.add(methodInfo);
return this;
}
/**
* フィールド情報を追加する。
* @param fieldInfo フィールド情報。
* @return
* @throws IllegalArgumentException fieldInfo is null.
*/
public Builder field(final FieldInfo fieldInfo) {
ArgUtils.notNull(fieldInfo, "fieldInfo");
this.fieldInfos.add(fieldInfo);
return this;
}
}
}