加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

结合依赖注入与AOP简单模拟实现Spring框架

发布时间：2020-12-13 20:50:06 所属栏目：百科 来源：网络整理
导读：回顾： 在上一篇文章“ 演进式例解AOP ：Java 动态代理 ”中用一个打印报表的例子很简单地温习了一下 Java 中的动态代理实现，其实最终目的如标题，即利用动态代理结合之前写的关于控制反转（ IoC ）容器、依赖注入（ DI ）、读外部配置文件，来 集中式地、

回顾：

在上一篇文章“演进式例解AOP：Java 动态代理”中用一个打印报表的例子很简单地温习了一下 Java 中的动态代理实现，其实最终目的如标题，即利用动态代理结合之前写的关于控制反转（IoC）容器、依赖注入（DI）、读外部配置文件，来集中式地、简单地模拟一下Spring中所具有的IoC、DI、AOP功能。

前面相关的文章有：其一：引入容器，Service Locator、其二：引入IoC，DI 、其三：结合配置文件完善DI。以下仍旧是用“演进式例解AOP：Java 动态代理”中的报表生成的需求来进行模拟实现。

问题描述：

与前面相同，即：开发一个能够根据本地文件路径、远程文件路径生成HTML、PDF格式的报表的应用。由于不同操作系统下的文件路径有不同的路径分隔符，因此这里存在一个特殊要求：接收到文件路径生成报表之前必须验证该文件路径的合法性。这里假设该应用系统可以根据需要决定是否在报表生成【之前、之后】进行日志记录（这里强调了before、after 是为了配合AOP的前置通知、后置通知进行模拟，而验证功能一般只是前置）。

注意这里的特殊要求是：要通过外部配置文件更加灵活地决定日志记录的使用与否，这种额外添加功能的特点是AOP横切关注点灵活的体现。而前面的动态代理只是硬编码到具体实现当中去了。

解决方案：

既然已经讲明需要读取外部的配置文件了，那么就和之前的“结合配置文件完善DI”类似，通过一个 BeanUtil 工具类来负责根据配置文件中的组件声明、组件间关系来分别创建对象或执行依赖注入动作。

问题在于：日志记录这种额外功能（Crosscutting Concern，即横切关注点）如何可选择性地添加到具体的应用系统当中去。

注：关于横切关注点的我也没有深入探究（毕竟能力、经验非常有限），只了解有这么一回事及其简单应用场景而已（两次读过《冒号课堂》一书又给忘了…但极力推荐本书），暂时先理解为需要额外添加的功能即可（例如日志记录），以下可能会时不时用到这概念。

实现方法：

为了使得这种before（前置）、after（后置）添加的额外功能更加通用，这里利用Java中的OO概念来抽象出Advice（通知）这一源自AOP的重要概念。关于Advice的调用执行（即横切关注点的执行），是在 ProxyHandler 类中的invoke() 方法利用了Java的动态代理技术来实现的：当beforeAdvice或afterAdvice被注入之后，则相对应地调用；若未注入Advice，则效果如普通方法调用一样。

另外，这里的外部配置文件依然采用 .properties 格式，即 Key-Value 形式，包含组件声明、组件间依赖注入关系，具体如下（注意其中组件名与具体实现代码相关）：

 
 
    
  
  
  1. #definebeans
    2. 
  
  
  2. Bean.target=AOP.aop_di.RemoteReportCreator
    3. 
  
  
  3. Bean.targetProxy=AOP.aop_di.ProxyHandler
    4. 
  
  
  4. Bean.logBeforeAdvice=AOP.aop_di.LogBeforeAdvice
    5. 
  
  
  5. Bean.logAfterAdvice=AOP.aop_di.LogAfterAdvice
    6. 
  
  
    7. 
  
  
  7. #defineDI
    8. 
  
  
  8. DI.targetProxy.target=target
    9. 
  
  
  9. DI.targetProxy.beforeAdvice=logBeforeAdvice
    10. 
  
  
  10. DI.targetProxy.afterAdvice=logAfterAdvice
    11.

好像下面的类图结构、具体代码实现然而让人更加容易明白，这里就不再说得更复杂难理解了。注意其中绿色背景的“AOP_DI 核心结构”是指类比Spring 框架，其他的则为框架使用者自定义（例如ReportCreator 类结构）或必须实现的子类（例如LogBeforeAdvice 子类）。对了，我还没画时序图呢，有时序图肯定会更加容易直观地理解。

