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

------- android培训、java培训、期待与您交流！ ----------
银行业务调度系统

模拟实现银行业务调度系统逻辑，具体需求如下：
1、银行内有6个业务窗口，1-4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为vip窗口。
2、有三种对应类型的客户：普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。
3、异步随机生成各种类型的客户，生成各类性用户的概率比例为：
VIP客户：普通客户：快速客户 = 1:6:3

4、客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程sleep的方式模拟）。
5、各类型客户在其对应窗口按顺序依次办理业务。
6、当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
7、随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
8、不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

需求分析：
1、根据面向对象的思想，分析上述需求，可以分为三个最主要的对象：窗口、客户和号码机。
客户类：限定只有三种客户，即普通客户、快速客户和VIP客户，可以考虑用枚举实现。枚举CustomerType{}

CustomerType

{
COMMON,EXPRESS,VIP;

}

号码机：包含生成客户号码的方法和叫号的方法,同时又分为三种类型：普通客户号码，快速客户号码和VIP客户号码。

类NumberMachine{}:用于获得三种不同类型的客户号码。

NumberMachine

{
getInstance(){};//应用单例设计模式，获得该类的唯一对象，以保证三种号码类型的唯一性。

getCommonManager(){};//获得普通客户号码生成与叫号

getExpressManager(){};//获得快速客户号码生成与叫号

getVipManager(){};//获得VIP客户号码生成与叫号

}

类NumberManager{}:用于实现客户号码生成及叫号的操作。

NumberManager

{
generateNewNumber(){};//生成新的客户号码

fetchServiceNumber(){};//叫号的实现

}

窗口类：ServiceWindow{},实现不同窗口对不同客户的具体服务操作。

普通窗口：面向普通客户服务。

快速窗口：面向快速客户服务，若没有快速客户等待服务，则面向普通客户服务，但是一旦有快速客户等待服务，优先服务快速客户。

VIP窗口：面向VIP客户服务，若没有VIP客户等待服务，则面向普通客户服务，但是一旦有VIP客户等待服务，优先服务VIP客户。

ServiceWindow

{
属性windowType;//表明窗口类型，普通窗口、快速窗口和VIP窗口

属性windowId;//表明窗口号码

start(){};//各种窗口对各种客户的具体实现

commonService(){};//普通窗口对普通客户服务的具体实现

expressService(){};//快速窗口对客户服务的具体实现

vipService(){};//VIP窗口对客户服务的具体实现

]

主函数类：MainClass,调用各个对象，各个方法，以保证整个程序的执行。

窗口服务启动：生成各个窗口，并让各个窗口开始执行服务。

号码机启动：生成各种类型客户的各种号码。

2、分析，图示如下：



3、技术要点
枚举类的使用：因为窗口类型只能是普通、快速和VIP三种，不能有其他值，因此可以使用枚举。

新特性线程池的使用：

Executors.newSingleThreadExecutor().execute(Runnable runnable):用线程池技术生成单个线程。

Executors.newScheduledThreadPool().scheduleAtFixedRate():连续定时启动，实现了号码机生成各种号码的操作。

4、整个流程
1）主函数类中启动，号码类生成普通、快速和VIP三种号码；窗口类生成三种窗口。

2）各种号码进入等待状态，各种窗口进入服务状态。

3）普通类窗口：判断是否有普通客户在等待服务，若有，提供服务；若无，短暂休息，然后再判断是否有普通客户在等待服务。

快速类窗口：判断是否有快速客户在等待服务，若有，提供服务；若无，判断是否有普通客户在等待服务，若有提供服务；若无，继续判断是否有快速客户在等待服务。

VIP类窗口：判断是否有VIP客户在等待服务，若有，提供服务；若无，判断是否有普通客户在等待服务，若有，提供服务；若无，判断是否有VIP客户在等待服务。

4）用while(true)保证各个窗口一直在服务状态。

5、代码实现：

package cn.itcast.banksystem;

import java.util.ArrayList;
import java.util.List;
//该类主要用于生成生成号码和叫号
public class NumberManager
{
//设定初始号码为1
Integer number = 1;
//该list用于存放生成的号码序列
private List<Integer> numberList = new ArrayList<Integer>();
//生成号码的方法
//由于方法generateNumber() 与fetchNumber（也就是两个线程）访问了共同的属性numberList ,因此需要对这两个方法加锁
public synchronized Integer generateNewNumber()
{
//将号码存放到numberList中，队列形式，先生成的先被叫号
numberList.add(number);
//号码生成规则是1、2、3、4、5、6.。。。。。。，
return number++;
}

//模拟叫号系统的方法，
public synchronized Integer fetchNumber()
{
//如果队列numberList中已经存入了号码，则正常叫号取号
if(numberList.size()>0)
{
return numberList.remove(0);
}
//如果队列中没有等待被叫的号，则返回空
return null;
}
}

--------------------------------------------------------------------------------------------------

