1.静态解耦:
先解释下我理解的静态耦合,指的是编译期依赖关系已经确定,在运行时环境中,代码间的依赖关系不能改变。例如,我们在开发中经常会说的“把代码写死了”。静态是相对动态的、运行时的、可配置的和插件式的。
那么在静态环境中,如何解耦?主要是依赖接口。下面举两个小例子简单说明下:
EX1: 假设一个人不知道接口的意义,那么他写出两个类的依赖关系一般如下:
- public class ClassA {
- public void invoke() {
- [color=blue]ClassB b = new ClassB();
- b.action();[/color] //do some other things
- }
- }
- public class ClassB {
- public void action() {
- //do something
- }
- }
我们常常说的“耦合”,我认为一个重要的因素就是环境的变,如果没有变化的环境,那么多么的“耦合”也是无所谓的;假如现在变化来了,ClassA中的
invoke()方法不符合现在的需求了,而且需要改变的部分恰好是invoke()中的前两行,也正是和ClassB耦合的那部分,而ClassB的
action方法还在别的代码有调用。现在如果更改,则必须修改invoke()的前两行代码。这个是面向对象中非常忌讳的。所谓代码应该对扩展开放,对修改封闭
,那么我们用“面向接口编程”的思想对他进行一下改造吧。
- public class ClassA {
- public void invoke() {
- Interface i = Factory.newInstance().produce(1 );
- i.action();
- }
- }
- public class Factory {
- private static Factory f = new Factory();
- public static Factory newInstance() {
- return f;
- }
- public Interface produce( int k) {
- if (k == 0 ) {
- return new Imp1(); //接口的实现类1
- } else if (k == 1 ){
- return new Imp2(); //接口的实现类2
- }//other implements
- return new DefautImpl();
- }
- }
现在的情况稍好一点了,至少我们把变化集中管理在了一个工厂类中,但是,如果有变化,我们还是要深入代码去修改这个工厂类,依赖关系仍旧局限于编译期;
难道没有解决办法了吗?当然有,那就是我理解的动态解耦。
2.动态解耦
所谓动态是对象之间的依赖关系不依赖于编译期,运行时动态确定。动态解耦与插件式,可配置具有某种意思的巧合。套用某句话,正是因为有了动态解耦技术,代码间的依赖关系才真正解脱了。
动态解耦所用的技术主要是反射机制并结合配置文件。下面是一个例子,仅仅演示什么是动态的(很粗糙的。。)
- public class Main {
- /**
- * @param args
- */
- public static void main(String[] args) {
- BufferedReader reader = new BufferedReader( new InputStreamReader(System.in));
- while ( true ) {
- String instruction = null ;
- try {
- instruction = reader.readLine();
- } catch (IOException e) {
- e.printStackTrace();
- System.exit(-1 );
- }
- if ( "exit" .equalsIgnoreCase(instruction)) {
- break ;
- }
- if ( "invoke" .equalsIgnoreCase(instruction)) {
- //一个类和被调用类直接耦合在一起
- Interface inter = loadFromCfgFile();
- if (inter == null ) continue ;
- inter.say("just say" );
- }
- }
- }
- private static Interface loadFromCfgFile() {
- InputStream in = MainClass.class .getResourceAsStream( "test.properties" );
- Properties p = new Properties();
- try {
- p.load(in);
- } catch (IOException e) {
- e.printStackTrace();
- return null ;
- }
- String className = p.getProperty("class" );
- System.out.println("class name loaded from config file is: " + className);
- Object object = loadClassAccordingClassName(className);
- if (object == null ) return null ;
- return (Interface) object;
- }
- private static Object loadClassAccordingClassName(String className) {
- Class<?> clazz = null ;
- try {
- clazz = Class.forName(className);
- } catch (ClassNotFoundException e) {
- System.out.println("can not find the class." );
- }
- if (clazz == null ) return null ;
- Object object = null ;
- try {
- object = clazz.newInstance();
- } catch (InstantiationException e) {
- System.out.println("can not instance the class." );
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- System.out.println("can not instance the class...." );
- e.printStackTrace();
- }
- return object;
- }
- }
实现类代码:
- public class ImplementClass implements Interface{
- public void say(String str) {
- System.out.println("say " + str);
- //System.out.println("added later.");//
- }
- }
配置文件代码:
- class =ImplementClass
你可以简单的修改ImplementClass.java的代码,加上注释掉的语句,编译后,就会发现输出和以前不同了。
如上所示,代码间的依赖关系,从源代码中移动到了配置文件中,并利用反射技术来动态确定其依赖关系;好处就是依赖集中管理、符合开放封闭原则;
对配置文件的修改产生的变化,还有一种更优雅的方式,可以启动一个守护线程对其进行定期检查,如变化,可重新加载并实例化,这个以后再续;