0%

静态代理与动态代理

发表于 分类于
本文是对java的动态代理以及静态代理的一些总结

静态代理

静态代理存在一些缺点，如每当要代理的方法越多，那你需要代理的方法也越多，这样可能会有很多的重复
下面我们先实现以下静态代理的例子

先创建一个接口

1
2
3
public interface Subject {
    void request();
}

创建一个实现类

1
2
3
4
5
6
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("This is request");
    }
}

创建一个静态代理类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ProxySubject implements Subject {

    private RealSubject realSubject;

    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("before");
        try {
            realSubject.request();
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }finally {
            System.out.println("after");
        }
    }
}

调用静态代理类

1
2
3
4
5
6
public class Client {
    public static void main(String[] args) {
        Subject subject = new ProxySubject(new RealSubject());
        subject.request();
    }
}

假设我们这个时候在Subject接口中新建一个hello()方法，这个时候我们需要重写RealSubject以及ProxySubject这两个类，这是很不方便的，下面让我们看一下动态代理如何实现的

JDK与Cglib代理对比

  • JDK只能针对有接口的类的接口方法进行动态代理
  • Cglib基于继承来实现代理,无法对static、final类进行代理
  • Cglib基于继承来实现代理,无法对private、static方法进行代理

动态代理

动态代理有两类实现：基于接口的代理和基于继承的代理，而这两类的代表分别为JDK代理和Cglib代理，下面我们来演示一下基于JDK的动态代理

而对于JDK动态代理的实现要点有以下三个

  1. 通过java.lang.reflect.Proxy类动态生成代理类
  2. 实现InvocationHandler这个几口
  3. JDK代理只能基于接口的动态代理

首先我们创建一个JDK代理类去实现InvocationHandler这个接口，然后重写里面的invoke方法，然后利用反射动态去反射方法

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

    private RealSubject realSubject;

    public JDKProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("proxy before");
        Object result = null;
        try {
            result = method.invoke(realSubject, args);
        }catch (Exception e){
            e.printStackTrace();
            throw e;
        }finally {
            System.out.println("proxy after");
        }
        return result;
    }
}

然后我们看看动态代理的调用

1
2
3
4
5
6
7
8
public class DynamicClient {
    public static void main(String[] args) {
        Subject subject = (Subject) Proxy.newProxyInstance(DynamicClient.class.getClassLoader(),
                new Class[]{Subject.class},
                new JDKProxySubject(new RealSubject()));
        subject.request();
    }
}

这个时候如果我们又要在Subject接口中新添加一个方法，这个时候我们的动态代理实现类并不需要去重写接口，因为我们实现了基于方法的反射机制