requestmanager.java

一个java rmi实现的分布式银行管理系统

package BS.server.businesslayer;
/**
 * @author 束罡
 * 
 * TODO To change the template for this generated type comment go to Window -
 * Preferences - Java - Code Style - Code Templates
 */


import BS.server.datastructure.Request;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 类：BankingTasksManager
 * 功能：接受用户端的业务请求task1，将用户请求打包填入服务队列taskqueue的尾部，
 *      再从taskqueue队列的头部弹出某一个业务请求task2，进行具体的业务操作。
 * 注意：这里的业务请求task1和task2并不一定是同一个。
 * */
public class RequestManager
{
	
	/**
	 * 方法：acceptTasks
	 * 功能：该方法负责接受客户端的访问，将用户的请求task1打包填入服务队列taskqueue的尾部，
	 *      再从taskqueue队列的头部弹出某一个业务请求task2，进行具体的业务操作。
	 * 注意：具体步骤参加程序内部的流程注解。
	 * 调用参数：用户的业务请求字符串String taskStr。
	 * 参数格式：这里的taskStr应当是这样的格式：(每一项之间用\t分割)
	 *         timestamp, account number, transaction type(withdrawl/deposit), amount
	 *         例如：10	101	w	200
	 * 返回值：返回给客户端的字符串，这个字符串是用户直接可见的运行结果！
	 * */
	public static synchronized String acceptTasks (String taskStr)
	{		
		//3、以下为定义分解串
		int timestamp = 0;				//时间戳
		int accountNumber =-1;			//帐户号
		char transactionType = '#';		//交易类型
		float amount = -1;				//交易额
		
		//4、以下为具体分解用户的业务请求串。
		//10	101	w	200
		int temp1 = 0;
		int temp2 = 0;
		String tempStr = "";
		try
		{		
			//确定第一位timestamp时间戳
			temp2 = taskStr.indexOf("\t");
			tempStr = taskStr.substring(0,temp2);
			timestamp = Integer.parseInt(tempStr);
			//确定第二位account number帐户号
			temp1 = temp2 + 1;
			temp2 = taskStr.indexOf("\t",temp1);
			tempStr = taskStr.substring(temp1,temp2);
			accountNumber = Integer.parseInt(tempStr);
			//确定第三位transaction type交易类型
			temp1 = temp2 + 1;
			temp2 = taskStr.indexOf("\t",temp1);
			tempStr = taskStr.substring(temp1,temp2);
			char tempChar [] = tempStr.toCharArray();
			transactionType = tempChar[0];
			//确定第四位amount交易额
			temp1 = temp2 + 1;
			temp2 = taskStr.length();
			tempStr = taskStr.substring(temp1,temp2);
			amount = Float.parseFloat(tempStr);
			
			//5、将用户的业务请求打包，并存入任务队列taskqueue的尾部
			Request cr1 = new Request();
			cr1.SETtimestamp(timestamp);
			cr1.SETaccountNumber(accountNumber);
			cr1.SETtransactionType(transactionType);
			cr1.SETamount((int)amount);
			AccessQueue aq = AccessQueue.getInstance();
			aq.add(cr1);
			
			//6、再从任务队列的头部弹出一个业务请求,通过调用底层加以执行
			Request cr2 = aq.poll();
			boolean flag = false;
			String returnStr = null;
			switch(cr2.GETtransactionType())
			{
			case 'w'://withDraw
				returnStr = "withDraw ";
				flag = TransactManager.withDraw (cr2.GETaccountNumber(),cr2.GETamount());
				if (flag==true)
					{returnStr = returnStr + "操作已成功!";}
				else
					{returnStr = returnStr + "操作失败!";}
				break;
			case 'd'://deposit
				returnStr = "deposit ";
				flag = TransactManager.deposit(cr2.GETaccountNumber(),cr2.GETamount());
				if (flag==true)
					{returnStr = returnStr + "操作已成功!";}
				else
					{returnStr = returnStr + "操作失败!";}
				break;
			case 'b'://balanceCheck
				String flagStr = null;
				returnStr = "balanceCheck ";
				flagStr = TransactManager.balanceCheck(cr2.GETaccountNumber());
				if (flagStr!=null) 
					{returnStr = returnStr + "操作已成功!\n" +flagStr;}
				else
					{returnStr = returnStr + "操作失败!\n";}
				break;
			default:
				return null;
			}
			return returnStr;
		}
		catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	 * 方法：main
	 * 功能：提供测试以上几个函数的功能。
	 * 调用参数：
	 * 返回值：
	 * */
	public static void main(String[] args) {
		String taskStr;
		String result;
				
		taskStr = "0	101	b	0";
		result = RequestManager.acceptTasks(taskStr);
		System.out.println(result);
		/*
		taskStr = "10	101	w	200";
		result = BankingTasksManager.acceptTasks(taskStr);
		System.out.println(result);
		*/
		taskStr = "10	101	d	200";
		result = RequestManager.acceptTasks(taskStr);
		System.out.println(result);
		taskStr = "0	101	b	0";
		result = RequestManager.acceptTasks(taskStr);
		System.out.println(result);
	}
}




/**
 * 类：AccessQueue
 * 功能：整个类实现了单件模式，保证后台的操作是顺序执行的，从而屏蔽了多线程调度所引发的各种问题
 * */
class AccessQueue{
	//以下的队列Queue q是任务处理队列，负责顺序化、唯一确定化来自client的任务请求
	public static LinkedBlockingQueue taskqueue = new LinkedBlockingQueue();
	//使用单件模式创建类QueuedAccess
	private static AccessQueue INSTANCE = null;
	