依据具体需求和分析，设计类图框架如下：

完整的简单代码实现如下：

 
 
    
  
  
  1. /**
    2. 
  
  
  2. *报表生成的公共接口
    3. 
  
  
  3. */
    4. 
  
  
  4. interfaceReportCreator{
    5. 
  
  
  5. publicvoidgetHtmlReport(Stringpath);
    6. 
  
  
    7. 
  
  
  7. publicvoidgetPdfReport(Stringpath);
    8. 
  
  
  8. }
    9. 
  
  
    10. 
  
  
  10. /**
    11. 
  
  
  11. *用于根据【本地】文件路径生成报表
    12. 
  
  
  12. */
    13. 
  
  
  13. classLocalReportCreatorimplementsReportCreator{
    14. 
  
  
    15. 
  
  
  15. publicvoidgetHtmlReport(Stringpath){
    16. 
  
  
  16. System.out.println("根据【本地】文件生成【HTML】格式的报表...");
    17. 
  
  
  17. }
    18. 
  
  
    19. 
  
  
  19. publicvoidgetPdfReport(Stringpath){
    20. 
  
  
  20. System.out.println("根据【本地】文件生成【PDF】格式的报表...");
    21. 
  
  
  21. }
    22. 
  
  
  22. }
    23. 
  
  
    24. 
  
  
  24. /**
    25. 
  
  
  25. *用于根据【远程】文件路径生成报表
    26. 
  
  
  26. */
    27. 
  
  
  27. classRemoteReportCreatorimplementsReportCreator{
    28. 
  
  
    29. 
  
  
  29. publicvoidgetHtmlReport(Stringpath){
    30. 
  
  
  30. System.out.println("根据【远程】文件生成【HTML】格式的报表...");
    31. 
  
  
  31. }
    32. 
  
  
    33. 
  
  
  33. publicvoidgetPdfReport(Stringpath){
    34. 
  
  
  34. System.out.println("根据【远程】文件生成【PDF】格式的报表...");
    35. 
  
  
  35. }
    36. 
  
  
  36. }
    37. 
 
 
 
 
    
  
  
  1. /**
    2. 
  
  
  2. *标识性接口，关键在于分离before、after横切关注点
    3. 
  
  
  3. */
    4. 
  
  
  4. interfaceAdvice{
    5. 
  
  
    6. 
  
  
  6. }
    7. 
  
  
    8. 
  
  
  8. /**
    9. 
  
  
  9. *before横切关注点，即在原方法调用【之前】被调用
    10. 
  
  
  10. */
    11. 
  
  
  11. interfaceBeforeAdviceextendsAdvice{
    12. 
  
  
  12. publicvoidbefore();
    13. 
  
  
  13. }
    14. 
  
  
    15. 
  
  
  15. /**
    16. 
  
  
  16. *after横切关注点，即在原方法调用【之后】被调用
    17. 
  
  
  17. */
    18. 
  
  
  18. interfaceAfterAdviceextendsAdvice{
    19. 
  
  
  19. publicvoidafter();
    20. 
  
  
  20. }
    21. 
 
 

 
 
    
  
  
  1. /**
    2. 
  
  
  2. *用户自定义具体实现的before横切关注点
    3. 
  
  
  3. */
    4. 
  
  
  4. classLogBeforeAdviceimplementsBeforeAdvice{
    5. 
  
  
    6. 
  
  
  6. publicvoidbefore(){
    7. 
  
  
  7. System.out.println("原业务方法被调用【之前】先打印日志...");
    8. 
  
  
  8. }
    9. 
  
  
  9. }
    10. 
  
  
    11. 
  
  
  11. classLogAfterAdviceimplementsAfterAdvice{
    12. 
  
  
    13. 
  
  
  13. publicvoidafter(){
    14. 
  
  
  14. System.out.println("原业务方法被调用【之后】再打印日志...");
    15. 
  
  
  15. }
    16. 
  
  
  16. }
    17. 
 
 

 
 
    
  
  
  1. /**
    2. 
  
  
  2. *代理提供者：实现invoke方法，构造具有横切关注点的动态代理对象
    3. 
  
  
  3. */
    4. 
  
  
  4. classProxyHandlerimplementsInvocationHandler{
    5. 
  
  
  5. privateObjecttarget;//被代理的目标对象
    6. 
  
  
  6. privateAdvicebeforeAdvice;//before横切关注点
    7. 
  
  
  7. privateAdviceafterAdvice;//after横切关注点
    8. 
  
  
    9. 
  
  
  9. publicProxyHandler(){
    10. 
  
  
  10. //空构造方法
    11. 
  
  
  11. }
    12. 
  
  
    13. 
  
  
  13. /**
    14. 
  
  
  14. *3个setter方式的用于依赖注入
    15. 
  
  
  15. */
    16. 
  
  
  16. publicvoidsetTarget(Objecttarget){
    17. 
  
  
  17. this.target=target;
    18. 
  
  
  18. }
    19. 
  
  
    20. 
  
  
  20. publicvoidsetBeforeAdvice(AdvicebeforeAdvice){
    21. 
  
  
  21. this.beforeAdvice=beforeAdvice;
    22. 
  
  
  22. }
    23. 
  
  
    24. 
  
  
  24. publicvoidsetAfterAdvice(AdviceafterAdvice){
    25. 
  
  
  25. this.afterAdvice=afterAdvice;
    26. 
  
  
  26. }
    27. 
  
  
    28. 
  
  
  28. /**
    29. 
  
  
  29. *实现invoke()方法，添加before、after关注点以实现AOP
    30. 
  
  
  30. */
    31. 
  
  
  31. publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
    32. 
  
  
  32. throwsThrowable{
    33. 
  
  
    34. 
  
  
  34. //在被代理对象业务方法前后添加横切关注点方法
    35. 
  
  
  35. this.aspect(this.beforeAdvice,"before");
    36. 
  
  
  36. Objectresult=method.invoke(this.target,args);
    37. 
  
  
  37. this.aspect(this.afterAdvice,"after");
    38. 
  
  
    39. 
  
  
  39. returnresult;
    40. 
  
  
  40. }
    41. 
  
  
    42. 
  
  
  42. /**
    43. 
  
  
  43. *依据是否注入横切关注点来决定before、after的调用
    44. 
  
  
  44. */
    45. 
  
  
  45. privatevoidaspect(Adviceadvice,StringaspectName)throwsException{
    46. 
  
  
  46. if(advice!=null){
    47. 
  
  
  47. Classc=advice.getClass();
    48. 
  
  
  48. Method[]methods=c.getMethods();
    49. 
  
  
  49. for(Methodm:methods){
    50. 
  
  
  50. if(aspectName.equals(m.getName())){
    51. 
  
  
  51. //以null参数调用已实现的before、after方法
    52. 
  
  
  52. methods[0].invoke(advice,null);
    53. 
  
  
  53. }
    54. 
  
  
  54. }
    55. 
  
  
  55. }
    56. 
  
  
  56. }
    57. 
  
  
    58. 
  
  
  58. /**
    59. 
  
  
  59. *静态工厂方法，用于获取已注入before、after的动态代理实例
    60. 
  
  
  60. */
    61. 
  
  
  61. publicObjectgetProxy(Objecttarget){
    62. 
  
  
  62. ClasstargetClass=target.getClass();
    63. 
  
  
  63. /*
    64. 
  
  
  64. *loader:目标类的类加载器interfaces:目标类已实现的接口handler:
    65. 
  
  
  65. *转发方法调用的调用处理类实例，这里是当前Handler
    66. 
  
  
  66. */
    67. 
  
  
  67. ClassLoaderloader=targetClass.getClassLoader();
    68. 
  
  
  68. Class[]interfaces=targetClass.getInterfaces();
    69. 
  
  
    70. 
  
  
  70. //创建并返回动态代理类实例
    71. 
  
  
  71. returnProxy.newProxyInstance(loader,interfaces,this);
    72. 
  
  
  72. }
    73. 
  
  
  73. }
    74. 
 
 

 
 
    
  
  
  1. /**
    2. 
  
  
  2. *工厂类：从外部读取配置信息创建并注入所需对象
    3. 
  
  
  3. */
    4. 
  
  
  4. classProxyFactory{
    5. 
  
  
    6. 
  
  
  6. //代理对象的提供者
    7. 
  
  
  7. privateProxyHandlerhandler;
    8. 
  
  
  8. //被代理对象
    9. 
  
  
  9. privateObjecttarget;
    10. 
  
  
  10. //所有组件类的集合
    11. 
  
  
  11. privateMap<String,Object>beans;
    12. 
  
  
    13. 
  
  
  13. /**
    14. 
  
  
  14. *读取外部配置文件初始化所有组件间的关系
    15. 
  
  
  15. */
    16. 
  
  
  16. publicProxyFactory(StringconfigFile){
    17. 
  
  
  17. beans=newHashMap<String,Object>();
    18. 
  
  
    19. 
  
  
  19. try{
    20. 
  
  
  20. Propertiesprops=newProperties();
    21. 
  
  
  21. props.load(newFileInputStream(configFile));
    22. 
  
  
    23. 
  
  
  23. //bean声明及依赖注入的key-value对
    24. 
  
  
  24. Map<String,String>beanKV=newHashMap<String,String>();
    25. 
  
  
  25. Map<String,String>diKV=newHashMap<String,String>();
    26. 
  
  
    27. 
  
  
  27. for(Map.Entryentry:props.entrySet()){
    28. 
  
  
  28. Stringkey=(String)entry.getKey();
    29. 
  
  
  29. Stringvalue=(String)entry.getValue();
    30. 
  
  
    31. 
  
  
  31. if(key.startsWith("Bean")){
    32. 
  
  
  32. beanKV.put(key,value);
    33. 
  
  
  33. }elseif(key.startsWith("DI")){
    34. 
  
  
  34. diKV.put(key,value);
    35. 
  
  
  35. }
    36. 
  
  
  36. }
    37. 
  
  
    38. 
  
  
  38. //一定要先处理bean声明再进行依赖注入
    39. 
  
  
  39. this.processKeyValue(beanKV);
    40. 
  
  
  40. this.processKeyValue(diKV);
    41. 
  
  
    42. 
  
  
  42. }catch(Exceptione){
    43. 
  
  
  43. e.printStackTrace();
    44. 
  
  
  44. }
    45. 
  
  
  45. }
    46. 
  
  
    47. 
  
  
  47. /**
    48. 
  
  
  48. *处理key-value
    49. 
  
  
  49. */
    50. 
  
  
  50. privatevoidprocessKeyValue(Map<String,String>map)throwsException{
    51. 
  
  
  51. for(Map.Entryentry:map.entrySet()){
    52. 
  
  
  52. Stringkey=(String)entry.getKey();
    53. 
  
  
  53. Stringvalue=(String)entry.getValue();
    54. 
  
  
  54. this.handleEntry(key,value);
    55. 
  
  
  55. }
    56. 
  
  
  56. }
    57. 
  
  
    58. 
  
  
  58. /**
    59. 
  
  
  59. *利用工具类BeanUtil处理key-value对，即创建或注入bean
    60. 
  
  
  60. */
    61. 
  
  
  61. privatevoidhandleEntry(Stringkey,Stringvalue)throwsException{
    62. 
  
  
  62. String[]keyParts=key.split(".");
    63. 
  
  
    64. 
  
  
  64. Stringtag=keyParts[0];
    65. 
  
  
  65. if("Bean".equals(tag)){
    66. 
  
  
  66. //组件定义：利用反射实例化该组件
    67. 
  
  
  67. Objectbean=Class.forName(value).newInstance();
    68. 
  
  
  68. System.out.println("组件定义："+bean.getClass().getName());
    69. 
  
  
  69. beans.put(keyParts[1],bean);
    70. 
  
  
    71. 
  
  
  71. }elseif("DI".equals(tag)){
    72. 
  
  
  72. //依赖注入：获取需要bean的主体，以及被注入的实例
    73. 
  
  
  73. Objectbean=beans.get(keyParts[1]);
    74. 
  
  
  74. ObjectfieldRef=beans.get(value);
    75. 
  
  
  75. System.out.println("依赖注入："+bean.getClass().getName()+
    76. 
  
  
  76. "."+fieldRef.getClass().getName());
    77. 
  
  
  77. BeanUtil.setProperty(bean,keyParts[2],fieldRef);
    78. 
  
  
  78. }
    79. 
  
  
  79. }
    80. 
  
  
    81. 
  
  
  81. /**
    82. 
  
  
  82. *针对Factory已创建的Target获取代理对象
    83. 
  
  
  83. */
    84. 
  
  
  84. publicObjectgetProxy(StringproxyName,StringtargetNanme){
    85. 
  
  
  85. Objecttarget=this.beans.get(targetNanme);
    86. 
  
  
  86. if(target!=null){
    87. 
  
  
  87. this.handler=(ProxyHandler)this.beans.get(proxyName);
    88. 
  
  
  88. returnthis.handler.getProxy(target);
    89. 
  
  
  89. }
    90. 
  
  
  90. returnnull;
    91. 
  
  
  91. }
    92. 
  
  
    93. 
  
  
  93. }
    94. 
 
 

 
 
    
  
  
  1. /**
    2. 
  
  
  2. *工具类：处理配置文件中K-V对，即创建或注入bean
    3. 
  
  
  3. */
    4. 
  
  
  4. publicclassBeanUtil{
    5. 
  
  
    6. 
  
  
  6. /**
    7. 
  
  
  7. *利用反射进行依赖注入
    8. 
  
  
  8. *@parambean需要注入外部依赖的主体类实例
    9. 
  
  
  9. *@paramfieldName需要注入的字段名
    10. 
  
  
  10. *@paramfieldRef被注入的组件实例
    11. 
  
  
  11. *@throwsException
    12. 
  
  
  12. */
    13. 
  
  
  13. publicstaticvoidsetProperty(Objectbean,StringfieldName,
    14. 
  
  
  14. ObjectfieldRef)throwsException{
    15. 
  
  
    16. 
  
  
  16. //获取主体类的完整名称
    17. 
  
  
  17. StringclassName=getClassName(bean);
    18. 
  
  
    19. 
  
  
  19. //获取主体类的所有Method
    20. 
  
  
  20. ClassbeanClass=Class.forName(className);
    21. 
  
  
  21. Method[]methods=beanClass.getMethods();
    22. 
  
  
    23. 
  
  
  23. //准备对应setter()方法的完整名称
    24. 
  
  
  24. StringsetterName="set"+fieldName.substring(0,1).toUpperCase()
    25. 
  
  
  25. +fieldName.substring(1,fieldName.length());
    26. 
  
  
    27. 
  
  
  27. //遍历找到对应setter方法，并调用invoke()方法进行注入
    28. 
  
  
  28. for(Methodm:methods){
    29. 
  
  
  29. if(m.getName().equals(setterName)){
    30. 
  
  
  30. m.invoke(bean,fieldRef);
    31. 
  
  
  31. System.out.println("已调用"+m.getName()+"()向"+className
    32. 
  
  
  32. +"注入"+getClassName(fieldRef));
    33. 
  
  
  33. return;
    34. 
  
  
  34. }
    35. 
  
  
  35. }
    36. 
  
  
  36. System.out.println(">>注入失败:"+className+"类中不存在"+fieldName
    37. 
  
  
  37. +"字段对应的setter()方法...");
    38. 
  
  
  38. }
    39. 
  
  
    40. 
  
  
  40. /**
    41. 
  
  
  41. *根据Object实例获取类的完整名称
    42. 
  
  
  42. */
    43. 
  
  
  43. privatestaticStringgetClassName(Objecto){
    44. 
  
  
  44. if(o==null){
    45. 
  
  
  45. System.out.println("传入的Object实例为null...");
    46. 
  
  
  46. returnnull;
    47. 
  
  
  47. }
    48. 
  
  
  48. StringfullName=o.toString();
    49. 
  
  
  49. StringclassName=fullName.substring(0,fullName.indexOf("@"));
    50. 
  
  
  50. returnclassName;
    51. 
  
  
  51. }
    52. 
  
  
  52. }
    53. 
 
 

 
 
    
  
  
  1. //测试
    2. 
  
  
  2. publicclassAOP_DI{
    3. 
  
  
  3. publicstaticvoidmain(String[]args){
    4. 
  
  
  4. //初始化环境配置
    5. 
  
  
  5. ProxyFactoryproxyFactory=newProxyFactory("config.properties");
    6. 
  
  
  6. //获取被代理后的Target对象
    7. 
  
  
  7. ReportCreatorreportCreator=(ReportCreator)proxyFactory
    8. 
  
  
  8. .getProxy("targetProxy","target");
    9. 
  
  
  9. //使用被代理后的target对象提供的服务
    10. 
  
  
  10. reportCreator.getHtmlReport("http://code.google.com/file/...");
    11. 
  
  
  11. }
    12. 
  
  
  12. }
    13.

