Java设计模式之 动态代理设计模式

什么是动态代理

Java动态代理的优势是实现无侵入式的代码扩展,也就是方法的增强;让你可以在不用修改源码的情况下,增强一些方法;在方法的前后你可以做你任何想做的事情(甚至不去执行这个方法就可以)

基于接口的动态代理

* 动态代理
*  特点:字节码随用创建和加载
*  作用:不修改源码的基础上对方法增强
*  分类:
*      基于接口的动态代理
*      基于子类的动态代理
*   基于接口的动态代理
*      涉及的类:Proxy
*      提供者:JDK官方
*   如何使用创建代理对象:
*      使用Proxy中的newProxyInstance方法
*      要求:被代理的类至少实现一个接口 否则不能使用
*      newProxyInstance方法的参数
*      ClassLoader:类加载器
*          用来加载代理对象的字节码,和被代理的对象使用相同的类加载器 固定的
*      Class[]:字节码数组
*          它是用于让代理对象和被代理类有相同的方法   固定的
*      InvocationGander:用于提供增加的代码
*          是写如何代理.一般是写该接口的实现类,通常情况下是匿名内部类 但是不是必须
*          此接口的实现类都是谁用谁写
*

案例: A是代理商 B是产品制造商 B把产品给A销售 那么代理商就要赚取差价 每次都要计算具体的差价,是很痛苦的 怎么解决 就是用动态代理

现在看一下实现的代码 新建 maven 项目

---

这是基于接口的动态代理

---

接口 IProducer.java

package proxy;

/**
 * @Author: icanci
 * @ProjectName: proxy
 * @PackageName: proxy
 * @Date: Created in 2020/1/10 11:28
 * @ClassAction: 对生产厂家的要求
 */
public interface IProducer {
    /**
     * 销售
     * @param money
     */
    void saleProduct(float money) ;

    /**
     * 售后
     * @param money
     */
    void afterService(float money) ;
}

IProducer.java的实现类 Producer .java

package proxy;

/**
 * @Author: icanci
 * @ProjectName: proxy
 * @PackageName: proxy
 * @Date: Created in 2020/1/10 11:26
 * @ClassAction: 成产者
 */
public class Producer implements IProducer{
    public void saleProduct(float money) {
        System.out.println("销售产品,并拿到钱:" + money);
    }

    public void afterService(float money) {
        System.out.println("提供售后服务,拿到钱:" + money);
    }
}

测试类:

package proxy;

import java.lang.Float;

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

/**
 * @Author: icanci
 * @ProjectName: proxy
 * @PackageName: proxy
 * @Date: Created in 2020/1/10 11:30
 * @ClassAction:
 */
public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();

        IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(
        producer.getClass().getClassLoader(), 
        producer.getClass().getInterfaces(), new InvocationHandler() {
            /**
             * 作用:执行所有的被代理对象的任何接口方法都必须经过该方法
             * @param proxy 代理对象的引用
             * @param method 当前执行的方法
             * @param args 当前执行的方法所需要的参数
             * @return 和被代理对象方法有相同的返回值
             * @throws Throwable
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws 
            Throwable {
                Object returnValue = null;
                //提供增强的代码
                //1.获取方法执行的参数
                Float money = (Float) args[0];
                //2.判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money * 0.8F);
                }
                return returnValue;
            }
        });
        proxyProducer.saleProduct(10000);
    }
}

//代理的以下写法也是可以的
//IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(
//Producer.class.getClassLoader(),
// Producer.class.getInterfaces(), new InvocationHandler() {}

测试打印结果:

销售产品,并拿到钱:8000.0

基于子类的动态代理

* 动态代理
*  特点:字节码随用创建和加载
*  作用:不修改源码的基础上对方法增强
*  分类:
*      基于接口的动态代理
*      基于子类的动态代理
*   基于子类的动态代理
*      涉及的类:Enhancer
*      提供者:第三方 cglib库
*   如何使用创建代理对象:
*      使用Enhancer中的create方法
*      要求:被代理的类不可以是最终类
*    create方法的参数
*      class:字节码
*          用来指定被代理对象的字节码
*      callback:用于提供增加的代码
*          是写如何代理.一般是写该接口的实现类,通常情况下是匿名内部类 但是不是必须
*          此接口的实现类都是谁用谁写
*          我们一般写该接口的子接口的实现类: MethodInterceptor

首先导入依赖:

      cglib
      cglib
      2.1_3

代理的子类 Producer.java

package cglib;

/**
 * @Author: icanci
 * @ProjectName: proxy
 * @PackageName: proxy
 * @Date: Created in 2020/1/10 11:26
 * @ClassAction: 成产者
 */
public class Producer{
    public void saleProduct(float money) {
        System.out.println("销售产品,并拿到钱:" + money);
    }

    public void afterService(float money) {
        System.out.println("提供售后服务,拿到钱:" + money);
    }
}

测试类:

package cglib;

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

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

/**
 * @Author: icanci
 * @ProjectName: proxy
 * @PackageName: proxy
 * @Date: Created in 2020/1/10 11:30
 * @ClassAction:
 */
public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();
        Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), 
        new MethodInterceptor() {
            /**
             *
             * @param proxy
             * @param method
             * @param args
             * 以上三个参数和基于接口的动态代理的invoke方法是一样的
             * @param methodProxy 当前执行方法的代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, 
            MethodProxy methodProxy) throws Throwable {
                Object returnValue = null;
                //提供增强的代码
                //1.获取方法执行的参数
                Float money = (Float) args[0];
                //2.判断当前方法是不是销售
                if ("saleProduct".equals(method.getName())) {
                    returnValue = method.invoke(producer, money * 0.8F);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduct(15000F);
    }
}

Over 这就是动态代理的简单写法 之后会补充 如果有需要的话