23种设计模式之代理模式-Proxy

public interface Rent {
	void rent();
}

public class Host implements Rent {
  // 真实角色要做的操作
	@Override
	public void rent() {
		System.out.println("房东要出租房子。。。。");
	}
}

// 房东不想去找客户租房子，让中介代理
public class HostProxy implements Rent{
  // 具体的目标对象（真实角色）
	private Host host;

	public HostProxy(){}

	public HostProxy(Host host){
		this.host = host;
	}

	@Override
	public void rent() {
		// 房东出租房子
		host.rent();
		// 中介带你看房子
		seeHouse();
		// 合适就签合同
		signRentContract();
		// 收中介费
		fee();
	}

	// 代理的一些附属操作：
	// 看房
	public void seeHouse() {
		System.out.println("中介带你看房子");
	}

	// 签合同
	public void signRentContract() {
		System.out.println("签租赁合同");
	}

	// 收中介费
	public void fee() {
		System.out.println("收中介费");
	}
}

public class Client {
	public static void main(String[] args) {
		Host host = new Host();
		HostProxy proxy = new HostProxy(host);
		proxy.rent();
	}
}

public interface UserService {
	void add();

	void delete();

	void update();

	void query();
}

public class UserServiceImpl implements UserService{
	@Override
	public void add() {
		System.out.println("新增了一个用户");
	}

	@Override
	public void delete() {
		System.out.println("删除了一个用户");
	}

	@Override
	public void update() {
		System.out.println("更新了一个用户");
	}

	@Override
	public void query() {
		System.out.println("查询了多个用户");
	}
}

public class UserServiceProxy implements UserService{
	private UserService userService;

	public void setUserService(UserService userService){
		this.userService = userService;
	}

	@Override
	public void add() {
		log("add");
		userService.add();
	}

	@Override
	public void delete() {
		log("delete")
		userService.delete();
	}

	@Override
	public void update() {
		log("update");
		userService.update();
	}

	@Override
	public void query() {
		log("query");
		userService.query();
	}

	private void log(String msg){
		System.out.println("【Debug】使用了"+ msg +"方法");
	}
}

public class UserClient {
	public static void main(String[] args) {
		UserServiceImpl userService = new UserServiceImpl();
		UserServiceProxy proxy = new UserServiceProxy();
		proxy.setUserService(userService);
		proxy.add();
	}
}

public class HostInvocationHandler implements InvocationHandler {
  // 被代理的接口
  private Rent rent;

  public void setRent(Rent rent) {
    this.rent = rent;
  }

  // 动态生成得到代理类
  // 第一个参数：类加载器路径
  // 第二个参数：要代理的接口
  // 第三个参数：InvocationHandler的实现类，动态代理应该怎么执行方法，就是下面的invoke方法
  // 返回一个动态代理类
  public Object getProxy() {
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
  }

  // 动态代理的核心，它会在这里拦截目标方法的执行，也就是接口rent的每一个方法执行
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
    // 动态代理的本质，就是使用反射机制实现
    Object result = method.invoke(rent,args); // 调用目标类的方法
    seeHouse();
    signRentContract();
    fee();
    return result;
  }

  // 看房
  public void seeHouse() {
    System.out.println("动态代理-中介带你看房子");
  }

  // 签合同
  public void signRentContract() {
    System.out.println("动态代理-签租赁合同");
  }

  // 收中介费
  public void fee() {
    System.out.println("动态代理-收中介费");
  }
}

public class Client {
  public static void main(String[] args) {
    // 真实角色：房东
    Host host = new Host();
    // 代理角色没有，动态生成一个
    HostInvocationHandler handler = new HostInvocationHandler();
    // 要代理的目标对象
    handler.setRent(host);
    Rent proxy =(Rent) handler.getProxy();
    proxy.rent();
  }
}

public class ProxyInvocationHandler implements InvocationHandler {
	// 被代理的接口
	private Object target;

	public void setTarget(Object target){
		this.target = target;
	}

	// 生成得到代理类
	public Object getProxy() {
		return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
	}

  // 动态代理的核心，它会在这里拦截目标方法的执行，也就是接口target的每一个方法执行
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
    // 通过反射获取方法名
    log(method.getName());
    Object result = method.invoke(target,args);
    return result;
  }
  
  private void log(String msg){
    System.out.println("【Debug】使用了"+ msg +"方法");
  }
}

