<黑马程序员>破解月薪7K的面试题-银行业务调度系统

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

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

•  银行业务调度系统需求说明

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

（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）如果我不是多次亲身经历银行的这种业务，再加之积累了大量面向对象的应用开发经验，我也不知道能否轻松进行这种设计，能否发掘出其中隐含的对象信息，我真说不出具体的经验是什么，就是日积月累出来的一种感觉。难道这就是传说中的：“只可意会，不可言传？”

•  编写表示号码管理器的类

[java]  view plain copy

1. /* 
2.  * generateNewManager方法和fecthServerNumber方法访问同一个数据lastNumber， 
3.  * 在多线程操作中会出现安全性问题，所以这两个方法必须是同步函数 
4.  */  
5.   
6. //号码管理器  
7. public class NumberManager {  
8.   
9.     private int lastNumber = 1;  
10.     //排队号，即将服务号码按顺序排成一个队列  
11.     private List<Integer> queueNumber = new ArrayList<Integer>();  
12.       
13.     //产生新的号码  
14.     public synchronized Integer generateNewManager() {  
15.         //将号码存储到队列中  
16.         queueNumber.add(lastNumber);  
17.         return lastNumber++;  
18.     }  
19.       
20.     //取服务号码  
21.     public synchronized Integer fecthServerNumber() {  
22.         Integer number = null;  
23.         //如果存在元素  
24.         if(queueNumber.size() > 0) {  
25.             //返回队列的第一个元素，同时移除该元素  
26.             number = queueNumber.remove(0);  
27.         }  
28.         return number;  
29.     }  
30. }  

• 编写表示号码机器的类

[java]  view plain copy

1. <span style="font-size:14px;">/* 号码生成器，它产生3个类型NumberManager 
2.  * 使用单例设计模式 
3.  */  
4. public class NumberMachine {  
5.   
6.     //普通客户  
7.     private NumberManager commonManager = new NumberManager();  
8.     //快速客户  
9.     private NumberManager expressManager = new NumberManager();  
10.     //VIP客户  
11.     private NumberManager vipManager = new NumberManager();  
12.     private static NumberMachine instance = new NumberMachine();  
13.       
14.     //私有化构造方法  
15.     private NumberMachine() {}  
16.       
17.     //获得NumberMachine对象  
18.     public static NumberMachine getInstance() {  
19.         return instance;  
20.     }  
21.       
22.     public NumberManager getCommonManager() {  
23.         return commonManager;  
24.     }  
25.       
26.     public NumberManager getExpressManager() {  
27.         return expressManager;  
28.     }  
29.       
30.     public NumberManager getVipManager() {  
31.         return vipManager;  
32.     }  
33. }</span>  

• 编写表示业务窗口的类的骨架代码

客户类型枚举类：

[java]  view plain copy

1. <span style="font-size:14px;">//客户类型枚举类，可以类型只有3种：普通客户、快速客户和VIP客户，使用枚举可以限定取值范围  
2. public enum CustomerType {  
3.   
4.     COMMON, EXPRESS, VIP;  
5.       
6.     @Override  
7.     public String toString() {  
8.         switch(this) {  
9.             case COMMON : return "普通";  
10.             case EXPRESS : return "快速";  
11.             case VIP : return "VIP";  
12.         }  
13.         return null;  
14.     }  
15. }</span>  

• 完成表示业务窗口的类的细节代码

服务窗口类：

[java]  view plain copy

