详解Java JDK动态代理

　　今天来看看java的另一种代理方式——jdk动态代理

　　我们之前所介绍的代理方式叫静态代理，也就是静态的生成代理对象，而动态代理则是在运行时创建代理对象。动态代理有更强大的拦截请求功能，因为可以获得类的运行时信息，可以根据运行时信息来获得更为强大的执（骚）行（操）力（作）。

　　我们还是以上一个例子为例，这里的istars接口和stars类都不需要修改，只需要修改代理类。

　　创建jdk动态代理需要先实现invocationhandler接口，并重写其中的invoke方法，具体步骤如下：

　　1. 创建一个类实现invocationhandler接口。

　　2. 给proxy类提供委托类的classloader和interfaces来创建动态代理类。

　　3. 利用反射机制得到动态代理类的构造函数。

　　4. 利用动态代理类的构造函数创建动态代理类对象。

　　我们用动态代理来改造一下之前的类：

　　接口和委托类不需要修改：

public interface istars {
  void sing();
  void dance();
}

public class stars implements istars{
  private string name;

  public stars(string name) {
    this.name = name;
  }

  public string getname() {
    return name;
  }

  public void setname(string name) {
    this.name = name;
  }

  public void sing(){
    system.out.println(getname() + " 唱了一首歌.");
  }

  public void dance(){
    system.out.println(getname() + " 跳了一支舞.");
  }
}

　　这是使用动态代理后的代理类：

public class starsnewproxy implements invocationhandler {

  //代理类持有委托类的对象引用
  private object object;

  //保存sing和dance的次数
  private int num;

  public starsnewproxy(object object){
    this.object = object;
  }

  @override
  public object invoke(object proxy, method method, object[] args) throws throwable {
    if (!runbefore(method)){
      return null;
    };
    //利用反射机制将请求分派给委托类处理，method的invoke返回object对象作为方法执行结果
    object result = method.invoke(object,args);
    runafter(method);
    return result;
  }

  private boolean runbefore(method method){
    system.out.println("我是代理，拦截到请求");
    if (method.getname().equals("dance")){
      system.out.println("抱歉，明星脚受伤了，不能跳舞表演了。");
      return false;
    }
    return true;
  }

  private void runafter(method method){
    system.out.println("我是代理，请求处理完毕");
  }
}

　　新建一个工厂类来返回代理实例：

public class starsnewproxyfactory {
  //构建工厂类，客户类调用此方法获得代理对象
  //对于客户类而言，代理类对象和委托类对象是一样的，不需要知道具体返回的类型
  public static istars getinstance(string name){
    istars stars = new stars(name);
    invocationhandler handler = new starsnewproxy(stars);
    istars proxy = null;
    proxy = (istars) proxy.newproxyinstance(
        stars.getclass().getclassloader(),
        stars.getclass().getinterfaces(),
        handler
    );
    return proxy;
  }
}

　　改写一下测试类：

public class test {
  public static void main(string[] args){
//    testa();
    testb();
  }

  /**
   * 静态代理
   */
  private static void testa(){
    //创建目标对象
    istars stars = new stars("frank");

    //代理对象，把目标传给代理对象，建立关系
    istars starsproxy = new starsproxy(stars);
    for (int i = 0;i < 5; i++){
      starsproxy.sing();
    }
  }

  /**
   * jdk动态代理
   */
  private static void testb(){
    istars proxy = starsnewproxyfactory.getinstance("frank");
    proxy.dance();
    proxy.sing();
  }
}

　　输出如下：

我是代理，拦截到请求
抱歉，明星脚受伤了，不能跳舞表演了。
我是代理，拦截到请求
frank 唱了一首歌.
我是代理，请求处理完毕

　　使用动态代理时实现了invocationhandler接口并重写了invoke方法，invoke方法的三个参数：

object invoke(object proxy, method method, object[] args) throws throwable

proxy:　　被代理的对象
method:　　被代理对象的某个方法的method对象
args:　　被代理对象的某个方法接受的参数

　　proxy的newproxyinstance方法详情如下：

public static object newproxyinstance(classloader loader, class<?>[] interfaces, invocationhandler h) throws illegalargumentexception

loader:　　一个classloader对象，定义了由哪个classloader对象来对生成的代理对象进行加载

interfaces:　　一个interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:　　一个invocationhandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个invocationhandler对象上

　　可以看到，这里的动态代理跟静态代理一样，在代理类内部保存了一个委托类的实例，实际上都是调用原来的委托实例来进行需要的操作，代理类相当于给委托类加上一个外壳，把委托类置于代理类的内部，从而可以控制客户类对委托类的访问，就像上例中，代理类拦截了客户类对stars类的dance方法的访问，并且输出了补充信息。

　　动态代理跟静态代理最大的不同便是生成代理类的时期不同，静态代理是在编译期，而动态代理则是在运行时根据委托类信息动态生成。

　　其次，动态代理实现的是invocationhandler接口，而静态代理则是直接实现公共接口。当然动态代理也是需要实现相同的接口的，只是将接口信息放在了getinstance内部，相当于代理类跟委托类之间的约定，“这几个方法帮我代理一下吧”。

　　最后，动态代理可以获得更多的运行时信息，使用起来也会更加灵活。

　　至此，jdk动态代理讲解完毕，欢迎大家继续关注！

以上就是详解java jdk动态代理的详细内容，更多关于java jdk动态代理的资料请关注其它相关文章！