掌握java动态代理及原理有多难？

前言：使用的jdk是1.7，需要了解反射机制 泛型 字节码登概念！

一、代理模式

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

二、编写一个java动态代理

1. 准备两个接口

分别是ProductService（生产接口）和 FactoryService（工厂接口）

代码如下：

package test.myproxy;

/**
 * 

 * 
Title: FactoryService
 * 
 *
 * @author ken
 * @date 2021/4/13 0013 上午 10:05
 */
public interface FactoryService {

    void addProduce(int num);

}

package test.myproxy;

/**
 * 

 * 
Title: ProductService
 * 
 *
 * @author ken
 * @date 2021/4/12 0012 下午 17:46
 */
public interface ProductService {

    /**
     * 添加产品
     * @param productName
     */
    void addProduct(String productName);

}

2. MyServiceImpl类实现上述两个接口

package test.myproxy;

/**
 * 

 * 
Title: MyServiceImpl
 * 
Description: TODO 
 * 
 *
 * @author ken
 * @date 2021/4/12 0012 下午 17:47
 */
public class MyServiceImpl implements ProductService,FactoryService {

    @Override
    public void addProduct(String productName) {
        System.out.println("正在添加"+productName);
    }


    @Override
    public void addProduce(int num) {
        System.out.println("准备生成"+num+"件商品");
    }
}

3.实现动态代理的功能

3.1 jdk中需要实现InvocationHandler这个接口，重写invoke方法

3.2 很多文章中为了便于理解，长把下面代码中的target 和getInstance的参数写成实际的接口，如上面的ProductService，这边不想这么写，是为了让大家能理解泛型，getInstance的接口里面我也明确指出参数是与代理对象是继承关系/实现接口的关系。

代码如下：

package test.myproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 

 * 
Title: JdkInvocationHandler
 * 
Description: TODO 
 * 
 *
 * @author ken
 * @date 2021/4/12 0012 下午 17:45
 */
public class JdkInvocationHandler implements InvocationHandler {
    //代理对象
    private T target;
        
    public  T getInstance(B target){
        this.target = target;
        Class clazz = this.target.getClass();
        // 参数1：被代理类的类加载器 参数2:被代理类的接口 参数3
        return (T)Proxy.newProxyInstance(clazz.getClassLoader(),
                clazz.getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String currentDate  = simpleDateFormat.format(new Date());
        System.out.println("日期【"+currentDate + "】添加了一款产品");
        return method.invoke(target,args);

    }
}

3.3 测试

这里的示例，用了泛型和强转两种方式：

 public static void main(String[] args) throws Exception {
        ProductService proxy =  new JdkInvocationHandler().getInstance(new MyServiceImpl());
        proxy.addProduct("iphone");
                
        FactoryService proxyFactory = (FactoryService) new JdkInvocationHandler().getInstance(new MyServiceImpl());
        proxyFactory.addProduce(500);

        // 这里我们将jdk生成的代理类输出了出来，方便后面分析使用
       /* byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{productService.getClass()});
        FileOutputStream os = new FileOutputStream("Proxy0.class");
        os.write(bytes);
        os.close();*/
    }

4.分析如何生成动态代理

在上面的 JdkInvocationHandler类 实现了 InvocationHandler接口，在getInstance方法中最关键的一行代码是Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(), this)；

下面跟随这个代码进一步剖析内容：

下面给大家介绍是
位置: java.lang.reflect
类： Proxy

在这个类里面有一些成员属性，先了解一下后面有些会用到。

4.1 newProxyInstance方法的内容

（为了看起来简洁 我把一些注释删掉了）

 public static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        /*
         * 查找或生成指定的代理类。
         * Look up or generate the designated proxy class.
         */
        Class cl = getProxyClass0(loader, interfaces); // stack walk magic: do not refactor
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            SecurityManager sm = System.getSecurityManager();
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction