Junit所使用的设计模式

使用继承的方式来实现适配器模式　

 

//目标类，它的方法里面调用Adaptee对象的方法

public interface Target

{

    public void method1();

}

 

//被适配对象，它的方法会被Target类的方法调用。

public class Adaptee

{

    public void method2()

    {

       System.out.println("method2 invoked");

    }

}

 

//使用继承的方式来实现适配器模式　

//适配器对象，实现用Target类的方法调用Adaptee类的方法，起到一个中间转化的作用。

public class Adapter extends Adaptee implements Target

{

    @Override

    public void method1()

    {

       this.method2();

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Target target = new Adapter();

      

       target.method1();

    }

}

 

 

使用对象组合的方式来实现适配器对象

 

public interface Target

{

    public void method1();

}

 

 

public class Adaptee

{

    public void method2()

    {

       System.out.println("method2 invoked");

    }

   

}

 

/**

 * 使用对象组合的方式来实现适配器对象

 * @author anllin

 *

 */

public class Adapter implements Target

{

    private Adaptee adaptee;

 

    public Adapter(Adaptee adaptee)

    {

       this.adaptee = adaptee;

    }

 

    @Override

    public void method1()

    {

       adaptee.method2();

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Target target = new Adapter(new Adaptee());

      

       target.method1();

    }

}

 

 

模拟AWT事件模型所使用的适配器模式

public class MyFrame

{

    public void addMouseMotionListener(MyMouseMotionListener listener)

    {

       listener.mouseMoved();

       listener.mouseDragged();

    }

}

 

public interface MyMouseMotionListener

{

    public void mouseMoved();

   

    public void mouseDragged();

}

 

public abstract class MyMouseMotionAdapter implements MyMouseMotionListener

{

    @Override

    public void mouseMoved()

    {

      

    }

 

    @Override

    public void mouseDragged()

    {

      

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       MyFrame frame = new MyFrame();

      

       frame.addMouseMotionListener(new MyMouseMotionAdapter()

       {

           @Override

           public void mouseMoved()

           {

              System.out.println("mouse Moved");

           }

       });

    }

}

 

 

 

命令模式

 

通用模型

public interface Command

{

    public void execute();

}

 

public class ConcreteCommand implements Command

{

    private Receiver recevier;

 

    public ConcreteCommand(Receiver recevier)

    {

       this.recevier = recevier;

    }

 

    @Override

    public void execute()

    {

       this.recevier.doAction();

    }

}

 

public class Invoker

{

    private Command command;

 

    public Invoker(Command command)

    {

       super();

       this.command = command;

    }

   

    public void doInvokerAction()

    {

       this.command.execute();

    }

}

 

public class Receiver

{

    public void doAction()

    {

       System.out.println("执行操作");

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Command command = new ConcreteCommand(new Receiver());

      

       Invoker invoker = new Invoker(command);

      

       invoker.doInvokerAction();

    }

}

 

现实中例子

我们去餐厅吃饭，点菜，然后服务员上菜

//订单

public interface Order

{

    public void orderDishes();

}

 

//具体定单内容

public class ConcreteOrder implements Order

{

    private Kitchener kitchener;

 

    public ConcreteOrder(Kitchener kitchener)

    {

       this.kitchener = kitchener;

    }

 

    //点菜

    @Override

    public void orderDishes()

    {

       kitchener.cooking();

    }

}

 

//厨师

public class Kitchener

{

    //烹饪

    public void cooking()

    {

       System.out.println("the dishes of customer is cooking...");

       System.out.println("cooking is finished");

       System.out.println("the waiter served the dishes");

    }

}

 

//服务员

public class Waiter

{

    private Order order;

 

    //下定单

    public Waiter(Order order)

    {

       this.order = order;

    }

   

    //上菜

    public void serveTheDishes()

    {

       this.order.orderDishes();

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Order order = new ConcreteOrder(new Kitchener());

      

       Waiter waiter = new Waiter(order);

      

       waiter.serveTheDishes();

    }

}

 

 

