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

---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------

1.项目需求：

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

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

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

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

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

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

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

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

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

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

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

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

分析：

1，有三种办不同业务类型的客户，普通客户，快速客户，VIP客户，它们都有各自对应的服务窗口进行服务，它产在各自对应的窗口服务时也是按顺序排队的，所以它们应该在叫号时会产生各自不同类型的号码。因此，想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。

2，窗口是怎么叫号的？用面向对象的思想，用张老师的一句经典的话“谁拥有数据谁就对外提供操作这些数据的方法”所以窗口在叫号时，叫的号码只有相对应的号码管理器最清楚，所以叫号也就是相对应的窗口问号码管理器要它所对应的号码。

3，知道了叫号的过程后，就可以创建三个类。NumberManager,用于存储和生产号码，存储的号码可以用一个集合来进行存储。并且要先存进去的先取出来。NumberMachine,定义生成三种客户的机器，但是它只存在于一个窗口，，所以要将它设计成单例。CustomerType枚举类，用来表示三种客户，并且重写goString方法，返回它们所对应的中文名称。ServiceWindow,它的内部有一个线程，根据服务窗口的不同分别循环调用三个不同的服务方法。MainClass，用for循环创建4个普通窗口，再创建一个快速窗口和一个VIP窗口，再创建三个定时器，分别控制它们所对应的客户生成的时间。Constants,定义三个常量，MAX_SERVICE_TIME(最长的服务时间)，MIN_SERVICE_TIME（最短的服务时间）,COMMON_CUSTOMER_INTERVAL_TIME(生成普客户的时间)。

[java]  view plain copy print ?

1. package com.isoftstone.interview.bank;  
2.   
3. import java.util.ArrayList;  
4. //号码生成器  
5. public class NumberManager {  
6.       private int lastNumber=1;  
7.       //此集合是为了装我们生成好的客户  
8.       private List<Integer> queueNumber =new ArrayList<Integer>();  
9.       public synchronized Integer generateNewManager()  
10.         {  
11.             queueNumber.add(lastNumber);  
12.             return lastNumber++;   
13.         }  
14.       //取号码的方法，先存的先取出来，并且生成号码和取号码用到了同一个对象queueNumber，所以要将它们进行同步  
15.       public synchronized Integer fetchServiceNumber()  
16.       {  
17.           Integer number=null;  
18.           if(queueNumber.size()>0)  
19.           {  
20.               number=queueNumber.remove(0);  
21.           }  
22.           return number;  
23.       }  
24.      
25. }  

[java]  view plain copy print ?

1. package com.isoftstone.interview.bank;  
2. //生成三种客户的机器，但是它只存在于一个机器中，所以要将它设计成单例  
3. public class NumberMachine {  
4.     private NumberManager  commonManager=new NumberManager();  
5.     private NumberManager  expressManager=new NumberManager();  
6.     private NumberManager  vipManager=new NumberManager();  
7.     public NumberManager getCommonManager() {  
8.         return commonManager;  
9.     }  
10.     public NumberManager getExpressManager() {  
11.         return expressManager;  
12.     }  
13.     public NumberManager getVipManager() {  
14.         return vipManager;  
15.     }  
16.       
17.     private NumberMachine(){}  
18.     private static NumberMachine instance =new NumberMachine();  
19.     public static NumberMachine getInstance()  
20.     {  
21.         return instance;  
22.     }  
23.       
24.   
25. }  

[java]  view plain copy print ?

