模拟银行业务调度系统逻辑

需求

模拟实现银行业务调度系统逻辑，具体需求如下：

银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。

有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

异步随机生成各种类型的客户，生成各类型用户的概率比例为：

VIP客户 ：普通客户 ：快速客户 = 1 ：6 ：3。

客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。

各类型客户在其对应窗口按顺序依次办理业务。

当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。

不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

分析

我们知道客户去银行办理业务，首先要去取号机取号，然后等待窗口叫号，那么窗口是通过什么叫号的呢，就是根据取号机内部产生和维护的不同的业务队列来完成的

所以

涉及的对象有：业务窗口、客户、取号机、业务类型以及取号机内部维护的业务队列

为了简化设计，用字符串形式代替客户信息，主要实现系统逻辑为主

面向对象分析与设计

业务类型BusinessType类：

采用枚举的方式，创建3个实例分别表示普通业务、快速业务、VIP业务

内部维护的业务队列Queue类：

内部维护一个集合用来存放队列中的客户信息

以及一个整型变量用来表示当天的客户队列号

实现加入一个客户到队列的方法

以及从队列中取出一个客户的方法（即叫号过程）

取号机TicketMachine类：

简化编程，我们将取号机设计成一个单例

内部维护三个不同业务类型的队列

对外提供取号方法给用户

提供获取队列方法给业务窗口

业务窗口Windows类：

业务窗口属性有：业务类型及窗口编号

对外提供开始业务的方法供银行调度

思考：

在对业务窗口进行设计的时候发现，虽然各窗口同属一类，但在提供服务的过程不尽相同，所以考虑的两种实现方式，如图

• 第一种就是考虑到在开展业务的时候各窗口的代码有不同之处，所以考虑用这种方式来设计，将不同的业务类型的窗口分配到不同的类
• 第二种是直接将所有业务类型的服务代码写在同一个类中

由于不太懂设计模式，个人的感觉是，这里主要实现的是系统逻辑，所以每个窗口的服务代码差异并没有想象的大，故采用第二种方式

如果是一个比较系统的需要长期维护的项目，我会采用第一种，确保每个类的单一功能

代码实现

业务类型BusinessType类：

/**
 * 业务类型
 * @author Shawn
 *
 */
public enum BusinessType {
    GENERAL,//普通业务类型
    QUICK,//快速业务类型
    VIP;//VIP业务类型

    @Override
    public String toString() {
        switch(this){
        case GENERAL:
            return "普通";
        case QUICK:
            return "快速";
        case VIP:
            return "VIP";
        }
        return null;
    }
}

用户队列Queue类：

/**
 * 用户队列
 * @author Shawn
 *
 */
public class Queue {

    private BusinessType businessType;//队列的业务类型
    private int customerNum = 1;//记录用户队列号
    List<String> queue = new LinkedList<String>();//队列载体

    public Queue(BusinessType businessType) {
        super();
        this.businessType = businessType;
    }

    //产生新的号码，加入到队列
    public synchronized String generateNewCustomer(){
        String name = businessType+"客户_"+(customerNum++)+"号";
        if(queue.add(name))
            return name;
        else
            return null;
    }

    //从队列中取出第一个客户
    public synchronized String getCustomer(){
        if(!isEmpty())
            return queue.remove(0);
        else
            return null;
    }

    //判断队列是否为空，即是否有客户等待业务
    public synchronized boolean isEmpty(){
        if(queue.size() > 0)
            return false;
        else
            return true;
    }
}

取号机TicketMachine类：

/**
 * 取号机
 * @author Shawn
 *
 */
public class TicketMachine {

    //内部维护的三个业务队列
    private Queue generalQueue = new Queue(BusinessType.GENERAL);
    private Queue quickQueue = new Queue(BusinessType.QUICK);
    private Queue vipQueue = new Queue(BusinessType.VIP);

    //获取相关业务队列的接口
    public Queue getQueue(BusinessType businessType){
        switch(businessType){
        case GENERAL:
            return generalQueue;
        case QUICK:
            return quickQueue;
        case VIP:
            return vipQueue;
        }
        return null;
    }

    //针对不同业务，加入新的客户到对应队列
    public String generateTicket(BusinessType businessType){
        switch(businessType){
        case GENERAL:
            return generalQueue.generateNewCustomer();
        case QUICK:
            return quickQueue.generateNewCustomer();
        case VIP:
            return vipQueue.generateNewCustomer();
        }
        return null;
    }
    //单例实现
    private TicketMachine(){}
    private static TicketMachine machineInstance = new TicketMachine();
    public static TicketMachine getInstance(){
        return machineInstance;
    }
}

业务窗口Windows类：

/**
 * 业务窗口
 * @author Shawn
 *
 */
public class Windows {
    private BusinessType businessType;//窗口业务类型
    private int winNum;//窗口编号
    private boolean available = false;//窗口开放状态

    public Windows(BusinessType businessType,int winNum) {
        super();
        this.businessType = businessType;
        this.winNum = winNum;
    }

