java 自学日志【二十三】---张老师银行业务调度系统

------android培训，java培训，期待与您交流------

银行业务调度系统
一、系统实现要求：
模拟实现银行业务调度系统逻辑，具体需求如下： 
1.银行内有6个业务窗口，1- 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
2. 有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 
3. 异步随机生成各种类型的客户，生成各类型用户的概率比例为： 
        VIP客户 ：普通客户 ：快速客户 =  1 ：6 ：3。 
4. 客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。 各类型客户在其对应窗口按顺序依次办理业务。 
5.当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。 
6.随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。 
7.不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

二、系统分析：
1.需求中涉及的对象（现实中的）：窗口，客户。需求中描述客户的是2、3和6，客户办理业务其实银行 处理业务，所以可以把办理业务的方法归到窗口中。这两类对象是怎么建立联系的？是直接把客户作为窗口的参数传递进去吗？肯定不是，现实中他们是通过取号机器建立联系的，所以需求中隐含一个取号机器这个对象。所以，需求中涉及三个现实世界中的对象：窗口，客户和取号机器。从现实空间映射到问题空间，就需要建立三个对应的类。
2.窗口：所以类型的窗口，都能为普通客户提供服务，不过对于VIP和快速窗口，VIP和快速客户的优先级高，可以把普通窗口作为基类，把VIP和快速作为子类，根据客户类型调用不同的处理方法。因为有优先级，所以给每个窗口添加个type属性，以标示其默认服务的客户类型；同时定义一个窗口ID，以给窗口标号。由这两个属性，我们就可以知道，这个窗口是VIP、普通还是快速窗口了。
3.客户：在模拟的时候，因为客户和窗口是多对一的关系，它唯一的行为就是等待办理业务，而这个时间其实就是窗口办理业务的时间。所以它不需要具体定义一个类，用数字表示就可以了。
4.取号机：客户来到银行，不是先到窗口，而是先取号，而且是根据他需要VIP、普通还会快速服务来取号。所以取号机要对其进行分类，可以在取号机中完成所有的工作，但是因为对不同的客户，它要都建立客户与窗口间的联系，为客户提供号码，向窗口提供要服务的客户号码，虽然能在一个类中实现，但为了减少耦合，最好建立几个号码管理器，并把取号机设计为单例。
5.号码管理器：建立一个集合属性存储客户和一个属性记录下一个要服务的客户号码，同时向外提供两个方法，分别使客户和窗口取得号码；因为多线程访问方法，所以这两个方法要加锁。

三、代码实现：

//1.号码管理器类：
import java.util.ArrayList;  
import java.util.List;  
  
public class NumberManager {  
    private  Integer lastNumber=1;  
    private  List<Integer> queueNumber=new ArrayList<Integer>();  
    public synchronized Integer generateNumber(){  
        queueNumber.add(lastNumber);  
        return lastNumber++;  
    }  
    public synchronized Integer fetchNumber(){  
        Integer number=null;  
        if(queueNumber.size()>0){  
            number=queueNumber.remove(0);  
        }  
        return number;  
    }  
      
}  
//2.取号机：

public class NumberMachine {  
      
    private NumberManager commonManager = new NumberManager();  
    private NumberManager expressManager = new NumberManager();  
    private NumberManager vipManager = new NumberManager();  
      
    private static  NumberMachine numberMachine=new NumberMachine();  
    private NumberMachine(){};  
    public static NumberMachine getInstance(){  
        return numberMachine;  
    }  
      
    public NumberManager getCommonManager() {  
        return commonManager;  
    }  
    public NumberManager getExpressManager() {  
        return expressManager;  
    }  
    public NumberManager getVipManager() {  
        return vipManager;  
    }  
  
}  
//3.服务窗口：

import java.util.Random;  
import java.util.concurrent.Executors;  
  
public class ServiceWindow {  
    private ConsumerType type=ConsumerType.COMMON;  
    private int windowID = 1;  
      
    public void setType(ConsumerType type) {  
        this.type = type;  
    }  
  
    public void setWindowID(int windowID) {  
        this.windowID = windowID;  
    }  
      
    //启动服务  
    public void start(){  
        Executors.newSingleThreadExecutor().execute(new Runnable(){  
            public void run() {   
                String windowName = windowID+"号"+type+"窗口";  
                while(true){                      
                    service(ServiceWindow.this.type,windowName);                      
                }  
            }             
        });  
    }  
      