public class Client {
  public static void main(String[] args) {
    // 真实角色
    UserServiceImpl userService = new UserServiceImpl();
    // 代理角色，不存在，通过handler生成
    ProxyInvocationHandler handler = new ProxyInvocationHandler();
    // 设置要代理的对象
    handler.setTarget(userService);
    UserService proxy = (UserService) handler.getProxy(); // 动态创建实现类 
    proxy.add();
    proxy.query();
  }
}

public class AutoMethodInterceptor implements MethodInterceptor {

  public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    System.out.println("---- 方法拦截 ----");
    Object object = methodProxy.invokeSuper(obj, args);
    return object;
  }
}

public class Client {
  public static void main(String[] args) {
    // 3、cglib动态代理
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Host.class);
    enhancer.setCallback(new AutoMethodInterceptor());
    Host host1 = (Host)enhancer.create();
    host1.rent();
  }
}

public class AutoMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("---- 方法拦截 ----");
        Object object = methodProxy.invokeSuper(obj, args);
        seeHouse();
        signRentContract();
        fee();
        return object;
    }

    // 看房
    public void seeHouse() {
        System.out.println("cglib动态代理-中介带你看房子");
    }
    // 签合同
    public void signRentContract() {
        System.out.println("cglib动态代理-签租赁合同");
    }
    // 收中介费
    public void fee() {
        System.out.println("cglib动态代理-收中介费");
    }
}

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

/**
 * @Author xiejw17
 * @Date 2021/1/20 11:03
 */
public class AssistByteCode {
    public static void createByteCode() throws Exception {
        ClassPool classPool = ClassPool.getDefault();
        // 类路径
        CtClass ctClass = classPool.makeClass("proxy.Host2");
        // 设置接口
        CtClass ctInterface = classPool.get("proxy.Rent");
        ctClass.setInterfaces(new CtClass[]{ctInterface});

        // 创建方法
        CtMethod rent = CtMethod.make("public void rent(){}",ctClass);
        rent.setBody("System.out.println(\"房东要出租房子。。。。\");");
        ctClass.addMethod(rent);

        // 输出字节码文件
        Class c = ctClass.toClass();
      	ctClass.writeFile("D:/jacob/code/c-ccs/web-parent/ccs-common/src/test/java/");
    }
}

public static void main(String[] args) {
  try {
    AssistByteCode.createByteCode();
  } catch (Exception e) {
    e.printStackTrace();
  }
}

import javassist.util.proxy.ProxyFactory;

/**
 * @Author xiejw17
 * @Date 2021/1/20 15:07
 */
public class JavaassistProxyFactory {
    public Object getProxy(Class clazz) throws Exception{

        // 代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        // 设置需要创建的子类
        proxyFactory.setSuperclass(clazz);
        proxyFactory.setHandler((self, thisMethod, proceed, args) -> {
            System.out.println("---- javassist动态代理,开始拦截 ----");
            Object result = proceed.invoke(self, args);
            System.out.println("---- javassist动态代理,结束拦截 ----");
            return result;
        });
        return proxyFactory.createClass().newInstance();
    }
}

public class Client {
    public static void main(String[] args) {
      // 4、javassist动态代理
      JavaassistProxyFactory proxyFactory = new JavaassistProxyFactory();
      Host proxy = null;
      try {
        proxy = (Host)proxyFactory.getProxy(Host.class);
      } catch (Exception e) {
        e.printStackTrace();
      }
      proxy.rent();
    }
}

public class AsmProxy extends ClassLoader implements Opcodes {

    public static void createAsmProxy() throws Exception {

        // 目标类类名 字节码中类修饰符以 “/” 分割
        String targetServiceName = TargetService.class.getName().replace(".", "/");
        // 切面类类名
        String aspectServiceName = AspectService.class.getName().replace(".", "/");
        // 代理类类名
        String proxyServiceName = targetServiceName+"Proxy";
        // 创建一个 classWriter 它是继承了ClassVisitor
        ClassWriter classWriter = new ClassWriter(0);
        // 访问类 指定jdk版本号为1.8, 修饰符为 public，父类是TargetService
        classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, proxyServiceName, null, targetServiceName, null);
        // 访问目标类成员变量 为类添加切面属性 “private TargetService targetService”
        classWriter.visitField(ACC_PRIVATE, "targetService", "L" + targetServiceName+";", null, null);
        // 访问切面类成员变量 为类添加目标属性 “private AspectService aspectService”
        classWriter.visitField(ACC_PRIVATE, "aspectService", "L" + aspectServiceName+";", null, null);

