这篇博文,我们主要以类图和代码的形式来对照学习一下静态代理和动态代理。重点解析各自的优缺点。

定义

代理模式(Proxy Pattern)是对象的结构型模式,代理模式给某一个对象提供了一个代理对象,并由代理对象控制对原对象的引用。

代理模式不会改变原来的接口和行为,仅仅是转由代理干某件事,代理能够控制原来的目标,比如:代理商,代理商仅仅会买东西,但并不会改变行为。不会制造东西。

让我们通过以下的代码好好理解一下这句话。

分类

静态代理和动态代理

静态代理

静态代理类图

代码演示样例

接口

  1. package com.liang.pattern;
  2.  
  3. public interface UserManager {
  4.  
  5. public void addUser(String userId,String userName);
  6.  
  7. public void delUser(String userId);
  8.  
  9. public void modifyUser(String userId,String userName);
  10.  
  11. public String findUser(String userId);
  12.  
  13. }

目标对象

  1. package com.liang.pattern;
  2.  
  3. public class UserManagerImpl implements UserManager {
  4.  
  5. public void addUser(String userId, String userName) {
  6.  
  7. try{
  8. System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
  9. }catch(Exception e){
  10. e.printStackTrace();
  11.  
  12. throw new RuntimeException();
  13. }
  14.  
  15. }
  16.  
  17. public void delUser(String userId) {
  18.  
  19. System.out.println("UserManagerImpl.delUser() userId-->>" + userId);
  20. }
  21.  
  22. public String findUser(String userId) {
  23.  
  24. System.out.println("UserManagerImpl.findUser() userId-->>" + userId);
  25. return "于亮";
  26. }
  27.  
  28. public void modifyUser(String userId, String userName) {
  29.  
  30. System.out.println("UserManagerImpl.modifyUser() userId-->>" + userId);
  31. }
  32.  
  33. }

代理类,我们使用代理对象做一些日志记录,我们将简略的打印信息到控制台。

  1. package com.liang.pattern;
  2.  
  3. public class UserManagerImplProxy implements UserManager {
  4.  
  5. private UserManager userManager;
  6. public UserManagerImplProxy(UserManager userManager){
  7. this.userManager = userManager;
  8. }
  9. public void addUser(String userId, String userName) {
  10. //记录日志等操作或打印输入參数
  11. System.out.println("start-->>addUser() userId-->>" + userId);
  12. try{
  13.  
  14. userManager.addUser(userId, userName);
  15. //运行成功。打印成功信息
  16. System.out.println("success-->>addUser()");
  17. }catch(Exception e){
  18. e.printStackTrace();
  19. //失败时。打印失败信息
  20. System.out.println("error-->>addUser()");
  21. //throw new RuntimeException();
  22. }
  23. }
  24.  
  25. public void delUser(String userId) {
  26. //同上,略
  27. userManager.delUser(userId);
  28. }
  29.  
  30. public String findUser(String userId) {
  31. //同上。略
  32. userManager.findUser(userId);
  33. return null;
  34. }
  35.  
  36. public void modifyUser(String userId, String userName) {
  37. //同上。略
  38. userManager.modifyUser(userId, userName);
  39.  
  40. }
  41.  
  42. }

client调用

  1. package com.liang.pattern;
  2.  
  3. public class Client {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9. UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
  10. userManager.addUser("001","于亮");
  11. }
  12. }

输出结果,此方法运行成功

  1. start-->>addUser() userId-->>001
  2. UserManagerImpl.addUser() userId-->>001
  3. success-->>addUser()

从类图我们能够看出。client本来能够直接和目标对象打交道,代理中间加了一个间接层。他们实现的功能是一样的,也没有改变參数。相信大家对上面的类图和代码非常熟悉。跟我们平时看别人的博文一样。没有不论什么差别。以下我们看一下静态代理的优缺点。

优缺点

长处

1、直观感受,静态代理是实实在在的存在的,我们自己写的。

2、在编译期增加,提前就指定好了谁调用谁,效率高。

缺点

相同,它的长处也成了它致命的缺点。

1、静态代理非常麻烦。须要大量的代理类

当我们有多个目标对象须要代理时,我就须要建立多个代理类。改变原有的代码,改的多了就非常有可能出问题,必须要又一次測试。

2、反复的代码会出如今各个角落里,违背了一个原则:反复不是好味道

我们应该杜绝一次次的反复。

3、在编译期增加,系统的灵活性差

