Java反射机制总结

public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //方式一(通过Class.forName的方式，括号中是包名.类名)常用
        Class clazz1 = Class.forName("xx.ReflectDemo1");
        //方式二(类名.class)
        Class clazz2 = ReflectDemo1.class;
        //方式三(创建类的实例对象，再通过getClass的方式)
        ReflectDemo1 ref = new ReflectDemo1();
        Class clazz3 = ref.getClass();
        
        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz2 == clazz3);//true,三个字节码对象是同一个字节码对象
    }
}

public class ReflectDemo2 {
    private String name;
    public ReflectDemo2(String name) {
        super();
        this.name = name;
    }
    @Override
    public String toString() {
        return "[name=" + name + "]";
    }
    public void method1(){
        System.out.println("你好啊");
    }
    public void method2(String name){
        System.out.println("hello"+name);
    }

    public static void main(String[] args) throws Exception {
        //通过反射获取有参构造,并通过有参构造创建对象
        Class clazz = Class.forName("course9.ReflectDemo2");
        Constructor c = clazz.getConstructor(String.class);
        ReflectDemo2 ref = (ReflectDemo2) c.newInstance("zx");
        System.out.println(ref);
        //通过反射获取成员变量并使用
        Field f = clazz.getDeclaredField("name");//获取姓名字段（暴力反射获取，即使是私有变量）
        f.setAccessible(true);//设置去除私有权限
        f.set(ref, "ls");
        System.out.println(ref);
        
        //通过反射获取方法并使用
        Method m1 = clazz.getMethod("method1");
        Method m2 = clazz.getMethod("method2",String.class);
        m1.invoke(ref);
        m2.invoke(ref,"张三");
        
    }
}

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        //使用反射越过泛型的检查
        ArrayList<Integer> list = new ArrayList<>();//创建一个存放整型的链表
        list.add(11);
        list.add(22);
        Class clazz = Class.forName("java.util.ArrayList");//获取java.util.ArrayList类的字节码对象
        Method m = clazz.getMethod("add", Object.class);//获取其中的add方法
        m.invoke(list, "abc");//链表中添加字符串
        System.out.println(list);
    }
}

public class ReflectDemo4 implements User{
    public static void main(String[] args) {
        ReflectDemo4 ref = new ReflectDemo4();
        ref.add();
        ref.delete();
        MyInvocationHandler m = new MyInvocationHandler(ref);//创建动态代理类(放入需要代理的对象)
        User user = (User) Proxy.newProxyInstance(ref.getClass().getClassLoader(), ref.getClass().getInterfaces(), m);//获取类加载器和接口
        
        System.out.println("-----------------------");
        user.add();
        user.delete();
    }
    @Override
    public void add() {
        System.out.println("添加功能");
    }
    @Override
    public void delete() {
        System.out.println("删除功能");
    }
}
interface User{
    public void add();
    public void delete(); 
}

//动态代理类
class MyInvocationHandler implements InvocationHandler{
    private Object target;
    public MyInvocationHandler(Object target) {
        super();
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("权限校验");
        method.invoke(target, args);//执行被代理target对象的方法
        System.out.println("日志记录");
        return null;
    }
    
}