package cn.itcast.banksystem;
/*
银行号码机是唯一的，需要用到单例设计模式，得到唯一的一个对象。
因此该对象的属性commonManager expressManager vipManager也是唯一的，从而保证了三者的属性（号码）的唯一性。

*/
public class NumberMachine {
//得到commonManager，用于管理普通客户号码生成与叫号
private NumberManager commonManager = new NumberManager();
//得到expressManager，用于管理快速客户号码生成与叫号
private NumberManager expressManager = new NumberManager();
//得到vipManager，用于管理VIP客户号码生成与叫号
private NumberManager vipManager = new NumberManager();

public NumberManager getCommonManager() {
return commonManager;
}
public NumberManager getExpressManager() {
return expressManager;
}
public NumberManager getVipManager() {
return vipManager;
}

//单例设计模式，用于保证得到的该类的对象是唯一的
private NumberMachine(){}
private static NumberMachine numberMachine = new NumberMachine();
public static NumberMachine getNumberMachine()
{
return numberMachine;
}
}

------------------------------------------------------------------------------------------

package cn.itcast.banksystem;

public class Constants
{
//属性MAX_TIME表示服务时间的最大值
public static int MAX_TIME = 10000;
//属性MIN_TIME表示服务时间的最小值
public static int MIN_TIME = 1000;

}

-----------------------------------------------------------------------------------------------

package cn.itcast.banksystem;

//服务窗口只有三种类型COMMON,EXPRESS,VIP
//因为服务窗口只能取得这三种类型的一个，不能取得其他值，因此使用枚举
public enum WindowType
{
//定义三个对象，表示三种服务窗口类型
COMMON,EXPRESS,VIP;

public String toString()
{
switch(this)
{
case COMMON:
return "普通";
case EXPRESS:
return "快速";
case VIP:
return "VIP";
}
return null;

}
}

-------------------------------------------------------------------------------------------------------------

package cn.itcast.banksystem;

import java.util.Random;
import java.util.concurrent.Executors;