我们能够看到代理类的每一个方法中,都有记录日志,运行成功或失败的代码,每一个方法都反复了一遍,假设我们须要改动的话,并没有比不用静态代理时降低改动的地方。仅仅是不用改动目标类。动态代理非常好的为我们攻克了这个问题。以下我们看一下动态代理。

动态代理

动态代理类图

代码演示样例

watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvaml1cWl5dWxpYW5n/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast" alt="">

代理类(不明确,就看看凝视吧)

  1. package com.liang.pattern;
  2.  
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6. /**
  7. * 採用JDK动态代理必须实现InvocationHandler接口。採用Proxy类创建对应的代理类
  8. * @author liang
  9. *
  10. */
  11. public class ProxyHandler implements InvocationHandler {
  12.  
  13. private Object targetObject;
  14. /**
  15. * 目标的初始化方法。依据目标生成代理类
  16. * @param targetObject
  17. * @return
  18. */
  19. public Object newProxyInstance(Object targetObject){
  20. this.targetObject = targetObject;
  21. //第一个參数,目标的装载器
  22. //第二个參数,目标接口,为每一个接口生成代理
  23. //第三个參数,调用实现了InvocationHandler的对象。当你一调用代理,代理就会调用InvocationHandler的invoke方法
  24. return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(), this);
  25. }
  26.  
  27. /**
  28. * 反射,这样你能够在不知道详细的类的情况下,依据配置的參数去调用一个类的方法。
  29.  
  30. 在灵活编程的时候很实用。
  31. */
  32. public Object invoke(Object proxy, Method method, Object[] args)
  33. throws Throwable {
  34. //记录日志等操作或打印输入參数
  35. System.out.println("start-->>" + method.getName());
  36. for(int i=0;i<args.length;i++){
  37. //打印调用目标方法的參数
  38. System.out.println(args[i]);
  39. }
  40. Object ret = null;
  41. try{
  42. //调用目标方法
  43. ret = method.invoke(targetObject, args);
  44. //运行成功。打印成功信息
  45. System.out.println("success-->>" + method.getName());
  46. }catch(Exception e){
  47. e.printStackTrace();
  48. //失败时,打印失败信息
  49. System.out.println("error-->>" + method.getName());
  50. throw e;
  51. }
  52.  
  53. return ret;
  54. }
  55.  
  56. }

client调用

  1. package com.liang.pattern;
  2.  
  3. public class Client {
  4.  
  5. /**
  6. * @param args
  7. */
  8. public static void main(String[] args) {
  9.  
  10. ProxyHandler proxyHandler = new ProxyHandler();
  11. UserManager userManager = (UserManager)proxyHandler.newProxyInstance(new UserManagerImpl());
  12.  
  13. String name = userManager.findUser("0001");
  14. System.out.println("client.main-->>" + name);
  15. }
  16.  
  17. }

输出结果,执行成功

  1. start-->>findUser
  2. 0001
  3. UserManagerImpl.findUser() userId-->>0001
  4. success-->>findUser
  5. client.main-->>于亮

接口和目标类,同上,我就不再浪费大家的带宽了。

优缺点

长处

1、一个动态代理类更加简单了,能够解决创建多个静态代理的麻烦,避免不断的反复多余的代码

2、调用目标代码时,会在方法“执行时”动态的增加,决定你是什么类型,才调谁,灵活

缺点

1、系统灵活了。可是相比而言,效率减少了,比静态代理慢一点

2、动态代理比静态代理在代码的可读性上差了一点,不太easy理解

3、JDK动态代理仅仅能对实现了接口的类进行代理

总结

静态代理VS动态代理,打成了平手,各自有各的独特之处,均不可取代,在项目中究竟使用哪种代理,没有最好。仅仅有更合适。

