黑马程序员——银行业务调度系统

------- android培训、java培训、期待与您交流！ ---------- 

银行业务调度系统具体需求：

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

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

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

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

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

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

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

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

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

 简单的分析：

这个题目和上一个交通灯管理系统的题目对比，更加复杂一些，因为其中有不同类型的客户，使得不能简单的定义一个集合进行获取操作。试想这里窗口可以自己实现叫号，它知道自己所具有的的属性，所以不需要定义这么一个是否有人的状态变量。下面是我看视频的一些总结

 

面向对象的分析与设计

1，有三种客户：VIP客户、普通客户、快速客户。需要异步随机产生各种类型的客户。

（1）每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以，要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。

（2）由于有三类客户，每类客户的号码编排都是完全独立的，所以，本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

2，各类客户到对应的窗口办理业务，是窗口在叫号

（1）窗口内部知道如何叫号，是通过号码机器获取的号，所以它内部应该有这个叫号的方法

（2）各类客户并不知道怎么操作叫号的方法，只是等待被叫

 

 张老师分析类图：

 

 

编写NumberManager类：实现取号、叫号功能

定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。
定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步。

[java]  view plain copy

1. <span style="font-size:12px;">package com.itheima.bank;  
2.   
3. import java.util.ArrayList;      
4. import java.util.List;      
5.   
6.        
7. //定义号码管理器，用于产生号码，返回等待的号码      
8. public class NumberManager {      
9.     //定义上一个客户号码      
10.     private int lastNumber=1;      
11.     //用于存储排队的客户号码（面向接口编程）      
12.     private List<Integer> queueNumber=new ArrayList<Integer>();      
13.     //定义一个产生新号码的方法      
14.     //由于不同的线程访问相同的数据，所以要加同步      
15.     public synchronized Integer generateNewNumber(){      
16.     //添加到集合中  
17.         queueNumber.add(lastNumber);      
18.         return lastNumber++;      
19.     }      
20.   
21.     //定义一个窗口取号时，该返回哪个客户号码的方法      
22.     //由于不同的线程访问相同的数据，所以要加同步      
23.     public synchronized Integer fetchServiceNumber(){      
24.        Integer number=null;      
25.        //如果有正在等待的客户则服务      
26.         if (queueNumber.size()>0) {      
27.             return queueNumber.remove(0);      
28.         }      
29.        return number;      
30.     }           
31. }    </span>  

 

编写NumberMachine类
定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个NumberManager对象。
这个号码机器在整个系统中始终只能有一个，将NumberMachine类设计成单例。

[java]  view plain copy

1. package com.itheima.bank;  
2.    
3. public class NumberMachine {   
4.   
5.    //定义三个号码管理器   
6.    private NumberManager commonManager=new NumberManager();   
7.    private NumberManager expressManager=new NumberManager();    
8.    private NumberManager vipManager=new NumberManager();   
9.   
10.    //三个返回方法   
11.     public NumberManager getCommonManager() {  
12.          return commonManager;   
13.      }   
14.     public NumberManager getExpressManager() {    
15.          return expressManager;    
16.      }      
17.     public NumberManager getVipManager() {   
18.           return vipManager;   
19.      }   
20.      //把对象变成单例,构造方法私有化，不能创建对象，所以方法不能直接调用    
21.      private NumberMachine(){};   
22.      //只能调用静态方法   
23.      public static  NumberMachine getInstance() {   
24.          return instance;     
25.      }    
26.      //自己创建返回的对象    
27.      private static NumberMachine instance = new NumberMachine();   
28.      //如果有正在等待的客户则服务      
29.      if (queueNumber.size()>0) {      
30.             return queueNumber.remove(0);      
31.      }      
32.      return number;      
33.     }           
34. }      

 

CustomerType枚举类：使用枚举列出客户类型，显得更加专业

系统中有三种类型的客户，所以定义一个枚举类，其中定义三个成员分别表示三种类型的客户。

[java]  view plain copy

1. package com.itheima.bank;  
2.    
3. public enum CustomerType {      
4.     COMMON,EXPRESS,VIP;      
5.           
6.     //覆盖toString方法，以便调用时用汉字输出更直观      
7.     public String toString(){      
8.         String name=null;      
9.         switch(this){      
10.         case COMMON:      
11.             name="普通";      
12.             break;      
13.         case EXPRESS:      
14.             name="快速";      
15.             break;      
16.         case VIP:      
17.             name=name();      
18.             break;      
19.         }      
20.         return name;      
21.     }                   
22. }      

 

 

编写ServiceWindow类
定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。 
定义三个方法分别对三种客户进行服务

[java]  view plain copy

