java中动态代理的实现

动态代理的实现

使用的模式：代理模式。

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。类似租房的中介。

两种动态代理：

（1）jdk动态代理，jdk动态代理是由java内部的反射机制来实现的，目标类基于统一的接口（invocationhandler）

（2）cglib动态代理，cglib动态代理底层则是借助asm来实现的，cglib这种第三方类库实现的动态代理应用更加广泛，且在效率上更有优势。

主要应用的框架：

spring中的aop，struts2中的拦截器

具体实现：

1、定义接口和实现类

package com.example.service;
public interface userservice {
  public string getname(int id);
  public integer getage(int id);
}

package com.example.service.impl;
import com.example.service.userservice;
public class userserviceimpl implements userservice {
  public string getname(int id) {
    system.out.println("------getname------");
    return "cat";
  }
  public integer getage(int id) {
    system.out.println("------getage------");
    return 10;
  }
}

2、jdk动态代理实现

package com.example.jdk;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
public class myinvocationhandler implements invocationhandler {
  private object target;
  /**
   * 绑定委托对象并返回一个代理类
   *
   * @param target
   * @return
   */
  public object bind(object target) {
    this.target = target;
    //取得代理对象
    return proxy.newproxyinstance(target.getclass().getclassloader(),
        target.getclass().getinterfaces(), this);  //要绑定接口(这是一个缺陷，cglib弥补了这一缺陷)
  }
  @override
  public object invoke(object proxy, method method, object[] args) throws throwable {
    if ("getname".equals(method.getname())) {
      system.out.println("------before " + method.getname() + "------");
      object result = method.invoke(target, args);
      system.out.println("------after " + method.getname() + "------");
      return result;
    } else {
      object result = method.invoke(target, args);
      return result;
    }
  }
}

package com.example.jdk;

import com.example.service.userservice;
import com.example.service.impl.userserviceimpl;

/**
 * 测试类
 */
public class runjdk {
  public static void main(string[] args) {
    myinvocationhandler proxy = new myinvocationhandler();
    userservice userserviceproxy = (userservice) proxy.bind(new userserviceimpl());
    system.out.println(userserviceproxy.getname(1));
    system.out.println(userserviceproxy.getage(1));
  }
}

运行结果：

------before getname------
------getname------
------after getname------
cat
------getage------
10

3、cglib动态代理实现：

jdk的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现jdk的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

cglib的核心类：

net.sf.cglib.proxy.enhancer – 主要的增强类
net.sf.cglib.proxy.methodinterceptor – 主要的方法拦截类，它是callback接口的子接口，需要用户实现
net.sf.cglib.proxy.methodproxy – jdk的java.lang.reflect.method类的代理类，可以方便的实现对源对象方法的调用。

net.sf.cglib.proxy.methodinterceptor接口是最通用的回调（callback）类型，它经常被基于代理的aop用来实现拦截（intercept）方法的调用。这个接口只定义了一个方法
public object intercept(object object, java.lang.reflect.method method,
object[] args, methodproxy proxy) throws throwable;

第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.method对象的一般反射调用，或者使用 net.sf.cglib.proxy.methodproxy对象调用。net.sf.cglib.proxy.methodproxy通常被首选使用，因为它更快。

package com.example.cglib;
import org.springframework.cglib.proxy.enhancer;
import org.springframework.cglib.proxy.methodinterceptor;
import org.springframework.cglib.proxy.methodproxy;
import java.lang.reflect.method;
public class cglibproxy implements methodinterceptor {
  private object target;
  /**
   * 创建代理对象
   *
   * @param target
   * @return
   */
  public object getinstance(object target) {
    this.target = target;
    enhancer enhancer = new enhancer();
    enhancer.setsuperclass(this.target.getclass());
    // 回调方法
    enhancer.setcallback(this);
    // 创建代理对象
    return enhancer.create();
  }
  @override
  public object intercept(object o, method method, object[] objects, methodproxy methodproxy) throws throwable {
    system.out.println("++++++before " + methodproxy.getsupername() + "++++++");
    system.out.println(method.getname());
    object result = methodproxy.invokesuper(o, objects);
    system.out.println("++++++after " + methodproxy.getsupername() + "++++++");
    return result;
  }
}

package com.example.cglib;
import com.example.service.userservice;
import com.example.service.impl.userserviceimpl;
/**
 * 测试cglib
 */
public class runcglib {
  public static void main(string[] args) {
    cglibproxy cglibproxy = new cglibproxy();
    userservice userservice = (userservice) cglibproxy.getinstance(new userserviceimpl());
    userservice.getname(1);
    userservice.getage(1);
  }
}

运行结果：

++++++before cglib$getname$0++++++
getname
------getname------
++++++after cglib$getname$0++++++
++++++before cglib$getage$1++++++
getage
------getage------
++++++after cglib$getage$1++++++

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持！