        // 访问默认构造方法 TargetServiceProxy()
        // 定义函数 修饰符为public 方法名为 <init>， 方法表述符为()V 表示无参数，无返回参数
        MethodVisitor initVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
        // 从局部变量表取第0个元素 “this”
        initVisitor.visitVarInsn(ALOAD, 0);
        // 调用super 的构造方法 invokeSpecial在这里的意思是调用父类方法
        initVisitor.visitMethodInsn(INVOKESPECIAL, targetServiceName, "<init>", "()V", false);
        // 方法返回
        initVisitor.visitInsn(RETURN);
        // 设置最大栈数量，最大局部变量表数量
        initVisitor.visitMaxs(1, 1);
        // 访问结束
        initVisitor.visitEnd();

        // 创建有参构造方法 TargetServiceProxy(TargetService var1, AspectService var2)
        // 定义函数 修饰符为public 方法名为 <init>， 方法表述符为(TargetService, AspectService)V 表示无参数，无返回参数
        MethodVisitor methodVisitor = classWriter.visitMethod(ACC_PUBLIC, "<init>", "(L" + targetServiceName + ";L"+aspectServiceName+";)V", null, null);
        // 从局部变量表取第0个元素 “this”压入栈顶
        methodVisitor.visitVarInsn(ALOAD, 0);
        // this出栈 , 调用super 的构造方法 invokeSpecial在这里的意思是调用父类方法。 <init>的owner是AspectService, 无参无返回类型
        methodVisitor.visitMethodInsn(INVOKESPECIAL, targetServiceName, "<init>", "()V", false);
        // 从局部变量表取第0个元素 “this”压入栈顶
        methodVisitor.visitVarInsn(ALOAD, 0);
        // 从局部变量表取第1个元素 “targetService”压入栈顶
        methodVisitor.visitVarInsn(ALOAD, 1);
        // this 和 targetService 出栈, 调用targetService put 赋值给this.targetService
        methodVisitor.visitFieldInsn(PUTFIELD, proxyServiceName, "targetService", "L" + targetServiceName + ";");
        // 从局部变量表取第0个元素 “this”压入栈顶
        methodVisitor.visitVarInsn(ALOAD, 0);
        // 从局部变量表取第2个元素 “aspectService”压入栈顶
        methodVisitor.visitVarInsn(ALOAD, 2);
        // this 和 aspectService 出栈 将 targetService put 赋值给this.aspectService
        methodVisitor.visitFieldInsn(PUTFIELD, proxyServiceName, "aspectService", "L" + aspectServiceName + ";");
        // 方法返回
        methodVisitor.visitInsn(RETURN);
        // 设置最大栈数量，最大局部变量表数量
        methodVisitor.visitMaxs(2, 3);
        // 方法返回
        methodVisitor.visitEnd();

        // 创建代理方法 修饰符为public，方法名为 demoQuest
        MethodVisitor visitMethod = classWriter.visitMethod(ACC_PUBLIC, "demoQuest", "()I", null, null);
        // 从局部变量表取第0个元素 “this”压入栈顶
        visitMethod.visitVarInsn(ALOAD, 0);
        // this 出栈 将this.aspectService压入栈顶
        visitMethod.visitFieldInsn(GETFIELD, proxyServiceName, "aspectService", "L"+aspectServiceName+";");
        // 取栈顶元素出栈 也就是targetService 调用其preOperation方法， demoQuest的owner是AspectService, 无参无返回类型
        visitMethod.visitMethodInsn(INVOKEVIRTUAL, aspectServiceName,"preOperation", "()V", false);
        // 从局部变量表取第0个元素 “this”压入栈顶
        visitMethod.visitVarInsn(ALOAD, 0);
        // this 出栈, 取this.targetService压入栈顶
        visitMethod.visitFieldInsn(GETFIELD, proxyServiceName, "targetService", "L"+targetServiceName+";");
        // 取栈顶元素出栈 也就是targetService调用其demoQuest方法, demoQuest的owner是TargetService, 无参无返回类型
        visitMethod.visitMethodInsn(INVOKEVIRTUAL, targetServiceName, "demoQuest", "()I", false);
        // 方法返回
        visitMethod.visitInsn(IRETURN);
        // 设置最大栈数量，最大局部变量表数量
        visitMethod.visitMaxs(1, 1);
        // 方法返回
        visitMethod.visitEnd();

        // 生成字节码二进制流
        byte[] code = classWriter.toByteArray();
        // 自定义classloader加载类
        Class<?> clazz = (new AsmProxy()).defineClass(TargetService.class.getName() + "Proxy", code, 0, code.length);
        // 取其带参数的构造方法
        Constructor constructor = clazz.getConstructor(TargetService.class, AspectService.class);
        // 使用构造方法实例化对象
        Object object = constructor.newInstance(new TargetService(), new AspectService());

