文档章节

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

s
 sun64bit
发布于 2015/04/24 10:26
字数 2509
阅读 11
收藏 0
------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------


需求

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

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

有三种对应类型的客户:VIP客户,普通客户,快速客户(办理如交水电费、电话费之类业务的客户)。

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

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

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

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

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

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

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

分析

我们知道客户去银行办理业务,首先要去取号机取号,然后等待窗口叫号,那么窗口是通过什么叫号的呢,就是根据取号机内部产生和维护的不同的业务队列来完成的

所以

涉及的对象有:业务窗口、客户、取号机、业务类型以及取号机内部维护的业务队列

为了简化设计,用字符串形式代替客户信息,主要实现系统逻辑为主

面向对象分析与设计

业务类型BusinessType类:

采用枚举的方式,创建3个实例分别表示普通业务、快速业务、VIP业务

内部维护的业务队列Queue类:

内部维护一个集合用来存放队列中的客户信息

以及一个整型变量用来表示当天的客户队列号

实现加入一个客户到队列的方法

以及从队列中取出一个客户的方法(即叫号过程)

取号机TicketMachine类:

简化编程,我们将取号机设计成一个单例

内部维护三个不同业务类型的队列

对外提供取号方法给用户

提供获取队列方法给业务窗口

业务窗口Windows类:

业务窗口属性有:业务类型及窗口编号

对外提供开始业务的方法供银行调度

思考:

在对业务窗口进行设计的时候发现,虽然各窗口同属一类,但在提供服务的过程不尽相同,所以考虑的两种实现方式

  • 第一种就是考虑到在开展业务的时候各窗口的代码有不同之处,所以考虑用这种方式来设计,将不同的业务类型的窗口分配到不同的类

  • 第二种是直接将所有业务类型的服务代码写在同一个类中

由于不太懂设计模式,个人的感觉是,这里主要实现的是系统逻辑,所以每个窗口的服务代码差异并没有想象的大,故采用第二种方式

如果是一个比较系统的需要长期维护的项目,我会采用第一种,确保每个类的单一功能

代码实现

业务类型BusinessType类:
1: /**
   2:  * 业务类型
   3:  * @author Shawn
   4:  *
   5:  */
   6: public enum BusinessType {
   7:     GENERAL,//普通业务类型
   8:     QUICK,//快速业务类型
   9:     VIP;//VIP业务类型
  10:     
  11:     @Override
  12:     public String toString() {
  13:         switch(this){
  14:         case GENERAL:
  15:             return "普通";
  16:         case QUICK:
  17:             return "快速";
  18:         case VIP:
  19:             return "VIP";
  20:         }
  21:         return null;
  22:     }
  23: }
用户队列Queue类:
   1: /**
   2:  * 用户队列
   3:  * @author Shawn
   4:  *
   5:  */
   6: public class Queue {
   7:     
   8:     private BusinessType businessType;//队列的业务类型
   9:     private int customerNum = 1;//记录用户队列号
  10:     List<String> queue = new LinkedList<String>();//队列载体
  11:     
  12:     public Queue(BusinessType businessType) {
  13:         super();
  14:         this.businessType = businessType;
  15:     }
  16:     
  17:     //产生新的号码,加入到队列
  18:     public synchronized String generateNewCustomer(){
  19:         String name = businessType+"客户_"+(customerNum++)+"号";
  20:         if(queue.add(name))
  21:             return name;
  22:         else
  23:             return null;
  24:     }
  25:     
  26:     //从队列中取出第一个客户
  27:     public synchronized String getCustomer(){
  28:         if(!isEmpty())
  29:             return queue.remove(0);
  30:         else 
  31:             return null;
  32:     }
  33:     
  34:     //判断队列是否为空,即是否有客户等待业务
  35:     public synchronized boolean isEmpty(){
  36:         if(queue.size() > 0)
  37:             return false;
  38:         else
  39:             return true;
  40:     }
  41: }
