使用Groovy的Adapter模式来处理遗留代码

使用Groovy的Adapter模式来处理遗留代码

如果使用Java语言，针对一个遗留的类Circle，需要建立一个接口，再建立新类和遗留类的适配器实现该接口，再建立一个控制器：

/**/ /*
 * Adapter模式经常用来处理遗留代码
 */
package  com.XiongYi.designPatterns;

//遗留代码 Circle类 方法drawCircle() 这个类不便做更改
class Circle... {
    public void draw()...{
        System.out.println("I'm a circle...");
    }
}

// 现要由于新的需要 要加入一些和Circle地位等价类，比如其中一个叫做Rect
// 并要让另一个扮演控制角色的Person类的方法draw()来统一操纵它们

//于是，创建接口Drawable，并让Circle的适配器和Rect的适配器代替他们各自工作
interface Drawable... {
    public void draw();
}

//再让原有Circle的适配器CircleAdapter实现Drawable
class CircleAdapter implements Drawable... {
    private Circle circle;
    public CircleAdapter()...{
        circle = new Circle();
    }
    public void draw() ...{
        circle.draw();
    }
}

//加入的Rect类
class Rect... {
    public void draw()...{
        System.out.println("I'm a rect...");
    }
}

//同样也让Rect的适配器RectAdapter实现Drawable
class RectAdapter implements Drawable... {
    private Rect rect;
    public RectAdapter()...{
        rect = new Rect();
    }
    public void draw()...{
        rect.draw();
    }
}

// 最后扮演控制角色的Person类，
//它可以通过work方法根据传入的实现了Drawable接口的对象来统一控制它们工作了
class Person... {
    private Drawable drawable;
    public Person(Drawable drawable)...{
        this.drawable = drawable;
    }
    public void work()...{
        drawable.draw();
    }
}

public class Adapter ... {
    public static void main(String[] args)...{
        
        new Person(new CircleAdapter()).work();
        new Person(new RectAdapter()).work();
        
    }
}

而使用Groovy的话，则变得超级简单：

package  com.XiongYi.groovy.designPatters

//遗留代码 Circle类 方法drawCircle() 这个类不便做更改
class Circle... {
    def draw()...{
        println "I'm a circle..."
    }
}

//现在加入Rect类
class Rect... {
    def draw()...{
        println "I'm a rect..."
    }
}

//Person类扮演控制者的角色
class Person... {
    private def graphic
    Person(args)...{
        graphic = args
    }
    def draw()...{
        try...{
            graphic.draw()
        }catch(MissingMethodException e)...{
            println "U can't draw..."
        }
    }
}

class Adapter ... {
    static void main(args) ...{
        new Person(new Circle()).draw()
        new Person(new Rect()).draw()
    }
}

可见，正是Groovy的动态语言特性，可以将类型判定一直延后到运行时进行，代码变得如此简单。

欢迎讨论。