1. package com.itheima.bank;  
2.    
3. import java.util.Random;      
4. import java.util.concurrent.Executors;      
5.              
6. public class ServiceWindow {      
7.   
8.     //定义客户类型变量      
9.     private CustomerType type = CustomerType.COMMON;      
10.     //定义服务窗口变量      
11.     private int windowId = 1;      
12.    //设置服务客户的类型      
13.     public void setType(CustomerType type) {      
14.         this.type = type;      
15.     }      
16.     //设置窗口号      
17.     public void setWindowId(int windowId) {      
18.         this.windowId = windowId;      
19.     }      
20.     //服务窗口启动方法      
21.     public void start(){      
22.     //利用线程来完成      
23.       Executors.newSingleThreadExecutor().execute(new Runnable() {      
24.             public void run() {      
25.                 switch(type) {      
26.                 case COMMON:   
27.                 //确定客户类型后，不停的叫号、服务      
28.                    while(true)      
29.                     commonService();          
30.                 case EXPRESS:      
31.                     while(true)      
32.                     expressService();      
33.                 case VIP:      
34.                    while(true)      
35.                     vipService();      
36.                 }             
37.             }         
38.         });      
39.     }      
40.   
41.     //为普通客户服务      
42.     private void commonService() {      
43.        String windowName = "第"+windowId+"号"+type+"窗口";      
44.               //从号码管理器中获取正在等待服务的客户              
45.         Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();      
46.        System.out.println(windowName+"正在获取普通任务");      
47.   
48.         //如果有正在等待服务的客户      
49.         if (number!=null) {      
50.             System.out.println(windowName+"为第"+number+"个普通客户服务");      
51.            //开始服务的时间      
52.       long beginTime = System.currentTimeMillis();      
53.            //最大服务时间与最小服务时间差      
54.             int maxRandom = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;      
55.            //随机从maxRandom中获取服务时间，再加上最小服务时间      
56.             long serviceTime=new Random().nextInt(maxRandom+1)+Constants.MIN_SERVICE_TIME;      
57.             try {      
58.                 //用线程休息方式表示为在为客户服务中      
59.                 Thread.sleep(serviceTime);      
60.             } catch (InterruptedException e) {      
61.                 e.printStackTrace();      
62.             }      
63.             //为客户服务的花费的时间      
64.             long costTime = System.currentTimeMillis()- beginTime;      
65.            System.out.println(windowName+"为第"+number+"个普通客户完成服务，耗时"+costTime/1000+"秒");           
66.         //如果没有正在等待服务的普通客户,就休息1秒   
67.         } else {                    
68.             System.out.println(windowName+"没有获取到普通任务，先休息1秒！");      
69.             try {      
70.                 Thread.sleep(1000);      
71.             } catch (InterruptedException e) {        
72.                 e.printStackTrace();      
73.             }      
74.         }      
75.     }      
76.           
77.     //为快速客户服务      
78.     private void expressService() {      
79.         String windowName="第"+windowId+"号"+type+"窗口";      
80.         //从号码管理器中获取正在等待服务的客户      
81.         Integer number=NumberMachine.getInstance().getExpressManager().fetchServiceNumber();      
82.         System.out.println(windowName+"正在获取快速任务");      
83.         //如果有正在等待服务的客户      
84.         if (number!=null) {      
85.             System.out.println(windowName+"为第"+number+"个快速客户服务");      
86.             //开始服务的时间      
87.             long beginTime=System.currentTimeMillis();      
88.             try {          
89.                 //快速客户服务时间为最小值      
90.                 Thread.sleep(Constants.MIN_SERVICE_TIME);      
91.             } catch (InterruptedException e) {      
92.                 e.printStackTrace();      
93.             }      
94.            //为客户服务的花费的时间      
95.             long costTime=System.currentTimeMillis()-beginTime;      
96.   
97.             System.out.println(windowName+"为第"+number+"个快速客户完成服务，耗时"+costTime/1000+"秒");      
98.         } else {                
99.       //如果没有正在等待服务的快速客户,就为普通客户服务      
100.             System.out.println(windowName+"没有获取到快速任务");      
101.             commonService();      
102.         }      
103.     }      
104.           
105.     //为vip客户服务      
106.     private void vipService() {      
107.         String windowName="第"+windowId+"号"+type+"窗口";      
108.         //从号码管理器中获取正在等待服务的客户      
109.         Integer number=NumberMachine.getInstance().getVipManager().fetchServiceNumber();      
110.        System.out.println(windowName+"正在获取vip任务");      
111.         //如果有正在等待服务的客户      
112.         if (number!=null) {      
113.             System.out.println(windowName+"为第"+number+"个VIP客户服务");      
114.             //开始服务的时间      
115.             long beginTime=System.currentTimeMillis();      
116.             //最大服务时间与最小服务时间差      
117.             int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;      
118.             //随机从maxRandom中获取服务时间，再加上最小服务时间      
119.             long serviceTime=new Random().nextInt(maxRandom+1)+Constants.MIN_SERVICE_TIME;      
120.             try {      
121.                 //用线程休息方式表示为在为客户服务中      
122.                 Thread.sleep(serviceTime);      
123.             } catch (InterruptedException e) {      
124.                 e.printStackTrace();      
125.             }      
126.             //为客户服务的花费的时间      
127.             long costTime=System.currentTimeMillis()-beginTime;      
128.            System.out.println(windowName+"为第"+number+"个VIP客户完成服务，耗时"+costTime/1000+"秒");      
129.        } else {      
130.             //如果没有正在等待服务的vip客户,则为普通客户服务      
131.             System.out.println(windowName+"没有获取到VIP任务");      
132.             commonService();      
133.         }      
134.     }      
135. }  

 

 

