jdk动态代理与cglib动态代理例子

1.JAVA的动态代理特征：特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

它是在运行是生成的class对象，在生成时必须提供一组或一个interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当做这些interface中的任何一个来用，当然，这个DynamicProxy其实就是一个Proxy，他不会替你做实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。因此，DynamicProxy必须实现InvocationHandler接口。
5） 一个动态代理了和一个InvocationHandler 实现关联的。每一个动态代理实例的调用都要通过InvocationHandler接口的handler（调用处理器）来调用，动态代理不做任何执行操作，只是在创建动态代理时，把要实现的接口和handler关联，动态代理要帮助被代理执行的任务，要转交给handler来执行。其实就是调用invoke方法

动态代理：在程序运行时，运用反射机制动态创建而成

2.实用动态代理步骤：

A． 创建一个实现接口InvocationHandler的类，他必须实现invoke方法
B． 创建被代理的类以及接口。
C． 通过Proxy的静态方法newProxyInstance（ClassLoader loader，Class【】interfaces，InvocationHandler handler）创建一个代理
D． 通过代理调用方法

 

3.jdk动态代理例子：

文件列表：

业务接口：UserService

业务实现：UserServiceImpl

代理类的调用Handler实现：ProxyHandler

JUnit测试类：SpringProxyTest

package com.niewj.service;

import com.niewj.model.User;

public class UserServiceImpl implements UserService {

 @Override
 public void add(User user) {
  System.out.println("User Saved. & ");
 }

 @Override
 public void delete(User user) {
  System.out.println("User Deleted. &");
 }
}

 

package com.niewj.service;

import com.niewj.model.User;

public class UserServiceImpl implements UserService {

 @Override
 public void add(User user) {
  System.out.println("User Saved. & ");
 }

 @Override
 public void delete(User user) {
  System.out.println("User Deleted. &");
 }
}

 

package com.niewj.service;

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

/**
 * JDK动态代理模拟
 *
 * 1.首先明确什么是目标对象target，什么是代理对象proxy！！
 *
 * 2.每个代理对象对象都会有一个相关的InvocationHandler对象。
 * 当代理对象生成的时候，是创建的代理对象，
 * 拿着相关的这个InvocationHandler对象，去自动调Handler类中实现的invoke方法的。
 * 下面一段话来自@javadoc@
 * <p>Each proxy instance has an associated invocation handler.
 * When a method is invoked on a proxy instance, the method
 * invocation is encoded and dispatched to the <code>invoke</code>
 * method of its invocation handler.
 *
 * 3.还有就是我发现，我的Eclipse控制台TMD输出的顺序有误，害的老以为我人品出了什么问题，
 * 不知道控制台的信息是不是不是栈式输出的。(好绕口)
 *
 */
public class ProxyHandler implements InvocationHandler {

 // 就是要给这个目标类创建代理对象。
 private Object target;

 // 传递代理目标的实例，因为代理处理器需要。也可以用set等方法。
 public ProxyHandler(Object target) {
  this.target = target;
 }

 /*
  * 这个方法是给代理对象调用的。
  * 留心的是内部的method调用的对象是目标对象，可别写错。
  */
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  Object ret = null;
  // 1.调用前
  cutIntoBefore(method.getName());

  ret = method.invoke(target, args);

  // 2.调用后
  cutIntoAfter(method.getName());
  return ret;
 }

 public void cutIntoBefore(String mName) {
  System.err.println("调用____" + mName + "()____方法之前");
 }

 public void cutIntoAfter(String mName) {
  System.err.println("调用____" + mName + "()____方法完后");
 }
}

 

package com.niewj;

import java.lang.reflect.Proxy;

import org.junit.Test;

import com.niewj.model.User;
import com.niewj.service.ProxyHandler;
import com.niewj.service.UserService;
import com.niewj.service.UserServiceImpl;

public class SpringProxyTest {

 @Test
 @SuppressWarnings("rawtypes")
 public void testJDKDynamicProxy() {

  /* 1.获取UserServiceImpl对象--目标对象--也就是需要被代理的对象。 */
  UserService userService = new UserServiceImpl();
  // 获取当前类名
  Class clazz = userService.getClass();
  /*
   * 2.获得代理对象。
   * 每一个代理对象都有一个相关的InvocationHandler对象,通过这个handler对象的invoke来实现调用中要完成的自定义猫腻行为
   * 。 可以使用Proxy类和自定义的调用处理逻辑来生成一个代理对象的。
   */
  UserService userServiceProxy = (UserService) Proxy.newProxyInstance(
    clazz.getClassLoader(), clazz.getInterfaces(),
    new ProxyHandler(userService));
  userServiceProxy.add(new User("dotjar"));
  userServiceProxy.delete(new User("DDD"));
 }
}

 

4.cglib动态代理

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

它的运行速度要远远快于JDK的Proxy动态代理。

 

使用CGLIB需要导入以下两个jar文件：

 

    asm.jar – CGLIB的底层实现。

 

    cglib.jar – CGLIB的核心jar包。

 

例子：

package com.niewj.service;

import java.lang.reflect.Method;

import com.niewj.model.User;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CgLibProxyImitation implements MethodInterceptor {

 private Enhancer enhancer = new Enhancer();

 /** 创建代理对象
  * @param targetClass
  * @return 返回代理对象
  */
 @SuppressWarnings("rawtypes")
 public Object getProxy(Class targetClass) {
  enhancer.setSuperclass(targetClass); //设置需要创建子类的类
  enhancer.setCallback(this);
  return enhancer.create(); //通过字节码技术动态创建子类实例

 }

 public void cutIntoBefore(String mName) {
  System.err.println("调用____" + mName + "()____方法之前");
 }

 public void cutIntoAfter(String mName) {
  System.err.println("调用____" + mName + "()____方法完后");
 }

 /*  生成的代理对象调用此对象来替代原始对象
  *
  * @java.lang.Object 增强对象
  * @java.lang.reflect.Method 拦截方法
  * @java.lang.Object[] 参数数组
  * @net.sf.cglib.proxy.MethodProxy  用于调用父类，按需要调用多次
  */
 @Override
 public Object intercept(Object obj, Method method, Object[] args,
   MethodProxy proxy) throws Throwable {
  cutIntoBefore(method.getName());
  Object result = proxy.invokeSuper(obj, args);
  cutIntoAfter(method.getName());
  return result;
 }
 
 public static void main(String[] args) {
//  UserService userService = new UserServiceImpl();
  CgLibProxyImitation cglib = new CgLibProxyImitation();
  UserServiceImpl userService = (UserServiceImpl)cglib.getProxy(UserServiceImpl.class);
  userService.add(new User("dotjar"));
  userService.delete(new User("hill"));
 }
}