1. //服务窗口  
2. public class ServerWindow {  
3.   
4.     //默认是客户类型为普通客户  
5.     private CustomerType type = CustomerType.COMMON;  
6.     //窗口号  
7.     int windowIn = 1;  
8.       
9.     //设置客户类  
10.     public void setType(CustomerType type) {  
11.         this.type = type;  
12.     }  
13.   
14.     //设置窗口编号  
15.     public void setWindowIn(int windowIn) {  
16.         this.windowIn = windowIn;  
17.     }  
18.   
19.     public void start() {  
20.         //创建线程池  
21.         Executors.newSingleThreadExecutor().execute(new Runnable() {  
22.             public void run() {  
23.                   
24.                 while(true) {  
25.                     //如果为普通客户,使用switch是因为比if-else效率高，switch中接收的参数为int类型和枚举类型的  
26.                     switch (type) {  
27.                     //普通客户  
28.                     case COMMON:  
29.                         commonServer();  
30.                         break;  
31.                     case EXPRESS:  
32.                         expressServer();  
33.                         break;  
34.                     case VIP:  
35.                         vipServer();  
36.                         break;  
37.                     }  
38.                 }  
39.             }  
40.   
41.         });  
42.     }  
43.       
44.     private void commonServer() {  
45.         //type的返回值调用CustomerType类的toString方法  
46.         String windowName = "第"+windowIn+"号"+type+"窗口";  
47.         Integer number = NumberMachine.getInstance().getCommonManager().fecthServerNumber();  
48.         System.out.println(windowName+"正在获取普通任务");  
49.         if(number != null) {  
50.             System.out.println(windowName+"正在为第"+number+"个普通客户服务");  
51.             long beginTime = System.currentTimeMillis();  
52.             //最大服务时间  
53.             int maxRand = Constants.MAX_SERVER_TIME - Constants.MIN_SERVER_TIME;  
54.             //普通客户服务时间为1000到1万之间是随机数（毫秒值）  
55.             long serverTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVER_TIME;  
56.             try {  
57.                 Thread.sleep(serverTime);  
58.             } catch (InterruptedException e) {  
59.                 e.printStackTrace();  
60.             }  
61.             long costTime = System.currentTimeMillis() - beginTime;  
62.             System.out.println(windowName+"为第"+number+"个普通客户完成服务，耗时"+costTime/1000+"秒");  
63.         }else {  
64.             System.out.println(windowName+"没有获取到普通服务任务，等待1秒钟");  
65.             //等待1秒钟  
66.             try {  
67.                 Thread.sleep(1000);  
68.             } catch (InterruptedException e) {  
69.                 e.printStackTrace();  
70.             }  
71.         }  
72.     }  
73.       
74.     private void expressServer() {  
75.         //type的返回值调用CustomerType类的toString方法  
76.         String windowName = "第"+windowIn+"号"+type+"窗口";  
77.         Integer number = NumberMachine.getInstance().getExpressManager().fecthServerNumber();  
78.         System.out.println(windowName+"正在获取"+type+"任务");  
79.         if(number != null) {  
80.             System.out.println(windowName+"正在为第"+number+"个"+type+"客户服务");  
81.             long beginTime = System.currentTimeMillis();  
82.             try {  
83.                 //快速客户服务时间为最小值  
84.                 Thread.sleep(Constants.MIN_SERVER_TIME);  
85.             } catch (InterruptedException e) {  
86.                 e.printStackTrace();  
87.             }  
88.             long costTime = System.currentTimeMillis() - beginTime;  
89.             System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");  
90.         }else {  
91.             System.out.println(windowName+"没有获取到"+type+"服务任务");  
92.             //为普通客户服务  
93.             commonServer();  
94.         }  
95.     }  
96.       
97.     private void vipServer() {  
98.         //type的返回值调用CustomerType类的toString方法  
99.         String windowName = "第"+windowIn+"号"+type+"窗口";  
100.         Integer number = NumberMachine.getInstance().getVipManager().fecthServerNumber();  
101.         System.out.println(windowName+"正在获取"+type+"任务");  
102.         if(number != null) {  
103.             System.out.println(windowName+"正在为第"+number+"个"+type+"客户服务");  
104.             long beginTime = System.currentTimeMillis();  
105.             try {  
106.                 Thread.sleep(1000);  
107.             } catch (InterruptedException e) {  
108.                 e.printStackTrace();  
109.             }  
110.             long costTime = System.currentTimeMillis() - beginTime;  
111.             System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");  
112.         }else {  
113.             System.out.println(windowName+"没有获取到"+type+"服务任务");  
114.             //VIP窗口没有VIP客户则为普通客户服务  
115.             commonServer();  
116.         }  
117.     }  
118.       
119. }  

•  编写程序的主类和完成客户取号功能

1. 常量类：

[java]  view plain copy

1. //常量类  
2. public class Constants {  
3.     //最大服务时间为10秒  
4.     public static int MAX_SERVER_TIME = 10000;  
5.     //最小服务时间味1秒  
6.     public static int MIN_SERVER_TIME = 1000;  
7.     //普通客户间隔时间  
8.     public static int COMMON_CUSTOMER_INTERVAl_TIME = 1;  
9. }  

2. 主类（主函数）：

[java]  view plain copy

1. public class MainClass {  
2.     public static void main(String[] args) {  
3.   
4.         //创建4个普通客户窗口  
5.         for(int i = 1; i < 5; i++) {  
6.             ServerWindow commonWindow = new ServerWindow();  
7.             commonWindow.setWindowIn(i);  
8.             commonWindow.start();  
9.         }  
10.           
11.         ServerWindow expressWindow = new ServerWindow();  
12.         //设置为快速客户类型，id不设置默认为1  
13.         expressWindow .setType(CustomerType.EXPRESS);  
14.         expressWindow .start();  
15.           
16.         ServerWindow vipWindow = new ServerWindow();  
17.         //设置为vip客户类型，id不设置默认为1  
18.         vipWindow .setType(CustomerType.VIP);  
19.         vipWindow .start();  
20.            
21.         //创建调度线程池，只需要1个线程  
22.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
23.                 new Runnable() {  
24.                     public void run() {  
25.                         Integer number = NumberMachine.getInstance().getCommonManager().generateNewManager();  
26.                         System.out.println(number+"号普通客户等待服务");  
27.                     }  
28.                 },   
29.                 0,   
30.                 Constants.COMMON_CUSTOMER_INTERVAl_TIME,//每隔1秒   
31.                 TimeUnit.SECONDS//单位为秒钟  
32.         );  
33.           
34.         //创建调度线程池，只需要1个线程  
35.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
36.                 new Runnable() {  
37.                     public void run() {  
38.                         Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();  
39.                         System.out.println(number+"号快速客户等待服务");  
40.                     }  
41.                 },   
42.                 0,   
43.                 //每隔2秒,间隔时间是普通客户的2倍，因为快速数量客户是普通客户的1/2  
44.                 Constants.COMMON_CUSTOMER_INTERVAl_TIME*2,   
45.                 TimeUnit.SECONDS//单位为秒钟  
46.         );  
47.           
48.         //创建调度线程池，只需要1个线程  
49.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
50.                 new Runnable() {  
51.                     public void run() {  
52.                         Integer number = NumberMachine.getInstance().getVipManager().generateNewManager();  
53.                         System.out.println(number+"号VIP客户等待服务");  
54.                     }  
55.                 },   
56.                 0,   
57.                 //每隔6秒,间隔时间是普通客户的6倍，因为vip客户数量是普通客户的1/6  
58.                 Constants.COMMON_CUSTOMER_INTERVAl_TIME*6,   
59.                 TimeUnit.SECONDS//单位为秒钟  
60.         );  
61.           
62.     }  
63. } 

64.  -------android培训、JAVA培训、期待与您交流！ ----------

    --------详细请查看www.itheima.com-------------