动态解耦 静态解耦

本文探讨了静态解耦和动态解耦的概念。静态解耦通过依赖接口来减少耦合,但仍然在编译期确定依赖关系。动态解耦利用反射和配置文件,使依赖关系在运行时确定,实现更灵活的代码结构,遵循开放封闭原则。文中通过示例代码展示了如何实现这两种解耦方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.静态解耦:
    先解释下我理解的静态耦合,指的是编译期依赖关系已经确定,在运行时环境中,代码间的依赖关系不能改变。例如,我们在开发中经常会说的“把代码写死了”。静态是相对动态的、运行时的、可配置的和插件式的。
    那么在静态环境中,如何解耦?主要是依赖接口。下面举两个小例子简单说明下:
    EX1: 假设一个人不知道接口的意义,那么他写出两个类的依赖关系一般如下:

Java代码  收藏代码
  1. public   class  ClassA {  
  2.     public   void  invoke() {  
  3.     [color=blue]ClassB b = new  ClassB();  
  4.     b.action();[/color]         //do some other things   
  5.     }  
  6. }  
  7.   
  8. public   class  ClassB {  
  9.     public   void  action() {  
  10.     //do something   
  11.     }  
  12. }  


   我们常常说的“耦合”,我认为一个重要的因素就是环境的变,如果没有变化的环境,那么多么的“耦合”也是无所谓的;假如现在变化来了,ClassA中的 invoke()方法不符合现在的需求了,而且需要改变的部分恰好是invoke()中的前两行,也正是和ClassB耦合的那部分,而ClassB的 action方法还在别的代码有调用。现在如果更改,则必须修改invoke()的前两行代码。这个是面向对象中非常忌讳的。所谓代码应该对扩展开放,对修改封闭 ,那么我们用“面向接口编程”的思想对他进行一下改造吧。

Java代码  收藏代码
  1. public   class  ClassA {  
  2.     public   void  invoke() {  
  3.     Interface i = Factory.newInstance().produce(1 );  
  4.     i.action();  
  5.     }  
  6. }  
  7. public   class  Factory {  
  8.     private   static  Factory f =  new  Factory();  
  9.       
  10.     public   static  Factory newInstance() {  
  11.     return  f;  
  12.     }  
  13.       
  14.     public  Interface produce( int  k) {  
  15.     if (k ==  0 ) {  
  16.         return   new  Imp1(); //接口的实现类1   
  17.     } else   if  (k ==  1 ){  
  18.         return   new  Imp2(); //接口的实现类2   
  19.     }//other implements   
  20.           
  21.     return   new  DefautImpl();  
  22.     }  
  23. }  


   现在的情况稍好一点了,至少我们把变化集中管理在了一个工厂类中,但是,如果有变化,我们还是要深入代码去修改这个工厂类,依赖关系仍旧局限于编译期;
    难道没有解决办法了吗?当然有,那就是我理解的动态解耦。

2.动态解耦
    所谓动态是对象之间的依赖关系不依赖于编译期,运行时动态确定。动态解耦与插件式,可配置具有某种意思的巧合。套用某句话,正是因为有了动态解耦技术,代码间的依赖关系才真正解脱了。  
    动态解耦所用的技术主要是反射机制并结合配置文件。下面是一个例子,仅仅演示什么是动态的(很粗糙的。。)

Java代码  收藏代码
  1. public   class  Main {  
  2.   
  3.     /**  
  4.      * @param args  
  5.      */   
  6.     public   static   void  main(String[] args) {  
  7.         BufferedReader reader = new  BufferedReader( new      InputStreamReader(System.in));  
  8.           
  9.         while ( true ) {  
  10.             String instruction = null ;  
  11.             try  {  
  12.                 instruction = reader.readLine();  
  13.             } catch  (IOException e) {  
  14.                 e.printStackTrace();  
  15.                 System.exit(-1 );  
  16.             }  
  17.               
  18.             if ( "exit" .equalsIgnoreCase(instruction)) {  
  19.                 break ;  
  20.             }  
  21.               
  22.             if ( "invoke" .equalsIgnoreCase(instruction)) {  
  23.                 //一个类和被调用类直接耦合在一起   
  24.                 Interface inter = loadFromCfgFile();  
  25.                 if (inter ==  nullcontinue ;  
  26.                   
  27.                 inter.say("just say" );  
  28.             }  
  29.         }  
  30.   
  31.     }  
  32.   
  33.     private   static  Interface loadFromCfgFile() {  
  34.         InputStream in = MainClass.class .getResourceAsStream( "test.properties" );  
  35.         Properties p = new  Properties();  
  36.         try  {  
  37.             p.load(in);  
  38.         } catch  (IOException e) {  
  39.             e.printStackTrace();  
  40.             return   null ;  
  41.         }  
  42.           
  43.         String className = p.getProperty("class" );  
  44.         System.out.println("class name loaded from config file is: "  + className);  
  45.           
  46.         Object object = loadClassAccordingClassName(className);  
  47.         if (object ==  nullreturn   null ;  
  48.           
  49.           
  50.         return  (Interface) object;  
  51.     }  
  52.   
  53.     private   static  Object loadClassAccordingClassName(String className) {  
  54.         Class<?> clazz = null ;  
  55.         try  {  
  56.             clazz = Class.forName(className);  
  57.         } catch  (ClassNotFoundException e) {  
  58.             System.out.println("can not find the class." );  
  59.         }  
  60.         if (clazz ==  nullreturn   null ;  
  61.           
  62.         Object object = null ;  
  63.         try  {  
  64.             object = clazz.newInstance();  
  65.         } catch  (InstantiationException e) {  
  66.             System.out.println("can not instance the class." );  
  67.             e.printStackTrace();  
  68.         } catch  (IllegalAccessException e) {  
  69.             System.out.println("can not instance the class...." );  
  70.             e.printStackTrace();  
  71.         }  
  72.         return  object;  
  73.     }  
  74.   
  75. }  



实现类代码:

Java代码  收藏代码
  1. public   class  ImplementClass  implements  Interface{  
  2.   
  3.     public   void  say(String str) {  
  4.         System.out.println("say "  + str);  
  5.                   //System.out.println("added later.");//   
  6.   
  7.     }  
  8.   
  9. }  



配置文件代码:

Java代码  收藏代码
  1. class =ImplementClass  



    你可以简单的修改ImplementClass.java的代码,加上注释掉的语句,编译后,就会发现输出和以前不同了。
    如上所示,代码间的依赖关系,从源代码中移动到了配置文件中,并利用反射技术来动态确定其依赖关系;好处就是依赖集中管理、符合开放封闭原则;
    对配置文件的修改产生的变化,还有一种更优雅的方式,可以启动一个守护线程对其进行定期检查,如变化,可重新加载并实例化,这个以后再续;

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值