JAVA安全|基础篇:反射的应用—动态代理 (qq.com)
Java反射和动态代理的区别(JDK Proxy和Cglib,常见面试题 (qq.com)
反射的正常使用
反射要调用类中的方法,需要通过关键方法“invoke()”实现的,方法调用也分为三种:
- 静态(static)方法调用
- 普通方法调用
- 私有方法调用
以下会分别演示,各种调用的实现代码,各种调用的公共代码部分,如下:
// 此段代码为公共代码
interface People {
int parentAge = 18;
public void sayHi(String name);
}
class PeopleImpl implements People {
private String privSex = "男";
public String race = "汉族";
@Override
public void sayHi(String name) {
System.out.println("hello," + name);
}
private void prvSayHi() {
System.out.println("prvSayHi~");
}
public static void getSex() {
System.out.println("18岁");
}
}
静态方法调用
// 核心代码(省略了抛出异常的声明)
public static void main(String[] args) {
Class myClass = Class.forName("example.PeopleImpl");
// 调用静态(static)方法
Method getSex = myClass.getMethod("getSex");
getSex.invoke(myClass);
}
静态方法的调用比较简单,使用 getMethod(xx) 获取到对应的方法,直接使用 invoke(xx)就可以了。
普通方法调用
普通非静态方法调用,需要先获取类示例,通过“newInstance()”方法获取,核心代码如下:
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method method = myClass.getMethod("sayHi",String.class);
method.invoke(object,"老王");
getMethod 获取方法,可以声明需要传递的参数的类型。
调用私有方法
调用私有方法,必须使用“getDeclaredMethod(xx)”获取本类所有什么的方法,代码如下:
Class myClass = Class.forName("example.PeopleImpl");
Object object = myClass.newInstance();
Method privSayHi = myClass.getDeclaredMethod("privSayHi");
privSayHi.setAccessible(true); // 修改访问限制
privSayHi.invoke(object);
除了“getDeclaredMethod(xx)”可以看出,调用私有方法的关键是设置 setAccessible(true) 属性,修改访问限制,这样设置之后就可以进行调用了。
总结
在反射中核心的方法是newInstance()获取类实例,getMethod(...)获取方法,使用invoke(...)进行方法调用,通过setAccessible修改访问私有变量/方法的限制
获取属性/方法的时候有无“Declared”的区别是,带有 Declared 修饰的方法或属性,可以获取本类的所有方法或属性(private 到 public),但不能获取到父类的任何信息;非 Declared 修饰的方法或属性,只能获取 public 修饰的方法或属性,并可以获取到父类的信息,比如 getMethod(..)和getDeclaredMethod(..)。
代理模式实例
代理模式,属于结构型模式。使用一个类代表另一个类的功能,在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。 比如生活中常见的中介与租房,租房者不需要直接与房东交互,房东把房屋租赁交给中介代理。代理模式的目的有:
(1)通过引入代理对象的方式来间接访问目标对象,防止直接访问目标对象给系统带来的不必要复杂性;
(2)通过代理对象对访问进行控制;
代理模式一般会有三个角色:
抽象角色:指代理角色和真实角色对外提供的公共方法,一般为一个接口
真实角色:需要实现抽象角色接口,定义了真实角色所要实现的业务逻辑,以便供代理角色调用。也就是真正的业务逻辑在此。
代理角色:需要实现抽象角色接口,是真实角色的代理,通过真实角色的业务逻辑方法来实现抽象方法,并可以附加自己的操作。将统一的流程控制都放到代理角色中处理!
实例如下:
首先,我们得有一个接口(比如ClothFactory,衣服工厂),有两个类(被代理类,比如NikeClothFactory;代理类,比如ProxyClothFactory)实现了这个接口,想通过代理类的方法调用到被代理类的同名方法,那么代理对象得将被代理对象包装起来。
怎么通过代码实现包装呢?代理对象中应有一个属性为被代理类对象,通过构造器传入,且在代理对象的方法中调用了被代理对象的同名方法,这样就实现了通过代理来调用原始对象。具体代码如下:
//共同接口
interface ClothFactory{
void produceCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产了一批运动服");
}
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory) {
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
测试代码:
//测试类
public class StaticProxyTest {
public static void main(String[] args) {
//创建被代理类的对象
ClothFactory nikeClothFactory = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);
//通过代理对象对被代理对象进行访问
proxyClothFactory.produceCloth();
}
}
运行结果:
代理工厂做一些准备工作
Nike工厂生产了一批运动服
代理工厂做一些后续的收尾工作
动态代理是一种方便运行时动态构建代理,动态处理代理方法调用的机制,很多场景都是利用类似机制做到的,比如用来包装RPC调用、面向切面的编程(AOP)。
实现动态代理的方式很多,比如利用JDK自身提供的动态代理,就是主要利用了上面提到的反射机制。还有其他的实现方式,比如利用传说中更高性能的字节码操作机制,类似ASM、cglib(基于ASM)等。
JDK Proxy 动态代理
JDK Proxy 是通过实现 InvocationHandler 接口来实现的,代码如下:
interface Animal {
void eat();
}
class Dog implements Animal {
@Override
public void eat() {
System.out.println("The dog is eating");
}
}
class Cat implements Animal {
@Override
public void eat() {
System.out.println("The cat is eating");
}
}
// JDK 代理类
class AnimalProxy implements InvocationHandler {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
// 取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("调用前");
Object result = method.invoke(target, args); // 方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// JDK 动态代理调用
AnimalProxy proxy = new AnimalProxy();
Animal dogProxy = (Animal) proxy.getInstance(new Dog());
dogProxy.eat();
}
如上代码,我们实现了通过动态代理,在所有请求之前和之后打印了一个简单的信息。
注意: JDK Proxy 只能代理实现接口的类(即使是extends继承类也是不可以代理的)。
JDK Proxy 为什么只能代理实现接口的类?
这个问题要从动态代理的实现方法 newProxyInstance 源码说起:
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 省略其他代码
来看前两个源码参数说明
* @param loader the class loader to define the proxy class
* @param interfaces the list of interfaces for the proxy class to implement
- loader:为类加载器,也就是 target.getClass().getClassLoader()
- interfaces:接口代理类的接口实现列表
所以这个问题的源头,在于 JDK Proxy 的源码设计。如果要执意动态代理,非接口实现类就会报错:
Exception in thread "main" java.lang.ClassCastException: com.sun.proxy.$Proxy0 cannot be cast to xxx
Cglib 动态代理
JDK 动态代理机制只能代理实现了接口的类,Cglib 是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对 final 修饰的类进行代理。
Cglib 可以通过 Maven 直接进行版本引用,Maven 版本地址:https://mvnrepository.com/artifact/cglib/cglib
本文使用的是最新版本 3.2.9 的 Cglib,在 pom.xml 添加如下引用:
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.9</version>
</dependency>
Cglib 代码实现,如下:
class Panda {
public void eat() {
System.out.println("The panda is eating");
}
}
class CglibProxy implements MethodInterceptor {
private Object target; // 代理对象
public Object getInstance(Object target) {
this.target = target;
Enhancer enhancer = new Enhancer();
// 设置父类为实例类
enhancer.setSuperclass(this.target.getClass());
// 回调方法
enhancer.setCallback(this);
// 创建代理对象
return enhancer.create();
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用前");
Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
System.out.println("调用后");
return result;
}
}
public static void main(String[] args) {
// CGLIB 动态代理调用
CglibProxy proxy = new CglibProxy();
Panda panda = (Panda)proxy.getInstance(new Panda());
panda.eat();
}
cglib 的调用通过实现 MethodInterceptor 接口的 intercept 方法,调用 invokeSuper 进行动态代理的,可以直接对普通类进行动态代理。
JDK VS. cjlib
JDK动态代理:利用反射机制生成代理类,可以动态指定代理类的目标类,要求实现invovationHandler接口,重写invoke方法进行功能增强,还要求目标类必须实现接口。
Cjlib动态代理:利用ASM开源包,把代理对象的Class文件加载进来,修改其字节码文件生成子类,子类重写目标类的方法,被final修饰的话就不可以,然后在子类采用方法拦截技术拦截父类方法调用,织入逻辑(定义拦截器实现MethodInterceptor接口)
JDK Proxy 的优势:
- 最小化依赖关系,减少依赖意味着简化开发和维护,JDK 本身的支持,更加可靠;
- 平滑进行 JDK 版本升级,而字节码类库通常需要进行更新以保证在新版上能够使用;
Cglib 框架的优势:
- 可调用普通类,不需要实现接口;
- 基于ASM,高性能;