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客户
    }

}
//

这个银行的排队号码管理系统，也不是很难，其中用到技术有线程池，如窗口开始服务的时候，模拟客户进银行的时候，主要的难点在于普通窗口和特殊窗口的工作方式不一样，在老师的视频教程里面
是分三个方法分别调用，我这里是在一个方法里调用，但是由于多了几个判断，代码意图不是很清晰，个人感觉还是个坑，看来应该听老师的提议的用子类的方法重写才对。
不过不要紧的，提炼方法，重构方法也是一个重要的技能。还有面向对象编程，感觉就像设计数据库一样，一开始的想法总不会是最终的版本，只有不断修改，不断完善，才能
让数据库理符合系统。面向对象的程序设计也是一样，一个类总是在不断修改中完善的，不要因为一下子设计不到位就气馁。

哎呀，好累啊，睡觉睡觉。