Java反射笔记

Java反射机制是指在运行状态中，对于任意一个类，都知道这个类的所有属性和方法；对于任意一个对象，都能调用它的属性和方法，反射功能十分的强大，但是使用反射的成本比较高。

Sun公司提供的类:

• java.lang.Class:类的包
• java.lang.reflect.Constructor:构造器的包
• java.lang.reflect.Field:动态创建和访问属性的包
• java.lang.reflect.Method:动态创建和访问方法的包
• java.lang.reflect.Array:动态创建和访问数组的包
• java.lang.reflect.InvocationHandler:动态代理
• java.lang.reflect.Proxy:动态代理

反射的主要功能:

• 运行时判断任意对象所属的类
• 运行时构造任意一个类的对象
• 运行时判断任意一个类所具有的成员变量和方法
• 运行时调用任意一个对象的方法
• 生成动态代理

1.获取属于哪个类

//使用getClass()
Class c1 = user.getClass();
//使用Class.forName()
Class c2 = Class.forName("me.buhuan.reflect.User");
//使用.class
Class c3 = User.class;

2.获取类的信息

//获取类名
String c1Name = c1.getName();
//获取所有方法
Method[] methods = c1.getDeclaredMethods();
//获取指定的构造器
Method method = c1.getMethod("getName", User.class);
//获取所有属性
Field[] fields = c1.getDeclaredFields();
//获取指定的构造器
Field filed = user.getDeclaredField("name");
//获取所有的构造器
Constructor[] constructors = User.class.getDeclaredConstructors();

getDeclaredMethods()获取的是本类中的所有方法，getMethods()获取的是包括父类的所有的public方法。其他的getDeclared都是同一个道理。

3.构建对象

//使用Class.forName
Class.forName("me.buhuan.reflect.User").newInstance();
//使用默认构造器
Constructor constructor = User.class.getDeclaredConstructor();
constructor1.setAccessible(true);
constructor.newInstance();

使用Class.forName方法时需要被构造的对象有一个无参构造函数，不然会抛出异常。

4.动态执行

//被执行的方法
private String getName(String name) { return name + "1"; }

Class<User> user = User.class;
Method method = user.getDeclaredMethod("getName", String.class);
System.out.println(method.invoke(user.newInstance(), "test"));

调用getDeclaredMethod获取方法第一个参数为方法名，第二个参数为不定参数类型，invoke动态执行方法。

5.动态操作属性

Class userClass = User.Class;
Field filed = userClass.getDeclaredField("name");
User user = userClass.newInstance();
filed.setAccessible(true);
filed.set(user, "Test");
System.out.println(user1.getName());

直接给private属性赋值，打破了Java的封装。

6.动态代理

//被代理的接口
public interface Calculator {
    int add(int a, int b);
}

//接口具体被代理的类
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

//代理对象
public class LogHandler implements InvocationHandler {
    private Object obj;

    public LogHandler(Object obj) {
        this.obj = obj;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.doBefore();
        Object o = method.invoke(obj, args);
        this.doAfter();
        return o;
    }
    
    /**
     *前置增强 
     */
    public void doBefore() {
        System.out.println("do this before");
    }
    
    /**
     *后置增强 
     */
    public void doAfter() {
        System.out.println("do this after");
    }

    public static void main(String[] args) {
        Calculator calculator = new CalculatorImpl();
        LogHandler lh = new LogHandler(calculator);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(calculator.getClass().getClassLoader(),
                calculator.getClass().getInterfaces(), lh);
        proxy.add(1, 1);
    }
}

JDK提供了一种实现动态代理的方式，还有cglib也是实现动态代理的框架。

public class CglibProxy implements MethodInterceptor {

    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls, this);
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invoke(o, objects);
        after();
        return result;
    }

    public void before() {

    }

    public void after() {

    }

}