黑马程序员_银行调度系统

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、银行业务需求

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

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

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

        3、异步随机生成各种类型的客户，生成各类型用户的概率比例为：VIP客户 ：普通客户 ：快速客户  =  1 ：6 ：3。

        4、客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，

快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。

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

        6、当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，

而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

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

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

二、面向对象的设计与分析

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

        1.每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以要有一个号码管理器对象，

让这个对象不断地产生号码，就等于随机生成了客户。

       2.由于有三类客户，每类客户的号码编排都是完全独立的，所以本系统一共要产生三个号码管理器对象，

各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，

这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

2、各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。

        1.各个窗口内部有相应的号码管理器方法，即服务窗口每次找号码管理器获取当前要被服务的号码。

        2.各类客户只是拿着号码等待被叫。

三、对象分析类图

四、代码实现

1、NumberManager类

1. 定义一个号码产生器，对外提供2个方法：

generateNumber();方法是给线程调用随机产生号码，模拟客户取了号码等待办理业务

fetchNumber();方法是给银行窗口获取正在等待被服务的客户对应的号码

2. 该类中还需要一个容器，用于临时存储随机产生的号码，要求号码形成队列结构

用到：ArrayList集合。

并且两个方法都是对同一集合的数据进行操作，需要同步synchroniaed

NumberManager代码实现：

[java]  view plain copy

1. package cn.the_bank;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. //号码产生器  
7. public class NumberManager {  
8.     //定义一个用于记住号码的变量  
9.     private int lastNumber=1;  
10.     //创建一个集合用于存储产生号码的队列集合  
11.     private List<Integer> queueNumber=new ArrayList<Integer>();  
12.       
13.     //添加和取出的数据同属于一个集合中，所以需要同步  
14.     //将产生的号码添加进集合  
15.     public synchronized Integer generateNewNumber(){  
16.         queueNumber.add(lastNumber);  
17.         return lastNumber++;  
18.     }  
19.     //服务窗口获取号码的方法  
20.     public synchronized Integer fetchServiceNunmber(){  
21.         Integer number=null;  
22.         //判断，集合中是否有数据，有，就删除第一个元素并且返回  
23.         if(queueNumber.size()>0){  
24.             return queueNumber.remove(0);  
25.         }  
26.         return number;  
27.     }  
28.       
29. }  

2、定义一个号码管理器：NumberMachine对象

1. 在该类中创建3个号码产生器对象（NumberManager）,分别对应3个类型的客户，

并且对外提供获取这3个对象的方法

2. 分析号码管理器始终是一个；相当于生活中银行里的取号机，所以将NumberMachine类设计

成单例，并且对外提供静态的的方法获取本类对象，私有构造方法

NumberMachine类代码：

[java]  view plain copy

1. package cn.the_bank;  
2.   
3.   
4. //号码管理器  
5. public class NumberMachine {  
6.       
7.     private NumberManager commonManager=new NumberManager();  
8.     private NumberManager expresManager=new NumberManager();  
9.     private NumberManager vipManager=new NumberManager();  
10.       
11.     public NumberManager getCommonManager() {  
12.         return commonManager;  
13.     }  
14.     public NumberManager getExpressManager() {  
15.         return expresManager;  
16.     }  
17.     public NumberManager getVipManager() {  
18.         return vipManager;  
19.     }  
20.     //私有构造方法  
21.     private NumberMachine(){}  
22.       
23.     //对外提供获取号码管理器对象方法  
24.     public static NumberMachine getInstance(){  
25.         return instance;  
26.     }  
27.     //创建本类对象  
28.     private static NumberMachine instance=new NumberMachine();  
29.       
30.       
31. }  

3、定义一个窗口为客户服务的时间类（Constants类），定义成静态常量

[java]  view plain copy

1. package cn.the_bank;  
2.   
3.   
4. //定义常量，表示服务的时间  
5. public class Constants {  
6.       
7.     //服务的最大时间  
8.     public static int MAX_SERVICE_TIME=10000;  
9.     //服务的最小时间  
10.     public static int MIN_SERVICE_TIME=1000;  
11.     //该常量用于定时器，客户号码产生的时间间隔频率  
12.     public static int COMMON_CUSTOMER_INTERVAL_TYME=1;  
13. }  

4、定义一个客户类型类：CustomerType类

3种客户类型，所以以枚举的方式定义，并且复写toString()方法

[java]  view plain copy

1. package cn.the_bank;  
2.   
3. public enum CustomerType {  
4.     COMMON,EXPRESS,VIP;  
5.       
6.     public String toString(){  
7.         String name=null;  
8.         switch(this){  
9.             case COMMON:  
10.                 return "普通";  
11.                   
12.             case EXPRESS:  
13.                 return "快速";  
14.                   
15.             case VIP:  
16.                 return name();  
17.                   
18.         }  
19.         return null;  
20.     }  
21. }  

5、定义一个服务窗口类：ServiceWindow类

1.提供一个开启服务窗口开启的方法，通过线程池线程方式来对3个类型的客户提供3个不同的