        // 使用TargetService类型的引用接收这个对象
        TargetService targetService;
        if (!(object instanceof TargetService)) {
            return;
        }
        targetService = (TargetService)object;

        System.out.println("生成代理类的名称: " + targetService.getClass().getName());
        // 调用被代理方法
        targetService.demoQuest();

        // 这里可以不用写, 但是如果想看最后生成的字节码长什么样子，可以写 "ascp-purchase-app/target/classes/"是我的根目录, 阅读者需要将其替换成自己的
        String classPath = "/Users/mr.l/cxuan-justdoit/";
        String path = classPath + proxyServiceName + ".class";
        FileOutputStream fos =
                new FileOutputStream(path);
        fos.write(code);
        fos.close();

    }
}

// 1、远程服务接口。
interface ThirdPartyTVLib is
    method listVideos()
    method getVideoInfo(id)
    method downloadVideo(id)

// 2、服务对象（目标对象）  
// 服务连接器的具体实现。该类的方法可以向腾讯视频请求信息。请求速度取决于
// 用户和腾讯视频的互联网连接情况。如果同时发送大量请求，即使所请求的信息
// 一模一样，程序的速度依然会减慢。
class ThirdPartyTVClass implements ThirdPartyTVLib is
    method listVideos() is
        // 向腾讯视频发送一个 API 请求。

    method getVideoInfo(id) is
        // 获取某个视频的元数据。

    method downloadVideo(id) is
        // 从腾讯视频下载一个视频文件。

// 3、代理对象  
// 为了节省网络带宽，我们可以将请求结果缓存下来并保存一段时间。但你可能无
// 法直接将这些代码放入服务类中。比如该类可能是第三方程序库的一部分或其签
// 名是`final（最终）`。因此我们会在一个实现了服务类接口的新代理类中放入
// 缓存代码。当代理类接收到真实请求后，才会将其委派给服务对象。
class CachedTVClass implements ThirdPartyTVLib is
    private field service: ThirdPartyTVLib
    private field listCache, videoCache
    field needReset

    constructor CachedTVClass(service: ThirdPartyTVLib) is
        this.service = service

    method listVideos() is
        if (listCache == null || needReset)
            listCache = service.listVideos()
        return listCache

    method getVideoInfo(id) is
        if (videoCache == null || needReset)
            videoCache = service.getVideoInfo(id)
        return videoCache

    method downloadVideo(id) is
        if (!downloadExists(id) || needReset)
            service.downloadVideo(id)

// 4、管理类
// 之前直接与服务对象交互的 GUI 类不需要改变，前提是它仅通过接口与服务对
// 象交互。我们可以安全地传递一个代理对象来代替真实服务对象，因为它们都实
// 现了相同的接口。
class TVManager is
    protected field service: ThirdPartyTVLib

    constructor TVManager(service: ThirdPartyTVLib) is
        this.service = service

    method renderVideoPage(id) is
        info = service.getVideoInfo(id)
        // 渲染视频页面。

    method renderListPanel() is
        list = service.listVideos()
        // 渲染视频缩略图列表。

    method reactOnUserInput() is
        renderVideoPage()
        renderListPanel()

// 5、客户端
// 程序可在运行时对代理进行配置。
class Application is
    method init() is
        aTVService = new ThirdPartyTVClass()
        aTVProxy = new CachedTVClass(aTVService)
        manager = new TVManager(aTVProxy)
        manager.reactOnUserInput()      
      

package refactoring_guru.proxy.example.some_cool_media_library;

import java.util.HashMap;

public interface ThirdPartyYouTubeLib {
    HashMap<String, Video> popularVideos();

    Video getVideo(String videoId);
}

public class ThirdPartyYouTubeClass implements ThirdPartyYouTubeLib {
  @Override
  public HashMap<String, Video> popularVideos() {
    connectToServer("http://www.youtube.com");
    return getRandomVideos();
  }

  @Override
  public Video getVideo(String videoId) {
    connectToServer("http://www.youtube.com/" + videoId);
    return getSomeVideo(videoId);
  }

  // -----------------------------------------------------------------------
  // Fake methods to simulate network activity. They as slow as a real life.

  private int random(int min, int max) {
    return min + (int) (Math.random() * ((max - min) + 1));
  }

  private void experienceNetworkLatency() {
    int randomLatency = random(5, 10);
    for (int i = 0; i < randomLatency; i++) {
      try {
        Thread.sleep(100);
      } catch (InterruptedException ex) {
        ex.printStackTrace();
      }
    }
  }