    //开始业务
    public void start(){
        available = true;
        System.out.println(this+"开始服务！");

        //创建新的线程开始不同窗口的业务
        ExecutorService pool = Executors.newSingleThreadExecutor();
        pool.execute(new Runnable(){
            public void run(){
                switch(businessType){
                case GENERAL:
                    while(available){
                        generalService();
                    }
                case QUICK:
                    while(available){
                        quickService();
                    }
                case VIP:
                    while(available){
                        vipService();
                    }
                }
            }
        });
    }
    //普通业务窗口服务过程
    private void generalService(){
        //普通业务只需要获得普通用户队列
        Queue queue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);
        //如果队列不为空，则开始叫号并模拟服务
        if(!queue.isEmpty()){
            String name = queue.getCustomer();
            System.out.println(this+"正在为 "+name+"服务~");
            int time = generalCustomerServicing();
            //System.out.println(this+"服务完毕，耗时"+time+"秒");
        }
        else{
            //System.out.println(this+"正在等待客户...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    //快速窗口业务服务过程
    private void quickService(){
        //快速窗口需要得到快速队列以及普通队列
        Queue quickQueue = TicketMachine.getInstance().getQueue(BusinessType.QUICK);
        Queue generalQueue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);

        //首先判断快速队列
        if(!quickQueue.isEmpty()){
            String name = quickQueue.getCustomer();
            System.out.println(this+"正在为 "+name+"服务~");
            int time = quickCustomerServicing();
            //System.out.println(this+"服务完毕，耗时"+time+"秒");
        }
        //若快速队列没有等待客户，则考虑普通队列
        else if(!generalQueue.isEmpty()){
            String name = generalQueue.getCustomer();
            System.out.println(this+"正在为 "+name+"服务~");
            int time = generalCustomerServicing();
            //System.out.println(this+"服务完毕，耗时"+time+"秒");
        }
        else{
            //System.out.println(this+"正在等待客户...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    //vip窗口业务服务过程
    private void vipService(){
        //vip窗口需要得到的vip队列以及普通队列
        Queue vipQueue = TicketMachine.getInstance().getQueue(BusinessType.VIP);
        Queue generalQueue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);

        //如果vip队列不为空，则取出vip客户处理
        if(!vipQueue.isEmpty()){
            String name = vipQueue.getCustomer();
            System.out.println(this+"正在为 "+name+"服务~");
            int time = vipCustomerServicing();
            //System.out.println(this+"服务完毕，耗时"+time+"秒");
        }
        //若vip队列为空，则考虑普通队列
        else if(!generalQueue.isEmpty()){
            String name = generalQueue.getCustomer();
            System.out.println(this+"正在为 "+name+"服务~");
            int time = generalCustomerServicing();
            //System.out.println(this+"服务完毕，耗时"+time+"秒");
        }
        else{
            //System.out.println(this+"正在等待客户...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
    //服务普通客户的模拟时间
    private int generalCustomerServicing(){
        int time = new Random().nextInt(
                Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME)+
                Constants.MIN_SERVICE_TIME;
        try {
            Thread.sleep(time*1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return time;
    }
    //服务快速客户的模拟时间
    private int quickCustomerServicing(){
        int time = Constants.MIN_SERVICE_TIME;
        try {
            Thread.sleep(time*1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return time;
    }
    //服务vip客户的模拟时间
    private int vipCustomerServicing(){
        int time = new Random().nextInt(
                    Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME)+
                    Constants.MIN_SERVICE_TIME;
        try {
            Thread.sleep(time*1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return time;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return businessType+"窗口"+winNum+"号";
    }
}

最后，统一维护的常量类，以及测试代码

/**
 * 统一维护的常量信息
 * @author Shawn
 *
 */
public class Constants {

    //客户服务的最大时间    10s
    public static int MAX_SERVICE_TIME = 10;
    //客户服务的最小时间    5s
    public static int MIN_SERVICE_TIME = 5;

    //产生普通客户的间隔时间    1s
    public static int COMMON_ITTERVAL_TIME = 1;
}

public class MainClass {

    /**
     * 测试代码
     * @param args
     */
    public static void main(String[] args) {
        ScheduledExecutorService timer = null;

        //建立普通窗口
        for(int i = 1 ; i <= 4 ; i ++){
            new Windows(BusinessType.GENERAL,i).start();
        }
        //建立快速窗口
        new Windows(BusinessType.QUICK,1).start();
        //建立VIP窗口
        new Windows(BusinessType.VIP,1).start();
        //普通用户拿票
        timer = Executors.newScheduledThreadPool(1);
        timer.scheduleAtFixedRate(
                new Runnable(){
                    public void run(){
                        String name = TicketMachine.getInstance().generateTicket(BusinessType.GENERAL);
                        //System.out.println(name + "正在等待服务...");
                    }
                },
                1,
                Constants.COMMON_ITTERVAL_TIME,
                TimeUnit.SECONDS);
        //快速用户拿票
        timer = Executors.newScheduledThreadPool(1);
        timer.scheduleAtFixedRate(
                new Runnable(){
                    public void run(){
                        String name = TicketMachine.getInstance().generateTicket(BusinessType.QUICK);
                        //System.out.println(name + "正在等待服务...");
                    }
                },
                1,
                Constants.COMMON_ITTERVAL_TIME*2,
                TimeUnit.SECONDS);

        //普通用户拿票
        timer = Executors.newScheduledThreadPool(1);
        timer.scheduleAtFixedRate(
                new Runnable(){
                    public void run(){
                        String name = TicketMachine.getInstance().generateTicket(BusinessType.VIP);
                        //System.out.println(name + "正在等待服务...");
                    }
                },
                1,
                Constants.COMMON_ITTERVAL_TIME*6,
                TimeUnit.SECONDS);
    }
}

总结

基本实现了银行取号调度的系统逻辑

在程序扩展性上产生了比较多的思考和疑惑，抓紧时间摸索设计模式，希望今后可以写出精良的代码