java代理

1.静态代理

静态代理缺点：
①.每次代理都要实现一个类，导致项目中代码很多；
②.代码都是写死的，一个代理只能实现固定的功能，无法灵活多变

1.继承方式实现代理（静态代理中的继承代理）

//目标对象
public class UserImpl {
    public void query(String name) {
        System.out.println("query name = " + name);
    }
}

//代理对象
public class LogUserProxy extends UserImpl{
    public void query(String name) {
        System.out.println("log ...");
        System.out.println("query name = " + name);
    }
}

//测试类
public class Main {
    public static void main(String[] args) {
        //父类指向子类
        UserImpl user = new LogUserProxy();
        user.query("张三");
    }
}

代理对象实现了对目标对象的增强，但只能增强一次。

2.聚合方式实现代理

//抽象对象
public interface UserService {
    public void query(String name);
}

//目标对象
public class UserImpl implements UserService {

    public void query(String name) {
        System.out.println("query name = " + name);
    }
}

//代理对象1
public class LogUserProxy implements UserService {

    private UserService userService;

    public LogUserProxy(UserService userService) {
        this.userService = userService;
    }

    public void query(String name) {
        System.out.println("log ...");
        userService.query(name);
    }
}

//代理对象2
public class TimeUserProxy implements UserService {

    private UserService userService;

    public TimeUserProxy(UserService user) {
        this.userService = user;
    }

    public void query(String name) {
        System.out.println("time ...");
        userService.query(name);
    }
}

public class Main {

    public static void main(String[] args) {
        UserService user = new UserImpl();
        UserService logUser = new LogUserProxy(user);
        UserService timeUser = new TimeUserProxy(logUser);
        timeUser.query("张三");
    }
}

输出结果：

time ...
log ...
query name = 张三

代理对象1和代理对象2对目标对象实现了两次增强。聚合代理方式可以实现多次增强。

2.动态代理

  动态代理有JDK的动态代理和cglib的动态代理，例如Spring Boot中就使用了这两种代理方式，默认使用JDK的代理方式，当类没有实现接口时使用cglib的动态代理。
Spring Boot动态代理参考文章 https://www.jianshu.com/p/8cd3b352ab38

下面介绍JDK的动态代理

  下面代码类似JDK框架的动态代理，主要作用是生成一个临时实现类。通过此代码可以了解JDK动态代理的思想

package com.tomorrowsg.test.util;

import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;


public class ProxyUtil {
    public static Object newProxyInstance(Object target) throws Exception{
        String content = "";
        String packageContent = "package com.test;";
        Class targetInfo = target.getClass().getInterfaces()[0];
        String targetInfoName = targetInfo.getSimpleName();
        String importContent = "import " + targetInfo.getName() + ";";
        String classContent = "public class $Proxy implements " + targetInfoName + "{";

        String fieldContent = "private " + targetInfoName + " target;";
        String construterContent = "public $Proxy(" + targetInfoName + " target){"
                                        +"this.target = target;}";
        String methodsContent = "";
        Method[] methods = targetInfo.getDeclaredMethods();
        for (Method method : methods) {
            String methodName = method.getName();
            Class returnType = method.getReturnType();
            Class<?>[] parameterTypes = method.getParameterTypes();
            String argsContent = "";
            String argsNames = "";
            int i = 0;
            for (Class<?> parameterType : parameterTypes) {
                String simpleName = parameterType.getSimpleName();
                argsContent+= simpleName + " p" + i + ",";
                argsNames+="p" + i + ",";
                i++;
            }
            if (argsContent.length() > 0) {
                argsContent = argsContent.substring(0, argsContent.lastIndexOf(",")-1);
                argsNames = argsNames.substring(0, argsNames.lastIndexOf(",")-1);
            }
            methodsContent += "public " + returnType + " " + methodName + "(" + argsContent+"){"
                    +"System.out.println(\"log...\");"
                            +"target." + methodName + "(" + argsNames + ");}";

        }
        content += packageContent + importContent + classContent + fieldContent + construterContent + methodsContent + "}";
        File file = new File("D:\\com\\test\\$Proxy.java");
        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fileWriter = new FileWriter(file);
        fileWriter.write(content);
        fileWriter.flush();
        fileWriter.close();

        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
        Iterable units = fileManager.getJavaFileObjects(file);
        JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, units);
        task.call();
        fileManager.close();
        URL[] urls = new URL[]{new URL("file:D:\\\\")};
        URLClassLoader urlClassLoader = new URLClassLoader(urls);
        Class clazz = urlClassLoader.loadClass("com.test.$Proxy");
        Constructor constructor = clazz.getConstructor(targetInfo);
        Object proxy = constructor.newInstance(target);
        return proxy;
    }
}

  上面代码的作用是在磁盘上生成一个类似如下代码的一个代理类，并自动完成编译、装载并返回一个实例化对象。此种方式生成的代理类更具灵活性，可以重用。

public class LogUserProxy implements UserService {

    private UserService userService;

    public LogUserProxy(UserService userService) {
        this.userService = userService;
    }

    public void query(String name) {
        System.out.println("log ...");
        userService.query(name);
    }
}

public class Main {

    public static void main(String[] args) throws Exception {
        UserService user = new UserImpl();
        UserService proxy = (UserService) ProxyUtil.newProxyInstance(user);
        proxy.query("张三");
    }
}

输出结果如下

log...
query name = 张三