実行時に（動的に）単純なPOJOクラス（バイトコード）を作成する
私は次のシナリオを持っています。
データベースに対してユーザー入力クエリを実行し、結果を返すツールを作成しています。
最も簡単な方法は、結果をList<String[]>として返すことですが、これをさらに一歩進める必要があります。
（runtimeで）いくつかの名前のPOJO（またはDTO）を作成し、そのためのフィールドとセッターおよびゲッターを作成して、データを入力する必要があります返された後、生成された.classファイルとともにユーザーに返します。
つまり、ここでのアイデアは、実行時に（動的に）単純なクラス（バイトコード）を作成する方法です基本的な検索を行ったところ、多くのlib Apache BCEL しかし、もっと簡単なものが必要だと思います...
あなたはそれをどう思いますか？
ありがとう。
CGLib ：を使用すると、ゲッターとセッターを使用して単純なPOJOを簡単に作成できます。
public static Class<?> createBeanClass(
/* fully qualified class name */
final String className,
/* bean properties, name -> type */
final Map<String, Class<?>> properties){
final BeanGenerator beanGenerator = new BeanGenerator();
/* use our own hard coded class name instead of a real naming policy */
beanGenerator.setNamingPolicy(new NamingPolicy(){
@Override public String getClassName(final String prefix,
final String source, final Object key, final Predicate names){
return className;
}});
BeanGenerator.addProperties(beanGenerator, properties);
return (Class<?>) beanGenerator.createClass();
}
テストコード：
public static void main(final String[] args) throws Exception{
final Map<String, Class<?>> properties =
new HashMap<String, Class<?>>();
properties.put("foo", Integer.class);
properties.put("bar", String.class);
properties.put("baz", int[].class);
final Class<?> beanClass =
createBeanClass("some.ClassName", properties);
System.out.println(beanClass);
for(final Method method : beanClass.getDeclaredMethods()){
System.out.println(method);
}
}
出力：
クラスsome.ClassName
public int [] some.ClassName.getBaz（）
public void some.ClassName.setBaz（int []）
public Java.lang.Integer some.ClassName.getFoo（）
public void some.ClassName.setFoo（Java.lang.Integer）
public Java.lang.String some.ClassName.getBar（）
public void some.ClassName.setBar（Java.lang.String）
しかし、問題は、これらのメソッドはコンパイル時に存在しないため、これらのメソッドに対してコーディングする方法がないため、これがどのように役立つかわかりません。
まあ これも試してみるかもしれません 。しかし、誰かが説明できるなら、私はこれを理解する必要があります。
更新：
アプリケーションが実行時に外部構成から動的にJava POJOインスタンスを作成する必要があると想像してください。このタスクはバイトコード操作ライブラリの1つを使用して簡単に実行できます。この投稿は、Javassistを使用してこれを実行する方法を示しています。図書館。
動的に作成されたPOJOに含める必要のあるプロパティの構成が次のとおりであると想定します。
Map<String, Class<?>> props = new HashMap<String, Class<?>>();
props.put("foo", Integer.class);
props.put("bar", String.class);
必要なプロパティを含む、指定されたクラス名とマップのClassオブジェクトを動的に生成するPojoGeneratorを作成しましょう。
import Java.io.Serializable;
import Java.util.Map;
import Java.util.Map.Entry;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import javassist.CtMethod;
import javassist.NotFoundException;
public class PojoGenerator {
public static Class generate(String className, Map<String, Class<?>> properties) throws NotFoundException,
CannotCompileException {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass(className);
// add this to define a super class to extend
// cc.setSuperclass(resolveCtClass(MySuperClass.class));
// add this to define an interface to implement
cc.addInterface(resolveCtClass(Serializable.class));
for (Entry<String, Class<?>> entry : properties.entrySet()) {
cc.addField(new CtField(resolveCtClass(entry.getValue()), entry.getKey(), cc));
// add getter
cc.addMethod(generateGetter(cc, entry.getKey(), entry.getValue()));
// add setter
cc.addMethod(generateSetter(cc, entry.getKey(), entry.getValue()));
}
return cc.toClass();
}
private static CtMethod generateGetter(CtClass declaringClass, String fieldName, Class fieldClass)
throws CannotCompileException {
String getterName = "get" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
StringBuffer sb = new StringBuffer();
sb.append("public ").append(fieldClass.getName()).append(" ")
.append(getterName).append("(){").append("return this.")
.append(fieldName).append(";").append("}");
return CtMethod.make(sb.toString(), declaringClass);
}
private static CtMethod generateSetter(CtClass declaringClass, String fieldName, Class fieldClass)
throws CannotCompileException {
String setterName = "set" + fieldName.substring(0, 1).toUpperCase()
+ fieldName.substring(1);
StringBuffer sb = new StringBuffer();
sb.append("public void ").append(setterName).append("(")
.append(fieldClass.getName()).append(" ").append(fieldName)
.append(")").append("{").append("this.").append(fieldName)
.append("=").append(fieldName).append(";").append("}");
return CtMethod.make(sb.toString(), declaringClass);
}
private static CtClass resolveCtClass(Class clazz) throws NotFoundException {
ClassPool pool = ClassPool.getDefault();
return pool.get(clazz.getName());
}
}
それでおしまい！
PojoGeneratorの使用は非常に簡単です。いくつかのPOJOを生成し、そのすべてのメソッドをリフレクションを介して出力し、いくつかのプロパティを設定して取得しましょう。
public static void main(String[] args) throws Exception {
Map<String, Class<?>> props = new HashMap<String, Class<?>>();
props.put("foo", Integer.class);
props.put("bar", String.class);
Class<?> clazz = PojoGenerator.generate(
"net.javaforge.blog.javassist.Pojo$Generated", props);
Object obj = clazz.newInstance();
System.out.println("Clazz: " + clazz);
System.out.println("Object: " + obj);
System.out.println("Serializable? " + (obj instanceof Serializable));
for (final Method method : clazz.getDeclaredMethods()) {
System.out.println(method);
}
// set property "bar"
clazz.getMethod("setBar", String.class).invoke(obj, "Hello World!");
// get property "bar"
String result = (String) clazz.getMethod("getBar").invoke(obj);
System.out.println("Value for bar: " + result);
}
上記を実行すると、次のコンソール出力が生成されます。
Clazz: class net.javaforge.blog.javassist.Pojo$Generated
Object: net.javaforge.blog.javassist.Pojo$Generated@55571e
Serializable? true
public void net.javaforge.blog.javassist.Pojo$Generated.setBar(Java.lang.String)
public Java.lang.String net.javaforge.blog.javassist.Pojo$Generated.getBar()
public Java.lang.Integer net.javaforge.blog.javassist.Pojo$Generated.getFoo()
public void net.javaforge.blog.javassist.Pojo$Generated.setFoo(Java.lang.Integer)
Value for bar: Hello World!
私は過去にこれにASMを使用しました。私が好きなのは、クラスを生成するコードを作成できるASMifierです。例えばJavaコードですべてのタイプの1つのフィールドをJavaで作成し、ASMifierを使用してJavaこれをバイトコードから作成し、任意のPOJOを生成するためのテンプレートとして使用するコード。
@Michaelが示唆しているように、任意のフィールドを取得するための無反射の方法を追加することをお勧めします。例えば.
public Set<String> fieldNames();
public Object getField(String name);
public void setField(String name, Object name);
なぜあなたはこれをしたいのですか？通常のマップを使用するよりも効率的にMap<String, Object>スタイルのオブジェクトを使用する方法がいくつかあります。
もう1つのアプローチは、Velocityを使用してJavaソースを生成し、Compiler APIを使用してコードをコンパイルすることです。使用するのが面倒なので、ここにラップを記述しました Essence JCF このアプローチを使用することの唯一の読み取り上の利点は、生成されたコードを簡単にデバッグできることです（ライブラリには、Javaコードを、コンパイラが見つけられる場所に保存するオプションがあります。生成されたコード）
呼び出し元doは、その場で生成され、したがって彼のコードが知ることができないクラスで何をしますか？それにアクセスする唯一の方法は、リフレクションを介することです。 List<String[]>またはMap<String, String>を返すことは、実際にははるかにクリーンで使いやすいデザインになります。
ゲッターやセッターを書くのも嫌いです。ネストされたクラスとして宣言されたPOJOであっても、POJOを使用したいと思います。
古いサーバーとテクノロジーを使用し、Springsを導入せずにこれを行う別の方法があります（JBoss4.2とJBossの不完全なEJB3.0を使用します）。 org.Apache.commons.beanutils.BeanMapを拡張すると、POJOをBeanマップでラップでき、取得または配置するときに、リフレクションを使用してフィールドを操作できます。ゲッターまたはセッターが存在しない場合は、フィールド操作を使用して取得します。明らかにそれは本物の豆ではないので、それは完全に大丈夫です。
package com.aaa.ejb.common;
import Java.io.Serializable;
import Java.lang.reflect.Constructor;
import Java.lang.reflect.Field;
import Java.lang.reflect.InvocationTargetException;
import Java.lang.reflect.Method;
import Java.lang.reflect.Modifier;
import Java.util.HashSet;
import Java.util.Set;
import org.Apache.commons.beanutils.BeanMap;
import org.Apache.commons.collections.set.UnmodifiableSet;
import org.Apache.log4j.Logger;
/**
* I want the bean map to be able to handle a POJO.
* @author gbishop
*/
public final class NoGetterBeanMap extends BeanMap {
private static final Logger LOG = Logger.getLogger(NoGetterBeanMap.class);
/**
* Gets a bean map that can handle writing to a pojo with no getters or setters.
* @param bean
*/
public NoGetterBeanMap(Object bean) {
super(bean);
}
/* (non-Javadoc)
* @see org.Apache.commons.beanutils.BeanMap#get(Java.lang.Object)
*/
public Object get(Object name) {
Object bean = getBean();
if ( bean != null ) {
Method method = getReadMethod( name );
if ( method != null ) {
try {
return method.invoke( bean, NULL_ARGUMENTS );
}
catch ( IllegalAccessException e ) {
logWarn( e );
}
catch ( IllegalArgumentException e ) {
logWarn( e );
}
catch ( InvocationTargetException e ) {
logWarn( e );
}
catch ( NullPointerException e ) {
logWarn( e );
}
} else {
if(name instanceof String) {
Class<?> c = bean.getClass();
try {
Field datafield = c.getDeclaredField( (String)name );
datafield.setAccessible(true);
return datafield.get(bean);
} catch (SecurityException e) {
throw new IllegalArgumentException( e.getMessage() );
} catch (NoSuchFieldException e) {
throw new IllegalArgumentException( e.getMessage() );
} catch (IllegalAccessException e) {
throw new IllegalArgumentException( e.getMessage() );
}
}
}
}
return null;
}
/* (non-Javadoc)
* @see org.Apache.commons.beanutils.BeanMap#put(Java.lang.Object, Java.lang.Object)
*/
public Object put(Object name, Object value) throws IllegalArgumentException, ClassCastException {
Object bean = getBean();
if ( bean != null ) {
Object oldValue = get( name );
Method method = getWriteMethod( name );
Object newValue = null;
if ( method == null ) {
if(name instanceof String) {//I'm going to try setting the property directly on the bean.
Class<?> c = bean.getClass();
try {
Field datafield = c.getDeclaredField( (String)name );
datafield.setAccessible(true);
datafield.set(bean, value);
newValue = datafield.get(bean);
} catch (SecurityException e) {
throw new IllegalArgumentException( e.getMessage() );
} catch (NoSuchFieldException e) {
throw new IllegalArgumentException( e.getMessage() );
} catch (IllegalAccessException e) {
throw new IllegalArgumentException( e.getMessage() );
}
} else {
throw new IllegalArgumentException( "The bean of type: "+
bean.getClass().getName() + " has no property called: " + name );
}
} else {
try {
Object[] arguments = createWriteMethodArguments( method, value );
method.invoke( bean, arguments );
newValue = get( name );
} catch ( InvocationTargetException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
} catch ( IllegalAccessException e ) {
logInfo( e );
throw new IllegalArgumentException( e.getMessage() );
}
firePropertyChange( name, oldValue, newValue );
}
return oldValue;
}
return null;
}
/* (non-Javadoc)
* @see org.Apache.commons.beanutils.BeanMap#keySet()
*/
public Set keySet() {
Class<?> c = getBean().getClass();
Field[] fields = c.getDeclaredFields();
Set<String> keySet = new HashSet<String>(super.keySet());
for(Field f: fields){
if( Modifier.isPublic(f.getModifiers()) && !keySet.contains(f.getName())){
keySet.add(f.getName());
}
}
keySet.remove("class");
return UnmodifiableSet.decorate(keySet);
}
}
トリッキーな部分は、POJOを因数分解して元に戻すことですが、リフレクションはそこで役立ちます。
/**
* Returns a new instance of the specified object. If the object is a bean,
* (serializable, with a default zero argument constructor), the default
* constructor is called. If the object is a Cloneable, it is cloned, if the
* object is a POJO or a nested POJO, it is cloned using the default
* zero argument constructor through reflection. Such objects should only be
* used as transfer objects since their constructors and initialization code
* (if any) have not have been called.
* @param obj
* @return A new copy of the object, it's fields are blank.
*/
public static Object constructBeanOrPOJO(final Object obj) {
Constructor<?> ctor = null;
Object retval = null;
//Try to invoke where it's Serializable and has a public zero argument constructor.
if(obj instanceof Serializable){
try {
ctor = obj.getClass().getConstructor((Class<?>)null);
if(ctor.isAccessible()){
retval = ctor.newInstance();
//LOG.info("Serializable class called with a public constructor.");
return retval;
}
} catch (Exception ignoredTryConeable) {
}
}
//Maybe it's Clonable.
if(obj instanceof Cloneable){
try {
Method clone = obj.getClass().getMethod("clone");
clone.setAccessible(true);
retval = clone.invoke(obj);
//LOG.info("Cloneable class called.");
return retval;
} catch (Exception ignoredTryUnNestedClass) {
}
}
try {
//Maybe it's not a nested class.
ctor = obj.getClass().getDeclaredConstructor((Class<?>)null);
ctor.setAccessible(true);
retval = ctor.newInstance();
//LOG.info("Class called with no public constructor.");
return retval;
} catch (Exception ignoredTryNestedClass) {
}
try {
Constructor[] cs = obj.getClass().getDeclaredConstructors();
for(Constructor<?> c: cs){
if(c.getTypeParameters().length==0){
ctor = c;
ctor.setAccessible(true);
retval = ctor.newInstance();
return retval;
}
}
//Try a nested class class.
Field parent = obj.getClass().getDeclaredField("this$0");
parent.setAccessible(true);
Object outer = (Object) parent.get(obj);
//ctor = (Constructor<? extends Object>) obj.getClass().getConstructors()[0];//NO, getDECLAREDConstructors!!!
ctor = (Constructor<? extends Object>) obj.getClass().getDeclaredConstructor(parent.get(obj).getClass());
ctor.setAccessible(true);
retval = ctor.newInstance(outer);
//LOG.info("Nested class called with no public constructor.");
return retval;
} catch (Exception failure) {
throw new IllegalArgumentException(failure);
}
}
Bean、クローン可能、またはPOJOからジェネリックBeanを取得するためのサンプルコード：
public List<Object> getGenericEJBData(String tableName, Object desiredFields, Object beanCriteria){
NoGetterBeanMap desiredFieldMap = new NoGetterBeanMap(desiredFields);
NoGetterBeanMap criteriaMap = new NoGetterBeanMap(beanCriteria);
List<Object> data = new ArrayList<Object>();
List<Map<String, Object>> mapData = getGenericEJBData(tableName, desiredFieldMap, criteriaMap);
for (Map<String,Object> row: mapData) {
Object bean = NoGetterBeanMap.constructBeanOrPOJO(desiredFields);//Cool eh?
new NoGetterBeanMap(bean).putAll(row);//Put the data back in too!
data.add(bean);
}
return data;
}
EJBでの使用例：
IGenericBean genericRemote = BeanLocator.lookup(IGenericBean.class);
//This is the minimum required typing.
class DesiredDataPOJO {
public String makename="";//Name matches column and return type.
}
class CriteriaPOJO {
//Names match column and contains criteria values.
public String modelname=model,yearid=year;
}
List<DesiredDataPOJO> data =
genericRemote.getGenericEJBData(ACES_VEHICLE_TABLE, new DesiredDataPOJO(), new CriteriaPOJO() );
for (DesiredDataPOJO o: data) {
makes.add(o.makename);
}
EJBには、次のようなインターフェースがあります。
package com.aaa.ejb.common.interfaces;
import Java.util.List;
import Java.util.Map;
import javax.ejb.Local;
import javax.ejb.Remote;
/**
* @see
* http://trycatchfinally.blogspot.com/2006/03/remote-or-local-interface.html
*
* Note that the local and remote interfaces extend a common business interface.
* Also note that the local and remote interfaces are nested within the business
* interface. I like this model because it reduces the clutter, keeps related
* interfaces together, and eases understanding.
*
* When using dependency injection, you can specify explicitly whether you want
* the remote or local interface. For example:
* @EJB(beanInterface=services.DistrictService.IRemote.class)
* public final void setDistrictService(DistrictService districtService) {
* this.districtService = districtService;
* }
*/
public interface IGenericBean {
@Remote
public interface IRemote extends IGenericBean {
}
@Local
public interface ILocal extends IGenericBean {
}
/**
* Gets a list of beans containing data.
* Requires a table name and pair of beans containing the fields
* to return and the criteria to use.
*
* You can even use anonymous inner classes for the criteria.
* EX: new Object() { public String modelname=model,yearid=year; }
*
* @param tableName
* @param fields
* @param criteria
* @return
*/
public <DesiredFields> List<DesiredFields> getGenericEJBData(String tableName, DesiredFields desiredFields, Object beanCriteria);
}
Ejb実装がどのように見えるかを想像できます。現在、プリペアドステートメントを作成して呼び出していますが、基準、または休止状態などのよりクールなものを使用できます。
これは大まかな例です（一部の人はこの部分を気に入らないでしょう）。この例では、第3正規形のデータを含む単一のテーブルがあります。これが機能するには、Beanフィールドがテーブルの列名と一致している必要があります。 toLowerCase（）呼び出しは、これが使用されているREAL Beanの場合であり、名前の一致（MyFieldとgetMyfield）を台無しにします。この部分はおそらくかなり良く磨かれるでしょう。特に、明確な順序はフラグか何かでなければなりません。おそらく他のエッジ条件も発生する可能性があります。もちろん、私はこれを1回だけ書く必要があり、パフォーマンスのために、パフォーマンスのためにデータをはるかに正確に受信することを妨げるものは何もありません。
@Stateless
public class GenericBean implements ILocal, IRemote {
...
/* (non-Javadoc)
* @see com.aaa.ejb.acesvehicle.beans.interfaces.IAcesVehicleBean#getGenericEJBData(Java.lang.String, Java.util.Map, Java.util.Map)
*/
@Override
public List<Map<String, Object>> getGenericEJBData(String tableName,Map<String, Object> desiredFields, Map<String, Object> criteria){
try {
List<Map<String,Object>> dataFieldKeyValuePairs = new ArrayList<Map<String,Object>>();
StringBuilder sql = new StringBuilder("SELECT DISTINCT ");
int selectDistinctLength = sql.length();
for(Object key : desiredFields.keySet()){
if(desiredFields.get(key)!=null) {
sql.append(key).append(", ");
}
}
sql.setLength(sql.length()-2);//Remove last COMMA.
int fieldsLength = sql.length();
sql.append(" FROM ").append(tableName).append(" WHERE ");
String sep = "";//I like this, I like it a lot.
for(Object key : criteria.keySet()){
sql.append(sep);
sql.append(key).append(" = COALESCE(?,").append(key).append(") ");
sep = "AND ";
}
sql.append(" ORDER BY ").append(sql.substring(selectDistinctLength, fieldsLength));
PreparedStatement ps = connection.prepareStatement(sql.toString(), ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
int criteriaCounter=1;
for(Object key : criteria.keySet()){
ps.setObject(criteriaCounter++, criteria.get(key));
}
ResultSet rs = ps.executeQuery();
while (rs.next()) {
Map<String,Object> data = new HashMap<String,Object>();
int columnIndex = rs.getMetaData().getColumnCount();
for(int x=0;x<columnIndex;x++){
String columnName = rs.getMetaData().getColumnName(x+1);
if(desiredFields.keySet().contains(columnName.toLowerCase())){
//Handle bean getters and setters with different case than metadata case.
data.put(columnName.toLowerCase(), rs.getObject(x+1));
} else {
data.put(columnName, rs.getObject(x+1));
}
}
dataFieldKeyValuePairs.add(data);
}
rs.close();
ps.close();
return dataFieldKeyValuePairs;
} catch (SQLException sqle) {
LOG.debug("National database access failed.", sqle);
throw new EJBException(new DataSourceException("Database access failed. \n"
+ "getGenericEJBData()", sqle.getMessage()));
}
}