1. package com.isoftstone.interview.bank;  
2. //服务窗口，有一个线程来循环操作窗口叫号功能  
3. import java.util.Random;  
4. import java.util.concurrent.Executors;  
5.   
6. public class ServiceWindow {  
7.     
8.     private CustomerType type= CustomerType.COMMON;  
9.     private int windowId=1;  
10.     public void setType(CustomerType type)   
11.     {  
12.         this.type = type;  
13.     }  
14.     public void setWindowId(int windowId)  
15.     {  
16.         this.windowId = windowId;  
17.     }  
18.     public void start()  
19.      {  
20.         //用线程池来创建一个单线程来不断的模拟三个不同类型的窗口不断取号的过程  
21.        Executors.newSingleThreadExecutor().execute(new Runnable()  
22.        {  
23.            public void run()  
24.            {  
25.                while (true)  
26.                {  
27.                      
28.                    switch(type)  
29.                    {  
30.                    case COMMON:  
31.                        commonService();  
32.                        break;  
33.                         
34.                   case EXPERESS:  
35.                       expressService();  
36.                        break;  
37.                   case VIP:  
38.                       vipService();  
39.                       break;  
40.                    }   
41.                      
42.                }  
43.            }  
44.        });  
45.    }  
46.     private void commonService()  
47.     {  
48.          String windowName="第"+windowId+"号"+type+"窗口";  
49.            
50.            Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();  
51.            System.out.println(windowName+"正在获取任务");  
52.            if(number!=null)  
53.            {  
54.                System.out.println(windowName+"为第"+number+"个"+type+"客户服务");  
55.               long  beginTime=System.currentTimeMillis();  
56.               int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
57.               long severTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;  
58.               try  
59.               {  
60.                  Thread.sleep(severTime);  
61.               }  
62.               catch(InterruptedException e)  
63.               {e.printStackTrace();}  
64.                long costTime=System.currentTimeMillis()-beginTime;  
65.                System.out.println(windowName+"为第"+number+"个"+"普通"+"客户完成任务，耗时"+costTime/1000+"秒");  
66.                  
67.            }  
68.            else  
69.            {  
70.                System.out.println(windowName+"没有取到任务,先休息1秒钟");  
71.                  
72.                try  
73.                   {  
74.                      Thread.sleep(1000);  
75.                   }  
76.                   catch(InterruptedException e)  
77.                   {e.printStackTrace();}  
78.            }  
79.     }  
80.     private void expressService()  
81.     {  
82.          String windowName="第"+windowId+"号"+type+"窗口";  
83.            
84.            Integer number=NumberMachine.getInstance().getExpressManager().fetchServiceNumber();  
85.            System.out.println(windowName+"正在获取任务");  
86.            if(number!=null)  
87.            {  
88.               long  beginTime=System.currentTimeMillis();  
89.              // int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
90.             //  long severTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;  
91.               try  
92.               {  
93.                  Thread.sleep(Constants.MIN_SERVICE_TIME);  
94.               }  
95.               catch(InterruptedException e)  
96.               {e.printStackTrace();}  
97.                long costTime=System.currentTimeMillis()-beginTime;  
98.                System.out.println(windowName+"为第"+number+"个"+type+"客户完成任务，耗时"+costTime/1000+"秒");  
99.                  
100.            }  
101.            else  
102.            {  
103.                System.out.println(windowName+"没有取到任务!");  
104.                commonService();  
105.                  
106.            }  
107.     }  
108.     private void vipService()  
109.     {  
110.          String windowName="第"+windowId+"号"+type+"窗口";  
111.              
112.            Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();  
113.            System.out.println(windowName+"正在获取任务");  
114.            if(number!=null)  
115.            {  
116.               long  beginTime=System.currentTimeMillis();  
117.               int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
118.               long severTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;  
119.               try  
120.               {  
121.                  Thread.sleep(severTime);  
122.               }  
123.               catch(InterruptedException e)  
124.               {e.printStackTrace();}  
125.                long costTime=System.currentTimeMillis()-beginTime;  
126.                System.out.println(windowName+"为第"+number+"个"+type+"客户完成任务，耗时"+costTime/1000+"秒");  
127.                  
128.            }  
129.            else  
130.            {  
131.                System.out.println(windowName+"没有取到任务!");  
132.                commonService();  
133.                  
134.            }  
135.     }  
136. }  

[java]  view plain copy print ?

1. package com.isoftstone.interview.bank;  
2. //因为只有三个窗口，所以可以用枚举来定义三个不同类型的窗口  
3. public enum CustomerType {  
4.       COMMON,EXPERESS,VIP;  
5.       public String toString()  
6.       {  
7.           switch(this){  
8.           case COMMON:  
9.               return "普通";  
10.           case EXPERESS:  
11.               return "快速";  
12.           case VIP:  
13.               return name();  
14.           }  
15.           return null;  
16.       }  
17. }  

[java]  view plain copy print ?

1. package com.isoftstone.interview.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.   
9. }  

[java]  view plain copy print ?

1. package com.isoftstone.interview.bank;  
2.   
3. import java.util.concurrent.Executors;  
4.   
5. public class MainClass {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.           
12.         for (int i=1;i<5;i++)  
13.         {  
14.             ServiceWindow commonwindow=new ServiceWindow();  
15.             commonwindow.setWindowId(i);  
16.             commonwindow.start();  
17.         }  
18.         //创建快速窗口  
19.         ServiceWindow experessWindow=new ServiceWindow();  
20.         experessWindow.setType(CustomerType.EXPERESS);  
21.         experessWindow.start();   
22.           
23.         //创建VIP窗口  
24.         ServiceWindow vipWindow=new ServiceWindow();  
25.         vipWindow.setType(CustomerType.VIP);  
26.         vipWindow.start();  
27.           
28.         //用线程池来设置三个对应的客户分别产生的时间  
29.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
30.                 new Runnable(){  
31.                 public void run() {  
32.                     Integer  number=NumberMachine.getInstance().getCommonManager().generateNewManager();  
33.                     System.out.println(number+"号普通客户等待服务！");  
34.                       
35.                 }},   
36.                 0,   
37.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME,   
38.                 TimeUnit.SECONDS);  
39.           
40.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
41.                 new Runnable(){@Override  
42.                 public void run() {  
43.                     Integer  number=NumberMachine.getInstance().getVipManager().generateNewManager();  
44.                     System.out.println(number+"号VIP客户等待服务！");  
45.                 }},   
46.                 0,   
47.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME *6,   
48.                 TimeUnit.SECONDS);    
49.           
50.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
51.                 new Runnable(){@Override  
52.                 public void run() {  
53.                     Integer  number=NumberMachine.getInstance().getExpressManager().generateNewManager();  
54.                     System.out.println(number+"号快速客户等待服务！");      
55.                       
56.                 }},   
57.                 0,   
58.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME *2,   
59.                 TimeUnit.SECONDS);  
60.   
61.     }  
62.   
63. }  

总结：一定要弄清它们之间的联系，最主要的是窗口叫号其实就是问号码管理器要号的过程，当快速窗口和VIP窗口没有对应的客户时就可以叫普通窗口的服务。还有就是线程池的用法，它里面有一个叫 scheduleAtFixedRate()它可以定时的去执行给定的方法。---------------------- ASP.Net+Unity开发、 .Net培训、期待与您交流！ ----------------------