Java 动态性之反射

public class ReflectTest {

    private static void test() throws Exception {

        String path = "com.test.reflect.User";

        // 获取类信息的方式有三种，三种方式获取的类对象相同；clazz是以后操作的关键
        // 第一种方式
        Class clazz = Class.forName(path);
        // 第二种方式
        Class clazz1 = User.class;
        // 第三种方式
        User u = new User();
        Class clazz2 = u.getClass();

        System.out.println(clazz.hashCode());
        System.out.println(clazz1.hashCode());
        System.out.println(clazz2.hashCode());

        // 获取类名称包名+类名；
        String className = clazz.getName(); // clazz.getSimpleName();    // 只有类名

        // 获取clazz构造方法
        // 利用无参的构造方法创建对象user, 比较常用
        User user = (User) clazz.newInstance();
        user.setName("张三");
        // 获取有参的构造方法
        Constructor<User> constructor = clazz.getConstructor(new Class[]{int.class, String.class});
        // 根据获取的有参的构造方法创建一个对象
        User user2 = constructor.newInstance(1001, "李四");
        System.out.println(user.getName()+"---------"+user2.getName());


        // 对属性的操作
        // 这样只能获取public的属性
        Field[] fields = clazz.getFields();
        // 获取所有的属性  declared：公告的
        Field[] fields1 = clazz.getDeclaredFields();  
        // 根据属性的名字获取属性
        Field field = clazz.getDeclaredField("name");
        // 跳过检查，不然给私有变量赋值会报错，也会提高效率，建议使用
        field.setAccessible(true);
        field.set(user, "王五");
        System.out.println(user.getName());


        // 对方法的操作
        // 获取所有的公共方法
        Method[] methods = clazz.getMethods();
        // 获取所有的方法
        Method[] methods1 = clazz.getDeclaredMethods();
        // 根据指定的名字获取方法， public类型的方法
        Method method = clazz.getMethod("hello", String.class);
        // 跳过验证 ，提高效率
        method.setAccessible(true);
        Object result = method.invoke(user, "调用方法");
        System.out.println(result);
    }

    public static void main(String[] args) throws Exception {
        test();
    }
}

public class User {

    private int id;
    private String name;

    // 无参的构造方法，容易被忘记
    public User(){

    }

    //有参的构造方法
    public User(int id, String name){
        this.id = id;
        this.name = name;
    }

    // 类中一个普通的方法
    public String hello(String name){
        System.out.println("hello:"+ name);
        return "方法调用成功";
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class JavaBean {

    private String name;

    ...
}

public class Main {

    private static final Map<Class<?>, List<ReflectionMetadata>> METADATA = new HashMap<>();
    private static final Map<String, Class<?>> CLASSES = new HashMap<>();

    // 解析的时候尽量放在<cinit>里面
    static {
        Class<?> clazz = JavaBean.class;
        CLASSES.put(clazz.getName(), clazz);
        List<ReflectionMetadata> metadataList = new ArrayList<>();
        METADATA.put(clazz, metadataList);
        try {
            for (Field f : clazz.getDeclaredFields()) {
                ReflectionMetadata metadata = new ReflectionMetadata();
                metadataList.add(metadata);
                metadata.setTargetClass(clazz);
                metadata.setField(f);
                String name = f.getName();
                Class<?> type = f.getType();
                metadata.setReadMethod(clazz.getDeclaredMethod(String.format("get%s%s", Character.toUpperCase(name.charAt(0)), name.substring(1))));
                metadata.setWriteMethod(clazz.getDeclaredMethod(String.format("set%s%s", Character.toUpperCase(name.charAt(0)), name.substring(1)), type));
            }
        } catch (Exception e) {
            throw new IllegalStateException(e);
        }
    }

    public static void main(String[] args) throws Exception {
        String fieldName = "name";
        Class<JavaBean> javaBeanClass = JavaBean.class;
        JavaBean javaBean = new JavaBean();
        invokeSetter(javaBeanClass, javaBean, fieldName , "Doge");
        System.out.println(invokeGetter(javaBeanClass,javaBean, fieldName));
        invokeSetter(javaBeanClass.getName(), javaBean, fieldName , "Throwable");
        System.out.println(invokeGetter(javaBeanClass.getName(),javaBean, fieldName));
    }

    private static void invokeSetter(String className, Object target, String fieldName, Object value) throws Exception {
        METADATA.get(CLASSES.get(className)).forEach(each -> {
            Field field = each.getField();
            if (field.getName().equals(fieldName)) {
                try {
                    each.getWriteMethod().invoke(target, value);
                } catch (Exception e) {
                    throw new IllegalStateException(e);
                }
            }
        });
    }

    private static void invokeSetter(Class<?> clazz, Object target, String fieldName, Object value) throws Exception {
        METADATA.get(clazz).forEach(each -> {
            Field field = each.getField();
            if (field.getName().equals(fieldName)) {
                try {
                    each.getWriteMethod().invoke(target, value);
                } catch (Exception e) {
                    throw new IllegalStateException(e);
                }
            }
        });
    }

    private static Object invokeGetter(String className, Object target, String fieldName) throws Exception {
        for (ReflectionMetadata metadata : METADATA.get(CLASSES.get(className))) {
            if (metadata.getField().getName().equals(fieldName)) {
                return metadata.getReadMethod().invoke(target);
            }
        }
        throw new IllegalStateException();
    }

    private static Object invokeGetter(Class<?> clazz, Object target, String fieldName) throws Exception {
        for (ReflectionMetadata metadata : METADATA.get(clazz)) {
            if (metadata.getField().getName().equals(fieldName)) {
                return metadata.getReadMethod().invoke(target);
            }
        }
        throw new IllegalStateException();
    }

    private static class ReflectionMetadata {

        private Class<?> targetClass;
        private Field field;
        private Method readMethod;
        private Method writeMethod;

        ...
    }
}