Java动态代理

静态代理

/**
* 接口
*/
public interface IUserDao {
   void save();
}

/**
* 接口实现
* 目标对象
*/
public class UserDao implements IUserDao {
   public void save() {
       System.out.println("----已经保存数据!----");
   }
}


/**
* 代理对象,静态代理
*/
public class UserDaoProxy implements IUserDao{
   //接收保存目标对象
   private IUserDao target;
   public UserDaoProxy(IUserDao target){
       this.target=target;
   }

   public void save() {
       System.out.println("开始事务...");
       target.save();//执行目标对象的方法
       System.out.println("提交事务...");
   }
}

/**
* 测试类
*/
public class App {
   public static void main(String[] args) {
       //目标对象
       UserDao target = new UserDao();

       //代理对象,把目标对象传给代理对象,建立代理关系
       UserDaoProxy proxy = new UserDaoProxy(target);

       proxy.save();//执行的是代理的方法
   }
}

jdk动态代理

/**
* 创建动态代理对象
* 动态代理不需要实现接口,但是需要指定接口类型
*/
public class ProxyFactory{

   //维护一个目标对象
   private Object target;
   public ProxyFactory(Object target){
       this.target=target;
   }

  //给目标对象生成代理对象
   public Object getProxyInstance(){
       return Proxy.newProxyInstance(
               target.getClass().getClassLoader(),
               target.getClass().getInterfaces(),
               new InvocationHandler() {
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       System.out.println("开始事务2");
                       //执行目标对象方法
                       Object returnValue = method.invoke(target, args);
                       System.out.println("提交事务2");
                       return returnValue;
                   }
               }
       );
   }

}

/**
* 测试类
*/
public class App {
   public static void main(String[] args) {
       // 目标对象
       IUserDao target = new UserDao();
       // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
       System.out.println(target.getClass());

       // 给目标对象，创建代理对象
       IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
       // class $Proxy0   内存中动态生成的代理对象
       System.out.println(proxy.getClass());

       // 执行方法   【代理对象】
       proxy.save();
   }
}

cglib动态代理

/**
* 目标对象,没有实现任何接口
*/
public class UserDao {

   public void save() {
       System.out.println("----已经保存数据!----");
   }
}

/**
* Cglib子类代理工厂
* 对UserDao在内存中动态构建一个子类对象
*/
public class ProxyFactory implements MethodInterceptor{
   //维护目标对象
   private Object target;

   public ProxyFactory(Object target) {
       this.target = target;
   }

   //给目标对象创建一个代理对象
   public Object getProxyInstance(){
       //1.工具类
       Enhancer en = new Enhancer();
       //2.设置父类
       en.setSuperclass(target.getClass());
       //3.设置回调函数
       en.setCallback(this);
       //4.创建子类(代理对象)
       return en.create();

   }

   @Override
   public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
       System.out.println("开始事务...");

       //执行目标对象的方法
       Object returnValue = method.invoke(target, args);

       System.out.println("提交事务...");

       return returnValue;
   }
}

/**
* 测试类
*/
public class App {

   @Test
   public void test(){
       //目标对象
       UserDao target = new UserDao();

       //代理对象
       UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

       //执行代理对象的方法
       proxy.save();
   }
}

自动选择代理

/**
 * @author cuishiying
 * @date 2021-10-13
 */
public interface IProxy {

    /**
     * 获取代理实现
     * @return 代理
     */
    Object getProxyInstance();
}

/**
 * 没有代理
 *
 * @author cuishiying
 * @date 2021-10-13
 */
public class NoneProxy implements InvocationHandler, IProxy {

    /**
     * 代理对象
     */
    private final Object target;

    public NoneProxy(Object target) {
        this.target = target;
    }

    /**
     * 返回原始对象，没有代理
     * @return 原始对象
     */
    @Override
    public Object getProxyInstance() {
        return this.target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(proxy, args);
    }
}

/**
 * JDK动态代理
 *
 * @author cuishiying
 * @date 2021-10-13
 */
public class DynamicProxy implements InvocationHandler, IProxy {

    private final Logger log = LoggerFactory.getLogger(getClass());

    /**
     * 被代理的对象
     */
    private final Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object getProxyInstance() {
        // 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("JDK动态代理-前置处理");
        Object invoke = method.invoke(target, args);
        log.info("JDK动态代理-后置处理");
        return invoke;
    }
}

/**
 * @author cuishiying
 * @date 2021-10-13
 */
public class CglibProxy implements MethodInterceptor, IProxy{

    private final Logger log = LoggerFactory.getLogger(getClass());

    /**
     * 被代理的对象
     */
    private final Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object getProxyInstance() {
        Enhancer enhancer = new Enhancer();
        //目标对象类
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        //通过字节码技术创建目标对象类的子类实例作为代理
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        log.info("Cglib动态代理-前置处理");
        Object invoke = method.invoke(target, args);
        log.info("Cglib动态代理-后置处理");
        return invoke;
    }
}

/**
 * @author cuishiying
 * @date 2021-10-13
 */
public final class AutoProxy {

    public AutoProxy() {
    }

    /**
     * 参考 {@link org.springframework.aop.framework.DefaultAopProxyFactory}
     *
     * @param targetClass
     * @param <T>
     * @return
     */
    @SneakyThrows
    @SuppressWarnings("all")
    public static <T> T getProxy(@NonNull final Class<T> targetClass) {
        if (targetClass.isInterface()) {
            throw new IllegalArgumentException("不支持接口类型的参数");
        }
        T target = targetClass.getDeclaredConstructor().newInstance();
        if(Objects.isNull(target)) {
            return (T) new NoneProxy(target).getProxyInstance();
        }
        if (targetClass.getInterfaces().length > 0) {
            return (T) new DynamicProxy(target).getProxyInstance();
        }
        return (T) new CglibProxy(target).getProxyInstance();
    }
}

单元测试

class AutoProxyTest {

    /**
     * UserService implements IUserService
     *
     * 18:06:23.757 [main] INFO com.example.javademo.proxy.DynamicProxy - JDK动态代理-前置处理
     * 18:06:23.760 [main] INFO com.example.javademo.proxy.UserService - hello:当我遇上你
     * 18:06:23.760 [main] INFO com.example.javademo.proxy.DynamicProxy - JDK动态代理-后置处理
     */
    @Test
    public void p1() {
        IUserService proxy = AutoProxy.getProxy(UserService.class);
        proxy.sayHello("当我遇上你");
    }

    /**
     * RoleService未实现接口
     *
     * 18:06:57.681 [main] INFO com.example.javademo.proxy.CglibProxy - Cglib动态代理-前置处理
     * 18:06:57.683 [main] INFO com.example.javademo.proxy.RoleService - has role:admin
     * 18:06:57.683 [main] INFO com.example.javademo.proxy.CglibProxy - Cglib动态代理-后置处理
     */
    @Test
    public void p2() {
        RoleService proxy = AutoProxy.getProxy(RoleService.class);
        proxy.hasRole("admin");
    }

}

最后

本文到此结束，感谢阅读。如果您觉得不错，请关注公众号【当我遇上你】，您的支持是我写作的最大动力。