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