根据最前面的配置文件信息，运行可得以下结果：

 
 
    
  
  
  1. 组件定义：AOP.aop_di.ProxyHandler
    2. 
  
  
  2. 组件定义：AOP.aop_di.LogBeforeAdvice
    3. 
  
  
  3. 组件定义：AOP.aop_di.LogAfterAdvice
    4. 
  
  
  4. 组件定义：AOP.aop_di.RemoteReportCreator
    5. 
  
  
  5. 依赖注入：AOP.aop_di.ProxyHandler.AOP.aop_di.LogBeforeAdvice
    6. 
  
  
  6. 已调用setBeforeAdvice()向AOP.aop_di.ProxyHandler注入AOP.aop_di.LogBeforeAdvice
    7. 
  
  
  7. 依赖注入：AOP.aop_di.ProxyHandler.AOP.aop_di.LogAfterAdvice
    8. 
  
  
  8. 已调用setAfterAdvice()向AOP.aop_di.ProxyHandler注入AOP.aop_di.LogAfterAdvice
    9. 
  
  
  9. 依赖注入：AOP.aop_di.ProxyHandler.AOP.aop_di.RemoteReportCreator
    10. 
  
  
  10. 已调用setTarget()向AOP.aop_di.ProxyHandler注入AOP.aop_di.RemoteReportCreator
    11. 
  
  
  11. 原业务方法被调用【之前】先打印日志...
    12. 
  
  
  12. 根据【远程】文件生成【HTML】格式的报表...
    13. 
  
  
  13. 原业务方法被调用【之后】再打印日志...
    14.

