java动态代理学习

java动态代理学习

学习资料： Java反序列化漏洞专题-基础篇(21/09/05更新类加载部分)_哔哩哔哩_bilibili

首先有个接口IUser

package proxy;

//定义一个接口
public interface IUser {
    void show();
    void create();
    void update();
}

然后我们建一个类Userimpl去实现这个接口

package proxy;
//定义一个类去实现这个接口
public class Userimpl implements IUser {
    public Userimpl(){

    }

    @Override
    public void show() {
        System.out.println("调用了show()方法");
    }
    public void create() {
        System.out.println("调用了create方法");
    }
    public void update() {
        System.out.println("调用了update方法");
    }
 /*   public void execute(){
        method.invoke(user,args);
    }*/
}

直接调用

有类之后，我实例化一个对象，然后调用其中的方法

package proxy;

public class Test {
    public static void main(String[] args) {
        IUser user = new Userimpl();
        //调用Userimpl类的show()方法
        user.show();
    }
}

这是比较简单的方法，然后接下来我们通过别的类间接调用Userimpl中的方法

间接调用

首先来说间接调用，Userimpl是目标类，我们要创建一个间接类（跳板），用这个间接类去调用Userimpl中的方法

间接类UserProxy

调用链UserProxy-->Userimpl-->show()

package proxy;

public class UserProxy implements IUser {
    IUser user;
    public UserProxy(){

    }

    public UserProxy(IUser user){
        this.user = user;
    }

    @Override
    public void show() {
        user.show();
        System.out.println("在UserProxy中调用了show()方法");
    }
    public void create() {
        user.create();
        System.out.println("在UserProxy中调用了create方法");
    }
    public void update() {
        user.update();
        System.out.println("在UserProxy中调用了show()方法");
    }
}

创建好间接类之后，测试Test.java

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {
    public static void main(String[] args){
        IUser user = new Userimpl();
        //调用Userimpl类的show()方法
        //user.show();

        //静态代理
        //IUser是个接口
        //用代理，user可以直接调用show()方法，但是我们用代理去整
        IUser userproxy = new UserProxy(user);
        userproxy.show();
    }
}

回显

但是静态代理有个缺陷，就是如果我们的IUser接口中有很多类，那么其实现类Userimpl就要将这些方法都实现，并且我们的间接类UserProxy也要将这些方法一一实现，这就比较繁琐了

而动态代理可以解决这个问题

动态代理

调用链InvocationHandler-->Userimpl-->show()

动态代理需要用到一个接口：InvocationHandler

public interface InvocationHandler {

    
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

我们要实现这个接口，用UserInvocationHandler类去实现它

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//注意这里实现了InvocationHandler接口
public class UserInvocationHandler implements InvocationHandler {
    IUser user;
    public UserInvocationHandler(){

    }
    public UserInvocationHandler(IUser user){
        this.user = user;
    }
    //重写InvocationHandler接口的invoke方法
    //作用是  不管外部调用了什么，都会用这个invoke方法，将其作为method传进来
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        method.invoke(user,args);
        return null;
    }
}

然后开始运行ProxyTest.java

注意一个函数Proxy.newProxyInstance，跟进看一下

其需要三个参数，（类加载器，接口，InvocationHandler），前两个参数通过java反射可以得到，而后面这个InvocationHandler我们已经通过类去实现接口，并且实例化为b，传进去

package proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args){
        IUser user = new Userimpl();

        //动态代理，，当有多个方法需要使用的时候
        //需要Proxy类
        //传 接口，要做的事情，类加载器
        InvocationHandler a = new UserInvocationHandler(user);
        //下面这个返回值是个Object
        //下面这个的第二个参数可以是数组接口数组（new Class<?>[]{Iuser.class}），也可以是单个的接口
        IUser b = (IUser) Proxy.newProxyInstance(user.getClass().getClassLoader(),user.getClass().getInterfaces(),a);

        //然后调用show()方法
        //可以看到虽然我们的UserInvocationHandler类中没有定义这些方法，但是一个invoke方法就可以将其全部解决，这就是和静态代理的区别
        b.show();
        b.create();
    }
}

然后就可以通过b来进行调用，比如b.show()，b.create()

invoke

注意，这里我们的间接类UserInvocationHandler其实只实现了invoke()这一个方法（构造方法除外）

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    method.invoke(user,args);
    return null;
}

具体的细节不用深究，这个方法会将外部调用的方法的名字（比如show()），传入method，执行

最后的思考

为什么要这个动态代理？

比如我们需要调用B.f，入口类A，可以向A传进去Object，A[O]

当O是一个动态代理类的时候，O中有invoke方法，利用invoke的自动执行

O[B].invoke–>B.f

invoke当遇到外部调用的时候，就会自动执行

这个和反序列化的时候自动调用readObject用法差不多

学习链接

1. Java反序列化漏洞专题-基础篇(21/09/05更新类加载部分)_哔哩哔哩_bilibili

大佬讲得很好，建议看看原视频