java中的meta-annotation

练习，根据对类的声明初始化对象，并根据输入初始化对应的属性

Info.java

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Info {
    String[] fields();
}

InitUtil.java

import java.lang.reflect.*;

public class InitUtil {
    
    public static <T> T initObj(Class<T> c, final Object... values) {
        String[] fl= c.getAnnotation(Info.class).fields();//use meta-annotation
        Field[] fs = c.getDeclaredFields();
        T obj = null;
        try {
            obj = c.newInstance();
            int index = 0;
            for (Field f : fs) {
                f.setAccessible(true);
                if(f.getName().equals(fl[index])) {
                    f.set(obj, values[index]);
                    index++;
                }
            }
        } catch (Exception e) {
            return null;
        } 
        return obj;
    }

}

Person.java

@Info(fields = {"name","age","gender"})
public class Person {

    private String name;
    private int age;
    private boolean gender;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public boolean getGender() {
        return gender;
    }
    public void setGender(boolean gender) {
        this.gender = gender;
    }
}

Test：

    public static void main(String[] args) {
        Person p;
        p=InitUtil.initObj(Person.class, "qwerty", 12, true);//call custom init
        System.out.println(p.getName()+p.getAge()+p.getGender());
    }

练习，根据对域的声明初始化对应域

InitAuto.java

import java.lang.annotation.*;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InitAuto {

}

InitUtil.java

import java.lang.reflect.*;

public class InitUtil {
    
    public static void initObj(Object o) {
        Class<?> c = o.getClass();
        Field[] fs = c.getDeclaredFields();
        for(Field f : fs) {
            if(f.isAnnotationPresent(InitAuto.class)) {//get field annotated by InitAuto
                f.setAccessible(true);
                try {
                    Class<?> cc = f.getType();
                    if(cc.getName().endsWith("Person")) {
                        Object obj = cc.newInstance();//init Person
                        Field ff = cc.getDeclaredField("name");
                        ff.setAccessible(true);
                        ff.set(obj, "test name");//set custom properties
                        f.set(o, obj);
                    } else {
                        //other type of field
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                //other type of annotation
            }
        }
    }
}

Person.java

same as above

Group.java

public class Group {
    @InitAuto
    private Person p1;
    @InitAuto
    private Object o1;
    
    public Person getP1() {
        return p1;
    }
    public Object getO1() {
        return o1;
    }
}

Test:

    public static void main(String[] args) {
        Group ps = new Group();
        InitUtil.initObj(ps);//真正实现的时候使用decorator模式
        System.out.println(ps.getP1().getName()+ps.getO1());
    }

 练习，根据注释调用方法

DataSource.java

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String source();
}

DataPattern.java

import java.lang.annotation.*;

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataPattern {
    String value() default "";//you can use DataPattern("...") if you declare value() property
}

 InitUtil.java

import java.lang.reflect.*;

public class InitUtil {
    
    public static void initMtd(Object o) {
        Class<?> c = o.getClass();
        Method[] ms = c.getDeclaredMethods();
        for(Method m : ms) {
            if(m.isAnnotationPresent(DataSource.class)) {
                m.setAccessible(true);
                
                //the first parameter is annotated to set the pattern
                DataPattern p = m.getParameters()[0].getAnnotation(DataPattern.class);
                String dataPattern = p.value();
                //the method is annotated to set the data source
                String dataSource = m.getAnnotation(DataSource.class).source();
                
                /*do something to listen to the data source*/
                
                try {
                    m.invoke(o, dataSource+"->"+dataPattern, 
                            new java.util.concurrent.ConcurrentHashMap<String,String>());
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }
        }
    }
}

 Action.java

public class Action {
    @DataSource(source = "page")
    public String excute(@DataPattern("data") String d , java.util.Map<String,String> m) {
        System.out.println(d);
        m.put("data", d+" in map");
        System.out.println(m.get("data"));
        return "";
    }
}

Test

    public static void main(String[] args) {    
        Action a = new Action();
        InitUtil.initMtd(a);
    }