黑马程序员-银行管理系统

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------

需求：

分析：

1、有三种对应类型的客户：VIP客户、普通客户、快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。

  首先，一个客户其实就是一个号码，所以应该有一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。

由于有三类客户，每类客户的号码编排时完全独立的，所以，本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码，而这三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中只能有一个，所以，它要被设计成单例。

2、各类型客户在其对应窗口按顺序依次办理业务，准确地说，应该是窗口依次叫号，

各窗口怎么知道该叫哪个号了？它一定是问相应的号码管理器，即服务窗口每次找号码管理器获取当前要被服务的号码。

 

首先我们要创建几个类NumberManager类、NumberMachine类，ServiceWindow类，MainClass类，我们要理清这几个类之间的关系。

 

NumberManager类：（操作数据，），提供产生号码，和获取号码的方法。

NumberMachine类：（机器），内部维护三个对NumberManager对象的引用（分别是commonManager，expressManager，VIPManager）。

ServiceWindow类：产生一个线程，该线程根据自己的窗口类型不断的从对应的NumberManager（commonManage，expressManage，VIPManager）中取出数据进行服务。

MainClass类：1、产生六个窗口，并分别调用其start方法让窗口开始服务。

             2、产生三个线程，分别调用自己对应的NumberManager不断产生数据。

 

此外：我们最后再定义两个类，Contants类，，CustomType类

 

Contants类：存放一些静态变量，列如题中所说的最大最小服务时间

CustomType类：（枚举） 存放客户类型

 

 

详细设计：

NumberManager类：

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

public class NumberManager {
	private int number;
	private List list = new ArrayList();

	public synchronized Integer createNumber() {
		number++;
		list.add(number);
		return number;
	}

	public synchronized Integer fetchNumber() {
		/* return list.remove(0); */// 不可以这样写，因为如果list中没有数据，而你又试图去移除第一个元素，
									// 就会抛出java.lang.IndexOutOfBoundsException
		if (list.size() > 0) {
			return list.remove(0);
		}
		return null;
	}

}

NumberMachine 类

public class NumberMachine {
	private static NumberMachine nm = new NumberMachine();

	private NumberMachine() {
	}

	public static NumberMachine getInstance() {
		return nm;
	}

	private NumberManager commonManager = new NumberManager();

	public NumberManager getCommonManager() {
		return commonManager;
	}

	public NumberManager getExpressManager() {
		return expressManager;
	}

	public NumberManager getVIPManager() {
		return VIPManager;
	}

	private NumberManager expressManager = new NumberManager();
	private NumberManager VIPManager = new NumberManager();

}

ServiceWindow 类

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

public class ServiceWindow {
	private int windowId;

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

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

	private CustomerType type;