修改配置文件，即去掉其中的LogAfterAdvice的注入，如下：

 
 
    
  
  
  1. #definebeans
    2. 
  
  
  2. Bean.target=AOP.aop_di.RemoteReportCreator
    3. 
  
  
  3. Bean.targetProxy=AOP.aop_di.ProxyHandler
    4. 
  
  
  4. Bean.logBeforeAdvice=AOP.aop_di.LogBeforeAdvice
    5. 
  
  
    6. 
  
  
  6. #defineDI
    7. 
  
  
  7. DI.targetProxy.target=target
    8. 
  
  
  8. DI.targetProxy.beforeAdvice=logBeforeAdvice
    9.

运行结果如下：

 
 
    
  
  
  1. 组件定义：AOP.aop_di.ProxyHandler
    2. 
  
  
  2. 组件定义：AOP.aop_di.LogBeforeAdvice
    3. 
  
  
  3. 组件定义：AOP.aop_di.RemoteReportCreator
    4. 
  
  
  4. 依赖注入：AOP.aop_di.ProxyHandler.AOP.aop_di.LogBeforeAdvice
    5. 
  
  
  5. 已调用setBeforeAdvice()向AOP.aop_di.ProxyHandler注入AOP.aop_di.LogBeforeAdvice
    6. 
  
  
  6. 依赖注入：AOP.aop_di.ProxyHandler.AOP.aop_di.RemoteReportCreator
    7. 
  
  
  7. 已调用setTarget()向AOP.aop_di.ProxyHandler注入AOP.aop_di.RemoteReportCreator
    8. 
  
  
  8. 原业务方法被调用【之前】先打印日志...
    9. 
  
  
  9. 根据【远程】文件生成【HTML】格式的报表...
    10.

小结：

似乎勉强达到了前面我所说的目标：利用动态代理结合之前写的关于控制反转（IoC）容器、依赖注入（DI）、读外部配置文件，来集中式地、简单地模拟一下Spring中所具有的IoC、DI、AOP功能。

其实问题存在不少，而且在我实现代码时也遇到一些问题，但现在篇幅已经挺长的了（不知道有没谁会坚持看完？哈…），可能会另外写一篇总结来记录一些我记忆较深刻的方面，我觉得其中更重要的是：写这几篇文章的意图是啥呢？从哪里得到思路的？:-D

瞧瞧以下您感兴趣的、相关的内容 ^_^

★演进式例解AOP：Java 动态代理

★演进式例解控制反转（IoC）、依赖注入（DI）之一

★演进式例解控制反转（IoC）、依赖注入（DI）之二

★结合配置文件、反射完善控制反转（IoC）、依赖注入（DI）

?装饰模式（Decorator）与动态代理的强强联合

?（Dynamic Proxy）动态代理模式的Java实现

?（Factory Method）工厂方法模式的Java实现

?Java RMI 框架的工厂方法模式实现

?（Mediator）中介者模式的Java实现（加修改）

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同