【黑马程序员】 学习笔记 - 直击7K面试题 - 张孝祥老师的银行业务调度管理系统

----------------------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：6：3产生随机数，按照随机数来产生客户编号，并分出3种客户类别

综上所述，自动排队机应该是随机产生各种数据，主要处理是窗口处理，客户是控制条件。

一下是张孝祥老师的分析，大家膜拜一下~：

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户。

        1）每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以要有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。
        2）由于有三类客户，每类客户的号码编排都是完全独立的，所以本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。
各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。
        1）各个窗口内部有相应的号码管理器方法，即服务窗口每次找号码管理器获取当前要被服务的号码。
        2）各类客户只是拿着号码等待被叫。

这个是思路图，画的不像，但是还是能凑合看，大家就将就一点吧~~~

话说，网上找的代码真心千疮百孔啊。。我来照着老师的思路改写一个~

首先是排号机，产生客户

package Bank;
/**随机号码产生器
 * @author yupengfei
 */

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

public class NumberManager 
{
	private int lastNumber = 0;
	private List<Integer> queueNumber = new ArrayList<Integer>();
	//创建排队的号码的一个集合	
	public synchronized Integer generateNewNumber()
	{//产生号码
		queueNumber.add(++lastNumber);
		return lastNumber;
	}
	
	public synchronized Integer fetchServiceNumber()
	{//取出一个号码
		Integer number = null;
		if(queueNumber.size()>0)
		{
			number = queueNumber.remove(0);
		}
		return number;
	}
}

然后是分类机，分类出普通，快速缴费用户和土豪金VIP客户

package Bank;
/**		传说中的排号机
 * 		分类用户什么的。。
 * @author LING
 *
 */

public class NumberMachine
{
	private NumberMachine(){}
	private NumberManager commonManager = new NumberManager();
	private NumberManager expressManager = new NumberManager();
	private NumberManager VIPManager = new NumberManager();
	public static NumberMachine getInstance() 
	{
		// 产生一个用户
		return instance;
	}
	//用户类别
	private static NumberMachine instance = new NumberMachine();
	public NumberManager getCommonManger() 
	{
		return commonManager;
	}
	public NumberManager getExpressManger() 
	{
		return expressManager;
	}
	public NumberManager getVIPManger() 
	{
		return VIPManager;
	}
}

这个是输出时用的，把客户类型重写toString写成汉字。。

package Bank;
/**	用户类型，并用重写的方式来让运行时显示更加容易看
 * 
 * @author LING
 *
 */
public enum CustomerType 
{
	COMMON,EXPRESS,VIP;
	//注解，防止重写函数写错。
	@Override
	public String toString()
	{
		String name = null;
		switch(this)
		{
		case COMMON:
			name = "普通";
			break;
		case EXPRESS:
			name = "快速";
			break;
		case VIP:
			name = "VIP";
			break;
		}
		return name;
	}
}

下面是激动人心的服务窗口了。。。就他难写

package Bank;


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

public class ServiceWindow 
{
	private CustomerType type = CustomerType.COMMON;
	private int windowId = 1;
	
	public void setType(CustomerType type) 
	{
		this.type = type;
	}

	public void setWindowId(int windowId) 
	{
		this.windowId = windowId;
	}
	
