小项目_银行业务调度

银行业务调度系统简述

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

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

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

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

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

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

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

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

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

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

2、我的分析

1）、银行里面都是用排队编号来标志用户的，当一个用户领取了一张编号，它的编号就会存入排队序列中，各个窗口根据编号的类型和顺序，为用户提供服务，所以这里编号还有不同类型的，如普通客户、快速、VIP的。

2）、假设有三种类型的编号，分别是从1开始，以1的增量递增。

 如c1、c2、c3、c4.。。。代表普通客户

e1、e2、e3、e4.。。。。。代表快速客户 

v1、v2、v3、v4.。。。。。代表VIP客户

3）、柜台窗口依次从序列中取出编号，为对应的客户服务。普通的窗口只能为普通用户服务、快速窗口为快速用户服务(当空闲时，也为普通用户服务)、VIP窗口为VIP用户服务(当空闲的时候，也为普通用户服务)。被服务完的客户对应号码，会立刻从排序序列中剔除。

4）、画个图，模拟一下银行营业厅的状况。

3、设计实现：

     首先，应该分析出有哪些实体，然后根据需要为实体提交属性和行为。简单分析了一下，主要有序号机、窗口、调度系统、客户

1） 序号机，可以产生3种类型的序号，分别对应普通客户、快速客户和VIP客户。可以用一个类来产出序号，在将其放入序号机中。

再用一个类来管理这些序号。

 ①序号产生类：存储序号、添加序号、移走序号

 

import java.util.ArrayList;
import java.util.List;
/**
 * @author Administrator @zsw 2012-7-21 下午08:58:33
 * 序号产生器
 */
public class NumberManager {
private int lastNumber=1;
private List<Integer> queueNumber=new ArrayList<Integer>();
//客户来的时候添加一个号码对应客户
public synchronized Integer generateNewManager(){
queueNumber.add(lastNumber);
return lastNumber++;
}
//窗口来取走一个号码，为对应号码的客户服务
public synchronized Integer fetchServiceNumber(){
Integer number=null;
if(queueNumber.size()>0){
number=queueNumber.remove(0);
}
return number;
}
}

②序号管理类：将不同类型的序号分类管理，由于序号管理机只有一个，所有只需要一个序号管理类的实例，本类使用单例模式。

/**
 * @author Administrator @zsw 2012-7-21 下午09:10:39
 */
public class NumberMachine {
//序号管理机器，拥有三种号码管理器
private NumberManager commonManager=new NumberManager();
private NumberManager expressManger=new NumberManager();
private NumberManager vipManager=new NumberManager();
public NumberManager getCommonManager() {
return commonManager;
}
public void setCommonManager(NumberManager commonManager) {
this.commonManager = commonManager;
}
public NumberManager getExpressManger() {
return expressManger;
}
public void setExpressManger(NumberManager expressManger) {
this.expressManger = expressManger;
}
public NumberManager getVipManager() {
return vipManager;
}
public void setVipManager(NumberManager vipManager) {
this.vipManager = vipManager;
}
private NumberMachine(){
}
public static NumberMachine getInstance(){
return instance;
}
private static NumberMachine instance=new NumberMachine();
}

2） 窗口类：为客户服务，由于窗口类型和客服类型的不同，需要产生不同的窗口为

 客户服务。

①本类属性：窗口类型、窗口编号

②本类行为：提供客户服务，不同的窗口提供不一样的服务，所以应该有多种服务类型。

③主要的逻辑：

代码如下：
package com.bank;
import java.util.Random;
import java.util.concurrent.Executors;
/**
 * @author Administrator @zsw 2012-7-21 下午09:17:42
 */