取号机TicketMachine类:
   1: /**
   2:  * 取号机
   3:  * @author Shawn
   4:  *
   5:  */
   6: public class TicketMachine {
   7:     
   8:     //内部维护的三个业务队列
   9:     private Queue generalQueue = new Queue(BusinessType.GENERAL);
  10:     private Queue quickQueue = new Queue(BusinessType.QUICK);
  11:     private Queue vipQueue = new Queue(BusinessType.VIP);
  12:     
  13:     //获取相关业务队列的接口
  14:     public Queue getQueue(BusinessType businessType){
  15:         switch(businessType){
  16:         case GENERAL:
  17:             return generalQueue;
  18:         case QUICK:
  19:             return quickQueue;
  20:         case VIP:
  21:             return vipQueue;
  22:         }
  23:         return null;
  24:     }
  25:     
  26:     //针对不同业务,加入新的客户到对应队列
  27:     public String generateTicket(BusinessType businessType){
  28:         switch(businessType){
  29:         case GENERAL:
  30:             return generalQueue.generateNewCustomer();
  31:         case QUICK:
  32:             return quickQueue.generateNewCustomer();
  33:         case VIP:
  34:             return vipQueue.generateNewCustomer();
  35:         }
  36:         return null;
  37:     }
  38:     //单例实现
  39:     private TicketMachine(){}
  40:     private static TicketMachine machineInstance = new TicketMachine();
  41:     public static TicketMachine getInstance(){
  42:         return machineInstance;
  43:     }
  44: }
业务窗口Windows类:
   1: /**
   2:  * 业务窗口
   3:  * @author Shawn
   4:  *
   5:  */
   6: public class Windows {
   7:     private BusinessType businessType;//窗口业务类型
   8:     private int winNum;//窗口编号
   9:     private boolean available = false;//窗口开放状态
  10:     
  11:     public Windows(BusinessType businessType,int winNum) {
  12:         super();
  13:         this.businessType = businessType;
  14:         this.winNum = winNum;
  15:     }
  16:     
  17:     //开始业务
  18:     public void start(){
  19:         available = true;
  20:         System.out.println(this+"开始服务!");
  21:         
  22:         //创建新的线程开始不同窗口的业务
  23:         ExecutorService pool = Executors.newSingleThreadExecutor();
  24:         pool.execute(new Runnable(){
  25:             public void run(){
  26:                 switch(businessType){
  27:                 case GENERAL:
  28:                     while(available){
  29:                         generalService();
  30:                     }
  31:                 case QUICK:
  32:                     while(available){
  33:                         quickService();
  34:                     }    
  35:                 case VIP:
  36:                     while(available){
  37:                         vipService();
  38:                     }    
  39:                 }
  40:             }
  41:         });
  42:     }
  43:     //普通业务窗口服务过程
  44:     private void generalService(){
  45:         //普通业务只需要获得普通用户队列
  46:         Queue queue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);
  47:         //如果队列不为空,则开始叫号并模拟服务
  48:         if(!queue.isEmpty()){
  49:             String name = queue.getCustomer();
  50:             System.out.println(this+"正在为 "+name+"服务~");
  51:             int time = generalCustomerServicing();
  52:             //System.out.println(this+"服务完毕,耗时"+time+"秒");
  53:         }
  54:         else{
  55:             //System.out.println(this+"正在等待客户...");
  56:             try {
  57:                 Thread.sleep(1000);
  58:             } catch (InterruptedException e) {
  59:                 // TODO Auto-generated catch block
  60:                 e.printStackTrace();
  61:             }
  62:         }
  63:     }
  64:     //快速窗口业务服务过程
  65:     private void quickService(){
  66:         //快速窗口需要得到快速队列以及普通队列
  67:         Queue quickQueue = TicketMachine.getInstance().getQueue(BusinessType.QUICK);
  68:         Queue generalQueue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);
  69:         
  70:         //首先判断快速队列
  71:         if(!quickQueue.isEmpty()){
  72:             String name = quickQueue.getCustomer();
  73:             System.out.println(this+"正在为 "+name+"服务~");
  74:             int time = quickCustomerServicing();
  75:             //System.out.println(this+"服务完毕,耗时"+time+"秒");
  76:         }
  77:         //若快速队列没有等待客户,则考虑普通队列
  78:         else if(!generalQueue.isEmpty()){
  79:             String name = generalQueue.getCustomer();
  80:             System.out.println(this+"正在为 "+name+"服务~");
  81:             int time = generalCustomerServicing();
  82:             //System.out.println(this+"服务完毕,耗时"+time+"秒");
  83:         }
  84:         else{
  85:             //System.out.println(this+"正在等待客户...");
  86:             try {
  87:                 Thread.sleep(1000);
  88:             } catch (InterruptedException e) {
  89:                 // TODO Auto-generated catch block
  90:                 e.printStackTrace();
  91:             }
  92:         }
  93:     }
  94:     //vip窗口业务服务过程
  95:     private void vipService(){
  96:         //vip窗口需要得到的vip队列以及普通队列
  97:         Queue vipQueue = TicketMachine.getInstance().getQueue(BusinessType.VIP);
  98:         Queue generalQueue = TicketMachine.getInstance().getQueue(BusinessType.GENERAL);
  99:         
 100:         //如果vip队列不为空,则取出vip客户处理
 101:         if(!vipQueue.isEmpty()){
 102:             String name = vipQueue.getCustomer();
 103:             System.out.println(this+"正在为 "+name+"服务~");
 104:             int time = vipCustomerServicing();
 105:             //System.out.println(this+"服务完毕,耗时"+time+"秒");
 106:         }
 107:         //若vip队列为空,则考虑普通队列
 108:         else if(!generalQueue.isEmpty()){
 109:             String name = generalQueue.getCustomer();
 110:             System.out.println(this+"正在为 "+name+"服务~");
 111:             int time = generalCustomerServicing();
 112:             //System.out.println(this+"服务完毕,耗时"+time+"秒");
 113:         }
 114:         else{
 115:             //System.out.println(this+"正在等待客户...");
 116:             try {
 117:                 Thread.sleep(1000);
 118:             } catch (InterruptedException e) {
 119:                 // TODO Auto-generated catch block
 120:                 e.printStackTrace();
 121:             }
 122:         }
 123:         
 124:     }
 125:     //服务普通客户的模拟时间
 126:     private int generalCustomerServicing(){
 127:         int time = new Random().nextInt(
 128:                 Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME)+
 129:                 Constants.MIN_SERVICE_TIME;
 130:         try {
 131:             Thread.sleep(time*1000);
 132:         } catch (InterruptedException e) {
 133:             // TODO Auto-generated catch block
 134:             e.printStackTrace();
 135:         }
 136:         return time;
 137:     }
 138:     //服务快速客户的模拟时间
 139:     private int quickCustomerServicing(){
 140:         int time = Constants.MIN_SERVICE_TIME;
 141:         try {
 142:             Thread.sleep(time*1000);
 143:         } catch (InterruptedException e) {
 144:             // TODO Auto-generated catch block
 145:             e.printStackTrace();
 146:         }
 147:         return time;
 148:     }
 149:     //服务vip客户的模拟时间
 150:     private int vipCustomerServicing(){
 151:         int time = new Random().nextInt(
 152:                     Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME)+
 153:                     Constants.MIN_SERVICE_TIME;
 154:         try {
 155:             Thread.sleep(time*1000);
 156:         } catch (InterruptedException e) {
 157:             // TODO Auto-generated catch block
 158:             e.printStackTrace();
 159:         }
 160:         return time;
 161:     }
 162:     
 163:     @Override
 164:     public String toString() {
 165:         // TODO Auto-generated method stub
 166:         return businessType+"窗口"+winNum+"号";
 167:     }
 168: }
