什么是代理？

我们不直接访问某个对象，而是通过代理对象去访问某个对象，并且可以对功能进行拓展，有个设计模式就叫做代理模式

image-20240112091741429

静态代理

我们会有一个代理类来替代 Cook类 访问方法

静态代理可以在不修改目标对象的功能前提下, 能通过代理对象对目标功能扩展；静态代理的不足在于只能对某一个方法拓展，如果实体类增加了方法，需要修改代理类的代码。

  • 组合方式：必须实现接口中的所有方法
  • 继承方式：可以只重写需要增强的方法，但是只有单继承，需要父类不能被final修饰

组合方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ProxyCook implements Cook{
    Cook cook;

    public ProxyCook(Cook cook) {
        this.cook = cook;
    }

    @Override
    public void cookDinner() {
        System.out.println("厨师前置动作...");
        cook.cookDinner();
        System.out.println("厨师后置动作...");
    }
}

继承方式

1
2
3
4
5
6
7
8
9
public class ProxyCook extends CookImpl{

    @Override
    public void cookDinner() {
        System.out.println("厨师前置动作...");
        super.cookDinner();
        System.out.println("厨师后置动作...");
    }
}

动态代理

有两个方法实现动态代理，一个是JDK自带的，一个是Cglib的代理方法

JDK代理的代理对象是利用反射机制动态生成，而Cglib的代理对象是利用拦截机制动态生成。

JDK自带的（要求被代理对象至少实现一个接口）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class ProxyJDK implements InvocationHandler {

    // 被代理的对象
    Object proxyTarget;

    public Object getProxyInstance(Object target) {
        this.proxyTarget = 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 obj = method.invoke(proxyTarget, args);
        System.out.println("厨师后置动作...");
        return obj;
    }
}

Cglib的代理方法（被代理对象可以不实现接口）

1
2
3
4
5
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ProxyCglib implements MethodInterceptor {

    // 被代理对象
    Object proxyTarget;

    public Object getProxyInstance(Object target) {
        this.proxyTarget = target;
        return Enhancer.create(target.getClass(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("厨师前置动作Cglib...");
        // 反射调用真正的方法
        Object obj = method.invoke(proxyTarget, args);
        // Object obj = methodProxy.invokeSuper(proxy, args);
        System.out.println("厨师后置动作Cglib...");
        return obj;
    }
}

静态代理和动态代理的区别？

静态代理被代理对象和代理对象之间的关系在编译期就已经确定；动态代理被代理对象和代理对象之间的关系要在运行期（比如通过反射这样的机制）才能确定

如果你需要对多个方法进行相同的拓展，动态代理是更好的选择，减少大量相似的代码同时减少了代理类的数量

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ProxyTest {

    public static void main(String[] args) {
        System.out.println("正常调用");
        Cook cook = new CookImpl();
        cook.cookDinner();

        System.out.println();

        System.out.println("静态代理");
        ProxyCook proxyCook = new ProxyCook(cook);
        proxyCook.cookDinner();

        System.out.println();

        System.out.println("JDK动态代理");
        Cook proxyJDK = (Cook) new ProxyJDK().getProxyInstance(cook);
        proxyJDK.cookDinner();

        System.out.println();

        System.out.println("Cglib动态代理");
        Cook proxyCglib = (Cook) new ProxyCglib().getProxyInstance(cook);
        proxyCglib.cookDinner();
    }
}