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

android培训java培训期待与您交流!!!

 银行业务调度系统

项目需求：1，银行内有6个业务 窗口，1-4号窗口为普通窗口，5号为快速窗口，6号为VIP窗口

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

                   3.异步随机生成各种类型的客户，生成各种类型的客户的概率比例为:VIP:普通:快速客户=1:6:3。

                   4.客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值。

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

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

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

面向对象的分析与设计：

1.有三种对应类型的客户：VIP客户，普通客户，快速客户 ，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务
首先，经常在银行办理业务的人更有利于理解本系统，每一个客户其实就是由银行的一个取

号机器产生号码的方式来表示的。所以，要有一个号码管理器对象，让这个对象不断地产生

号码，就等于随机生成了客户。
2.由于有三类客户，每类客户的号码编排都是完全独立的，本系统一共要产生三个号码管理

器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管

理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。
3.各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。
各个窗口怎么知道该叫哪一个号了呢？它一定是问的相应的号码管理器，即服务窗口每次找

号码管理器获取当前要被服务的号码。

对象与对象之间的关系分析完成后，下面就可以开始设计类中的属性和方法了

NumberManager(号码管理器对象)

1.定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。
2.定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步

NuberMachine(号码机器对象，只有一个)

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

serviceWindow(服务窗口对象)

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

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

息

customerType(客户类型，枚举)

 

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

 

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

 

虑。

 

constants(数据都是常量)
定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

 

test(测试银行系统类)

 

1用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。
2接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP

 

客户号码

 

思路完成后，接下来就可以开始编写代码了(代码中会添加大量注释，便于理解)

首先编写号码管理器类(NumberManager)

 

package cn.itcast.Bankqueue;

import java.util.ArrayList;
import java.util.List;


public class NumberManager {
	// 用于存储上一个客户号码
	private int lastNumber = 0;
	// 用于存储所有等待服务的客户号码的队列集合
	private List queueNumbers = new ArrayList();

	/**
	 * 定义一个产生新号码的方法
	 */
	public synchronized Integer generateNewNumber() {
		queueNumbers.add(++lastNumber);
		return lastNumber;
	}

	/**
	 * 获取马上要为之服务的号码的方法,给服务窗口使用
	 */
	public synchronized Integer fetchNumber() {
		if (queueNumbers.size() > 0) {
			return (Integer) queueNumbers.remove(0);//删除便返回该号码
		}
		return null;// 代表没有要服务的客户
	}
}

 接着编写一个号码机器类(NumberMachine)用于管理各类的号码管理器比如（commonManager，expressManager,VipManager）

 

package cn.itcast.Bankqueue;
/**
 * 由于有三类客户，每类客户的号码编排都是完全独立的，
 * 所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码
 * 。这三个号码管理器对象统一由一个号码机器进行管理，
 * 这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例
 * 思路：
 * 定义三个成员变量分别指向三个NumberManager对象，
 * 分别表示普通、快速和VIP客户的号码管理器，
 * 定义三个对应的方法来返回这三个NumberManager对象。
将NumberMachine类设计成单例
 */
public class NumberMachine {
	public NumberManager getCommonManager() {
		return commonManager;
	}
	public NumberManager getExpressManager() {
		return expressManager;
	}
	public NumberManager getVIPManager() {
		return VIPManager;
	}
	private NumberManager commonManager=new NumberManager();
	private NumberManager expressManager=new NumberManager();
	private NumberManager VIPManager=new NumberManager();
	
	private static NumberMachine instance  =new NumberMachine();
	private NumberMachine(){
		
	}
	public static NumberMachine getInstance(){
		return instance;
	}
	
}

 因为有三种客户类型，所以编写一个枚举类，保存三种客户

 package cn.itcast.Bankqueue;

public enum CustomerType {
 COMMON, ERPRESS, VIP;
 public String toString() {
  // this是指向本类对象的引用
  String name = null;
  switch (this) {

   case COMMON:
    name = "普通";
    break;
   case ERPRESS:
    name = "快速";
    break;
   case VIP:
    name = "vip";
    break;
  }
  return name;
 }
}

 程序中会用到一些常量数据，所以专门用一个常量类来保存

package cn.itcast.Bankqueue;
/**
 * 保存所有的常量  
 * @author huhao
 /*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
	 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以，
	 * 1秒钟产生一个普通客户比较合理，*/

public class Constant {
	public static int MAX_SERVICE_TIME=10000;//办理业务的最大时间
	public static int MIN_SERVICE_TIME=1000;//办理业务的最小时间
	
	public static int COMMON_CUSTOMER_INTERVAL_TIME=1;//普通窗口产生一个客户所需要的时间
	
}

 代码逻辑比较复杂的serviceWindow(窗口)类

package cn.itcast.Bankqueue;

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

/**
 * 服务窗口每次找号码管理器获取当前要被服务的号码。
 * @author huhao
 *思路：
 *定义一个start方法，内部启动一个线程，  根据服务窗口的类别分别循环调用三个不同的方法。 
 定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息
 */
/**
 * 没有把VIP窗口和快速窗口做成子类， 是因为实际业务中的普通窗口可以随时被设置为VIP窗口和快速窗口。
 * */
public class ServiceWindow {
	private static Logger logger = Logger.getLogger("cn,itcast.Bankqueue");
	// 服务窗口当前服务的号码
	private int number = 1;
	//窗的客户类型，默认是普通客户
	private CustomerType type = CustomerType.COMMON;