  private void connectToServer(String server) {
    System.out.print("Connecting to " + server + "... ");
    experienceNetworkLatency();
    System.out.print("Connected!" + "\n");
  }

  private HashMap<String, Video> getRandomVideos() {
    System.out.print("Downloading populars... ");

    experienceNetworkLatency();
    HashMap<String, Video> hmap = new HashMap<String, Video>();
    hmap.put("catzzzzzzzzz", new Video("sadgahasgdas", "Catzzzz.avi"));
    hmap.put("mkafksangasj", new Video("mkafksangasj", "Dog play with ball.mp4"));
    hmap.put("dancesvideoo", new Video("asdfas3ffasd", "Dancing video.mpq"));
    hmap.put("dlsdk5jfslaf", new Video("dlsdk5jfslaf", "Barcelona vs RealM.mov"));
    hmap.put("3sdfgsd1j333", new Video("3sdfgsd1j333", "Programing lesson#1.avi"));

    System.out.print("Done!" + "\n");
    return hmap;
  }

  private Video getSomeVideo(String videoId) {
    System.out.print("Downloading video... ");

    experienceNetworkLatency();
    Video video = new Video(videoId, "Some video title");

    System.out.print("Done!" + "\n");
    return video;
  }
}

public class Video {
  public String id;
  public String title;
  public String data;

  Video(String id, String title) {
    this.id = id;
    this.title = title;
    this.data = "Random video.";
  }
}

public class YouTubeCacheProxy implements ThirdPartyYouTubeLib {
  private ThirdPartyYouTubeLib youtubeService;
  private HashMap<String, Video> cachePopular = new HashMap<String, Video>();
  private HashMap<String, Video> cacheAll = new HashMap<String, Video>();

  public YouTubeCacheProxy() {
    this.youtubeService = new ThirdPartyYouTubeClass();
  }

  @Override
  public HashMap<String, Video> popularVideos() {
    if (cachePopular.isEmpty()) {
      cachePopular = youtubeService.popularVideos();
    } else {
      System.out.println("Retrieved list from cache.");
    }
    return cachePopular;
  }

  @Override
  public Video getVideo(String videoId) {
    Video video = cacheAll.get(videoId);
    if (video == null) {
      video = youtubeService.getVideo(videoId);
      cacheAll.put(videoId, video);
    } else {
      System.out.println("Retrieved video '" + videoId + "' from cache.");
    }
    return video;
  }

  public void reset() {
    cachePopular.clear();
    cacheAll.clear();
  }
}

public class YouTubeDownloader {
    private ThirdPartyYouTubeLib api;

    public YouTubeDownloader(ThirdPartyYouTubeLib api) {
        this.api = api;
    }

    public void renderVideoPage(String videoId) {
        Video video = api.getVideo(videoId);
        System.out.println("\n-------------------------------");
        System.out.println("Video page (imagine fancy HTML)");
        System.out.println("ID: " + video.id);
        System.out.println("Title: " + video.title);
        System.out.println("Video: " + video.data);
        System.out.println("-------------------------------\n");
    }

    public void renderPopularVideos() {
        HashMap<String, Video> list = api.popularVideos();
        System.out.println("\n-------------------------------");
        System.out.println("Most popular videos on YouTube (imagine fancy HTML)");
        for (Video video : list.values()) {
            System.out.println("ID: " + video.id + " / Title: " + video.title);
        }
        System.out.println("-------------------------------\n");
    }
}

public class Demo {
  public static void main(String[] args) {
    YouTubeDownloader naiveDownloader = new YouTubeDownloader(new ThirdPartyYouTubeClass());
    YouTubeDownloader smartDownloader = new YouTubeDownloader(new YouTubeCacheProxy());

    long naive = test(naiveDownloader);
    long smart = test(smartDownloader);
    System.out.print("Time saved by caching proxy: " + (naive - smart) + "ms");
  }

  private static long test(YouTubeDownloader downloader) {
    long startTime = System.currentTimeMillis();
    // User behavior in our app:
    downloader.renderPopularVideos();
    downloader.renderVideoPage("catzzzzzzzzz");
    downloader.renderPopularVideos();
    downloader.renderVideoPage("dancesvideoo");
    // Users might visit the same page quite often.
    downloader.renderVideoPage("catzzzzzzzzz");
    downloader.renderVideoPage("someothervid");

    long estimatedTime = System.currentTimeMillis() - startTime;
    System.out.print("Time elapsed: " + estimatedTime + "ms\n");
    return estimatedTime;
  }
}