public class ServiceWindow {
private CustomerType type = CustomerType.COMMON;
private int windowId=1;
private String name;
public CustomerType getType() {
return type;
}
public void setType(CustomerType type) {
this.type = type;
}
public int getWindowId() {
return windowId;
}
public void setWindowId(int windowId) {
this.windowId = windowId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
    //创建一个窗口，并调用方法启动服务
public void start(){
Executors.newSingleThreadExecutor().execute(new Runnable(){
@Override
public void run() {
while(true){
/*①第一次的时候，每一个case后面都是没有加continue，导致
  问题：普通窗口可以服务：普通、快速、vip
       快速窗口可以服务：快速、vip
  ②解决方式就是加case
 */
switch(type){
case COMMON:
commonService();
continue;
case  EXPRESS:
      expressService();
      continue;
case VIP:
 vipService();
continue;
    
 
}
}
}});
}
/**
 * 1:普通窗口：只提供普通服务
 */
private void commonService() {
String windowName="第"+windowId+"号"+type+"窗口";
Integer number=NumberMachine.getInstance().getCommonManager().fetchServiceNumber();
System.out.println(windowName+"正在获取普通用户任务");
if(number!=null){
System.out.println(windowName+"正在为第"+number+"号普通用户服务");
//②为普通用户服务中
long beginTime=System.currentTimeMillis();
long serveTime=new Random().nextInt(Constants.COMMON_MAX_SERVICE_TIME)+1;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime=System.currentTimeMillis();
long costTime=((endTime-beginTime)); //消耗毫秒数
System.out.println(windowName+"为第"+number+"普通用户服务,消耗了"+costTime+"毫秒");
}else{
System.out.println(windowName+"没有取到普通用户任务,先休息一秒钟");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/*
 * 2:快速窗口：提供快速服务，当空闲时，也提供普通服务
 */
private void expressService() {
String windowName="第"+windowId+"号"+type+"窗口";
Integer number=NumberMachine.getInstance().getExpressManger().fetchServiceNumber();
System.out.println(windowName+"正在获取vip用户任务");
if(number!=null){
System.out.println(windowName+"正在为第"+number+"号"+type+"用户服务");
long beginTime=System.currentTimeMillis();
//②为快速用户服务中..
long serveTime=new Random().nextInt(Constants.EXPRESS_MAX_SERVICE_TIME)+1;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime=System.currentTimeMillis();
long costTime=((endTime-beginTime));
System.out.println(windowName+"为第"+number+type+"用户服务,消耗了"+costTime+"毫秒");
}else{
System.out.println(windowName+"没有取到快速用户任务,");
commonService();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/*
 * 3:vip窗口：提供vip服务，空闲时，提供普通服务
 */
private void vipService() {
String windowName="第"+windowId+"号"+type+"窗口";
System.out.println(windowName+"正在获取vip用户任务");
Integer number=NumberMachine.getInstance().getVipManager().fetchServiceNumber();
if(number!=null){
System.out.println(windowName+"正在为第"+number+"号"+type+"用户服务");
//③为vip服务中
long beginTime=System.currentTimeMillis();
long serveTime=new Random().nextInt(Constants.VIP_MAX_SERVICE_TIME)+1;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long endTime=System.currentTimeMillis();
long costTime=((endTime-beginTime));
System.out.println(windowName+"为第"+number+type+"用户服务,消耗了"+costTime+"毫秒");
}else{
System.out.println(windowName+"没有取到vip用户任务,");
commonService();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

3） 辅助类有：

①服务类型枚举类：根据类型返回对应的服务名称

public enum CustomerType {
COMMON,EXPRESS,VIP;
public String toString(){
switch(this){
case COMMON:
 return "普通";
case EXPRESS:
 return "快速";
case VIP:
 return name();
}
return null;
}
}
②服务时间的最大最小值等等常量
public  class Constants {
//①普通用户时间：0-5000 ②快速 0-2000 ③ vip 0-10000
public static int COMMON_MAX_SERVICE_TIME=5000;
public static int EXPRESS_MAX_SERVICE_TIME=1000;
public static int VIP_MAX_SERVICE_TIME=10000;
}

4） 主调类：

整个程序的逻辑：

①产生4个普通窗口、1个快速窗口和1个VIP窗口，都同时启动服务，利用线程监听序号机里面序号的情况，取出对应的序号，调用对应的服务为客户服务。

②同时，利用定时器线程池，按照一定的时间，产生大量的序列号模拟真实的客户，让窗口为之服务。

代码如下：

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
 * @author Administrator @zsw 2012-7-22 上午09:31:56
 */
public class MainClass {
public static void main(String[] args) {
//创建5个普通窗口(默认是普通的)
for(int i=1;i<=5;i++){
ServiceWindow window=new ServiceWindow();
window.setWindowId(i);
window.start();
}
//创建1个快速窗口
for(int i=1;i<=1;i++){
ServiceWindow window=new ServiceWindow();
window.setWindowId(i);
window.setType(CustomerType.EXPRESS);
window.start();
}
//创建1个vip窗口
for(int i=1;i<=1;i++){
ServiceWindow window=new ServiceWindow();
window.setWindowId(i);
window.setType(CustomerType.VIP);
window.start();
}
//客户产生比例,普通：快速：vip=6:1:3
//产生普通客户(每1秒钟来一个)
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
Integer number=NumberMachine.getInstance().getCommonManager().generateNewManager();
System.out.println(number+"号普通客户等待服务");
}},
0,
                1, 
                TimeUnit.SECONDS
                );
//产生express客户(每2秒钟来一个)
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
Integer number=NumberMachine.getInstance().getExpressManger().generateNewManager();
System.out.println(number+"号普通客户等待服务");
}},
0,
3,
                TimeUnit.SECONDS
                );
//产生vip客户(每6秒钟来一个)
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable(){
@Override
public void run() {
Integer number=NumberMachine.getInstance().getVipManager().generateNewManager();
System.out.println(number+"号VIP客户等待服务");
}},
0,
6, 
                TimeUnit.SECONDS
                );
}
}