	public void setNumber(int number) {
		this.number = number;
	}

	public void setType(CustomerType type) {
		this.type = type;
	}

	public void Start() {
		Executors.newSingleThreadExecutor().execute(new Runnable() {

			@Override
			public void run() {
				switch (type) {
				case COMMON:
					while(true)//代表的是不停的为客户服务
					commonService();
					
				case ERPRESS:
					while(true)
					expressService();
					
				case VIP:
					while(true)
					vipService();
					
				}
			}

		});

	}
/*
 * 提供VIP窗口服务，空闲时也可以为普通窗口服务
 */
	private void vipService() {
		String windowName="第"+number+"个"+type+"窗口";
	
		System.out.println(windowName+"正在获取"+type+"任务");
		Integer serviceNumber=NumberMachine.getInstance().getCommonManager().fetchNumber();
		if(serviceNumber!=null){
			System.out.println(windowName+"开始为第" + serviceNumber + "号"+type+"客户服务");
			int maxRandom=Constant.MAX_SERVICE_TIME=Constant.MIN_SERVICE_TIME;
			int serviceTime=(new Random().nextInt(maxRandom)+1)+Constant.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serviceTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(windowName + "完成为第" + serviceNumber + "号"+type+"客户服务，总共耗时" + 
					serviceTime/1000 + "秒");		
		}
		else{
			System.out.println(windowName+"没有获取到"+type+"客户服务");
			commonService();
		}
	}
/*
 * 提供快速窗口服务，空闲时也可以为普通窗口服务
 */
	private void expressService() {
		String windowName="第"+number+"个"+type+"窗口";
		
		System.out.println(windowName+"正在获取"+type+"任务");
		Integer serviceNumber=NumberMachine.getInstance().getCommonManager().fetchNumber();
		if(serviceNumber!=null){
			System.out.println(windowName+"开始为第" + serviceNumber + "号"+type+"客户服务");
			try {
				Thread.sleep(Constant.MIN_SERVICE_TIME);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(windowName + "完成为第" + serviceNumber + "号"+type+"客户服务，总共耗时" + 
					Constant.MIN_SERVICE_TIME/1000 + "秒");		
		}
		else{
			System.out.println(windowName+"没有获取到"+type+"客户服务");
			commonService();
		}
	}
/*
 * 提供普通窗口服务
 */
	private void commonService() {
		String windowName="第"+number+"个"+type+"窗口";
	
		System.out.println(windowName+"正在获取普通任务");
		Integer serviceNumber=NumberMachine.getInstance().getCommonManager().fetchNumber();
		if(serviceNumber!=null){
			System.out.println(windowName+"开始为第" + serviceNumber + "号普通客户服务");
			int maxRandom=Constant.MAX_SERVICE_TIME-Constant.MIN_SERVICE_TIME;
			int serviceTime=(new Random().nextInt(maxRandom)+1)+Constant.MIN_SERVICE_TIME;
			try {
				Thread.sleep(serviceTime);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(windowName + "完成为第" + serviceNumber + "号普通客户服务，总共耗时" + 
					serviceTime/1000 + "秒");		
		}
		else{
			System.out.println(windowName+"没有获取到号普通客户服务");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				
				
				e.printStackTrace();
			}
		}
	}
}

 最后，编写测试类(test)

package cn.itcast.Bankqueue;

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

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//产生四个普通窗口
		for (int i = 1; i < 5; i++) {
			ServiceWindow window=new ServiceWindow();
			window.setNumber(i);
			window.Start();
		}
		
		//产生一个快速窗口
		ServiceWindow expresswindow=new ServiceWindow();
		expresswindow.setType(CustomerType.ERPRESS);
		expresswindow.Start();
		
		//产生一个VIP窗口
		ServiceWindow VipWindow=new ServiceWindow();
		VipWindow.setType(CustomerType.VIP);
		VipWindow.Start();
		
		//普通客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					
					@Override
					public void run() {
						
						Integer serviceNumber=NumberMachine.getInstance().getCommonManager().generateNewNumber();
						System.out.println("第"+serviceNumber+"号普通客户正在等待服务");
					}
				},
				0,
				Constant.COMMON_CUSTOMER_INTERVAL_TIME, 
				TimeUnit.SECONDS);
		
		//快速客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					
					@Override
					public void run() {
						Integer serviceNumber=NumberMachine.getInstance().getExpressManager().generateNewNumber(); 
						System.out.println("第"+serviceNumber+"号快速客户正在等待服务");
					}
				},
				0, 
				Constant.COMMON_CUSTOMER_INTERVAL_TIME*2, 
				TimeUnit.SECONDS);
		//VIP客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					
					@Override
					public void run() {
						Integer serviceNumber=NumberMachine.getInstance().getVIPManager().generateNewNumber(); 
						System.out.println("第"+serviceNumber+"号VIP客户正在等待服务");
					}
				},
				0, 
				Constant.COMMON_CUSTOMER_INTERVAL_TIME*6, //产生一个vip客户所需的时间是普通客户的6倍
				TimeUnit.SECONDS);
	}
	


	
}

 到这里，银行业务调度系统就写完了。

 

 心得：程序代码虽然不多，但是思路却很难理顺，必须按照面向对象的思想设计，需求中的对象分析出来，并将其中的对象的属性和方法分析出来。

对象与对象之间协同操作，要理清各个对象之间的关系。

面向对象的设计是非常关键的，要不断的体会和领悟，任重而道远，不可以松懈。