	public void start()
	{
		Executors.newSingleThreadExecutor().execute(new Runnable()
		{
			public void run()
			{
				while(true)
				{
					switch(type)
					{
					case COMMON:
						commonService();
						break;
					case EXPRESS:
						expressService();
						break;
					case VIP:
						vipService();
						break;
					}
				}
			}
		});
	}
	private void commonService()
	{
		String windowName = "第" + windowId +"号"+type+"窗口";
		System.out.println(windowName+"正在叫号");
		Integer number = NumberMachine.getInstance().getCommonManger().fetchServiceNumber();
		if(number!=null)
		{
			System.out.println(windowName + "开始为第" + number + "号普通客户服务");	
			//记录时间基准值
			long beginTime = System.currentTimeMillis();
			//耗时范围
			int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
			//随机耗时
			long serviceTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
			try
			{//模拟业务耗时
				Thread.sleep(serviceTime);
			} 
			catch (InterruptedException e) 
			{
				e.printStackTrace();
			}
			//得到处理业务的耗时
			long costTime = System.currentTimeMillis()-beginTime;
			System.out.println(windowName + "为第" + number+"个"+type+"客户完成服务，耗时" +costTime/1000 + "秒");
		}
		else
		{
			System.out.println(windowName+"没有取到服务任务");
		}
	}
	private void expressService() 
	{
		String windowName = "第" + windowId +"号"+type+"窗口";
		System.out.println(windowName+"正在叫号");
		//取出一个号码
		Integer number = NumberMachine.getInstance().getExpressManger().fetchServiceNumber();
		//如果返回的号码不为空
		if(number!=null)
		{
			//当前的系统时间
			System.out.println(windowName + "开始为第" + number + "号快速客户服务");	
			long beginTime = System.currentTimeMillis();
			//耗时范围
			int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
			//随机耗时
			long serviceTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
			try
			{
				Thread.sleep(serviceTime);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			long costTime = System.currentTimeMillis()-beginTime;
			System.out.println(windowName + "为第" + number+"个"+type+"客户完成服务，耗时" +costTime/1000 + "秒");
		}
		else
		{
			System.out.println(windowName+"没有取到服务任务");
			commonService();
			try {
				Thread.sleep(Constants.MIN_SERVICE_TIME);
			} 
			catch (InterruptedException e) 
			{
				e.printStackTrace();
			}
		}
	}
	
	private void vipService() 
	{
		String windowName = "第" + windowId +"号"+type+"窗口";
		System.out.println(windowName+"正在叫号");
		Integer number = NumberMachine.getInstance().getVIPManger().fetchServiceNumber();
		if(number!=null)
		{
			System.out.println(windowName + "开始为第" + number + "号VIP客户服务");	
			long beginTime = System.currentTimeMillis();
			int maxRand = Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
			long serviceTime = new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
			try 
			{
				Thread.sleep(serviceTime);
			}
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
			long costTime = System.currentTimeMillis()-beginTime;
			System.out.println(windowName + "为第" + number+"个"+type+"客户完成服务，耗时" +costTime/1000 + "秒");
		}
		else
		{
			System.out.println(windowName+"没有取到服务任务");
			commonService();
			try 
			{
				Thread.sleep(Constants.MIN_SERVICE_TIME);
			} 
			catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}	
}

好的 配置下服务时间和快速客户的时间

package Bank;
//设置参数，可以修改。。
public class Constants {
	public static int MAX_SERVICE_TIME = 10000;
	public static int MIN_SERVICE_TIME = 1000;
	public static int COMMON_CUST_TIME = 1;
}

最后是主程序：

package Bank;
/**
 * @author yupengfei
 * 
 */
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class MainClass 
{
	public static void main(String[] args) throws InterruptedException //异常直接抛了- -
	{
		for(int i=0;i<5;i++)
		{
			ServiceWindow commonWindow = new ServiceWindow();
			commonWindow.setWindowId(i);
			commonWindow.start();
		}
		ServiceWindow expressWindow = new ServiceWindow();
		expressWindow.setType(CustomerType.EXPRESS);
		expressWindow.start();
		ServiceWindow vipWindow = new ServiceWindow();
		vipWindow.setType(CustomerType.VIP);
		vipWindow.start();
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable()
				{
					public void run()
					{
						Integer number = NumberMachine.getInstance().getCommonManger().generateNewNumber();
						System.out.println(number+"普通客户在等待服务");
					}
				}, 
				0, 
				Constants.COMMON_CUST_TIME, 
				TimeUnit.SECONDS);
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable()
				{
					public void run()
					{
						Integer number = NumberMachine.getInstance().getExpressManger().generateNewNumber();
						System.out.println(number+"快速客户在等待服务");
					}
				}, 
				0, 
				Constants.COMMON_CUST_TIME*3, 
				TimeUnit.SECONDS);
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable()
				{
					public void run()
					{
						Integer number = NumberMachine.getInstance().getVIPManger().generateNewNumber();
						System.out.println(number+"VIP客户在等待服务");
					}
				}, 
				0, 
				Constants.COMMON_CUST_TIME*6, 
				TimeUnit.SECONDS);
	}
}

下面上一张结果图~~

大功告成 大家可以试试~~

通过这次学习，让我明白了把任何难题都可看成一堆对象，然后各个击破就会解决这个问题~