java - Java 中匿名内部类的替代方案

Question

鉴于下面的实体 - 是否可以以某种方式避免使用由 /***** 标记的匿名内部类摆脱这个匿名内部类 ******/。 问题是“SomeEntity”可以包含数百个字段，并且有多个实现此接口(interface)的类，每个类都需要元信息。这意味着开始生成数千个匿名内部类，导致我的构建时间非常非常慢，并且当类加载器加载所有类时，系统的启动时间非常慢。

我无法使用反射，因为我的类在发布之前就被混淆了

public interface SomeEntity {

    ///// boolean someField
    // getter
    void someField(boolean someField);

    // setter
    boolean someField();

    final static String someField = "someField";

    ///// boolean someField2
    // getter
    void someField2(int someField2);

    // setter
    int someField2();

    final static String someField2 = "someField2";

}


public class SomeEntityImpl implements SomeEntity {
    boolean someField = false;
    int someField2 = 0;

    @Override
    public void someField(boolean someField) {
        this.someField = someField;
    }

    @Override
    public boolean someField() {
        return this.someField;
    }

    @Override
    public void someField2(int someField2) {
        this.someField2 = someField2;
    }

    @Override
    public int someField2() {
        return someField2;
    }
}


public class SomeEntityMeta {

    public static interface Meta<T> {
        T get(SomeEntity x);
        void set(SomeEntity x, T t);
        void copy(SomeEntity from, SomeEntity to);
    }

    Meta<Boolean> metaForSomeField = new Meta<Boolean>() {

        @Override
        public Boolean get(SomeEntity x) {
            return x.someField();
        }

        @Override
        public void set(SomeEntity someEntity, Boolean newFieldValue) {
            someEntity.someField(newFieldValue);
        }

        @Override
        public void copy(SomeEntity from, SomeEntity to) {
            to.someField(from.someField());
        }

    };
    Meta<Integer> metaForSomeField2 = new Meta<Integer>() {

        @Override
        public Integer get(SomeEntity someField2) {
            return someField2.someField2();
        }

        @Override
        public void set(SomeEntity someEntity, Integer newFieldValue) {
            someEntity.someField2(newFieldValue);
        }

        @Override
        public void copy(SomeEntity from, SomeEntity to) {
            to.someField2(from.someField2());
        }

    };

    Map<String, Meta<?>> metaMapForAllFields = new HashMap<String, Meta<?>>() {
        private static final long serialVersionUID = 1L;
        {
            put(SomeEntity.someField, metaForSomeField);
            put(SomeEntity.someField2, metaForSomeField2);
        }
    };

}    
    // used as follows:


        public final static void main(String[] args) {
            SomeEntity someEntity = new SomeEntityImpl();
            SomeEntityMeta entityMeta = new SomeEntityMeta();
            /// 
            Map<String, Object> fieldNameValueMap = getFieldNameValueMapFromExternalsSystem();

            for ( Entry<String, Object> fieldNameValueEntry : fieldNameValueMap.entrySet()) {
                Meta<Object> meta = (Meta<Object>) entityMeta.metaMapForAllFields.get(fieldNameValueEntry.getKey());
                meta.set(someEntity, fieldNameValueEntry.getValue());
            }
        }   

Answer 1

我建议将 SomeEntity 制作为简单对象的组合，这样就不再需要您的小元类。

(很快就会有人提到反射或JavaBeans，我建议先尝试解决设计问题。)