//该类用于实现窗口对客户服务的具体实现方式
//1-4窗口服务普通客户
//5号窗口服务快速客户，在没有快速客户时，向普通客户提供服务
//6号窗口服务VIP客户，在没有VIP客户时，向VIP客户提供服务
public class ServiceWindow
{
//windowType用于表示窗口类型，有三种COMMON VIP EXPRESS
WindowType windowType =WindowType.COMMON;
//windowId,表示窗口编号
int windowId = 1;

public void setWindowType(WindowType windowType) {
this.windowType = windowType;
}
public void setWindowId(int windowId) {
this.windowId = windowId;
}

//方法start()具体执行服务操作
public void start()
{
//采用线程池方式创建单个线程，参数类型为Runnable
Executors.newSingleThreadExecutor().execute(new Runnable()
{
public void run()
{
//while(true)表示该窗口会一致进行服务
while(true)
{
//采用switch方式，用于判断是哪种窗口进行服务
switch(windowType)
{
//若是普通窗口，执行commonService()方法，进行服务
case COMMON:
commonService();
break;
//若是快速窗口，执行expressService()方法，进行服务
case EXPRESS:
expressService();
break;
//若是VIP窗口，执行vipService()方法，进行服务
case VIP:
vipService();
break;
}
}

}

});

}

//方法commonService()用于实现普通窗口对普通客户的操作
private void commonService()
{

System.out.println(windowId+"号普通窗口正在获取普通客户任务");
//获得系统当前时间，以便计算服务时间
long beginTime = System.currentTimeMillis();
//取得正在队列中等待服务的客户号码
NumberMachine numberMachine = NumberMachine.getNumberMachine();
Integer number = numberMachine.getCommonManager().fetchNumber();
//需要判断是否有客户正在等待服务
if(number!=null)
{
//System.out.print(windowId+"号普通窗口正在为"+number+"号普通客户服务");
int randomTime = Constants.MAX_TIME-Constants.MIN_TIME;
int serveTime = new Random().nextInt(randomTime)+1+Constants.MIN_TIME;
try {
//这里用sleep模拟服务时间
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = (System.currentTimeMillis()-beginTime)/1000;
System.out.println(windowId+"号普通窗口正在为"+number+"号普通客户服务"+",历时"+costTime+"秒");
}else
{
System.out.println(windowId+"号普通窗口没有取得任务，休息1秒");
try {
//若没有普通客户需要服务，则休息1秒，休息完毕后继续查看是否有客户需要服务
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

//快速窗口对客户服务的具体实现操作
private void expressService()
{

System.out.println("5号快速窗口正在获取快速客户任务");
long beginTime = System.currentTimeMillis();
//获得当前正在等待被服务的快速客户的号码
NumberMachine numberMachine = NumberMachine.getNumberMachine();
Integer number = numberMachine.getExpressManager().fetchNumber();
//判断当前是否有快速客户需要服务，若有就服务；若没有就向普通客户服务
if(number!=null)
{
//System.out.print("5号快速窗口正在为"+number+"号快速客户服务");
try {
//这里用sleep方法模拟服务
Thread.sleep(Constants.MIN_TIME);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = (System.currentTimeMillis()-beginTime)/1000;
System.out.println("5号快速窗口正在为"+number+"号快速客户服务"+",历时"+costTime+"秒");
}else
{
//若没有快速客户等待服务，则快速窗口面向普通客户进行服务
System.out.println("5号快速窗口没有获得快速客户任务，正在获取普通客户任务");
//获得正在等待的普通客户的号码
numberMachine = NumberMachine.getNumberMachine();
number = numberMachine.getCommonManager().fetchNumber();
//判断是否有普通客户等待服务
if(number!=null)
{
//System.out.print("5号快速窗口正在为"+number+"号普通客户服务");
int randomTime = Constants.MAX_TIME-Constants.MIN_TIME;
int serveTime = new Random().nextInt(randomTime)+1+Constants.MIN_TIME;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = (System.currentTimeMillis()-beginTime)/1000;
System.out.println("5号快速窗口正在为"+number+"号普通客户服务"+",历时"+costTime+"秒");
}else
{
System.out.println("5号快速窗口没有取得任务");

}
}

}

//方法具体实现VIP窗口对VIP客户与普通客户服务的具体实现
private void vipService()
{

System.out.println("6号VIP窗口正在获取VIP客户任务");
long beginTime = System.currentTimeMillis();
NumberMachine numberMachine = NumberMachine.getNumberMachine();
Integer number = numberMachine.getVipManager().fetchNumber();
//判断室友VIP客户正在等待服务，若有就叫号提供服务；若没有就面向普通客户进行服务
if(number!=null)
{
//System.out.print("6号VIP窗口正在为"+number+"号VIP客户服务");
int randomTime = Constants.MAX_TIME-Constants.MIN_TIME;
int serveTime = new Random().nextInt(randomTime)+1+Constants.MIN_TIME;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = (System.currentTimeMillis()-beginTime)/1000;
System.out.println("6号VIP窗口正在为"+number+"号VIP客户服务,历时"+costTime+"秒");
}else
{
//没有VIP客户等待服务，VIP窗口面向普通客户提供服务
System.out.println("6号VIP窗口没有获得VIP客户任务，正在获取普通客户任务");
numberMachine = NumberMachine.getNumberMachine();
number = numberMachine.getCommonManager().fetchNumber();
//判断是否有普通客户等待服务
if(number!=null)
{
//System.out.print("6号VIP窗口正在为"+number+"号普通客户服务");
int randomTime = Constants.MAX_TIME-Constants.MIN_TIME;
int serveTime = new Random().nextInt(randomTime)+1+Constants.MIN_TIME;
try {
Thread.sleep(serveTime);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
long costTime = (System.currentTimeMillis()-beginTime)/1000;
System.out.println("6号VIP窗口正在为"+number+"号普通客户服务,历时"+costTime+"秒");
}else
{
System.out.println("6号VIP窗口没有取得任务");

}
}

}
}

--------------------------------------------------------------------------------------------------

package cn.itcast.banksystem;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class MainClass {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

//该方法用于产生普通客户号码
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable()
{
public void run()
{
//生成 普通客户号码
Integer number = NumberMachine.getNumberMachine().getCommonManager().generateNewNumber();
System.out.println(number+"号普通客户等待服务");
}
},
//0表示立刻开始执行
0,
//1表示执行的间隔时间
1,
//时间单位为秒
TimeUnit.SECONDS
);

//该方法用于获得快速客户的号码
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable()
{
public void run()
{
//生成快速客户的号码
Integer number = NumberMachine.getNumberMachine().getExpressManager().generateNewNumber();
System.out.println(number+"号快速客户等待服务");
}
},
//0表示立刻开始执行
0,
//3表示间隔时间
3,
//时间单位为秒
TimeUnit.SECONDS
);

//该方法用于生成VIP号码
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
new Runnable()
{
public void run()
{
//生成VIP号码
Integer number = NumberMachine.getNumberMachine().getVipManager().generateNewNumber();
System.out.println(number+"号VIP客户等待服务");
}
},
//0表示立刻开始执行
0,
//间隔时间为6
6,
//时间单位为秒
TimeUnit.SECONDS
);

//生成1-4号普通窗口，并开始执行服务
for(int i=1;i<5;i++)
{
//获得ServiceWindow对象
ServiceWindow commonerviceWindow = new ServiceWindow();
//为windowType赋值COMMON，表示为普通窗口
commonerviceWindow.setWindowType(WindowType.COMMON);
//该窗口编号为i
commonerviceWindow.setWindowId(i);
//该窗口开始执行服务
commonerviceWindow.start();
}

//生成快速客户服务窗口，并开始执行服务
//获得窗口对象
ServiceWindow expressServiceWindow = new ServiceWindow();
//对对象属性windowType赋值为EXPRESS，表示该窗口为快速服务窗口
expressServiceWindow.setWindowType(WindowType.EXPRESS);
//快速服务窗口开始执行服务
expressServiceWindow.start();

//生成VIP服务窗口，并开始执行服务
//获得窗口对象
ServiceWindow vipServiceWindow = new ServiceWindow();
//对对象属性windowType赋值为VIP，表示该窗口为VIP服务窗口
vipServiceWindow.setWindowType(WindowType.VIP);
//VIP服务窗口开始执行服务
vipServiceWindow.start();
}

}