最后,统一维护的常量类,以及测试代码
   1: /**
   2:  * 统一维护的常量信息
   3:  * @author Shawn
   4:  *
   5:  */
   6: public class Constants {
   7:     
   8:     //客户服务的最大时间    10s
   9:     public static int MAX_SERVICE_TIME = 10;
  10:     //客户服务的最小时间    5s
  11:     public static int MIN_SERVICE_TIME = 5;
  12:     
  13:     //产生普通客户的间隔时间    1s
  14:     public static int COMMON_ITTERVAL_TIME = 1;
  15: }
   1: public class MainClass {
   2:  
   3:     /**
   4:      * 测试代码
   5:      * @param args
   6:      */
   7:     public static void main(String[] args) {
   8:         ScheduledExecutorService timer = null;
   9:         
  10:         //建立普通窗口
  11:         for(int i = 1 ; i <= 4 ; i ++){
  12:             new Windows(BusinessType.GENERAL,i).start();
  13:         }
  14:         //建立快速窗口
  15:         new Windows(BusinessType.QUICK,1).start();
  16:         //建立VIP窗口
  17:         new Windows(BusinessType.VIP,1).start();
  18:         //普通用户拿票
  19:         timer = Executors.newScheduledThreadPool(1);
  20:         timer.scheduleAtFixedRate(
  21:                 new Runnable(){
  22:                     public void run(){
  23:                         String name = TicketMachine.getInstance().generateTicket(BusinessType.GENERAL);
  24:                         //System.out.println(name + "正在等待服务...");
  25:                     }
  26:                 }, 
  27:                 1, 
  28:                 Constants.COMMON_ITTERVAL_TIME, 
  29:                 TimeUnit.SECONDS);
  30:         //快速用户拿票
  31:         timer = Executors.newScheduledThreadPool(1);
  32:         timer.scheduleAtFixedRate(
  33:                 new Runnable(){
  34:                     public void run(){
  35:                         String name = TicketMachine.getInstance().generateTicket(BusinessType.QUICK);
  36:                         //System.out.println(name + "正在等待服务...");
  37:                     }
  38:                 }, 
  39:                 1, 
  40:                 Constants.COMMON_ITTERVAL_TIME*2, 
  41:                 TimeUnit.SECONDS);
  42:         
  43:         //普通用户拿票
  44:         timer = Executors.newScheduledThreadPool(1);
  45:         timer.scheduleAtFixedRate(
  46:                 new Runnable(){
  47:                     public void run(){
  48:                         String name = TicketMachine.getInstance().generateTicket(BusinessType.VIP);
  49:                         //System.out.println(name + "正在等待服务...");
  50:                     }
  51:                 }, 
  52:                 1, 
  53:                 Constants.COMMON_ITTERVAL_TIME*6, 
  54:                 TimeUnit.SECONDS);    
  55:     }
  56: }
  总结