服务方式：普通客户的服务；快速客户的服务；VIP客户服务

用上switch语句

2.类中定义一个CustomerType类型的变量，记住枚举类返回的类型客户

提供设置客户类型的方法

3. 类中定义一个 int类型的变量，记住窗口号码

提供设置窗口号码的方法

[java]  view plain copy

1. package cn.the_bank;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.Executors;  
5.   
6. //服务窗口，明确客户类型，启动服务，服务耗时，  
7. public class ServiceWindow {  
8.     //定义客户类型变量，初始化为普通客户类型  
9.     private CustomerType type=CustomerType.COMMON;  
10.     //定义窗口变量，从1开始  
11.     private int windowId=1;  
12.       
13.     //设置客户类型方法  
14.     public void setType(CustomerType type) {  
15.         this.type = type;  
16.     }  
17.     //设置窗口号码的方法  
18.     public void setWindowId(int windowId) {  
19.         this.windowId = windowId;  
20.     }  
21.   
22.     //启动服务，开始叫号  
23.     public void start(){  
24.         //线程控制，从获取任务到接收任务  
25.         Executors.newSingleThreadExecutor().execute(new Runnable(){  
26.             public void run(){  
27.                   
28.                 while(true){      
29.                       
30.                   
31.                     switch(type){  
32.                         case COMMON:  
33.                               
34.                             commonService();  
35.                                   
36.                             break;  
37.                         case EXPRESS:  
38.                             expressService();  
39.                             break;  
40.                         case VIP:  
41.                             VIPService();  
42.                             break;  
43.                     }  
44.                 }  
45.             }  
46.         });  
47.           
48.     }  
49.     //将代码提取，封装成一个函数，对普通客户服务的窗口  
50.       
51.     public void commonService(){  
52.             String windowName=windowId+"号"+type+"窗口";  
53.               
54.               
55.             //通过获取号码管理器对象，获取服务客户的号码  
56.             Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNunmber();  
57.             System.out.println(windowName+"........正在获取普通任务");  
58.                           
59.             //如果取得被服务的客户号码，就进行服务  
60.                 if(number!=null){  
61.                       
62.                     System.out.println(windowName+"为第"+number+"个=======================普通客户服务");   
63.                       
64.                     long beginTime=System.currentTimeMillis();  
65.                         int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
66.                           
67.                         long serviceTime=new Random().nextInt(maxRand)+1+Constants.MAX_SERVICE_TIME;  
68.                         try {  
69.                             Thread.sleep(serviceTime);  
70.                         } catch (InterruptedException e) {  
71.                               
72.                             e.printStackTrace();  
73.                         }  
74.                           
75.                     long costTime=System.currentTimeMillis()-beginTime;  
76.                       
77.                     System.out.println(windowName+"为第"+number+"个普通客户服务，耗时时间"+(costTime)/1000);  
78.                       
79.                 }  
80.                 //如果没有取得被服务的客户的号码，就休息1秒  
81.                 else{  
82.                       
83.                     System.out.println(windowName+"没有取到普通任务,休息一秒！");  
84.                     try {  
85.                         Thread.sleep(1000);  
86.                     } catch (InterruptedException e) {  
87.                         // TODO Auto-generated catch block  
88.                         e.printStackTrace();  
89.                     }  
90.                       
91.                 }  
92.                 //System.out.println("-----------------------------------------------");  
93.             }     
94.     //快速窗口服务函数  
95.                 public void expressService(){  
96.                     String windowName=windowId+"号"+type+"窗口";  
97.                       
98.                       
99.                     //通过获取号码管理器对象，获取服务客户的号码  
100.                     Integer number=NumberMachine.getInstance().getExpressManager().fetchServiceNunmber();  
101.                     System.out.println(windowName+".......正在获取任务");  
102.                   
103.                 //如果取得被服务的客户号码，就进行服务  
104.                 if(number!=null){  
105.                       
106.                       
107.                     System.out.println(windowName+"为第"+number+"个====================快速客户服务");   
108.                     //开始服务时间  
109.                     long beginTime=System.currentTimeMillis();  
110.                           
111.                         //服务时间应该为最少时间Constants.MIN_SERVICE_TIME  
112.                           
113.                       
114.                         try {  
115.                             Thread.sleep(Constants.MIN_SERVICE_TIME);  
116.                         } catch (InterruptedException e) {  
117.                               
118.                             e.printStackTrace();  
119.                         }  
120.                           
121.                     long costTime=System.currentTimeMillis()-beginTime;  
122.                       
123.                     System.out.println(windowName+"为第"+number+"个"+type+"客户服务，耗时时间"+(costTime)/1000);  
124.                 }  
125.                 //如果没有取得被服务的客户的号码，就去普通任务的号码  
126.                 else{  
127.                       
128.                     System.out.println(windowName+"没有取得快速任务");  
129.                     commonService();  
130.                       
131.                 }  
132.                 //System.out.println("-----------------------------------------------");  
133.             }  
134.                               
135.       
136.         //为VIP客户服务的函数  
137.                 public void VIPService() {  
138.                     String windowName=windowId+"号"+type+"窗口";  
139.                       
140.                       
141.                     //通过获取号码管理器对象，获取服务客户的号码  
142.                     Integer number=NumberMachine.getInstance().getVipManager().fetchServiceNunmber();  
143.                     System.out.println(windowName+"..........正在获取任务");  
144.                       
145.                     //如果取得被服务的客户号码，就进行服务  
146.                     if(number!=null){  
147.                           
148.                           
149.                         System.out.println(windowName+"为第"+number+"个===================VIP客户服务");   
150.                         //开始服务时间  
151.                         long beginTime=System.currentTimeMillis();  
152.                               
153.                             //服务时间应该为最大时间减去最小时间  
154.                            int maxRandom=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;    
155.                             //随机从maxRandom中获取服务时间，再加上最小服务时间    
156.                             long serviceTime=new Random().nextInt(maxRandom+1)+Constants.MIN_SERVICE_TIME;   
157.                           
158.                             try {  
159.                                 Thread.sleep(serviceTime);  
160.                             } catch (InterruptedException e) {  
161.                                   
162.                                 e.printStackTrace();  
163.                             }  
164.                               
165.                         long costTime=System.currentTimeMillis()-beginTime;  
166.                           
167.                         System.out.println(windowName+"为第"+number+"个"+type+"客户服务，耗时时间"+(costTime)/1000);  
168.                     }  
169.                     //如果没有取得被服务VIP客户的号码，就去取普通任务的号码  
170.                     else{  
171.                           
172.                         System.out.println(windowName+"没有取得VIP任务");  
173.                         commonService();  
174.                           
175.                     }  
176.                     //System.out.println("-----------------------------------------------");  
177.                 }                 
178.           
179. }  