	/**
	 * 方法：QueuedAccess
	 * 功能：通过将QueuedAccess定义为private，从而不允许外部直接创建类的实例
	 * 调用参数：无
	 * 返回值：无
	 * */
	private AccessQueue()
	{
	}	
	
	/**
	 * 方法：QueuedAccess
	 * 功能：返回类的实例。因为使用了singletom，实际上只有一种返回值
	 * 调用参数：无
	 * 返回值：QueuedAccess INSTANCE
	 * */
	public static AccessQueue getInstance()
	{
		if (INSTANCE==null)
		{
			INSTANCE = new AccessQueue ();
		}		
		return INSTANCE;
	}	
	
	/**
	 * 方法：add
	 * 功能：向队列中添加一项数据
	 * 调用参数：ClientRequest cr,即一条用户操作所转化为的sql语句
	 * 返回值：操作成功返回true,否则false
	 * */
	public boolean add(Request cr)
	{
		boolean flag = taskqueue.add(cr);
		return flag;
	}
		
	/**
	 * 方法：poll
	 * 功能：从队列头部读出一条数据
	 * 调用参数：无
	 * 返回值：操作成功返回指定的数据(ClientRequest型),否则返回null
	 * */
	public Request poll()
	{
		Request cr = null;
		cr = (Request)taskqueue.poll();
		return cr;
	}
		
	/**
	 * 方法：kill
	 * 功能：释放全部队列内容
	 * 调用参数：无
	 * 返回值：无
	 * */
	public static void kill()
	{
		taskqueue = null;
	}
	
	/**
	 * 方法：test1
	 * 功能：测试add,poll函数
	 * 调用参数：无
	 * 返回值：无
	 * */
	public synchronized void test1 ()
	{
		//以下测试顺序添加测试数据(ClientRequest型)
		Request cr = null;
		for (int i=0; i<6; i++)
		{
			cr = new Request();
			cr.SETamount(i);
			add(cr);	
		}
		//以下测试按照fifo方式打印出的数据
		while (!taskqueue.isEmpty())
		{
			cr = (Request)poll();
			System.out.println(cr.GETamount());	
		}
	}	
	
	/**
	 * 方法：main
	 * 功能：提供测试以上几个函数的功能。
	 * 调用参数：
	 * 返回值：
	 * */
	public static void main(String[] args) {
		AccessQueue aq = AccessQueue.getInstance();
		aq.test1();
	}
}