黑马程序员_银行业务管理系统_黑马程序员银行管理系统-优快云博客

本文链接：https://blog.youkuaiyun.com/u013956836/article/details/28628003

黑马程序员

------- android培训、java培训、期待与您交流！ ----------

模拟实现银行业务调度系统逻辑，具体要求如下:
银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。
有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。
异步随机生成各种类型的客户，生成各类型用户的概率比例为：
VIP客户：普通客户：快速客户 = 1 ：6 ：3。
客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间,
快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。
各类型客户在其对应窗口按顺序依次办理业务。
当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务,
而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。
随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果.

有三种对应类型的客户,VIP客户,普通客户,快速客户,异步随机生成各种类型的客户,
各类客户在其对应的窗口按顺序依次办理业务:
1.每一个客户,其实是银行的一个取号机器产生号码的方式来表示的,
所以系统中有一个号码管理器对象,让这个对象不断地随机产生号码,就等于随机生成了客户
2.由于三类客户,每类客户的号码编排都是完全独立的,所以一共要产生三个
号码管理器对象,各自管理一类用户的排队号码,这三个号码管理器对象统一
由一个号码机器进行管理,这个号码机器在整个系统中只能有一个(因为现实生活中是这样的),
所以,它要被设计成单列
各类型客户在其对应的窗口按顺序依次办理业务:
1.可以理解为窗口依次叫号,窗口如何知道接下来是哪一个号呢?一定是问相应的号码管理器

即服务窗口每次找号码管理器获取当前需要被服务的号码

实现代码:

编写Constants类

package com.itheima.interview.bankqueue;

/**
 * 常量
 */
public class Constants {

	public static final int MAX_SERVICE_TIME_MS = 10 * 1000;	// 10秒
	public static final int MIN_SERVICE_TIME_MS = 1 * 1000;		// 1秒

	/*
	 * 每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
	 * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，
	 * 所以， 1秒钟产生一个普通客户比较合理，
	 */
	public static int COMMON_CUSTOMER_INTERVAL_TIME_S = 1;		//1秒

}

编写CustomerType类:

package com.itheima.interview.bankqueue;

/**
 * 客户类型
 */
public enum CustomerType {
	COMMON,			// 普通客户
	EXPERSS,		// 快速客户
	VIP;			// VIP客户

	@Override
	public String toString() {
		String name = null;
		switch (this) {
			case COMMON:
				name = "普通";
				break;
			case EXPERSS:
				name = "快速";
				break;
			case VIP:
				name = name();
				break;
		}
		return name;
	}

}

编写NumberManager类:

package com.itheima.interview.bankqueue;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * 号码管理器
 */
public class NumberManager {
	
	private String prefix;	//号码的前缀
	private int number;		//号码
	private List<String> queueNumber = new ArrayList<String>();
	
	public NumberManager(String prefix) {
		this.prefix = prefix;
		number = 0;
	}
	
	/**
	 * 生成号码
	 */
	public synchronized String generateNewNumber() {
		String num = prefix + new DecimalFormat("000").format(++number);
		queueNumber.add(num);
		return num;
	}
	
	/**
	 * 取号 
	 */
	public synchronized String fetchNumber() {
		if(queueNumber.size() > 0) {
			return queueNumber.remove(0);
		}
		return null;
	}
	
	/**
	 * 获取当前号码管理器生成的客户等待人数 
	 */
	public synchronized int getQueueSize() {
		return queueNumber.size();
	}
	
}

编写 NumberMachine类:

package com.itheima.interview.bankqueue;

/**
 * 号码机器，叫号机器 
 */
public class NumberMachine {
	
	//一般叫号机器只有一台，所以设计成单例模式
	private static NumberMachine instance = new NumberMachine();
	
	private NumberManager commonManager = new NumberManager("A");	//普通客户
	private NumberManager expressManager = new NumberManager("E");	//快速客户
	private NumberManager vipManager = new NumberManager("V");		//VIP客户

	private NumberMachine() {
	}

	public static NumberMachine getInstance() {
		return instance;
	}

	public NumberManager getCommonManager() {
		return commonManager;
	}

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

}

编写ServiceWindow类:

package com.itheima.interview.bankqueue;

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

/**
 * 业务窗口
 */
public class ServiceWindow {
	private CustomerType type; 	// 窗口类型
	private int number; 		// 窗口号
	
	public ServiceWindow(CustomerType type, int number) {
		this.type = type;
		this.number = number;
	}