基本实现了银行取号调度的系统逻辑

© 著作权归作者所有

s
粉丝 0
博文 15
码字总数 25126
作品 0
卢湾
私信 提问
黑马程序员----银行业务调度

-------------------------android培训、 java培训、期待与您交流! ------------------------- 一、需求 1. 银行内有6个业务窗口,1 – 4号窗口为普通窗口,5号窗口为快速窗口,6号窗口为V...

长平狐
2013/07/01
113
0
【备忘】2017年黑马【淘宝店铺装修实战操作视频】全套无加密

2017年黑马【淘宝店铺装修实战操作视频】全套无加密 简介: 淘宝装修,对于一个好的店铺来讲,是至关重要的,因为客户只能从网上的文字和图片来了解您,了解产品,所以做得好能增加用户的信任...

qq_38155396
2017/07/01
0
0
黑马程序员---多线程

------------------------------ android培训、 java培训、期待与您交流! ------------------------------ 多线程是这样一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个...

长平狐
2013/07/01
105
0
JavaWeb01-HTML篇笔记(一)

1.1 案例一:网站信息页面的显示:1.1.1 需求: 在网页中显示网站的信息的页面:效果如下: 1.1.2 分析:1.1.2.1 技术分析: 【HTML的概述】 Ø 什么是HTML HTML:Hyper Text Markup Language ...

我是小谷粒
2018/04/25
0
0
2014年IT毕业生——年终总结与生存调查报告

从事IT行业的比例及薪资对比 2014年,近百万IT相关毕业生就业情况如何,都从事什么行业呢?据麦克斯2014年IT专业毕业生从业调查数据显示,仅有约45%的毕业生找到IT相关工作,那其余毕业生都从...

郭奕峰
2015/03/04
439
0

没有更多内容

加载失败,请刷新页面

加载更多

rime设置为默认简体

转载 https://github.com/ModerRAS/ModerRAS.github.io/blob/master/_posts/2018-11-07-rime%E8%AE%BE%E7%BD%AE%E4%B8%BA%E9%BB%98%E8%AE%A4%E7%AE%80%E4%BD%93.md 写在开始 我的Arch Linux上......

zhenruyan
今天
4
0
简述TCP的流量控制与拥塞控制

1. TCP流量控制 流量控制就是让发送方的发送速率不要太快,要让接收方来的及接收。 原理是通过确认报文中窗口字段来控制发送方的发送速率,发送方的发送窗口大小不能超过接收方给出窗口大小。...

鏡花水月
今天
8
0
OSChina 周日乱弹 —— 别问,问就是没空

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @tom_tdhzz :#今日歌曲推荐# 分享容祖儿/彭羚的单曲《心淡》: 《心淡》- 容祖儿/彭羚 手机党少年们想听歌,请使劲儿戳(这里) @wqp0010 :周...

小小编辑
今天
907
11
golang微服务框架go-micro 入门笔记2.1 micro工具之micro api

micro api micro 功能非常强大,本文将详细阐述micro api 命令行的功能 重要的事情说3次 本文全部代码https://idea.techidea8.com/open/idea.shtml?id=6 本文全部代码https://idea.techidea8....

非正式解决方案
今天
5
0
Spring Context 你真的懂了吗

今天介绍一下大家常见的一个单词 context 应该怎么去理解,正确的理解它有助于我们学习 spring 以及计算机系统中的其他知识。 1. context 是什么 我们经常在编程中见到 context 这个单词,当...

Java知其所以然
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部