编写Constants类：等待时间为常量
定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

[java]  view plain copy

1. package it.cast.bank;    
2.     
3. public class Constants {    
4.     public static int MAX_SERVICE_TIME = 10000;    
5.     public static int MIN_SERVICE_TIME = 1000;    
6.     //普通客户来取号的频率  
7.      public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;    
8. }   

编写MainClass类

用for循环创建出4个普通窗口，再单独创建出1个快速窗口（5号）和一个VIP窗口（6号）。

接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

[java]  view plain copy

1. package com.itheima.bank;  
2.   
3. import java.util.concurrent.Executors;      
4. import java.util.concurrent.TimeUnit;    
5.   
6. public class MainClass {      
7.     public static void main(String[] args) {      
8.         //产生4个普通窗口，并开始服务      
9.         for (int i = 1; i < 5; i++) {      
10.             ServiceWindow commonWindow = new ServiceWindow();      
11.             commonWindow.setWindowId(i);      
12.             commonWindow.start();      
13.         }      
14.   
15.         //产生5号快速窗口，并开始服务      
16.         ServiceWindow expressWindow=new ServiceWindow();      
17.         expressWindow.setWindowId(5);      
18.         expressWindow.setType(CustomerType.EXPRESS);      
19.         expressWindow.start();      
20.   
21.        //产生6号vip窗口，并开始服务      
22.         ServiceWindow vipWindow=new ServiceWindow();      
23.         vipWindow.setWindowId(6);      
24.         vipWindow.setType(CustomerType.VIP);      
25.         vipWindow.start();      
26.   
27.        //普通客户定时取号 ，应用1.5新特性创造线程    
28.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(      
29.                 new Runnable() {                      
30.                     public void run() {      
31.                        Integer number=NumberMachine.getInstance().getCommonManager().generateNewNumber();      
32.                         System.out.println(number+"号普通客户正在等待服务！");      
33.                     }      
34.                 },      
35.                 0,      
36.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME,      
37.                 TimeUnit.SECONDS);      
38.               
39.        //快速客户定时取号      
40.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(      
41.                 new Runnable() {                  
42.                     public void run() {      
43.                         Integer number=NumberMachine.getInstance().getExpressManager().generateNewNumber();      
44.                         System.out.println(number+"号快速客户正在等待服务！");      
45.                     }      
46.                 },      
47.                 0,      
48.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,      
49.                 TimeUnit.SECONDS);      
50.                
51.         //vip客户定时取号      
52.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(      
53.                 new Runnable() {                      
54.                     public void run() {      
55.                         Integer number=NumberMachine.getInstance().getVipManager().generateNewNumber();      
56.                         System.out.println(number+"号vip客户正在等待服务！");      
57.                     }      
58.                 },      
59.                 0,      
60.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,      
61.                 TimeUnit.SECONDS);      
62.     }       
63. }       

定义一个号码管理的类，实现取号、叫号功能；号码机器，实现了3中不同类型的号码,并采用单例设计模式（复习了单例）；使用枚举列出客户类型，显得更加专业同时也复习了枚举；窗口是代码最复杂的类，不过思维确不复杂，只要不断叫号，叫到号之后等待一段时间。这种思维的体现形式十分特别，面向对象的思维是多元化的，不存在固定的套路，只要能实现功能，并且代码简单都是好程序，所以发散思维尤为重要，不能陷入僵化的思维模式。

这个系统使用多次线程池，需要注意这个新特新。要记住了Executors这个关键的类，如此类使用的newScheduledThreadPool(1).scheduleAtFixedRate()就是一个时间控制器，每隔固定的时间执行一次（炸八角大楼），不需要我们再用sleep套上循环来使用，十分简单与方便，又学习一个简便方法。