×

Java反射笔记

96
黄步欢
2017.05.16 21:57* 字数 446

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() {

    }

}
Java
Web note ad 1