zoukankan      html  css  js  c++  java

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

    ================ ASP.Net +Android+IOS开发、.Net培训、 期待与您交流！ ================

    系统需求：

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

     

    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方式展现程序运行结果。

    需求分析：

     有三种对应类型的客户：VIP客户，普通客户，快速客户 ，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务 。

    首先，经常在银行办理业务的人更有利于理解本系统，例如，我经常陪老婆跑银行，对银行的这个业务算是比较熟悉了，我知道每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以，我想到要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。

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

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

    各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

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

    类图：

    代码实现：

    NumberManager类：

    定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。

    定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步。

    程序代码：

     

     1 import java.util.ArrayList;
 2 
 3 import java.util.List;
 4 
 5  
 6 
 7 public class NumberManager {
 8 
 9 private int lastNumber = 0;
10 
11 private List queueNumbers = new ArrayList();
12 
13  
14 
15 public synchronized Integer generateNewNumber(){
16 
17 queueNumbers.add(++lastNumber);
18 
19 return lastNumber;
20 
21 }
22 
23  
24 
25 public synchronized Integer fetchNumber(){
26 
27 if(queueNumbers.size()>0){
28 
29 return (Integer)queueNumbers.remove(0);
30 
31 }else{
32 
33 return null;
34 
35 }
36 
37 }
38 
39 }

     

    NumberMachine类：

    定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个NumberManager对象。

    将NumberMachine类设计成单例。

    程序代码：

     

     1 public class NumberMachine {
 2 
 3  
 4 
 5 private NumberMachine(){}
 6 
 7 private static NumberMachine instance = new NumberMachine();
 8 
 9 public static NumberMachine getInstance(){
10 
11 return instance;
12 
13 }
14 
15  
16 
17 private NumberManager commonManager = new NumberManager();
18 
19 private NumberManager expressManager = new NumberManager();
20 
21 private NumberManager vipManager = new NumberManager();
22 
23 public NumberManager getCommonManager() {
24 
25 return commonManager;
26 
27 }
28 
29 public NumberManager getExpressManager() {
30 
31 return expressManager;
32 
33 }
34 
35 public NumberManager getVipManager() {
36 
37 return vipManager;
38 
39 }
40 
41  
42 
43 }

     

     

    CustomerType枚举类：

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

    重写toString方法，返回类型的中文名称。这是在后面编码时重构出来的，刚开始不用考虑。

    程序代码：

     

     1 public enum CustomerType {
 2 
 3 COMMON,EXPRESS,VIP;
 4 
 5 public String toString(){
 6 
 7 String name = null;
 8 
 9 switch(this){
10 
11 case COMMON:
12 
13 name = "普通";
14 
15 break;
16 
17 case EXPRESS:
18 
19 name = "快速";
20 
21 break;
22 
23 case VIP:
24 
25 name = name();
26 
27 break;
28 
29 }
30 
31 return name;
32 
33 }
34 
35 }

     

     

     

    ServiceWindow类：

    定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。 

    定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息。

    程序代码：

     

      1 import java.util.Random;
  2 
  3 import java.util.concurrent.Executors;
  4 
  5 import java.util.logging.Logger;
  6 
  7  
  8 
  9 /**
 10 
 11  * 没有把VIP窗口和快速窗口做成子类，是因为实际业务中的普通窗口可以随时被设置为VIP窗口和快速窗口。
 12 
 13  * */
 14 
 15 public class ServiceWindow {
 16 
 17 private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");
 18 
 19 private CustomerType type = CustomerType.COMMON;
 20 
 21 private int number = 1;
 22 
 23  
 24 
 25 public CustomerType getType() {
 26 
 27 return type;
 28 
 29 }
 30 
 31  
 32 
 33 public void setType(CustomerType type) {
 34 
 35 this.type = type;
 36 
 37 }
 38 
 39  
 40 
 41 public void setNumber(int number){
 42 
 43 this.number = number;
 44 
 45 }
 46 
 47  
 48 
 49 public void start(){
 50 
 51 Executors.newSingleThreadExecutor().execute(
 52 
 53 new Runnable(){
 54 
 55 public void run(){
 56 
 57 //下面这种写法的运行效率低，最好是把while放在case下面
 58 
 59 while(true){
 60 
 61 switch(type){
 62 
 63 case COMMON:
 64 
 65 commonService();
 66 
 67 break;
 68 
 69 case EXPRESS:
 70 
 71 expressService();
 72 
 73 break;
 74 
 75 case VIP:
 76 
 77 vipService();
 78 
 79 break;
 80 
 81 }
 82 
 83 }
 84 
 85 }
 86 
 87 }
 88 
 89 );
 90 
 91 }
 92 
 93  
 94 
 95 private void commonService(){
 96 
 97 String windowName = "第" + number + "号" + type + "窗口";
 98 
 99 System.out.println(windowName + "开始获取普通任务!");
100 
101 Integer serviceNumber = NumberMachine.getInstance().getCommonManager().fetchNumber();
102 
103 if(serviceNumber != null ){
104 
105 System.out.println(windowName + "开始为第" + serviceNumber + "号普通客户服务");
106 
107 int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
108 
109 int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;
110 
111  
112 
113 try {
114 
115 Thread.sleep(serviceTime);
116 
117 } catch (InterruptedException e) {
118 
119 e.printStackTrace();
120 
121 }
122 
123 System.out.println(windowName + "完成为第" + serviceNumber + "号普通客户服务，总共耗时" + serviceTime/1000 + "秒");
124 
125 }else{
126 
127 System.out.println(windowName + "没有取到普通任务，正在空闲一秒");
128 
129 try {
130 
131 Thread.sleep(1000);
132 
133 } catch (InterruptedException e) {
134 
135 e.printStackTrace();
136 
137 }
138 
139 }
140 
141 }
142 
143  
144 
145 private void expressService(){
146 
147 Integer serviceNumber = NumberMachine.getInstance().getExpressManager().fetchNumber();
148 
149 String windowName = "第" + number + "号" + type + "窗口";
150 
151 System.out.println(windowName + "开始获取快速任务!");
152 
153 if(serviceNumber !=null){
154 
155 System.out.println(windowName + "开始为第" + serviceNumber + "号快速客户服务");
156 
157 int serviceTime = Constants.MIN_SERVICE_TIME;
158 
159 try {
160 
161 Thread.sleep(serviceTime);
162 
163 } catch (InterruptedException e) {
164 
165 e.printStackTrace();
166 
167 }
168 
169 System.out.println(windowName + "完成为第" + serviceNumber + "号快速客户服务，总共耗时" + serviceTime/1000 + "秒");
170 
171 }else{
172 
173 System.out.println(windowName + "没有取到快速任务！");
174 
175 commonService();
176 
177 }
178 
179 }
180 
181  
182 
183 private void vipService(){
184 
185  
186 
187 Integer serviceNumber = NumberMachine.getInstance().getVipManager().fetchNumber();
188 
189 String windowName = "第" + number + "号" + type + "窗口";
190 
191 System.out.println(windowName + "开始获取VIP任务!");
192 
193 if(serviceNumber !=null){
194 
195 System.out.println(windowName + "开始为第" + serviceNumber + "号VIP客户服务");
196 
197 int maxRandom = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
198 
199 int serviceTime = new Random().nextInt(maxRandom)+1 + Constants.MIN_SERVICE_TIME;
200 
201 try {
202 
203 Thread.sleep(serviceTime);
204 
205 } catch (InterruptedException e) {
206 
207 e.printStackTrace();
208 
209 }
210 
211 System.out.println(windowName + "完成为第" + serviceNumber + "号VIP客户服务，总共耗时" + serviceTime/1000 + "秒");
212 
213 }else{
214 
215 System.out.println(windowName + "没有取到VIP任务！");
216 
217 commonService();
218 
219 }
220 
221 }
222 
223 }

     

    MainClass类：

    用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。

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

    程序代码：

     

      1 import java.util.concurrent.Executors;
  2 
  3 import java.util.concurrent.TimeUnit;
  4 
  5 import java.util.logging.Logger;
  6 
  7  
  8 
  9 public class MainClass {
 10 
 11  
 12 
 13 private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");
 14 
 15  
 16 
 17  
 18 
 19 public static void main(String[] args) {
 20 
 21 //产生4个普通窗口
 22 
 23 for(int i=1;i<5;i++){
 24 
 25 ServiceWindow window =  new ServiceWindow();
 26 
 27 window.setNumber(i);
 28 
 29 window.start();
 30 
 31 }
 32 
 33  
 34 
 35 //产生1个快速窗口
 36 
 37 ServiceWindow expressWindow =  new ServiceWindow();
 38 
 39 expressWindow.setType(CustomerType.EXPRESS);
 40 
 41 expressWindow.start();
 42 
 43  
 44 
 45 //产生1个VIP窗口
 46 
 47 ServiceWindow vipWindow =  new ServiceWindow();
 48 
 49 vipWindow.setType(CustomerType.VIP);
 50 
 51 vipWindow.start();
 52 
 53  
 54 
 55 //普通客户拿号
 56 
 57 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
 58 
 59 new Runnable(){
 60 
 61 public void run(){
 62 
 63 Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();
 64 
 65 /**
 66 
 67  * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来，
 68 
 69  * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。
 70 
 71  */
 72 
 73 //logger.info("第" + serviceNumber + "号普通客户正在等待服务！");
 74 
 75 System.out.println("第" + serviceNumber + "号普通客户正在等待服务！");
 76 
 77 }
 78 
 79 },
 80 
 81 0,
 82 
 83 Constants.COMMON_CUSTOMER_INTERVAL_TIME, 
 84 
 85 TimeUnit.SECONDS);
 86 
 87  
 88 
 89 //快速客户拿号
 90 
 91 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
 92 
 93 new Runnable(){
 94 
 95 public void run(){
 96 
 97 Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();
 98 
 99 System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");
100 
101 }
102 
103 },
104 
105 0,
106 
107 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2, 
108 
109 TimeUnit.SECONDS);
110 
111  
112 
113 //VIP客户拿号
114 
115 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
116 
117 new Runnable(){
118 
119 public void run(){
120 
121 Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();
122 
123 System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");
124 
125 }
126 
127 },
128 
129 0,
130 
131 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, 
132 
133 TimeUnit.SECONDS);
134 
135 }
136 
137  
138 
139 }

     

    Constants类：

    定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

    程序代码：

     

     1 public class Constants {
 2 
 3 public static int MAX_SERVICE_TIME = 10000; //10秒！
 4 
 5 public static int MIN_SERVICE_TIME = 1000; //1秒！
 6 
 7  
 8 
 9 /*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
10 
11  * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以，
12 
13  * 1秒钟产生一个普通客户比较合理，*/
14 
15 public static int COMMON_CUSTOMER_INTERVAL_TIME = 1; 
16 
17 }

     

    ================ ASP.Net +Android+IOS开发、.Net培训、 期待与您交流！ ================

    详细请查看：http://edu.csdn.net

     

     
  • 相关阅读:
    Linux Core Dump
    ODP.NET Managed正式推出
    获取EditText的光标位置
    （Java实现） 洛谷 P1603 斯诺登的密码
    （Java实现） 洛谷 P1603 斯诺登的密码
    (Java实现) 洛谷 P1036 选数
    (Java实现) 洛谷 P1036 选数
    （Java实现） 洛谷 P1012 拼数
    （Java实现） 洛谷 P1012 拼数
    （Java实现） 洛谷 P1028 数的计算
  • 原文地址：https://www.cnblogs.com/super614508584/p/3509043.html
Copyright © 2011-2022 走看看