JAVA动态代理

java的代理模式分为两种 静态代理和动态代理

静态代理

好比现实情况就是 租客他只需要找到中介就可以完成租房 而中介去跟房东探讨合同等一系列的事情,从而敲定房子的事情 现在来看代码是怎么实现这个思想的

Rent.java

可以把它理解为抽象房东 它的手里有房子 可以完成出租操作

package src.JdkProxy.StaticProxy;  
  
// 租房的接口  
public interface Rent {  
  
    public void rent();  
}

Host.java

host 实现了Rent的接口 ,相当于一个真实的房东了,要出租房子了

package src.JdkProxy.StaticProxy;  
  
public class Host implements Rent {  
  
    public void rent(){  
        System.out.println("房东要出租房子");  
 }  
}

Proxy.java

这个就是中介,它不需要去继承房东,而是通过租客传入房东类 在具体知道是哪个房东

package src.JdkProxy.StaticProxy;  
  
// 中介  
public class Proxy {  
  
    private Host host;  
  
 public Proxy(){}  
    public Proxy(Host host){  
        this.host = host;  
 }  
  
    public void rent(){  
        host.rent();  
 }  
}

Client.java

这个就是租客了

package src.JdkProxy.StaticProxy;  
  
// 启动器  
public class Client {  
    public static void main(String[] args) {  
        Host host = new Host();  
 Proxy proxy = new Proxy(host);  
 proxy.rent();  
 }  
}

这样就完成了一个简易的静态代理,我们来稍加完善一下

中介他肯定不只是出租房子,他还要带客户去看房子,然后收取中介费,这些都是跟房东无关的,属于中介的独立方法

改进后的proxy.java

package src.JdkProxy.StaticProxy;  
  
// 中介  
public class Proxy {  
  
    private Host host;  
  
 public Proxy(){}  
    public Proxy(Host host){  
        this.host = host;  
 }  
  
    public void rent(){  
        host.rent();  
 contract();  
 fare();  
 }  
  
    // 看房  
 public void seeHouse(){  
        System.out.println("中介带你看房");  
 }  
  
    // 收中介费  
 public void fare(){  
        System.out.println("收中介费");  
 }  
  
    // 签租赁合同  
 public void contract(){  
        System.out.println("签租赁合同");  
 }  
}

优点:

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
  • 公共的业务由代理来完成 . 实现了业务的分工 ,
  • 公共业务发生扩展时变得更加集中和方便 .

缺点 :

  • 一个真是类对应一个代理角色,代码量翻倍,开发效率降低 .

我们想要静态代理的好处,又不想要静态代理的缺点,所以 , 就有了动态代理 !

在proxy代理类中我们可以发现,在可以不用改变原始代码的情况下,就可以增加一些功能,所以在真实业务的情况下,代码量是很多的,动原始代码,很有可能会出问题,所以一般都是使用代理类去完成

动态代理

前文我们说到静态代理的问题,每多一个房东就需要多一个中介,这显然不符合生活认知(对于租客来说,如果是用静态代理模式,每当想要换一个房东,那就必须要再换一个中介,在开发中,如果有多个中介代码量就更大了)

动态代理的出现就是为了解决上面静态代理的缺点。

  • 动态代理的角色和静态代理的一样。需要一个实体类,一个代理类,一个启动器。
  • 动态代理的代理类是动态生成的,静态代理的代理类是我们提前写好的。

JDK的动态代理需要了解两个类

核心 : InvocationHandler 调用处理程序类和 Proxy 代理类

InvocationHandler:调用处理程序

JAVA

public interface InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口

每个代理实例都有一个关联的调用处理程序。

JAVA

Object invoke(Object proxy, 方法 method, Object[] args);

当在代理实例上调用方法的时候,方法调用将被编码并分派到其调用处理程序的invoke()方法。

参数

  • proxy – 调用该方法的代理实例
  • method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口,它可以是代理类继承该方法的代理接口的超级接口。
  • args -包含的方法调用传递代理实例的参数值的对象的阵列,或null如果接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中,例如java.lang.Integerjava.lang.Boolean

Proxy : 代理

JAVA

public class Proxy extends Object implements Serializable