	public void start() {
		ExecutorService es = Executors.newSingleThreadExecutor();
		es.execute(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				while (true) {
					switch (type) {
					case commom:
						commonService();
						break;
					case express:
						expressService();
						break;
					case VIP:
						VIPService();
						break;
					}
				}
			}
		});
	}

	public void commonService() {
		// System.out.println(windowId+"号"+type+"窗口正在等待服务");
		NumberManager commonManager = NumberMachine.getInstance()
				.getCommonManager();
		Integer commonNumber = commonManager.fetchNumber();
		if (commonNumber != null) {
			System.out.println(type + "" + windowId + "窗口为" + commonNumber
					+ "普通用户服务");
			long startTime = System.currentTimeMillis();
			int maxRandom = Contants.maxServiceTime - Contants.minServiceTime;
			int sleepTime = new Random().nextInt(maxRandom) + 1
					+ Contants.minServiceTime;
			try {
				Thread.sleep(sleepTime);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			long endTime = System.currentTimeMillis();
			long serviceTime = (endTime - startTime) / 1000;
			System.out.println(type + "窗口为普通用户" + commonNumber + "号服务"
					+ serviceTime + "秒");
		} else {
			switch (type) {
			case commom:
				System.out.println("目前没有要服务的普通用户对象，普通窗口先休息一会吧！");
				break;
			case express:
				System.out.println("目前没有要服务的普通用户对象，快速窗口先休息一会吧！");
				break;
			case VIP:
				System.out.println("目前没有要服务的普通用户对象，VIP窗口先休息一会吧！");
				break;
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public void expressService() {

		// System.out.println(windowId+"号"+type+"窗口正在等待服务");
		NumberManager expressManager = NumberMachine.getInstance()
				.getExpressManager();
		Integer expressNumber = expressManager.fetchNumber();
		if (expressNumber != null) {
			System.out.println(type + "" + windowId + "窗口为" + expressNumber
					+ "快速用户服务");
			try {
				Thread.sleep(Contants.minServiceTime);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			long serviceTime = Contants.minServiceTime / 1000;
			System.out.println(type + "窗口为快速用户" + expressNumber + "号服务"
					+ serviceTime + "秒");
		} else {
			System.out.println("目前没有快速用户需要服务，快速窗口正准备给普通用户服务");
			commonService();
		}
	}

	public void VIPService() {

		// System.out.println(windowId+"号"+type+"窗口正在等待服务");
		NumberManager VIPManager = NumberMachine.getInstance().getVIPManager();
		Integer VIPNumber = VIPManager.fetchNumber();
		if (VIPNumber != null) {
			System.out.println(type + "" + windowId + "窗口为" + VIPNumber
					+ "VIP用户服务");
			long startTime = System.currentTimeMillis();
			int maxRandom = Contants.maxServiceTime - Contants.minServiceTime;
			int sleepTime = new Random().nextInt(maxRandom) + 1
					+ Contants.minServiceTime;
			try {
				Thread.sleep(sleepTime);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			long endTime = System.currentTimeMillis();
			long serviceTime = (endTime - startTime) / 1000;
			System.out.println(type + "窗口为VIP用户" + VIPNumber + "号服务"
					+ serviceTime + "秒");
		} else {
			System.out.println("目前没有VIP用户需要服务，VIP窗口正准备给普通用户服务");
			commonService();
		}
	}

}

MainClass 类

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
		for (int i = 1; i < 5; i++) {
			ServiceWindow commonWindow = new ServiceWindow();
			commonWindow.setWindowId(i);
			commonWindow.setType(CustomerType.commom);
			commonWindow.start();
		}
		ServiceWindow expressWindow = new ServiceWindow();
		expressWindow.setType(CustomerType.express);
		expressWindow.setWindowId(5);
		expressWindow.start();
		ServiceWindow VIPWindow = new ServiceWindow();
		VIPWindow.setType(CustomerType.VIP);
		VIPWindow.setWindowId(6);
		VIPWindow.start();
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				Integer serviceNumber = NumberMachine.getInstance()
						.getCommonManager().createNumber();
				System.out.println("第" + serviceNumber + "号普通用户正在等待服务");
			}
		}, 1, Contants.VipComeTime * 6, TimeUnit.SECONDS);
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				Integer serviceNumber = NumberMachine.getInstance()
						.getExpressManager().createNumber();
				System.out.println("第" + serviceNumber + "号快速用户正在等待服务");
			}
		}, 1, Contants.VipComeTime * 3, TimeUnit.SECONDS);
		Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				Integer serviceNumber = NumberMachine.getInstance()
						.getVIPManager().createNumber();
				System.out.println("第" + serviceNumber + "号VIP用户正在等待服务");
			}
		}, 1, Contants.VipComeTime, TimeUnit.SECONDS);

	}

}

Contants 类

public class Contants {
	public static int minServiceTime = 1000;
	public static int maxServiceTime = 9000;
	public static int VipComeTime = 1;
}

CustomType 类

public enum CustomerType {
	commom, express, VIP
}

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------