--------android培训、java培训、期待与你交流！--------
银行业务调度系统
模拟实现银行业务调度系统逻辑，具体需求如下：
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窗口没有客户时,这两种窗口也会对普通客户服务,
所以设计一个窗口类,其中普通窗口有1-4的编号,窗口有三种类型,所以窗口的类型可以做为窗口类的一个属性,因为VIP客户窗口和快速窗口都可以为普通客户服务,也就是说这两种窗口都有为普通客户的功能
所以在面向对象设计时,我们可以创建一个统一的模型,就是服务窗口类,有编号功能,其中VIP客户窗口和快速窗口只有一个,所以可以默认为1号,都有一个窗口类型的字段,来用区分,都有为所有客户服务的方法,具体要使用那种方法,按窗口的类型(即按为那种类型的客户服务)来选择，由于几个窗口的相关服务是互不干扰的，同时进行，所以在窗口处理业务开始的时候，要使用多线程来实现。
其实现代码如下:
//
package com.fyle.test;
import java.util.Random;
import java.util.concurrent.Executors;
public class ServiceWindow
{
private CustomerType type = CustomerType.COMMON;
private int number = 1;
public CustomerType getType()
{
return type;
}
public void setType(CustomerType type)
{
this.type = type;
}
public void setNumber(int number)
{
this.number = number;
}
public void start()
{
Executors.newSingleThreadExecutor().execute(new Runnable()
{
public void run()
{
try
{
while (true)
{
beginService(CustomerType.COMMON);
}
} catch (Exception e1)
{
e1.printStackTrace();
}
}
});
}
private void beginService(CustomerType customerType) throws Exception
{
Integer customerNum = NumberMachine.getInstance().getManager(customerType).fetchNumber();
String windowName = "第" + number + "号" + type + "窗口";
System.out.println(windowName + "开始获取" + customerType.toString() + "任务！");
if (customerNum != null)
{
doSome(customerType, customerNum, Constants.MAXTIME, Constants.MINTIME);
} else
{
System.out.println(windowName + "没有取到" + customerType.toString() + "任务！");
if (this.type != CustomerType.COMMON && customerType != CustomerType.COMMON)
{
beginService(CustomerType.COMMON);
} else
{
System.out.println(windowName + "等待一秒！");
Thread.sleep(1000);
}
}
}
private void doSome(CustomerType customerType, int customerNum, int maxTime, int minTime) throws Exception
{
String window = "第" + number + "号" + this.type.toString() + "窗口";
System.out.println(window + "开始为第" + customerNum + "号" + customerType.toString() + "客户服务");
int serviceTime = getRandomTime(customerType);
Thread.sleep(serviceTime);
System.out.println(window + "完成为第" + customerNum + "号" + customerType.toString() + "客户服务，耗时" + serviceTime / 1000 + "秒");
}
int getRandomTime(CustomerType customerType)
{
int time = 0;
if (customerType == CustomerType.EXPRESS)
{
time = 1000;
} else
{
time = new Random().nextInt(Constants.MAXTIME) + 1 + Constants.MINTIME;
}
return time;
}
}
//
在这个窗口服务的类中，我们用到了一个常量，为了我们统一管理各种常量，我们可以在一个类中定义一些静态的属性，方便我们使用和日后修改
这个常量类的代码为：
//
package com.fyle.test;
public class Constants
{
public static int MAXTIME = 10000; // 10秒！
public static int MINTIME = 1000; // 1秒！
public static int COMMON_CUSTOMER_INTERVAL_TIME = 1;// 1秒
}
//
还有另外用到的，一个来用表示用户类型的枚举，在分辨服务窗口的类型的时候，也有这个来区分
//
package com.fyle.test;
public enum CustomerType {
// 有普通，快速，VIP客户
COMMON, EXPRESS, VIP;
public String toString()
{
String name = null;
switch (this)
{
case COMMON:
name = "普通";
break;
case EXPRESS:
name = "快速";
break;
case VIP:
name = name();
break;
}
return name;
}
}
//
如我们平常去银行时所见,银行排队的时候,其实不是我们人的排队,而是我们拿的那个号码排队,所以我们在这是也同样做一个那样功能相似的号码生产器,
在需求中要求有异步生成的各种人,当然生成各种客户的功能不是在这个类中实现的，这个类只管理三种类型的客户的排队列表的，一个银行，只有一个取号机，所以我们的这个号码管理器也是一个而已
因而在这里使用单例模式，，，其实细细一想，第个银行只实例化一个号码管理器也是可以的，用不着用单例模式，但是刚才前不久学习了这个模式，所以就当是复习吧。
代码如下:
//
package com.fyle.test;
public class NumberMachine
{
private static NumberMachine instance = new NumberMachine();
private NumberManager commonManager = new NumberManager();
private NumberManager expressManager = new NumberManager();
private NumberManager vipManager = new NumberManager();
private NumberMachine()
{
}
public static NumberMachine getInstance()
{
return instance;
}
// 通过那种类型的客户来取得那种客户排除号码管理器，就好像银行排队的时候，由客户自己选择那种服务类型，选择排在那里
public NumberManager getManager(CustomerType type)
{
NumberManager manager = null;
switch (type)
{
case COMMON:
manager = this.commonManager;
break;
case EXPRESS:
manager = this.expressManager;
break;
case VIP:
manager = this.vipManager;
break;
}
return manager;
}
}
//
有了号码生成器,和服务窗口,我们还要为客户和服务窗口搭上关系,当一个服务窗口正在服务的客户结束了业务处理之后,服务窗口就申请新的客户,这个时候服务窗口不是直接叫那些正在排队的客户的.而是通过一个第三方来实现一个功能,这个第三方从号码生成器里面查看有没有对应的客户,如果有,就把对应客户的排队号码给服务窗口,然后由服务窗口发出通知,然后客户到服务窗口处理业务.而这个第三方我们可以叫它为客户队列管理器,即专门管理排队号码列表的.管理器的功能很简单，只是往队伍里面加人，往队伍里面移除已经到窗口处理业务的人，就像银行一样，新来的人给一个新生成的号码，新来的VIP给一个VIP的排队号码，普通人就给普通的排除号码。由于是几个窗口共用一个排队的数据（对普通客户来说，6个窗口都有可能都会取得普通客户），即几个窗口是互不影响的取排队数据的，也就是多线程的使用数据，所以为了数据安全，这里给操作数据的方法加上同步锁，无论是添加客户还是取出客户。
代码如下:
//
package com.fyle.test;
import java.util.*;
public class NumberManager
{
private int lastNumber = 0;
private List<Integer> queueNumbers = new ArrayList<Integer>();
public synchronized Integer generateNewNumber()
{
queueNumbers.add(++lastNumber);
return lastNumber;
}
public synchronized Integer fetchNumber()
{
if (queueNumbers.size() > 0)
{
return (Integer) queueNumbers.remove(0);
} else
{
return null;
}
}
}
//
基本上一个银行排队,分配号码,接受服务等功能需的功能大概都实现了,下面我们来做一下模拟银行,并测试相关的业务处理流程.首先是按需求实例化6个窗口，然后窗口开始服务，然后用三个线程模拟三种客户的排队，第添加一个客户，打印提示。
代码如下:
//
package com.fyle.test;
import java.util.concurrent.*;
public class Test
{
public static void main(String[] args)
{
// 产生4个普通窗口
for (int i = 1; i < 5; i++)
{
ServiceWindow window = new ServiceWindow();
window.setNumber(i);
window.start();
}
// 产生1个快速窗口
ServiceWindow expressWindow = new ServiceWindow();
expressWindow.setType(CustomerType.EXPRESS);
expressWindow.start();
// 产生1个VIP窗口
ServiceWindow vipWindow = new ServiceWindow();
vipWindow.setType(CustomerType.VIP);
vipWindow.start();
// 三种客户模拟比例分别是普通：快速：VIP=6：3：1
// 普通客户拿号
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable()
{
public void run()
{
Integer serviceNumber = NumberMachine.getInstance().getManager(CustomerType.COMMON).generateNewNumber();
System.out.println("第" + serviceNumber + "号普通客户正在等待服务！");
}
}, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME, TimeUnit.SECONDS);// 假如每秒一个，60秒后有60个普通客户
// 快速客户拿号
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable()
{
public void run()
{
Integer serviceNumber = NumberMachine.getInstance().getManager(CustomerType.EXPRESS).generateNewNumber();
System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");
}
}, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2, TimeUnit.SECONDS);// 每2秒一个，60秒有30个快速客户
// VIP客户拿号
Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable()
{
public void run()
{
Integer serviceNumber = NumberMachine.getInstance().getManager(CustomerType.VIP).generateNewNumber();
System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");
}
}, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, TimeUnit.SECONDS);// 第6秒一个，60秒后有10个VIP客户
}
}
//
这个银行的排队号码管理系统，也不是很难，其中用到技术有线程池，如窗口开始服务的时候，模拟客户进银行的时候，主要的难点在于普通窗口和特殊窗口的工作方式不一样，在老师的视频教程里面
是分三个方法分别调用，我这里是在一个方法里调用，但是由于多了几个判断，代码意图不是很清晰，个人感觉还是个坑，看来应该听老师的提议的用子类的方法重写才对。
不过不要紧的，提炼方法，重构方法也是一个重要的技能。还有面向对象编程，感觉就像设计数据库一样，一开始的想法总不会是最终的版本，只有不断修改，不断完善，才能
让数据库理符合系统。面向对象的程序设计也是一样，一个类总是在不断修改中完善的，不要因为一下子设计不到位就气馁。
哎呀，好累啊，睡觉睡觉。