模拟junit中的使用命令模式的方式

public abstract class MyTestCase

{  

    private TestFixture testFixture = new TestFixture();

   

    protected abstract void setUp();

   

    protected abstract void tearDown();

   

    protected void execute(Method method) throws Exception

    {

       setUp();

       testFixture.run(this,method);

       tearDown();

    }

}

 

public class MyConcreteTestCase extends MyTestCase

{

    @Override

    protected void setUp()

    {

       System.out.println("set up");

    }

   

    @Override

    protected void tearDown()

    {

       System.out.println("tear down");

    }

   

    public void testAdd()

    {

       System.out.println("test add");

    }

   

    public void testSubstract()

    {

       System.out.println("test subtract");

    }

   

    public void testMuitiply()

    {

       System.out.println("test multiply");

    }

   

    public void testDevide()

    {

       System.out.println("test devide");

    }

}

 

public class TestFixture

{

    public void run(MyTestCase testCase,Method method) throws Exception

    {

       method.invoke(testCase, new Object[0]);

    }

}

 

public class TestRunner

{

    private MyTestCase myTestCase;

 

    public TestRunner(MyTestCase myTestCase)

    {

       this.myTestCase = myTestCase;

    }

 

    public void runTest() throws Exception

    {

       Class<?> clazz = myTestCase.getClass();

 

       Method[] methods = clazz.getMethods();

 

       for (Method method : methods)

       {

           if (method.getName().contains("test")

                  && Modifier.isPublic(method.getModifiers())

                  && method.getReturnType() == void.class)

           {

              myTestCase.execute(method);

           }

       }

    }

}

 

 

模板方法

 

/**

 * junit3.8中的模板方法的应用 利用反射实现的adapter模式

 *

 * @author anllin

 *

 */

public abstract class AbastractTestCase

{

    // 当这个类被继承，this指定的就是子类的对象

    public void execute() throws Exception

    {

       /**

        * 一般使用时，需要先调用构造函数实例化一个对象。 然后利用实例化对象调用方法

        */

       // Object constructor = clazz.getConstructor(new

       // Class[]{}).newInstance(new Object[]{});

       // method.invoke(constructor, new Object[] {});

 

       Class<?> clazz = this.getClass();// 子类的类型

 

       Method[] methods = clazz.getMethods();// 子类的方法

       this.setUpBeforeClass();

       for (Method method : methods)

       {

           if (method.getName().contains("test")

                  && Modifier.isPublic(method.getModifiers()))

           {

              this.setUp();

              method.invoke(this, new Object[0]);// this就是子类的实例，所以不用引用构造函数

              this.tearDown();

           }

       }

       this.tearDownAfterClass();

    }

 

    protected abstract void setUpBeforeClass();

 

    protected abstract void tearDownAfterClass();

 

    protected abstract void setUp();

 

    protected abstract void tearDown();

}

 

public class TestMyTemplate

{

    public static void main(String[] args) throws Exception

    {

       AbastractTestCase test = new MyTestCase();

      

       test.execute();

    }

}

 

public class MyTestCase extends AbastractTestCase

{

    @Override

    protected void setUpBeforeClass()

    {

       System.out.println("set up before class");

    }

 

    @Override

    protected void tearDownAfterClass()

    {

       System.out.println("tear down after class");

    }

 

    @Override

    protected void setUp()

    {

       System.out.println("set up ");

    }

 

    @Override

    protected void tearDown()

    {

       System.out.println("tear down");

    }

   

    public void testAdd()

    {

       System.out.println("test add");

    }

   

    public void testSubstract()

    {

       System.out.println("test subtract");

    }

   

    public void testMuitiply()

    {

       System.out.println("test multiply");

    }

   

    public void testDevide()

    {

       System.out.println("test devide");

    }

}

 

 

组合模式

 

通用实现模型

