1、 配额管理模块设计的思路：
a、引入账户模型。通过引入账户模型，可以通过控制配额账户的活动，我们可以允许透支，可以规定额度，也可以冻结其账户。另外系统可以追溯配额的使用情况，来龙去脉。
b、引入生产者和消费者模型。配额的产生和配额的使用是两个不同的活动。我把前一种活动产生的配额叫生产配额，后一种叫消费配额。
生产配额是有期限的，过期的生产配额是无法使用的，同时生产配额必须记录它已经使用了多少配额，这通过持有消费配额的集合 来达到目的。
与此相反，消费配额没有有效期，但是它必须记录配额在什么时候被使用。
通过这种方式，可以计算某个消费配额的剩余额度，也容易地作废某些过期配额。
2、集体实现
首先是 QuotaEntery(配额条目)，做为配额增加、减少、使用、调整、作废等情况的。
/**
* 配额条目
*/
public class QuotaEntry {
/** 项目类型*/
protected QuotaEntryType entryType;
/** 额度，可正，可负 */
protected int amount;
/** 创建时间*/
private Date createTime;
protected QuotaAccount account;
public QuotaEntryType getEntryType() {
return entryType;
}
public void setEntryType(QuotaEntryType entryType) {
this.entryType = entryType;
}
public int getAmount() {
return amount;
}
public void setAmount(int amount) {
this.amount = amount;
}
public QuotaAccount getAccount() {
return account;
}
public void setAccount(QuotaAccount account) {
this.account = account;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
其次是ConsumeQuotaEntry（消费者）和ProduceQuotaEntry（生产者）。他们继承QuotaEntry，不同的是ProdcuceQuotaEntry记录配额的产生，ConsumeQuotaEntry则是记录配额的减少，
/**
* 生产配额 条目
*/
public class ProduceQuotaEntry extends QuotaEntry implements Comparable<ProduceQuotaEntry>{
/**
* 有效期
*/
public static int DEFALUT_LIFE_YEAR = 2;
/**
* 配额的有效期
*/
private Date beginTime;
private Date endTime;
private List<ConsumeQuotaEntry> consumeEntries = new ArrayList<ConsumeQuotaEntry>(10);
public Date getBeginTime() {
return beginTime;
}
public void setBeginTime(Date beginTime) {
this.beginTime = beginTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
/**
* 是否是可用的配额条目
*/
public boolean isUsable() {
Date current = new Date();
return current.getTime() >= beginTime.getTime() && current.getTime() <= endTime.getTime() &&
caclRemainQuota() > 0;
}
/**
* 是否是过期的配额
* @return
*/
public boolean isOverdue(){
return new Date().getTime() > endTime.getTime();
}
/**
* 计算当前条目剩下可用的配额
* @return
*/
public int caclRemainQuota(){
int used = 0;
for(ConsumeQuotaEntry entry:consumeEntries){
used += entry.getAmount();
}
return amount + used;
}
public int compareTo(ProduceQuotaEntry o) {
if(this.getEndTime().getTime() > o.getEndTime().getTime()){
return 1;
}
if(this.getEndTime().getTime() < o.getEndTime().getTime()){
return -1;
}
return 0;
}
public void addConsumeEntry(ConsumeQuotaEntry consume) {
consumeEntries.add(consume);
consume.setProduce(this);
}
}
/**
* 消费配额
*/
public class ConsumeQuotaEntry extends QuotaEntry {
/**减少配额 所依据的 消费配额额 */
private ProduceQuotaEntry produce;
public ProduceQuotaEntry getProduce() {
return produce;
}
public void setProduce(ProduceQuotaEntry produce) {
this.produce = produce;
}
}
QuotaEntryType，枚举类，记录 导致配额增加，减少的业务种类
public enum QuotaEntryType {
TransferFrom, //转入
TransferTo, //转出
Deduct, //扣减
Restore, //归还
Init, //初始
Decrease, //减少
Increase, //增加
Repeal; //作废
}
QuotaEntryFactory，配额条目工厂，屏蔽创建配额条目的细节
public class QuotaEntryFactory {
/**
* 返回 过期作废的配额条目
* @param amount
* @return
*/
public static ConsumeQuotaEntry getRepealEntry(int amount) throws QuotaException {
return getReducedEntry(amount,QuotaEntryType.Repeal);
}
/**
* 返回 转出的 配额
* @param amount
* @return
* @throws QuotaException
*/
public static ConsumeQuotaEntry getTransferToEntry(int amount) throws QuotaException {
return getReducedEntry(amount,QuotaEntryType.TransferTo);
}
/**
* 返回 扣减的配额
* @param amount
* @return
* @throws QuotaException
*/
public static ConsumeQuotaEntry getDeductEntry(int amount) throws QuotaException {
return getReducedEntry(amount,QuotaEntryType.Deduct);
}
/**
* 返回 减少的配额
* @param amount
* @return
* @throws QuotaException
*/
public static ConsumeQuotaEntry getDecreaseEntry(int amount) throws QuotaException {
return getReducedEntry(amount,QuotaEntryType.Decrease);
}
/**
* 返回 归还的配额
* @param consume
* @return
* @throws QuotaException
*/
public static ConsumeQuotaEntry getRestoreEntry(ConsumeQuotaEntry consume) throws QuotaException {
ConsumeQuotaEntry newConsume = new ConsumeQuotaEntry();
newConsume.setEntryType(QuotaEntryType.Restore);
newConsume.setAmount(-consume.getAmount());
newConsume.setCreateTime(new Date());
return newConsume;
}
public static ConsumeQuotaEntry getReducedEntry(int amount,QuotaEntryType type) throws QuotaException {
check(amount);
ConsumeQuotaEntry consume = new ConsumeQuotaEntry();
consume.setEntryType(type);
consume.setCreateTime(new Date());
consume.setAmount(-amount);
return consume;
}
public static ProduceQuotaEntry getInitEntry(int amount) throws QuotaException {
check(amount);
return getRaisedEntry(amount,QuotaEntryType.Init);
}
public static ProduceQuotaEntry getIncreaseQuotaEntry(int amount) throws QuotaException {
check(amount);
return getRaisedEntry(amount,QuotaEntryType.Increase);
}
public static ProduceQuotaEntry getTransferFromEntry(int amount) throws QuotaException {
check(amount);
return getRaisedEntry(amount,QuotaEntryType.TransferFrom);
}
public static ProduceQuotaEntry getRaisedEntry(int amount,QuotaEntryType type){
ProduceQuotaEntry entry = new ProduceQuotaEntry();
entry.setEntryType(type);
Calendar c = Calendar.getInstance();
entry.setBeginTime(c.getTime());
c.add(Calendar.YEAR, ProduceQuotaEntry.DEFALUT_LIFE_YEAR);
entry.setEndTime(c.getTime());
entry.setAmount(amount);
entry.setCreateTime(new Date());
return entry;
}
private static void check(int amount) throws QuotaException {
if (amount < 0) throw new QuotaException(QuotaMsg.QuotaMustBeMoreThanZero.getName());
}
}
QuotaException（配额异常消息类）
public class QuotaException extends Exception {
public QuotaException(String s) {
super(s);
}
}
QuotaMsg（各种异常消息）
public enum QuotaMsg {
AccountHasBeenFrozen {
public String getName() {
return "账户已被冻结";
}
},
AccountCantBeOverDraft {
public String getName() {
return "账户不可透支";
}
},
ItHasBeyondLimitQuota {
public String getName() {
return "已经超过透支额度";
}
},
QuotaMustBeMoreThanZero {
public String getName() {
return "配额必须大于0";
}
},
AnAccountOnlyHasAnInitEntry {
public String getName() {
return "一个账户只有一条Init记录";
}
};
public abstract String getName();
}
QuotaAccount，业务逻辑发生的地方
/**
* 配额账户..
*/
public class QuotaAccount {
/** 账户名称 */
private String name;
/** 是否冻结 */
private boolean frozen;
/** 是否可以透支 */
private boolean overdrawn;
/** 透支额度 */
private Long limit;
/** 配额条目 */
private List<QuotaEntry> quotaEntries = new ArrayList<QuotaEntry>(16);
/**
* 购买商品后，扣减配额
* @param amount 额度
*/
public List<ConsumeQuotaEntry> deduct(int amount) throws QuotaException {
checkAccount(amount);
//可用的生产配额
List<ProduceQuotaEntry> avaiEntries = findAvaiEntry();
//生成的消费配额
List<ConsumeQuotaEntry> consumeList = reduceQuota(avaiEntries,amount,QuotaEntryType.Deduct);
return consumeList;
}
/**
* 计算剩余配额
* @return
*/
public int caclOddQuota(){
int count = 0;
for(QuotaEntry entry:quotaEntries){
count += entry.getAmount();
}
return count;
}
/**
* 归还配额
* @param consume 消费配额
* @throws QuotaException
*/
private void restore(ConsumeQuotaEntry consume) throws QuotaException {
//1、找到对应的生产积分条目
ProduceQuotaEntry produce = consume.getProduce();
//2、生成一条 归还条目
ConsumeQuotaEntry newConsume = QuotaEntryFactory.getRestoreEntry(consume);
//3、把积分写到指定生产配额下
produce.addConsumeEntry(newConsume);
//4、添加到账户下
addQuotaEntry(newConsume);
}
/**
* 归还配额
* @param consumeList 消费条目列表
* @throws QuotaException
*/
public void restore(List<ConsumeQuotaEntry> consumeList) throws QuotaException {
for(ConsumeQuotaEntry consume:consumeList){
restore(consume);
}
}
/**
* 作废生产配额
* @param produce 生产配额
* @return
* @throws QuotaException
*/
public ConsumeQuotaEntry repeal(ProduceQuotaEntry produce) throws QuotaException {
int remain = produce.caclRemainQuota();
ConsumeQuotaEntry consume = QuotaEntryFactory.getRepealEntry(remain);
produce.addConsumeEntry(consume);
addQuotaEntry(consume);
return consume;
}
/**
* 作废所有过期的配额
* @return
*/
public void repeal() throws QuotaException {
for(QuotaEntry entry:quotaEntries) {
if(ProduceQuotaEntry.class.isInstance(entry)){
ProduceQuotaEntry produce = (ProduceQuotaEntry)entry;
if(produce.isOverdue() && produce.caclRemainQuota() > 0){
repeal(produce);
}
}
}
}
/**
* 把 一定数量的配额 转移到 另一个账户上
*
* @param account 目标账户
* @param amount 额度
* @throws QuotaException
*/
public void transferTo(QuotaAccount account, int amount) throws QuotaException {
checkAccount(amount);
List<ProduceQuotaEntry> avaiEntries = findAvaiEntry();
List<ConsumeQuotaEntry> consumeList= reduceQuota(avaiEntries,amount,QuotaEntryType.TransferTo);
account.transferFrom(consumeList);
}
/**
* 接收 从某个账户转移过来的额度
*
*/
public void transferFrom(List<ConsumeQuotaEntry> consumeList) throws QuotaException {
int amount = 0;
for(ConsumeQuotaEntry consume:consumeList){
amount += consume.getAmount();
}
amount = Math.abs(amount);
transferFrom(amount);
}
private void transferFrom(int amount) throws QuotaException {
ProduceQuotaEntry produce = QuotaEntryFactory.getTransferFromEntry(amount);
addQuotaEntry(produce);
}
/**
* 增加 配额
*
* @param amount
*/
public ProduceQuotaEntry increaseQuota(int amount) throws QuotaException {
ProduceQuotaEntry produce = QuotaEntryFactory.getIncreaseQuotaEntry(amount);
addQuotaEntry(produce);
return produce;
}
/**
* 减少 配额
* produce 生产配额
* @param amount
*/
public void decreaseQuota(ProduceQuotaEntry produce,int amount) throws QuotaException {
checkAccount(amount);
if(produce.caclRemainQuota() <amount) throw new QuotaException("生产配额少于消费配额");
ConsumeQuotaEntry consume = QuotaEntryFactory.getDeductEntry(amount);
addQuotaEntry(consume);
}
/**
* 找到可用的配额账目
* @return
*/
private List<ProduceQuotaEntry> findAvaiEntry(){
List<ProduceQuotaEntry> avaiEntries = new ArrayList<ProduceQuotaEntry>(10);
for(QuotaEntry entry:quotaEntries){
if(!ProduceQuotaEntry.class.isInstance(entry)) break;
ProduceQuotaEntry produce = (ProduceQuotaEntry) entry;
if(produce.caclRemainQuota() > 0 && produce.isUsable()){
avaiEntries.add(produce);
}
}
Collections.sort(avaiEntries);
return avaiEntries;
}
/**
* 创建初始配额账户
*
* @param amount
*/
public void init(int amount) throws QuotaException {
if (hasInitEntry()) throw new QuotaException(QuotaMsg.AnAccountOnlyHasAnInitEntry.getName());
addQuotaEntry(QuotaEntryFactory.getInitEntry(amount));
}
public boolean hasInitEntry() {
boolean has = false;
for (QuotaEntry entry : quotaEntries) {
if (entry.getEntryType().equals(QuotaEntryType.Init)) {
has = true;
break;
}
}
return has;
}
/**
* 从一群 可用的而生产配额中，减去 配额
* @param avaiEntries
* @param amount
* @return 扣减记录
* @throws QuotaException
*/
private List<ConsumeQuotaEntry> reduceQuota(List<ProduceQuotaEntry> avaiEntries,int amount,QuotaEntryType type) throws QuotaException {
List<ConsumeQuotaEntry> consumeList= new ArrayList<ConsumeQuotaEntry>(4);
int remain =amount;
int toReduce = amount;
Iterator<ProduceQuotaEntry> iterator = avaiEntries.iterator();
while(iterator.hasNext()){
ProduceQuotaEntry produce = iterator.next();
remain -= produce.caclRemainQuota();
ConsumeQuotaEntry consume= null;
//如果还没有扣完，而且还有配额条目
if(remain > 0 && iterator.hasNext()){
consume = QuotaEntryFactory.getReducedEntry(produce.getAmount(),type);
toReduce = amount - produce.getAmount();
//如果没有扣完，也没有其他配额条目,
}else if(remain > 0 && !iterator.hasNext()){
consume = QuotaEntryFactory.getDeductEntry(toReduce);
}else if(remain <= 0){
consume = QuotaEntryFactory.getDeductEntry(toReduce);
}
produce.addConsumeEntry(consume);
addQuotaEntry(consume);
consumeList.add(consume);
}
return consumeList;
}
/**
* 检验配额是是否足够
* @param amount
* @throws QuotaException
*/
private void checkAccount(int amount) throws QuotaException {
if (isFrozen()) throw new QuotaException(QuotaMsg.AccountHasBeenFrozen.getName());
if (!isOverdrawn() && caclOddQuota() < amount)
throw new QuotaException(QuotaMsg.AccountCantBeOverDraft.getName());
if (isOverdrawn() && (caclOddQuota() + limit < amount))
throw new QuotaException(QuotaMsg.ItHasBeyondLimitQuota.getName());
}
/**
* 添加配额条目
* @param quotaEntry
*/
private void addQuotaEntry(QuotaEntry quotaEntry){
quotaEntries.add(quotaEntry);
quotaEntry.setAccount(this);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isFrozen() {
return frozen;
}
public void setFrozen(boolean frozen) {
this.frozen = frozen;
}
public boolean isOverdrawn() {
return overdrawn;
}
public void setOverdrawn(boolean overdrawn) {
this.overdrawn = overdrawn;
}
public Long getLimit() {
return limit;
}
public void setLimit(Long limit) {
this.limit = limit;
}
public List<QuotaEntry> getQuotaEntries() {
return quotaEntries;
}
public void setQuotaEntries(List<QuotaEntry> quotaEntries) {
this.quotaEntries = quotaEntries;
}
}测试类
public class QuotaAccountTest {
private QuotaAccount account;
private QuotaAccount accountTwo;
@Before
public void setUp() throws QuotaException, ParseException {
account = new QuotaAccount();
account.increaseQuota(34);
account.setFrozen(false);
account.setLimit(10L);
account.setOverdrawn(true);
account.setName("小明的账户");
accountTwo = new QuotaAccount();
accountTwo.increaseQuota(34);
accountTwo.setFrozen(false);
accountTwo.setLimit(10L);
accountTwo.setOverdrawn(true);
accountTwo.setName("小明的账户2");
}
@After
public void tearDown(){
account =null;
accountTwo = null;
}
@Test
public void caclRemainQuota(){
assertEquals(34, account.caclOddQuota());
}
@Test
public void caclRemainQuotaAfterDeducting4Quotas() throws QuotaException {
account.deduct(4);
assertEquals(30,account.caclOddQuota());
}
@Test
public void caclRemainQuotaAfterDeducting44Quotas() throws QuotaException {
account.deduct(44);
assertEquals(-10,account.caclOddQuota());
}
@Test(expected = QuotaException.class)
public void caclRemainQuotaAfterDeductingAndAccountItIsNotOverdrawn() throws QuotaException {
account.setOverdrawn(false);
account.deduct(44);
}
@Test
public void caclRemainQuotaAfterRestoreQuota() throws QuotaException {
List<ConsumeQuotaEntry> consumes =account.deduct(44);
assertEquals(-10,account.caclOddQuota());
account.restore(consumes);
assertEquals(34,account.caclOddQuota());
}
@Test
public void caclRemainQuotaAferIncreasingQuotaAndDecutingQuota() throws QuotaException {
account.increaseQuota(20);
List<ConsumeQuotaEntry> consumes =account.deduct(44);
assertEquals(10,account.caclOddQuota());
}
@Test
public void transferSmallQuotas() throws QuotaException {
account.transferTo(accountTwo,12);
assertEquals(22,account.caclOddQuota());
assertEquals(46,accountTwo.caclOddQuota());
}
@Test
public void transferMiddleQuotas() throws QuotaException {
account.transferTo(accountTwo,34);
assertEquals(0,account.caclOddQuota());
assertEquals(68,accountTwo.caclOddQuota());
}
@Test
public void transferLargeQuotas() throws QuotaException {
account.transferTo(accountTwo,44);
assertEquals(-10,account.caclOddQuota());
assertEquals(78,accountTwo.caclOddQuota());
}
@Test
public void transferLargeLargeQuota() throws QuotaException {
account.increaseQuota(30);
account.transferTo(accountTwo,44);
assertEquals(20,account.caclOddQuota());
assertEquals(78,accountTwo.caclOddQuota());
}
@Test
public void testRepealEntry() throws QuotaException {
ProduceQuotaEntry produce = new ProduceQuotaEntry();
produce.setAmount(34);
ConsumeQuotaEntry consume =account.repeal(produce);
assertEquals(0, produce.getAmount() + consume.getAmount());
}
}
4284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