【java项目实战】代理模式(Proxy Pattern),静态代理 VS 动态代理的更多相关文章

  1. 设计模式系列之代理模式(Proxy Pattern)——对象的间接访问

    说明:设计模式系列文章是读刘伟所著<设计模式的艺术之道(软件开发人员内功修炼之道)>一书的阅读笔记.个人感觉这本书讲的不错,有兴趣推荐读一读.详细内容也可以看看此书作者的博客https:/ ...

  2. 代理模式(Proxy pattern)

    代理模式(proxy pattern):作用:为其他对象提供一种代理,以控制对这个对象的访问.代理对象在客户端对象和目标对象之间起中介的作用. 代理模式涉及到的角色: 抽象角色:声明真实对象和代理对象 ...

  3. 乐在其中设计模式(C#) - 代理模式(Proxy Pattern)

    原文:乐在其中设计模式(C#) - 代理模式(Proxy Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 代理模式(Proxy Pattern) 作者:webabcd 介绍 为 ...

  4. 二十四种设计模式:代理模式(Proxy Pattern)

    代理模式(Proxy Pattern) 介绍为其他对象提供一个代理以控制对这个对象的访问. 示例有一个Message实体类,某对象对它的操作有Insert()和Get()方法,用一个代理来控制对这个对 ...

  5. 设计模式 - 代理模式(proxy pattern) 未使用代理模式 具体解释

    代理模式(proxy pattern) 未使用代理模式 详细解释 本文地址: http://blog.csdn.net/caroline_wendy 部分代码參考: http://blog.csdn. ...

  6. 你管这叫代理模式(Proxy Pattern)

    代理模式   代理模式即给一个真实类提供一个代理类,该代理类代替真实类完成其功能,一般还可在代理类上添加一些真实类不具有的附加功能,通俗来讲代理模式就是我们生活中常见的中介,代理模式又可分为静态代理和 ...

  7. 七个结构模式之代理模式(Proxy Pattern)

    定义: 给某一个对象提供一个代理或者占位符,并由代理类来控制对原对象的访问.代理对象在客户端和实际对象之间启到了中介作用,并且强调了代理类对原对象的控制作用.例如:安全代理.缓冲代理.远程代理等. 结 ...

  8. 13.代理模式(Proxy Pattern)

    using System; namespace Test { //抽象角色:声明真实对象和代理对象的共同接口. //代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象, //同时代理 ...

  9. C#设计模式——代理模式(Proxy Pattern)

    一.概述在软件开发中,有些对象由于创建成本高.访问时需要与其它进程交互等原因,直接访问会造成系统速度慢.复杂度增大等问题.这时可以使用代理模式,给系统增加一层间接层,通过间接层访问对象,从而达到隐藏系 ...

  10. 设计模式——代理模式(Proxy Pattern)

    代理模式(Proxy),为其他对象提供一种代理以控制对这个对象的访问. UML图: 模型设计: Subject类: package com.cnblog.clarck; /** * Subject 类 ...

随机推荐

  1. thinkphp 具体常量,在view里面使用

    1 2 3 4 5 6 7 8 9 '__TMPL__'      =>  APP_TMPL_PATH,  // 项目模板目录 '__ROOT__'      =>  __ROOT__,  ...

  2. linux Redis 5.0集群搭建

    文档结构如下: Redis cluster 是redis的分布式解决方案,在3.0版本正式推出后,有效的解决了redis分布式方面的需求:当遇到单机内存,并发,流量等瓶颈是,可以采用cluster架构 ...

  3. 如何用jQuery实现div随鼠标移动而移动?(详解)----2017-05-12

    重点是弄清楚如何获取鼠标现位置与移动后位置,div现在位置与移动后位置: 用jQuery实现div随鼠标移动而移动,不是鼠标自身的位置!!而是div相对于之前位置的移动 代码如下:(注意看绿色部分的解 ...

  4. c语言system()介绍

    2013-09-0916:06:02 1. 头文件: #include <stdlib.h> 2. 定义函数: int system(const char * string); 3. 函数 ...

  5. web前端处理订单待支付倒计时计算显示问题

    在商城类项目的时候,有很多待支付的订单,有时候在订单列表页面会分别显示倒计时,就是页面会有很多倒计时的订单. 处理方法: 1.调用后端接口拿到所有的订单,获取所有的倒计时订单,获取到期时间(尽量时间戳 ...

  6. SQLServer int转float

    例: select 2/4  会得到0 改为 select 2/4.0 则会得到0.500000 也同时达到了int转float的效果

  7. WordPress的wordfence插件的设置方法

  8. mybatis 高级映射和spring整合之高级映射(4)

    mybatis 高级映射和spring整合之高级映射 ----------------学习结构-------------------- 0.0 对订单商品数据模型进行分析 1.0 高级映射 1.1 一 ...

  9. hdu1811 Rank of Tetris 拓扑排序+并查集

    这道题是拓扑排序和并查集的综合运用. 由于排行榜是一种从高到低的排序.所以在拓扑排序的时候,如果有一次加入的入度为零的点数大于1,就有变得不确定了(UNCERTAIN). 由于只有一棵树,当树的数量大 ...

  10. UVa10082 没有通过

    #include<stdio.h> char s[]={"`1234567890-=QWERTYUIOP[]\ASDFGHJKL;'ZXCVBNM,./"},b[100 ...