	/**
	 * 启动窗口服务
	 */
	public void start() {
		
		//每隔一秒查询号码管理器，如果有客户，则取客户
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				
				new Runnable() {
					
					private NumberManager commonNumberManager = NumberMachine.getInstance().getCommonManager();
					private NumberManager experssNumberManager = NumberMachine.getInstance().getExpressManager();
					private NumberManager vipNumberManager = NumberMachine.getInstance().getVipManager();
					
					@Override
					public void run() {
						String customer = null;
						switch (type) {
							case COMMON:
								if((customer = commonNumberManager.fetchNumber()) != null) {
									toWindow(customer);			//如果取到号，则叫客户到相应窗口
									commonService(customer);
								}
								break;
							case EXPERSS:
								if((customer = experssNumberManager.fetchNumber()) != null) {
									toWindow(customer);
									experssService(customer);
								} else if ((customer = commonNumberManager.fetchNumber()) != null) {
									//如果当前没有快速客户等待，则取普通客户
									toWindow(customer);
									commonService(customer);
								}
								break;
							case VIP:
								if((customer = vipNumberManager.fetchNumber()) != null) {
									toWindow(customer);
									vipService(customer);
								} else if ((customer = commonNumberManager.fetchNumber()) != null) {
									//如果当前没有VIP客户等待，则取普通客户
									toWindow(customer);
									commonService(customer);
								}
								break;
						}
					}
				}, 
				1, 
				1, 
				TimeUnit.SECONDS);

	}
	
	/**
	 * 到窗口处理业务
	 */
	private void toWindow(String customerNumber) {
		System.out.println(customerNumber + "号客户到 " + number + "号窗口" + "(" + type + ")");
	}
	
	/**
	 * 处理普通客户的业务
	 */
	private void commonService(String customerNumber) {
		startService(customerNumber);
		long serviceTime = new Random().nextInt(Constants.MAX_SERVICE_TIME_MS - Constants.MIN_SERVICE_TIME_MS + 1) + Constants.MIN_SERVICE_TIME_MS;
		doService(serviceTime);
		endService(customerNumber, serviceTime);
	}

	/**
	 * 处理快速客户的业务
	 */
	private void experssService(String customerNumber) {
		startService(customerNumber);
		doService(Constants.MIN_SERVICE_TIME_MS);
		endService(customerNumber, Constants.MIN_SERVICE_TIME_MS);
	}

	/**
	 * 处VIP客户的业务
	 */
	private void vipService(String customerNumber) {
		startService(customerNumber);
		long serviceTime = new Random().nextInt(Constants.MAX_SERVICE_TIME_MS - Constants.MIN_SERVICE_TIME_MS) + Constants.MIN_SERVICE_TIME_MS;
		doService(serviceTime);
		endService(customerNumber, serviceTime);
	}
	
	/**
	 * 开始办理业务打印信息 
	 */
	private void startService(String customerNumber) {
		System.out.println(customerNumber + "号客户在 " + number + "号窗口" + "(" + type + ") 正在办理业务......");
	}
	
	/**
	 * 办理业务
	 */
	private void doService(long timeMS) {
		try {
			Thread.sleep(timeMS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 结束办理业务打印信息 
	 */
	private void endService(String customerNumber, long timeMS) {
		System.out.println(customerNumber + "号客户在 " + number + "号窗口" + "(" + type + ") 办理业务完成。共耗时" + (timeMS / 1000) + "秒");
	}

	public CustomerType getType() {
		return type;
	}

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

	public int getNumber() {
		return number;
	}

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

}

编写MainClass类:

package com.itheima.interview.bankqueue;

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

/**
 * 银行排队叫号系统 
 */
public class MainClass {
	
	public static void main(String[] args) {
		generatorServiceWindow();		//生成窗口
		customerFetchNumber();			//客户取号
	}
	
	/**
	 * 产生窗口
	 */
	private static void generatorServiceWindow() {
		//产生1-4号普通窗口
		for (int i = 1; i <= 4; i++) {
			new ServiceWindow(CustomerType.COMMON, i).start();
		}
		
		//产生5号快速窗口
		new ServiceWindow(CustomerType.EXPERSS, 5).start();
		
		//产生6号VIP窗口
		new ServiceWindow(CustomerType.VIP, 6).start();
	}
	
	/**
	 * 客户取号
	 */
	private static void customerFetchNumber() {
		//普通客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					@Override
					public void run() {
						String serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();
						fetchNumberSuccess(CustomerType.COMMON, serviceNumber, NumberMachine.getInstance().getCommonManager().getQueueSize() - 1);
					}
				}, 
				1, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME_S, 
				TimeUnit.SECONDS);
		
		//快速客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					@Override
					public void run() {
						String serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();
						fetchNumberSuccess(CustomerType.EXPERSS, serviceNumber, NumberMachine.getInstance().getExpressManager().getQueueSize() - 1);
					}
				}, 
				1, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME_S * 3, 
				TimeUnit.SECONDS);
		
		//VIP客户拿号
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
				new Runnable() {
					@Override
					public void run() {
						String serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();
						fetchNumberSuccess(CustomerType.VIP, serviceNumber, NumberMachine.getInstance().getVipManager().getQueueSize() - 1);
					}
				}, 
				1, 
				Constants.COMMON_CUSTOMER_INTERVAL_TIME_S * 6, 
				TimeUnit.SECONDS);
	}
	
	/**
	 * 取号成功打印信息
	 */
	private static void fetchNumberSuccess(CustomerType customerType, String serviceNumber, int waitCount) {
		System.out.println(
				customerType + "客户取号成功，号码为：" 
				+ serviceNumber + "\t" 
				+ "前面还有"
				+ customerType
				+ "客户"
				+ waitCount
				+ "人等待");
	}
	
}

黑马程序员

------- android培训、java培训、期待与您交流！ ----------