6、定义MainClass 类作为程序入口，并且模拟客户调用号码管理器中

的号码产生器中的生成客户排队号码，通过定时器固定频率定时产生客户号码

并且创建窗口，开启服务窗口

实例代码：

[java]  view plain copy

1. package cn.the_bank;  
2.   
3. import java.util.concurrent.Executors;  
4. import java.util.concurrent.TimeUnit;  
5.   
6. public class MainClass {  
7.   
8.     /** 
9.      * @param args 
10.      */  
11.     public static void main(String[] args) {  
12.         // TODO Auto-generated method stub  
13.         //通过循环创建4个普通窗口并开启服务  
14.         for(int i=1;i<5;i++)  
15.         {     
16.             //创建普通窗口  
17.             ServiceWindow commonWindow=new ServiceWindow();  
18.             commonWindow.setWindowId(i);  
19.               
20.             //开启线程并进行服务  
21.             commonWindow.start();  
22.         }  
23.         //创建5号快速窗口，并开启服务  
24.         ServiceWindow expressWindow=new ServiceWindow();  
25.         expressWindow.setType(CustomerType.EXPRESS);  
26.         expressWindow.setWindowId(5);  
27.         expressWindow.start();  
28.           
29.         //创建6号VIP窗口，并开启服务  
30.         ServiceWindow VIPWindow=new ServiceWindow();  
31.         VIPWindow.setType(CustomerType.VIP);  
32.         VIPWindow.setWindowId(6);  
33.         VIPWindow.start();  
34.           
35.         //通过定时器思想，普通客户定时循环取号  
36.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
37.                 new Runnable(){  
38.                     public void run(){  
39.                         Integer number=NumberMachine.getInstance().getCommonManager().generateNewNumber();  
40.                           
41.                         //为了更好的查看代码的运行状态  
42.                         System.out.println("普通客户：第<"+number+">号正在等待服务");  
43.                     }  
44.                 },  
45.                 0,  
46.                 Constants.COMMON_CUSTOMER_INTERVAL_TYME,  
47.                 TimeUnit.SECONDS);  
48.           
49.         //快速客户定时取号  
50.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
51.                 new Runnable(){  
52.                     public void run(){  
53.                         Integer number=NumberMachine.getInstance().getExpressManager().generateNewNumber();  
54.                           
55.                         System.out.println("快速客户第：<"+number+">号正在等待服务");  
56.                     }  
57.                 },  
58.                 0,  
59.                 Constants.COMMON_CUSTOMER_INTERVAL_TYME*2,  
60.                 TimeUnit.SECONDS);  
61.           
62.         //VIP客户定时取号  
63.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
64.                 new Runnable(){  
65.                     public void run(){  
66.                         Integer number=NumberMachine.getInstance().getVipManager().generateNewNumber();  
67.                           
68.                         System.out.println("VIP客户：第<"+number+">号正在等待服务");  
69.                     }  
70.                 },   
71.                 0,   
72.                 Constants.COMMON_CUSTOMER_INTERVAL_TYME*6,  
73.                 TimeUnit.SECONDS);  
74.           
75.       
76.       
77.     }  
78.   
79. }