反射
反射的官方定义是这样的:
在运行状态中,对于任意的一个类,都能够知道这个类的所有属性和方法,对任意一个对象都能够通过反射机制调用一个类的任意方法,这种动态获取类信息及动态调用类对象方法的功能称为java的反射机制。
一般创建类的方式:
Car car = new Car(); car.setName("宝马");
而反射则是一开始并不知道我要初始化的类对象是什么,自然也无法使用 new 关键字来创建对象了。这时候,我们使用 JDK 提供的反射 API 进行反射调用:
Class clz = Class.forName("Car"); Method method = clz.getMethod("setName", String.class); Constructor constructor = clz.getConstructor(); Object object = constructor.newInstance(); method.invoke(object, "宝马");
jdk提供了三种方式获取一个对象的Class,就Car car来说
1.car.getClass(),这个是Object类里面的方法
2.Car.Class属性,任何的数据类型,基本数据类型或者抽象数据类型,都可以通过这种方式获取类
3.Class.forName(""),Class类提供了这样一个方法,让我们通过类名来获取到对象类
这三种方法用的最多的就是第三种,那么获取到类之后,Class类提供了很多获取类属性,方法,构造方法的api。
通过反射创建类对象主要有两种方式:通过 Class 对象的 newInstance() 方法、通过 Constructor 对象的 newInstance() 方法。
第一种:通过 Class 对象的 newInstance() 方法。
Class clz = Car.class; Car car = (Car)clz.newInstance();
第二种:通过 Constructor 对象的 newInstance() 方法
Class clz = Car.class; Constructor constructor = clz.getConstructor(); Car car = (Car)constructor.newInstance();
通过 Constructor 对象创建类对象可以选择特定构造方法,而通过 Class 对象则只能使用默认的无参数构造方法。下面的代码就调用了一个有参数的构造方法进行了类对象的初始化。
Class clz = Car.class; Constructor constructor = clz.getConstructor(String.class); Car car = (Car) constructor.newInstance("宝马");
通过反射获取类属性、方法、构造器:
getDeclaredMethods() 获取所有的方法
getReturnType() 获得方法的放回类型
getParameterTypes() 获得方法的传入参数类型
getDeclaredMethod("方法名",参数类型.class,……) 获得特定的方法
getDeclaredConstructors() 获取所有的构造方法
getDeclaredConstructor(参数类型.class,……) 获取特定的构造方法
getSuperclass() 获取某类的父类
getInterfaces() 获取某类实现的接口
getFields():获得某个类的所有的公共(public)的字段,包括父类中的字段。
getDeclaredFields():获得某个类的所有声明的字段,即包括public、private和proteced,但是不包括父类的申明字段。
同样类似的还有getConstructors()和getDeclaredConstructors()、getMethods()和getDeclaredMethods(),这两者分别表示获取某个类的方法、构造函数。
一般情况下,我们并不能对类的私有字段进行操作,利用反射也不例外,但有的时候,例如要序列化的时候,我们又必须有能力去处理这些字段,这时候,我们就需要调用AccessibleObject上的setAccessible()方法来允许这种访问,而由于反射类中的Field,Method和Constructor继承自AccessibleObject,因此,通过在这些类上调用setAccessible()方法,我们可以实现对这些字段的操作。
例子:
Car.java
public class Car { private String name; public Car(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
如果在Car.java内部创建mian方法测试的时候,是不会报异常的。
TestReflect.java
import java.lang.reflect.Field; public class TestReflect { public static void main(String[] args) throws Exception { Car car = new Car("宝马"); Class clz = Car.class; Field name = clz.getDeclaredField("name"); // name.setAccessible(true); System.out.println(name.get(car));//获取当前对象中当前Field的value } }
测试报异常:
Exception in thread "main" java.lang.IllegalAccessException: Class TestReflect can not access a member of class Car with modifiers "private" at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102) at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296) at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288) at java.lang.reflect.Field.get(Field.java:390) at TestReflect.main(TestReflect.java:9)
取消注释后正常
动态代理
代理模式的定义:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。而代理模式又分为静态代理和动态代理。
静态代理通俗点将就是自己手写一个代理类,而动态代理则不用我们手写,而是依赖于java反射机制。
Subject.java
public interface Subject { void doSomething(); }
RealSubject.java
public class RealSubject implements Subject { @Override public void doSomething() { System.out.println("doSomething"); } }
ProxyObject.java
public class ProxyObject implements Subject { @Override public void doSomething() { System.out.println("proxy Subject"); new RealSubject().doSomething(); } public static void main(String[] args) { new ProxyObject().doSomething(); } }
ProxyObject就是RealSubject的静态代理类,代替了RealSubject完成doSomething的工作。
Java中动态代理的实现,关键就是这两个东西:Proxy、InvocationHandler
ProxyHandler.java
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class ProxyHandler implements InvocationHandler { private Object realObject = null; public ProxyHandler(Object proxied) { this.realObject = proxied; } public Subject getProxy() { return (Subject) Proxy.newProxyInstance(realObject.getClass().getClassLoader(), realObject.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("before invoke"); return method.invoke(realObject, args); } public static void main(String[] args) { ProxyHandler proxyHandler = new ProxyHandler(new RealSubject()); Subject subject = proxyHandler.getProxy(); subject.doSomething(); } }
动态代理,必须先实现这个InvocationHandler接口,然后通过Proxy生成一个代理对象。
方法里面有一个Proxy类,这个Proxy类提供了很多方法,这里我们用的是newProxyInstance方法,它有三个参数,第一个是被代理类的类构造器,第二个指的是被代理类的接口,也就是Subject接口,第三个是实现这个代理的类,这里就是本类。具体的来说,这个方法执行了下面三步:
1.生成一个实现了参数interfaces里所有接口且继承了Proxy的代理类的字节码,然后用参数里的classLoader加载这个代理类。
2.使用代理类父类的构造函数 Proxy(InvocationHandler h)来创造一个代理类的实例,将我们自定义的InvocationHandler的子类传入。
3.返回这个代理类实例,因为我们构造的代理类实现了interfaces(也就是我们程序中传入的realObject.getClass().getInterfaces())里的所有接口,因此返回的代理类可以强转成Subject类型来调用接口中定义的方法。
可以添加打印生成的代理对象的相关信息已方便分析:
新的ProxyHandler.java
import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class ProxyHandler implements InvocationHandler { private Object realObject = null; public ProxyHandler(Object proxied) { this.realObject = proxied; } public Subject getProxy() { return (Subject) Proxy.newProxyInstance(realObject.getClass().getClassLoader(), realObject.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("before invoke"); return method.invoke(realObject, args); } public static void main(String[] args) { ProxyHandler proxyHandler = new ProxyHandler(new RealSubject()); Subject subject = proxyHandler.getProxy(); //这里可以通过运行结果证明subject是Proxy的一个实例,这个实例实现了Subject接口 System.out.println(subject instanceof Proxy); //这里可以看出subject的Class类是$Proxy0,这个$Proxy0类继承了Proxy,实现了Subject接口 System.out.println("subject的Class类是:" + subject.getClass().toString()); System.out.print("subject中的属性有:"); Field[] field = subject.getClass().getDeclaredFields(); for (Field f : field) { System.out.print(f.getName() + ", "); } System.out.print(" " + "subject中的方法有:"); Method[] method = subject.getClass().getDeclaredMethods(); for (Method m : method) { System.out.print(m.getName() + ", "); } System.out.print(" " + "subject的父类是:" + subject.getClass().getSuperclass()); System.out.print(" " + "subject实现的接口是:"); Class<?>[] interfaces = subject.getClass().getInterfaces(); for (Class<?> i : interfaces) { System.out.print(i.getName() + ", "); } System.out.println(" " + "运行结果为:"); subject.doSomething(); } }
运行得到结果:
true subject的Class类是:class com.sun.proxy.$Proxy0 subject中的属性有:m1, m3, m2, m0, subject中的方法有:equals, toString, hashCode, doSomething, subject的父类是:class java.lang.reflect.Proxy subject实现的接口是:Subject, 运行结果为: before invoke doSomething
分析Proxy类源代码
newProxyInstance方法功能:
(1)根据参数loader和interfaces调用方法 getProxyClass(loader, interfaces)创建代理类$Proxy0.$Proxy0类 实现了interfaces的接口,并继承了Proxy类.
(2)实例化$Proxy0并在构造方法中把DynamicSubject传过去,接着$Proxy0调用父类Proxy的构造器,为h赋值,如下
protected Proxy(InvocationHandler h) { Objects.requireNonNull(h); this.h = h; }
为了分析$Proxy0,可以生成 Proxy0的class文件,然后反编译出代码。
生成class文件的函数:
public static void getProxy0Code() { byte[] classFile = ProxyGenerator.generateProxyClass("Proxy0", Subject.class.getInterfaces()); try { File file = new File("Proxy0.class"); FileOutputStream fos = new FileOutputStream(file); fos.write(classFile); fos.flush(); fos.close(); } catch (IOException e) { e.printStackTrace(); } finally { } }
通过jd-gui反编译出源代码
来看一下这个继承了Proxy的$Proxy0的源代码:
import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class Proxy0 extends Proxy implements Subject { private static Method m1; private static Method m3; private static Method m2; private static Method m0; public Proxy0(InvocationHandler paramInvocationHandler) { super(paramInvocationHandler); } public final boolean equals(Object paramObject) { try { return ((Boolean) this.h.invoke(this, m1, new Object[]{paramObject})).booleanValue(); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final void doSomething() { try { this.h.invoke(this, m3, null); return; } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String toString() { try { return (String) this.h.invoke(this, m2, null); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final int hashCode() { try { return ((Integer) this.h.invoke(this, m0, null)).intValue(); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")}); m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } } }
接着把得到的$Proxy0实例强制转换成Subject,并将引用赋给subject。当执行subject.doSomething()方法时,就调用 了$Proxy0类中的doSomething()方法,进而调用父类Proxy中的h的invoke()方法.即 InvocationHandler.invoke()。
newProxyInstance生成代理对象的详细分析过程参考
如果不是继承接口的类可以用cglib来实现代理,cglib提供更加丰富的功能,比如可以提供多个callback,在根据设置的filter选择合适的代理实现。
当然首先要引入cglib包
<dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency>
定义正式的业务类
public class RealSubject { public void doSomething() { System.out.println("doSomething"); } }
定义代理类
public class ProxyHandler implements MethodInterceptor { public Object getInstance(Class<?> target) { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(target); // 设置回调方法 enhancer.setCallback(this); // 创建代理对象 return enhancer.create(); } @Override public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable { System.out.println("Before Method Invoke"); proxy.invokeSuper(object, objects); System.out.println("After Method Invoke"); return object; } public static void main(String[] args) { ProxyHandler proxyHandler = new ProxyHandler(); RealSubject instance = (RealSubject) proxyHandler.getInstance(RealSubject.class); instance.doSomething(); } }
查看生成的代理对象
如果想查看生成代理对象的源码,可以在创建对象前添加
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://class");
这样就会在指定的目录生成对应包的类
运行结果:
当有断点的时候会打印多次,而且次数还不一样,可能是IDA有些什么处理吧。