问设计-在执行每个方法之前检查一个条件

EN

@Aspect
class ClassName {
...

@PointCut("call(public void ClassName.*(..))") //includes all void methods of ClassName object 
public void myPointCut(){}

@Around("myPointCut()")
public void myLogicMethod(ProceedingJoinPoint thisJoinPoint) {

    if(shouldGetExecuted1(context.getXXX())){
        thisJoinPoint.proceed()
    }
}
}

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class X {

    public static void main(String[] args) {

        for (int i = 0; i < 100; i++) {

            Method shouldGetExecuted = X.class.getMethod("shouldGetExecuted" + i, String.class);
            boolean b = (boolean) shouldGetExecuted.invoke(null, context.getXXX());
            if (b) {
                Method tranformDataForField = X.class.getMethod("tranformDataForField");
                Field data = X.class.getField("availableData" + i); 
                Object result = tranformDataForField.invoke(null, data.get(null));
                Method set = X.class.getMethod("setField" + i, TransformDataType.class);
                set.invoke(null, result);
            }
        }
    }

}

public class Document {
    private String name;
    private int size;

    @Override
    public String toString() {
        return "Document [name=" + name + ", size=" + size + "]";
    }
}

public class Transformer {
    public enum ContextType {
        NAME, SIZE
    }

    public boolean shouldTransformName(Set<ContextType> context) {
        return context.contains(ContextType.NAME);
    }

    public boolean shouldTransformSize(Set<ContextType> context) {
        return context.contains(ContextType.SIZE);
    }

    public String transformName(String name) {
        return "::" + name;
    }

    public int transformSize(int size) {
        return size + 1;
    }
}

public class DataProvider {
    private final String name;
    private final int size;

    public DataProvider(String name, int size) {
        this.name = name;
        this.size = size;
    }

    public String findName() {
        return name;
    }

    public int findSize() {
        return size;
    }
}

public class Main {

    private static final String TRANSFORM_METHOD_PREFIX = "transform";
    private static final String CHECK_METHOD_PREFIX = "shouldTransform";
    private static final String DATAPROVIDER_METHOD_PREFIX = "find";

    private final DataProvider dataProvider;
    private final Transformer transformer;

    public Main(DataProvider dataProvider, Transformer transformer) {
        this.dataProvider = dataProvider;
        this.transformer = transformer;
    }

    public Document transformFields(Set<ContextType> context)
            throws ReflectiveOperationException {
        Document document = new Document();

        for (Field field : Document.class.getDeclaredFields()) {

            String capitalizedfieldName = capitalize(field.getName());
            Class<?> fieldType = field.getType();

            if (shouldTransform(context, capitalizedfieldName)) {

                Object data = findData(capitalizedfieldName);
                Object transformed = transformData(capitalizedfieldName,
                        fieldType, data);

                // in presence of a security manager, a reflective call of the
                // setter could be performed
                field.setAccessible(true);
                field.set(document, transformed);
            }
        }

        return document;
    }

    private Object transformData(String capitalizedfieldName,
            Class<?> fieldType, Object data)
            throws ReflectiveOperationException {

        String methodName = TRANSFORM_METHOD_PREFIX + capitalizedfieldName;
        Method method = Transformer.class.getMethod(methodName, fieldType);
        return method.invoke(transformer, data);
    }

    private Object findData(String capitalizedfieldName)
            throws ReflectiveOperationException {

        String methodName = DATAPROVIDER_METHOD_PREFIX + capitalizedfieldName;
        Method method = DataProvider.class.getMethod(methodName);
        return method.invoke(dataProvider);
    }

    private boolean shouldTransform(Set<ContextType> context,
            String capitalizedfieldName) throws ReflectiveOperationException {

        String methodName = CHECK_METHOD_PREFIX + capitalizedfieldName;
        Method method = Transformer.class.getMethod(methodName, Set.class);
        return (Boolean) method.invoke(transformer, context);
    }

    private String capitalize(String fieldName) {
        char upperCaseFirstChar = Character.toUpperCase(fieldName.charAt(0));

        if (fieldName.length() > 1) {
            return upperCaseFirstChar + fieldName.substring(1);
        } else {
            return Character.toString(upperCaseFirstChar);
        }
    }

    public static void main(String[] args) throws ReflectiveOperationException {
        DataProvider dataProvider = new DataProvider("sample", 1);
        Set<ContextType> context = EnumSet.of(ContextType.NAME,
                ContextType.SIZE);

        Main main = new Main(dataProvider, new Transformer());
        Document document = main.transformFields(context);

        System.out.println(document);
    }
}