public interface Component

{

    public void doSomething();

}

 

public class Composite implements Component

{

    private List<Component> list = new ArrayList<Component>();

   

    public void add(Component component)

    {

        list.add(component);

    }

   

    public void remove(Component component)

    {

       list.remove(component);

    }

   

    public List<Component> getAll()

    {

       return this.list;

    }

   

    //注意：这时隐含了一个递归

    @Override

    public void doSomething()

    {

       for(Component component : list)

       {

           component.doSomething();

       }

    }

}

 

public class Leaf implements Component

{

    @Override

    public void doSomething()

    {

       System.out.println("执行操作");

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Component leaf1 = new Leaf();

        Component leaf2 = new Leaf();

      

       Composite com1 = new Composite();

      

       com1.add(leaf1);

       com1.add(leaf2);

      

       Component leaf3 = new Leaf();

       Component leaf4 = new Leaf();

      

       Composite com2 = new Composite();

      

       com2.add(com1);

       com2.add(leaf3);

       com2.add(leaf4);

      

       com2.doSomething();

      

    }

}

 

空实现模型

public interface Component

{

    public void add(Component component);

   

    public void remove(Component component);

   

    public List<Component> getAll();

   

    public void doSomething();

}  

 

public class Composite implements Component

{

    private List<Component> list = new ArrayList<Component>();

 

    @Override

    public void add(Component component)

    {

       list.add(component);

    }

 

    @Override

    public void remove(Component component)

    {

       list.remove(component);

    }

 

    @Override

    public List<Component> getAll()

    {

       return this.list;

    }

 

    @Override

    public void doSomething()

    {

       for(Component component : list)

       {

           component.doSomething();

       }

    }

}

 

public class Leaf implements Component

{

 

    @Override

    public void add(Component component)

    {

      

    }

 

    @Override

    public void remove(Component component)

    {

      

    }

 

    @Override

    public List<Component> getAll()

    {

       return null;

    }

 

    @Override

    public void doSomething()

    {

       System.out.println("执行操作");

    }

}

 

public class Client

{

    public static void main(String[] args)

    {

       Component leaf1 = new Leaf();

       Component leaf2 = new Leaf();

      

       Component com1 = new Composite();

      

       com1.add(leaf1);

       com1.add(leaf2);

      

       Component leaf3 = new Leaf();

       Component leaf4 = new Leaf();

      

       Component com2 = new Composite();

      

       com2.add(com1);

       com2.add(leaf3);

       com2.add(leaf4);

      

       com2.doSomething();

    }

}

 

模拟junit中测试套件的组合模式的实现方式

public interface MySuite

{

    public void runTest();

}

 

public class MyTestSuite implements MySuite

{

    private List<MySuite> list = new ArrayList<MySuite>();

   

    public void add(MySuite suite)

    {

       list.add(suite);

    }

   

    public void remove(MySuite suite)

    {

       list.remove(suite);

    }

   

    public List<MySuite> getAll()

    {

       return list;

    }

   

    @Override

    public void runTest()

    {

       for(MySuite suite : list)

       {

           suite.runTest();

       }

    }

}

 

public class MyTestCase  implements MySuite

{

    @Override

    public void runTest()

    {

       System.out.println("execute tese case method");

    }

}

 

public class TestRunner

{

    public static void main(String[] args)

    {

       MySuite testCase1 = new MyTestCase();

       MySuite testCase2 = new MyTestCase();

      

       MyTestSuite testSuite1 = new MyTestSuite();

      

       testSuite1.add(testCase1);

       testSuite1.add(testCase2);

      

       MySuite testCase3 = new MyTestCase();

       MySuite testCase4 = new MyTestCase();

      

       MyTestSuite testSuite2 = new MyTestSuite();

      

       testSuite2.add(testSuite1);

       testSuite2.add(testCase3);

       testSuite2.add(testCase4);

      

       testSuite2.runTest();

    }

}