发一个在学习Junit3.81源码时的小demo

    此代码,是在阅读unit3.81源码时写的,虽然有些粗糙,但是可以理解junit的设计思想:)

    一、类得基本介绍

         1、command包

             a、command,抽象命令类

             b、SingleCommand,单一命令

             c、CommandSuite,复杂命令

             d、RepeatedCommand,可以重估执行多次命令,装饰类

             e、PauseCommand,暂停一段时候后,执行命令,装饰类

        2、person包

             a、Person ,描述人人可以执行的动作

             b、BackwardCommand,后退命令

             c、SitDownCommand,坐下命令

             d、WalkCommand,前进命令

        3、其他

             a、CommandListener,通知命令的执行结果

             b、ComandResult,观察命令的执行情况,并把情况告诉CommandListner

             c、FailCommandException,命令执行失败异常类

    二、相关说明

        1、command是命令模式、装饰器模式、组合模式的核心

        2、CommandResult,用来观察command的执行结果,用到模板模式

        3、CommandListener。命令执行结果的输出地,只要实现Listener,可以输出到屏幕,txt,数据库

        4、这些都可以在junit找到影子:)

    三、相关代码

/** 命名类,核心中的核心 */
public interface Command {
    public void exec(CommandResult result) ;
}

 

/**复合命令 */
public class CommandSuite  implements Command {
    private List<Command> commands = new LinkedList<Command>();
    public void addCommand(Command c){
        commands.add(c);
    }
    public void exec(CommandResult result){
         for(Command c:commands){
            c.exec(result);
         }
    }
}

 

/**单一命令 */
public interface SingleCommand extends Command {
    public void doCommand() throws FailedCommandException;
    public Person getPerson();
}

 

/**装饰器类,暂时5s,再执行 */
public class PauseCommand implements Command {
    private Command c;
    public PauseCommand(Command c){
        this.c = c;
    }
    public void baseExec(CommandResult result) {
        c.exec(result);
    }
    public void exec(CommandResult r){
        System.out.println("暂停5s!");
        baseExec(r);
    }
}

 

/**重复十次 */
public class RepeatedCommand implements Command {
    private Command c;
    public RepeatedCommand(Command c){
        this.c = c;
    }
    public void baseExec(CommandResult result) {
        c.exec(result);
    }
    public void exec(CommandResult r){
        System.out.println("重复10次!");
        for(int i = 0 ;i < 10;i++){
            baseExec(r);
        }
    }
}

 

/** 人的各种行为 */
public class Person  {
    private String  name;
    public Person(String name){
        this.name = name  ;
    }
    public Person() {
    }
    public void walk() throws FailedCommandException {
        int a = new Random().nextInt() % 2;
        if(a == 0 ){
            throw new FailedCommandException(name+",拒绝命令");
        }
        System.out.println(name+",前进!");
    }
    public void sitDown() throws  FailedCommandException{
       int a = new Random().nextInt() % 2;
        if(a == 0 ){
            throw new FailedCommandException(name+",拒绝命令");
        }
        System.out.println(name+",坐下");
    }
    public void backward() throws FailedCommandException{
        int a = new Random().nextInt() % 2;
        if(a == 0 ){
            throw new FailedCommandException(name+",拒绝命令");
        }
        System.out.println(name+",后退");
    }
    public String getName() {
        return name;
    }
}

/**后退命令*/
public class BackwardCommand implements SingleCommand {
    private Person p;
    public BackwardCommand(Person p){
        this.p = p;
    }
    public void exec(CommandResult result) {
       result.doCommand(this);
    }
    public void doCommand() throws FailedCommandException {
        p.backward();
    }
    public Person getPerson() {
        return p;
    }
}
/**坐下命令 */
public class SitDownCommand implements SingleCommand {
    private Person p;
    public SitDownCommand(Person p){
        this.p = p;
    }
    public void exec(CommandResult result){
       result.doCommand(this);
    }
    public void doCommand() throws FailedCommandException {
        p.sitDown();
    }
    public Person getPerson() {
        return p;
    }
}

/** 前进命令*/
public class WalkCommand implements SingleCommand {
    private Person p;
    public WalkCommand(Person p){
        this.p = p;
    }
    public void exec(CommandResult result) {
        result.doCommand(this);
    }
    public void doCommand() throws FailedCommandException {
        p.walk();
    }
    public Person getPerson() {
        return p;
    }
}

 

/**本来要先写个接口,再写个实现类,但在这里采用简单一点方式实现 */
public class CommandListener {
    public void onAddFailureCommand(SingleCommand c,Throwable e){
        System.out.println(e.getMessage());
    }
    public void onAddSuccessCommand(SingleCommand c){
        System.out.println(c.getPerson().getName()+"得到小红花");
    }
}

 

public class CommandResult {
    int failureCommands = 0;
    int successCommands = 0;
    CommandListener cl =new CommandListener();

    public void fireSuccessCommand(SingleCommand c){
        cl.onAddSuccessCommand(c);
    }
    public void fireFailedCommand(SingleCommand c,Throwable t){
        cl.onAddFailureCommand(c,t);
    }
    public void doCommand(SingleCommand c){
        try {
            c.doCommand();
            successCommands++;
            fireSuccessCommand(c);
        } catch (FailedCommandException e) {
           failureCommands++;
           fireFailedCommand(c,e);
           return;
        }

    }
    public int getFailureCommands() {
        return failureCommands;
    }
    public int getSuccessCommands() {
        return successCommands;
    }
}

 

public class MainTest {
    public static void main(String[] args){
        Person zhangSan =new Person("张三");
        Command c1 = new SitDownCommand(zhangSan);
        Command c2 = new WalkCommand(zhangSan);
        Command c3 = new BackwardCommand(zhangSan);
        CommandSuite cs =new CommandSuite();
        cs.addCommand(c1);
        cs.addCommand(c2);
        cs.addCommand(c3);
        cs.addCommand(c2);
        cs.addCommand(c1);
        cs.addCommand(c2);
        cs.addCommand(c3);
        cs.addCommand(c2);
        cs.addCommand(c1);
        cs.addCommand(c2);
        cs.addCommand(c3);
        cs.addCommand(c2);
        cs.addCommand(c1);
        cs.addCommand(c2);
        cs.addCommand(c3);
        cs.addCommand(new PauseCommand(c2));
        cs.addCommand(c3);
        cs.addCommand(new RepeatedCommand(c2));
        CommandResult cr =new CommandResult();
        PauseCommand cc = new PauseCommand(cs) ;
        cc.exec(cr);
        System.out.println("failure:"+cr.getFailureCommands());
        System.out.println("success:"+cr.getSuccessCommands());
    }
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值