    //窗口服务  
    public void service(ConsumerType type,String windowName) {        
        Integer number = getServiceNumber(type);                      
        System.out.println(windowName+"正在获取"+type+"客户号码");  
        if(number!=null){  
            System.out.println(windowName+"正在为"+number+"号"+type+"客户服务");  
            long startTime = System.currentTimeMillis();  
            int serviceTime = getServiceTime(type);  
            sleep(serviceTime);  
            long endTime =System.currentTimeMillis();  
            long costTime = (endTime - startTime)/1000;  
            System.out.println(windowName+"为"+"第"+number+"号"+type+"客户完成服务，耗时"+costTime+"秒");  
        }  
        else{  
            //如果是普通用户窗口，那么就休息  
            if(type.equals(ConsumerType.COMMON)){                 
                System.out.println(windowName+"没有取到号，休息一秒钟");                         
                sleep(1000);      
            }else{  
            //如果是非普通用户窗口，就开始为普通用户服务,使用递归调用  
                System.out.println(windowName+"没有取到号，"+"开始为普通客户服务");      
                service(ConsumerType.COMMON,windowName);  
            }  
        }  
    }  
//获得服务号码  
    public Integer getServiceNumber(ConsumerType type) {  
        Integer number =null;  
        switch(type){  
        case COMMON:  
            number = NumberMachine.getInstance().getCommonManager().fetchNumber();  
            break;  
        case EXPRESS:  
            number = NumberMachine.getInstance().getExpressManager().fetchNumber();  
            break;    
        case VIP:  
            number = NumberMachine.getInstance().getVipManager().fetchNumber();  
            break;  
        }  
        return number;  
    }     
  
//获取服务时间  
    public int getServiceTime(ConsumerType type) {  
        int serviceTime=0;  
        switch(type){  
        case COMMON:  
        case VIP:  
            int randomTime =Constant.MAX_SERVICE_TIME-Constant.MIN_SERVICE_TIME;  
            serviceTime = new Random().nextInt(randomTime+1)+Constant.MIN_SERVICE_TIME;  
            break;  
        case EXPRESS:  
            serviceTime =Constant.MIN_SERVICE_TIME;  
            break;  
              
        }  
        return serviceTime;  
          
    }  
//获得停滞时间,服务或者休息。  
    public void sleep(int sleepTime) {  
        try {  
            Thread.sleep(sleepTime);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  
  
  
}  
//4.常量类：（这是为了满足需求中的6）
public class Constant {  
    public static final long COMMON_INTERAL_TIME = 1;  
    public static final int MIN_SERVICE_TIME=1000;  
    public static final int MAX_SERVICE_TIME=10000;  
}  
//5.客户类型：

public enum ConsumerType {  
    COMMON,EXPRESS,VIP;  
    public String toString(){  
        switch(this){  
        case COMMON:  
            return "普通";  
        case EXPRESS:  
            return "快速";  
        case VIP:  
            return name();  
        }  
        return null;  
    }  
}  

6.启动运行类：
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
public class MainClass {  
  
      
    public static void main(String[] args) {  
       
        for(int x =1;x<5;x++){  
            ServiceWindow commonWindow=new ServiceWindow();  
            commonWindow.setWindowID(x);  
            commonWindow.start();  
        }  
          
        ServiceWindow expressWindow=new ServiceWindow();  
        expressWindow.setType(ConsumerType.EXPRESS);  
        expressWindow.start();  
          
        ServiceWindow vipWindow=new ServiceWindow();  
        vipWindow.setType(ConsumerType.VIP);  
        vipWindow.start();  
          
        //定时生成普通客户  
                Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                        new Runnable(){  
                            public void run() {  
                                Integer number=NumberMachine.getInstance().getCommonManager().generateNumber();  
                                System.out.println("第"+number+"号普通客户正在等待服务-------");  
                            }  
                              
                        },   
                        0,   
                        Constant.COMMON_INTERAL_TIME,   
                        TimeUnit.SECONDS);  
                //定时生成快速客户  
                Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                        new Runnable(){  
                            public void run() {  
                                Integer number= NumberMachine.getInstance().getExpressManager().generateNumber();  
                                System.out.println("第"+number+"号快速客户正在等待服务********");  
                            }  
                              
                        },   
                        0,   
                        Constant.COMMON_INTERAL_TIME*2,   
                        TimeUnit.SECONDS);  
                //定时生成VIP客户  
                Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                        new Runnable(){  
                            public void run() {  
                                Integer number=NumberMachine.getInstance().getVipManager().generateNumber();  
                                System.out.println("第"+number+"号VIP客户正在等待服务…………………………");  
                            }                     
                        },   
                        0,   
                        Constant.COMMON_INTERAL_TIME*6,   
                        TimeUnit.SECONDS);   
    }  
  
}