Proxy提供了创建动态代理类和实例的静态方法,它也是由这些方法创建的所有动态代理类的超类。

动态代理类 (以下简称为代理类 )是一个实现在类创建时在运行时指定的接口列表的类,具有如下所述的行为。 代理接口是由代理类实现的接口。 代理实例是代理类的一个实例。

JAVA

public static Object newProxyInstance(ClassLoader loader, 类<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException

返回指定接口的代理类的实例,该接口将方法调用分派给指定的调用处理程序。

参数

  • loader – 类加载器来定义代理类
  • interfaces – 代理类实现的接口列表
  • h – 调度方法调用的调用处理函数
动态代理的代码实现
  • 要写动态代理的代码,需要抓牢两个要点

①:我们代理的是接口,而不是单个用户。
②:代理类是动态生成的,而非静态定死。

我只能说这种编程思想是真的牛逼,其实我们还可以实现任意接口的动态代理实现,在这里就不贴出来了。

首先是我们的接口类
UserService.java

JAVA

package src.JdkProxy.DynamicProxy;  
  
  
public interface UserService {  
    public void add();  
 public void delete();  
 public void update();  
 public void query();  
}

接着,我们需要用实体类去实现这个抽象类

UserServiceImpl.java

JAVA

package src.JdkProxy.DynamicProxy;  
  
public class UserServiceImpl implements UserService{  
    @Override  
 public void add() {  
        System.out.println("增加了一个用户");  
 }  
  
    @Override  
 public void delete() {  
        System.out.println("删除了一个用户");  
 }  
  
    @Override  
 public void update() {  
        System.out.println("更新了一个用户");  
 }  
  
    @Override  
 public void query() {  
        System.out.println("查询了一个用户");  
 }  
}

接着,是动态代理的实现类

JAVA

package src.JdkProxy.DynamicProxy;  
  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
public class UserProxyInvocationHandler implements InvocationHandler {  
  
    // 被代理的接口  
 private UserService userService;  
  
 public void setUserService(UserService userService) {  
        this.userService = userService;  
 }  
  
    // 动态生成代理类实例  
 public Object getProxy(){  
        Object obj = Proxy.newProxyInstance(this.getClass().getClassLoader(), userService.getClass().getInterfaces(), this);  
 return obj;  
 }  
  
    // 处理代理类实例,并返回结果  
 @Override  
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        log(method);  
 Object obj = method.invoke(userService, args);  
 return obj;  
 }  
  
    //业务自定义需求  
 public void log(Method method){  
        System.out.println("[Info] " + method.getName() + "方法被调用");  
 }  
}
  • 最后编写我们的 Client,也就是启动器

Client.java

JAVA

package src.JdkProxy.DynamicProxy;  
  
import src.JdkProxy.DynamicProxy.UserServiceImpl;  
  
public class Client {  
    public static void main(String[] args) {  
        // 真实角色  
 UserServiceImpl userServiceImpl = new UserServiceImpl();  
 // 代理角色,不存在  
 UserProxyInvocationHandler userProxyInvocationHandler = new UserProxyInvocationHandler();  
 userProxyInvocationHandler.setUserService((UserService) userServiceImpl); // 设置要代理的对象  
  
 // 动态生成代理类  
 UserService proxy = (UserService) userProxyInvocationHandler.getProxy();  
  
 proxy.add();  
 proxy.delete();  
 proxy.update();  
 proxy.query();  
 }  
}

在调用方法的时候,invoke方法会自动触发

在反序列化中动态代理的作用

我们先假设存在一个能够漏洞利用的类为 B.f,比如 Runtime.exec 这种。
我们将入口类定义为 A,我们最理想的情况是 A[O] -> O.f,那么我们将传进去的参数 O 替换为 B 即可。但是在实战的情况下这种情况是极少的。

回到实战情况,比如我们的入口类 A 存在 O.abc 这个方法,也就是 A[O] -> O.abc;而 O 呢,如果是一个动态代理类,Oinvoke 方法里存在 .f 的方法,便可以漏洞利用了

因为invoke方法也是会自动执行的,所以只有能对其进行恶意的拼接,就能进行漏洞利用

参考文献:

Java反序列化基础篇-04-JDK动态代理 | Drunkbaby’s Blog

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值