遊戲中VIP會員模塊的簡單實現

時間 2019-11-14

標籤遊戲 vip 會員模塊簡單實現欄目遊戲简体版

原文原文鏈接

哈哈今天週末有時間，再整理一篇博文上來，雖然已經不作遊戲老長時間了，但仍是要把之前作過的東西總結一下，藉此能夠回顧之前的東西，也能夠分享給你們。java

今天說一下游戲中VIP會員模塊的實現思路。每款遊戲的消費體系中必不可缺乏的一個模塊就是VIP，VIP用戶能夠得到額外的獎勵，好比每日登錄獎勵，遊戲中各個功能針對VIP和普通用戶都有所差別，這樣可使遊戲運做更加良好，若是一款商業遊戲不賺錢，那麼這款遊戲的路確定很差走。本文的VIP模塊的相似於QQ會員的成長體系，你們可去QQ會員網站中看看。ide

接下來進入正題：測試

成長體系圖

VIP經驗等級成長方案

VIP經驗等級成長方案配置表1網站			VIP經驗等級成長方案配置表2this
VIP等級編碼	VIP經驗spa	VIP經驗區段3d	VIP等級日誌	VIP經驗code	VIP經驗區段
0	0	0	0	0	0
1	16	0-16	1	16	0-16
2	68	16-68	2	68	16-84
3	158	68-158	3	158	84-242
4	618	158-618	4	618	242-860
5	1236	618-1236	5	1236	860-2096
6	2472	1236-2472	6	2472	2096-4568
7		2472-	7		4568-

VIP會員成長值

會員成長值 = 每日成長值 + 購買贈送成長值 - 非會員成長值降低

l 每日成長值：VIP普通會員每日 +10點；VIP超級會員每日 +15點；

l 購買贈送成長點：既購買VIP產品贈送的成長點

l 非會員成長值降低：VIP會員過時以後天天降低 -10點

l 會員成長值超過VIP7上限以後將不會繼續增長成長值

VIP會員類型

n VIP普通會員

n VIP超級會員

VIP普通會員（現有VIP普通會員時間大於0）

如何成爲VIP普通會員：購買VIP產品（月卡、季卡、年卡）

延長VIP普通會員時間：= 現有VIP普通會員時間 + 購買VIP產品中配置的時間

VIP普通會員天天增長成長值 + 10點（配置）

VIP超級會員（現有VIP超級會員時間大於0）

如何成爲VIP超級會員：現有VIP（普通）會員時間大於60天購買VIP產品（月卡、季卡、年卡），或直接購買VIP產品（季卡、年卡）

延長VIP超級會員時間：

若是現有VIP普通會員時間大於60，則 = 現有VIP普通會員時間 - 60 + 購買VIP產品中配置的時間

若是現有VIP普通會員時間等於0，購買了季卡或年卡，則 = 購買VIP產品中配置的時間 - 60

VIP超級會員天天增長成長值 + 15點（配置）

VIP經驗成長的狀況

用戶上次登錄時間：lastLoginTime; 用戶今天登錄時間：loginTime;

普通VIP結束時間：vipEndTime; 超級VIP結束時間：superVipEndTime;

第一種狀況；VIP超級會員

第二種狀況：VIP超級會員已過時，成爲VIP普通會員

第三種狀況：VIP超級會員、VIP普通會員都已過時

第四種狀況：上次登錄前VIP超級會員過時

第五種狀況：VIP普通會員已過時

第六種狀況：上次登錄前VIP普通會員已過時

VIP經驗等級計算

用戶本次登錄與上次登錄時間之差：loginT = loginTime - lastLogin

VIP普通會員到期時間與登錄時間之差：vipEndTimeT = vipEndTime - loginTime;

VIP普通會員到期時間與上次登錄時間之差：lastVipEndTimeT = vipEndTime - lastLoginTime;

VIP超級會員到期時間與登錄時間之差：superVipEndTimeT = superVipEndTime - loginTime;

VIP超級會員到期時間與上次登錄時間之差：lastSuperVipEndTimeT = superVipEndTime - lastLoginTime;

VIP普通會員到期時間與VIP超級會員到期時間之差：vipBetweenSuperT = vipEndTime - superVipEndTime;

        public static final int COMMON_VIPEXP_DAY_ADD_VALUE = 10;
        public static final int SUPER_VIPEXP_DAY_ADD_VALUE = 15;
        public static final int VIPEXP_DAY_REMOVE_VALUE = 10;

        int loginTime = 0,//用戶本次登錄時間
            lastLoginTime = 0,//用戶上次登錄時間
            vipEndTime = 0,//普通VIP結束時間
            superVipEndTime = 0;//超級VIP結束時間
        int loginT,vipEndTimeT ,lastVipEndTimeT  ,superVipEndTimeT  ,lastSuperVipEndTimeT ,vipBteweenSuperT;
        //用戶本次登錄與上次登錄時間之差
        loginT = loginTime - lastLoginTime;
        //VIP普通會員到期時間與登錄時間之差
        vipEndTimeT  = vipEndTime - loginTime;
        //VIP普通會員到期時間與上次登錄時間之差
        lastVipEndTimeT  = vipEndTime - lastLoginTime;
        //VIP超級會員到期時間與登錄時間之差
        superVipEndTimeT  = superVipEndTime - loginTime;
        //VIP超級會員到期時間與上次登錄時間之差
        lastSuperVipEndTimeT  = superVipEndTime - lastLoginTime;
        //VIP普通會員到期時間與VIP超級會員到期時間之差
        vipBteweenSuperT = vipEndTime - superVipEndTime;
        //計算VIP經驗點
        long vipExp = 0l;
        //上次登錄前VIP已過時
        if(lastVipEndTimeT  < 0){
            vipExp = loginT*VIPEXP_DAY_REMOVE_VALUE*(-1);
        //VIP已過時
        }else if(vipEndTimeT  < 0 && lastVipEndTimeT  > 0 && lastSuperVipEndTimeT  < 0){
            vipExp = lastVipEndTimeT*COMMON_VIPEXP_DAY_ADD_VALUE + vipEndTimeT*VIPEXP_DAY_REMOVE_VALUE;
        //VIP超級會員、VIP普通會員都已過時
        }else if(vipEndTimeT  < 0 && lastVipEndTimeT  > 0 && superVipEndTimeT  < 0 && lastSuperVipEndTimeT  > 0){
            vipExp = lastSuperVipEndTimeT*SUPER_VIPEXP_DAY_ADD_VALUE + vipBteweenSuperT*COMMON_VIPEXP_DAY_ADD_VALUE + vipEndTimeT*VIPEXP_DAY_REMOVE_VALUE;
        //上次登錄前VIP超級會員過時
        }else if(vipEndTimeT  > 0 && lastSuperVipEndTimeT  < 0){
            vipExp = loginT*COMMON_VIPEXP_DAY_ADD_VALUE;
        //VIP超級會員已過時，成爲VIP普通會員
        }else if(vipEndTimeT  > 0 && superVipEndTimeT < 0 && lastSuperVipEndTimeT  > 0){
            vipExp = lastSuperVipEndTimeT*SUPER_VIPEXP_DAY_ADD_VALUE + superVipEndTimeT*COMMON_VIPEXP_DAY_ADD_VALUE*(-1);
        //VIP超級會員
        }else if(lastSuperVipEndTimeT  > 0){
            vipExp = loginT*SUPER_VIPEXP_DAY_ADD_VALUE;
        }

VIP等級獎勵

n 每日登錄獎勵

n 特權獎勵

隨後補上源碼

今天已經整理好了代碼貼上來供分享

demo目錄圖以下

package com.game.vip.data.user;

/**
 * @author Administrator
 * 用戶
 */
public class User {
    /**
     * 用戶Id
     */
    private long userId;
    
    /**
     * 用戶名
     */
    private String name;

    private UserVipInfo userVipInfo;
    
    private UserLoginLog userLoginLog;
    
    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public UserVipInfo getUserVipInfo() {
        return userVipInfo;
    }

    public void setUserVipInfo(UserVipInfo userVipInfo) {
        this.userVipInfo = userVipInfo;
    }

    public UserLoginLog getUserLoginLog() {
        return userLoginLog;
    }

    public void setUserLoginLog(UserLoginLog userLoginLog) {
        this.userLoginLog = userLoginLog;
    }
}

package com.game.vip.data.user;

/**
 * @author Administrator
 * 用戶登錄日誌
 */
public class UserLoginLog {
    
    /**
     * 用戶Id
     */
    private long userId;
    
    /**
     * 上次登錄時間
     */
    private long lastLoginTime;

    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public long getLastLoginTime() {
        return lastLoginTime;
    }

    public void setLastLoginTime(long lastLoginTime) {
        this.lastLoginTime = lastLoginTime;
    }
}

package com.game.vip.data.user;

import com.game.vip.strategy.VipLevelStrategy;

/**
 * @author Administrator
 * 用戶Vip的信息
 */
public class UserVipInfo {
    
    public static final int VIP_STATUS_N = 0;
    public static final int VIP_STATUS_Y = 1;
    
    /**
     * 用戶id
     */
    private long userId;
    
    /**
     * vip標誌[0：普通用戶；1：普通VIP會員；2：白金VIP會員]
     */
    private int vipStatus;
    
    /**
     * 當前VIP級別
     */
    private int curVipLevel;
    
    /**
     * 以前VIP級別
     */
    private int preVipLevel;
    
    /**
     * 當前VIP經驗
     */
    private long curVipExp;
    
    /**
     * 升級到下一級所需的VIP經驗
     */
    private long nextLevelNeedExp;
    
    /**
     * 普通VIP截止時間
     */
    private long vipEndTime;
    
    /**
     * 超級VIP截止時間
     */
    private long superVipEndTime;
    
    /**
     * VIP等級策略
     */
    private VipLevelStrategy vipLevelStrategy;

    public void init(){
        this.vipStatus = VIP_STATUS_N;
        this.vipEndTime = 0;
        this.superVipEndTime = 0;
        this.curVipExp = 0;
        this.curVipLevel = 0;
        this.preVipLevel = 0;
        this.nextLevelNeedExp = 0;
    }
    
    public void toVipUser(){
        this.vipStatus = VIP_STATUS_Y;
        this.curVipExp = 0;
        this.curVipLevel = this.vipLevelStrategy.getMinLevel();
        this.preVipLevel = 0;
        this.nextLevelNeedExp = this.vipLevelStrategy.getNextLevelNeedExp(this.curVipLevel, this.curVipExp);
    }
    
    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }

    public int getVipStatus() {
        return vipStatus;
    }

    public void setVipStatus(int vipStatus) {
        this.vipStatus = vipStatus;
    }

    public int getCurVipLevel() {
        return curVipLevel;
    }

    public void setCurVipLevel(int curVipLevel) {
        this.curVipLevel = curVipLevel;
    }

    public int getPreVipLevel() {
        return preVipLevel;
    }

    public void setPreVipLevel(int preVipLevel) {
        this.preVipLevel = preVipLevel;
    }

    public long getCurVipExp() {
        return curVipExp;
    }

    public void setCurVipExp(long curVipExp) {
        this.curVipExp = curVipExp;
    }

    public long getNextLevelNeedExp() {
        return nextLevelNeedExp;
    }

    public void setNextLevelNeedExp(long nextLevelNeedExp) {
        this.nextLevelNeedExp = nextLevelNeedExp;
    }

    public VipLevelStrategy getVipLevelStrategy() {
        return vipLevelStrategy;
    }

    public void setVipLevelStrategy(VipLevelStrategy vipLevelStrategy) {
        this.vipLevelStrategy = vipLevelStrategy;
    }

    public long getVipEndTime() {
        return vipEndTime;
    }

    public void setVipEndTime(long vipEndTime) {
        this.vipEndTime = vipEndTime;
    }

    public long getSuperVipEndTime() {
        return superVipEndTime;
    }

    public void setSuperVipEndTime(long superVipEndTime) {
        this.superVipEndTime = superVipEndTime;
    }
}

package com.game.vip.data.vip.product;

/**
 * @author Administrator
 * VIP卡（月卡，季卡，年卡）
 */
public class VipProduct {
    
    /**
     * 產品id
     */
    private long id;
    
    /**
     * 產品名稱
     */
    private String name;
    
    /**
     * VIP時間
     */
    private int vipTime;

    /**
     * 贈送VIP經驗點
     */
    private long vipExpGift;

    
    public VipProduct(long id, String name, int vipTime, long vipExpGift) {
        super();
        this.id = id;
        this.name = name;
        this.vipTime = vipTime;
        this.vipExpGift = vipExpGift;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getVipTime() {
        return vipTime;
    }

    public void setVipTime(int vipTime) {
        this.vipTime = vipTime;
    }

    public long getVipExpGift() {
        return vipExpGift;
    }

    public void setVipExpGift(long vipExpGift) {
        this.vipExpGift = vipExpGift;
    }
}

package com.game.vip.data.vip;

/**
 * @author Administrator
 * vip等級配置信息
 */
public class VipLevelInfo {

    /**
     * vip等級
     */
    private int vipLevel;

    /**
     * 對應的vip的經驗點
     */
    private long vipExp;

    
    public VipLevelInfo(int vipLevel, long vipExp) {
        super();
        this.vipLevel = vipLevel;
        this.vipExp = vipExp;
    }

    public int getVipLevel() {
        return vipLevel;
    }

    public void setVipLevel(int vipLevel) {
        this.vipLevel = vipLevel;
    }

    public long getVipExp() {
        return vipExp;
    }

    public void setVipExp(long vipExp) {
        this.vipExp = vipExp;
    }
}

package com.game.vip.data.vip;

import java.util.List;

/**
 * @author Administrator
 * vip等級所對應的獎勵
 */
public class VipLevelReward {
    
    /**
     * 類型[1：數值；2：道具；3：真假（0：假；1：真）]
     */
    private int rewardType;
    
    /**
     * 編碼(如vip升級禮包，登錄禮包，充值禮包)
     */
    private int rewardCode;
    
    /**
     * 對應VIP等級
     */
    private int vipLevel;
    
    /**
     * 獎勵名稱
     */
    private String name;
    
    /**
     * 描述
     */
    private String desc;
    
    public VipLevelReward(int vipLevel, String name, String desc) {
        super();
        this.vipLevel = vipLevel;
        this.name = name;
        this.desc = desc;
    }

    /**
     * 具體了獎勵物品
     */
    private List<Object> rewardList;

    public int getRewardType() {
        return rewardType;
    }

    public void setRewardType(int rewardType) {
        this.rewardType = rewardType;
    }

    public int getRewardCode() {
        return rewardCode;
    }

    public void setRewardCode(int rewardCode) {
        this.rewardCode = rewardCode;
    }

    public int getVipLevel() {
        return vipLevel;
    }

    public void setVipLevel(int vipLevel) {
        this.vipLevel = vipLevel;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public List<Object> getRewardList() {
        return rewardList;
    }

    public void setRewardList(List<Object> rewardList) {
        this.rewardList = rewardList;
    }
    
    public boolean isEnable(int vipLevel){
        return this.getVipLevel() == vipLevel;
    }
}

package com.game.vip.manager.impl;

import java.text.SimpleDateFormat;
import java.util.Date;

import com.game.vip.data.user.User;
import com.game.vip.data.user.UserLoginLog;
import com.game.vip.data.user.UserVipInfo;
import com.game.vip.data.vip.VipLevelReward;
import com.game.vip.data.vip.product.VipProduct;
import com.game.vip.manager.VipManager;
import com.game.vip.strategy.VipLevelStrategy;
import com.game.vip.util.DateUtil;

/**
 * @author Administrator
 * vip管理實現類1
 */
public class VipManagerImpl1 implements VipManager{
    
    @Override
    public void userToVipUser(User user) {
        System.out.println("普通會員轉成VIP會員");
        UserVipInfo userVipInfo = user.getUserVipInfo();
        //設置vipStatus
        userVipInfo.toVipUser();
    }

    @Override
    public void userLogin(User user) {
        System.out.println("------------------------用戶登錄 Start----------------------------");
        try{
            if(user.getUserVipInfo().getVipStatus() == UserVipInfo.VIP_STATUS_N){
                System.out.println("當前用戶：" + user.getName());
                System.out.println("當前用戶不是VIP用戶！");
                return;
            }
            UserLoginLog loginLog = user.getUserLoginLog();
            UserVipInfo userVipInfo = user.getUserVipInfo();
            System.out.println("當前用戶：" + user.getName());
            System.out.println("當前VIP等級：" + userVipInfo.getCurVipLevel());
            System.out.println("當前VIP經驗：" + userVipInfo.getCurVipExp());
            System.out.println("VIP普通會員到期時間：" + DateUtil.format(userVipInfo.getVipEndTime()));
            System.out.println("VIP超級會員到期時間：" + DateUtil.format(userVipInfo.getSuperVipEndTime()));
            System.out.println("當前升級到下一級所須要的VIP經驗：" + userVipInfo.getNextLevelNeedExp());
            System.out.println("上次登錄時間：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(loginLog.getLastLoginTime()));
            long updateVipExp = getUpdateVipExp(loginLog, userVipInfo);
            System.out.println("更新VIP信息");
            System.out.println("VIP經驗成長值：" + updateVipExp);
            updateUserVipExp(updateVipExp, userVipInfo);
            System.out.println("當前VIP等級：" + userVipInfo.getCurVipLevel());
            System.out.println("當前VIP經驗：" + userVipInfo.getCurVipExp());
            System.out.println("當前升級到下一級所須要的VIP經驗：" + userVipInfo.getNextLevelNeedExp());
            loginLog.setLastLoginTime(new Date().getTime());
        }catch(Exception e){
        }finally{
            System.out.println("------------------------用戶登錄 End----------------------------");
        }
        
    }

    @Override
    public void rewardVipUser(User user) {
        System.out.println("------------------------獎勵VIP用戶 Start----------------------------");
        try{
            if(user.getUserVipInfo().getVipStatus() == UserVipInfo.VIP_STATUS_N || user.getUserVipInfo().getVipEndTime() < DateUtil.getNowTime()){
                System.out.println("當前用戶不是VIP用戶或VIP已過時！");
                return;
            }
            UserVipInfo userVipInfo = user.getUserVipInfo();
            VipLevelReward reward = userVipInfo.getVipLevelStrategy().getLevelReward(userVipInfo.getCurVipLevel());
            if(reward != null){
                System.out.println("當前用戶：" + user.getName());
                System.out.println("VIP等級：" + user.getUserVipInfo().getCurVipLevel());
                System.out.println("獲取VIP獎勵：" + reward.getName() + "(" +reward.getDesc() + ")");
            }else{
                System.out.println("尚未設置VIP獎品");
            }
        }catch(Exception e){
        }finally{
            System.out.println("------------------------獎勵VIP用戶 End----------------------------");
        }
        
    }

    @Override
    public void buyVipProduct(User user, VipProduct vipProduct) {
        System.out.println("------------------------購買VIP產品 Start----------------------------");
        try{
            //普通用戶轉爲VIP會員
            //第一步初始化會員信息
            userToVipUser(user);
            //第二步更新會員時間
            long updateVipTime = DateUtil.getTimeByDays(vipProduct.getVipTime());
            updateUserVipTime(updateVipTime, user.getUserVipInfo());
            //第三步贈送相應的VIP經驗
            if(vipProduct.getVipExpGift() > 0){
                System.out.println("贈送VIP經驗點：" + vipProduct.getVipExpGift());
                updateUserVipExp(vipProduct.getVipExpGift(), user.getUserVipInfo());
                System.out.println("當前VIP等級：" + user.getUserVipInfo().getCurVipLevel());
                System.out.println("當前VIP經驗：" + user.getUserVipInfo().getCurVipExp());
                System.out.println("當前升級到下一級所須要的VIP經驗：" + user.getUserVipInfo().getNextLevelNeedExp());
            }
        }catch(Exception e){
        }finally{
            System.out.println("------------------------購買VIP產品 End----------------------------");
        }
    }
    
    /**
     * 更新用戶VIP的信息
     * @param updateVipExp
     * @param userVipInfo
     */
    @Override
    public void updateUserVipExp(long updateVipExp, UserVipInfo userVipInfo){
        System.out.println("更新用戶VIP經驗信息");
        VipLevelStrategy vipLevelStrategy = userVipInfo.getVipLevelStrategy();
        System.out.println("用戶所使用的VIP等級策略：" + vipLevelStrategy.getClass().getSimpleName());
        long vipExp = vipLevelStrategy.getExpByLevel(userVipInfo.getCurVipLevel(), userVipInfo.getCurVipExp());
        vipExp += updateVipExp;
        long curExp = vipLevelStrategy.getCurExpByVipExp(vipExp);
        int curLevel = vipLevelStrategy.getLevelByExp(vipExp);
        long nextLevelNeedExp = vipLevelStrategy.getNextLevelNeedExp(curLevel, curExp);
        System.out.println("更新前VIP經驗：" + userVipInfo.getCurVipExp());
        System.out.println("更新前VIP等級：" + userVipInfo.getCurVipLevel());
        int curVipLevel = userVipInfo.getCurVipLevel();
        int preVipLevel = userVipInfo.getPreVipLevel();
        if(curLevel != curVipLevel){
            preVipLevel = curVipLevel;
            curVipLevel = curLevel;
        }
        curExp = (curExp < 0)? 0 : curExp;
        nextLevelNeedExp = (nextLevelNeedExp < 0)? 0 : nextLevelNeedExp;
        
        System.out.println("更新後VIP經驗：" + curExp);
        System.out.println("更新後VIP等級：" + curLevel);
        userVipInfo.setCurVipExp(curExp);
        userVipInfo.setNextLevelNeedExp(nextLevelNeedExp);
        userVipInfo.setCurVipLevel(curVipLevel);
        userVipInfo.setPreVipLevel(preVipLevel);
        
    }
    
    /**
     * 更新用戶VIP的信息
     * VIP普通會員（現有VIP普通會員時間大於0）
     * 如何成爲VIP普通會員：購買VIP產品（月卡、季卡、年卡）
     * 延長VIP普通會員時間：= 現有VIP普通會員時間 + 購買VIP產品中配置的時間
     * VIP超級會員（現有VIP超級會員時間大於0）
     * 如何成爲VIP超級會員：現有VIP（普通）會員時間大於60天購買VIP產品（月卡、季卡、年卡），或直接購買VIP產品（季卡、年卡）
     * 延長VIP超級會員時間：
     * 若是現有VIP普通會員時間大於60，則 = 現有VIP普通會員時間 - 60 + 購買VIP產品中配置的時間
     * 若是現有VIP普通會員時間等於0，購買了季卡或年卡，則 = 購買VIP產品中配置的時間 - 60
     * @param updateVipTime
     * @param userVipInfo
     */
    @Override
    public void updateUserVipTime(long updateVipTime, UserVipInfo userVipInfo){
        System.out.println("更新用戶VIP時間信息");
        long curVipEndTime = userVipInfo.getVipEndTime();
        long curSuperVipEndTime = userVipInfo.getSuperVipEndTime();
        long nowTime = DateUtil.getNowTime();
        int updateDays = DateUtil.getDays(updateVipTime);
        System.out.println("購買的VIP卡的天數：" + updateDays);
        //初始化VIP到期時間爲當前時間
        if((curVipEndTime == 0 && curSuperVipEndTime == 0) || curVipEndTime < nowTime){
            curVipEndTime = nowTime;
            curSuperVipEndTime = nowTime;
        }
        System.out.println("更新前VIP普通會員時間：" + DateUtil.format(curVipEndTime));
        System.out.println("更新前VIP超級會員時間：" + DateUtil.format(curSuperVipEndTime));
        //VIP超級會員時間
        //第一種狀況VIP普通會員已過時再購卡的，若是買的是季卡或年卡則增長VIP超級會員時間
        if(curVipEndTime == nowTime && updateDays > 60){
            curSuperVipEndTime = DateUtil.getNDayTimeByNow(updateDays - 60);
        //第二種狀況VIP普通會員未過時再購卡，且VIP普通會員到期時間大於60天
        }else if(DateUtil.getBetweenDays(curVipEndTime) > 60){
            curSuperVipEndTime = curVipEndTime - DateUtil.getTimeByDays(60) + updateVipTime;
        }
        //VIP普通會員時間
        curVipEndTime += updateVipTime;
        
        System.out.println("更新後VIP普通會員時間：" + DateUtil.format(curVipEndTime));
        System.out.println("更新後VIP超級會員時間：" + DateUtil.format(curSuperVipEndTime));
        
        userVipInfo.setVipEndTime(curVipEndTime);
        userVipInfo.setSuperVipEndTime(curSuperVipEndTime);
    }
    
    private long getUpdateVipExp(UserLoginLog loginLog, UserVipInfo userVipInfo){
        long loginTime = new Date().getTime(),//用戶本次登錄時間
            lastLoginTime = loginLog.getLastLoginTime(),//用戶上次登錄時間
            vipEndTime = userVipInfo.getVipEndTime(),//普通VIP結束時間
            superVipEndTime = userVipInfo.getSuperVipEndTime();//超級VIP結束時間
        
        int loginT,vipEndTimeT ,lastVipEndTimeT  ,superVipEndTimeT  ,lastSuperVipEndTimeT ,vipBteweenSuperT;
        //用戶本次登錄與上次登錄時間之差
        loginT = DateUtil.getBetweenDays(loginTime, lastLoginTime);
        //VIP普通會員到期時間與登錄時間之差
        vipEndTimeT  = DateUtil.getBetweenDays(vipEndTime, loginTime);
        //VIP普通會員到期時間與上次登錄時間之差
        lastVipEndTimeT  = DateUtil.getBetweenDays(vipEndTime, lastLoginTime);
        //VIP超級會員到期時間與登錄時間之差
        superVipEndTimeT  = DateUtil.getBetweenDays(superVipEndTime, loginTime);
        //VIP超級會員到期時間與上次登錄時間之差
        lastSuperVipEndTimeT  = DateUtil.getBetweenDays(superVipEndTime, lastLoginTime);
        //VIP普通會員到期時間與VIP超級會員到期時間之差
        vipBteweenSuperT = DateUtil.getBetweenDays(vipEndTime, superVipEndTime);
        
        //計算VIP經驗點
        long vipExp = 0l;
        //上次登錄前VIP已過時
        if(lastVipEndTimeT  < 0){
            vipExp = loginT*VIPEXP_DAY_REMOVE_VALUE*(-1);
        //VIP已過時,上次登錄VIP超級會員已過時
        }else if(vipEndTimeT  < 0 && lastVipEndTimeT  > 0 && lastSuperVipEndTimeT  < 0){
            vipExp = lastVipEndTimeT*COMMON_VIPEXP_DAY_ADD_VALUE + vipEndTimeT*VIPEXP_DAY_REMOVE_VALUE;
        //VIP超級會員、VIP普通會員都已過時
        }else if(vipEndTimeT  < 0 && lastVipEndTimeT  > 0 && superVipEndTimeT  < 0 && lastSuperVipEndTimeT  > 0){
            vipExp = lastSuperVipEndTimeT*SUPER_VIPEXP_DAY_ADD_VALUE + vipBteweenSuperT*COMMON_VIPEXP_DAY_ADD_VALUE + vipEndTimeT*VIPEXP_DAY_REMOVE_VALUE;
        //VIP普通會員未過時，上次登錄前VIP超級會員過時
        }else if(vipEndTimeT  > 0 && lastSuperVipEndTimeT  < 0){
            vipExp = loginT*COMMON_VIPEXP_DAY_ADD_VALUE;
        //VIP超級會員已過時，成爲VIP普通會員
        }else if(vipEndTimeT  > 0 && superVipEndTimeT < 0 && lastSuperVipEndTimeT  > 0){
            vipExp = lastSuperVipEndTimeT*SUPER_VIPEXP_DAY_ADD_VALUE + superVipEndTimeT*COMMON_VIPEXP_DAY_ADD_VALUE*(-1);
        //VIP超級會員
        }else if(lastSuperVipEndTimeT  > 0){
            vipExp = loginT*SUPER_VIPEXP_DAY_ADD_VALUE;
        }
        return vipExp;
    }
    
    public static void main(String[] args) {
        long lastLoginTime = DateUtil.getNDayTimeByNow(-13);
        long vipEndTime = 0l;
        long superVipEndTime = 0l;
        
        UserLoginLog loginLog = new UserLoginLog();
        loginLog.setLastLoginTime(lastLoginTime);
        
        UserVipInfo userVipInfo = new UserVipInfo();
        int type = 6;        
        switch(type){
        case 1:
            //上次登錄前VIP已過時
            vipEndTime = DateUtil.getNDayTimeByNow(-14);
            superVipEndTime = DateUtil.getNDayTimeByNow(-50);
            break;
        case 2:
            //VIP已過時,上次登錄VIP超級會員已過時
            vipEndTime = DateUtil.getNDayTimeByNow(-10);
            superVipEndTime = DateUtil.getNDayTimeByNow(-50);
            break;
        case 3:
            //VIP超級會員、VIP普通會員都已過時
            vipEndTime = DateUtil.getNDayTimeByNow(-5);
            superVipEndTime = DateUtil.getNDayTimeByNow(-10);
            break;
        case 4:
            //VIP普通會員未過時，上次登錄前VIP超級會員過時
            vipEndTime = DateUtil.getNDayTimeByNow(5);
            superVipEndTime = DateUtil.getNDayTimeByNow(-20);
            break;
        case 5:
            //VIP超級會員已過時，成爲VIP普通會員
            vipEndTime = DateUtil.getNDayTimeByNow(20);
            superVipEndTime = DateUtil.getNDayTimeByNow(-5);
            break;
        case 6:
            //VIP超級會員
            vipEndTime = DateUtil.getNDayTimeByNow(10);
            superVipEndTime = DateUtil.getNDayTimeByNow(40);
            break;
        }
        
        userVipInfo.setVipEndTime(vipEndTime);
        userVipInfo.setSuperVipEndTime(superVipEndTime);
        
        VipManagerImpl1 vipManager = new VipManagerImpl1();
        long updateVipExp = vipManager.getUpdateVipExp(loginLog, userVipInfo);
        System.out.println(updateVipExp);
    }
}

package com.game.vip.manager;

import com.game.vip.data.user.User;
import com.game.vip.data.user.UserVipInfo;
import com.game.vip.data.vip.product.VipProduct;

/**
 * @author Administrator
 * vip管理接口
 */
public interface VipManager {

    public static final int COMMON_VIPEXP_DAY_ADD_VALUE = 10;
    public static final int SUPER_VIPEXP_DAY_ADD_VALUE = 15;
    public static final int VIPEXP_DAY_REMOVE_VALUE = 10;
    
    /**
     * 普通用戶轉換成VIP用戶（如充值）
     * @param userVipInfo
     */
    public void userToVipUser(User user);
    
    /**
     * 購買了vip季卡或月卡
     * @param userVipInfo
     * @param vipProduct
     */
    public void buyVipProduct(User user, VipProduct vipProduct);
    
    /**
     * 用戶VIP經驗成長
     * @param loginLog
     * @param userVipInfo
     */
    public void userLogin(User user);
    
    /**
     * 獎勵VIP用戶
     * @param userVipInfo
     */
    public void rewardVipUser(User user);
    
    /**
     * 更新用戶VIP的信息
     * @param updateVipExp
     * @param userVipInfo
     */
    public void updateUserVipExp(long updateVipExp, UserVipInfo userVipInfo);
    
    /**
     * 更新用戶VIP的信息
     * @param updateVipTime
     * @param userVipInfo
     */
    public void updateUserVipTime(long updateVipTime, UserVipInfo userVipInfo);
}

package com.game.vip.strategy.impl;

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

import com.game.vip.data.vip.VipLevelInfo;
import com.game.vip.strategy.VipLevelStrategy;

/**
 * @author Administrator
 * VIP等級經驗段級策略1
 */
public class VipLevelStrategyImpl1 extends VipLevelStrategy{

    public VipLevelStrategyImpl1(List<VipLevelInfo> vipLevelList) {
        super(vipLevelList);
    }

    @Override
    public List<LevelNeedVipExp> initLevelNeedVipExp(
            List<VipLevelInfo> vipLevelList) {
        List<LevelNeedVipExp> list = null;
        long vipExpStart = 0l;
        long vipExpEnd = 0l;
        if(vipLevelList != null && vipLevelList.size()>0){
            list = new ArrayList<LevelNeedVipExp>();
            for(int i = 0, len = vipLevelList.size(); i < len; i++){
                vipExpStart = vipLevelList.get(i).getVipExp();
                vipExpEnd =(i == len-1)? vipLevelList.get(i).getVipExp() :  vipLevelList.get(i+1).getVipExp();
                list.add(new LevelNeedVipExp(i+1, vipExpStart, vipExpEnd));
            }
        }
        return list;
    }

    @Override
    public long getExpByLevel(int vipLevel, long curVipExp) {
        if(curVipExp>0)
            return curVipExp;
        long vipExp = 0l;
        List<VipLevelInfo> vipLevelList = getVipLevelList();
        if(vipLevelList != null && vipLevelList.size()>0){
            for(int i = 0, len = vipLevelList.size(); i < len; i++){
                if(vipLevel == vipLevelList.get(i).getVipLevel()){
                    vipExp = vipLevelList.get(i).getVipExp();
                    break;
                }
            }
        }
        return vipExp;
    }

    @Override
    public long getCurExpByVipExp(long vipExp) {
        return vipExp;
    }

}

package com.game.vip.strategy.impl;

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

import com.game.vip.data.vip.VipLevelInfo;
import com.game.vip.strategy.VipLevelStrategy;

/**
 * @author Administrator
 * VIP等級經驗段級策略2
 */
public class VipLevelStrategyImpl2 extends VipLevelStrategy{

    public VipLevelStrategyImpl2(List<VipLevelInfo> vipLevelList) {
        super(vipLevelList);
    }

    @Override
    public List<LevelNeedVipExp> initLevelNeedVipExp(
            List<VipLevelInfo> vipLevelList) {
        List<LevelNeedVipExp> list = null;
        long vipExpStart = 0l;
        long vipExpEnd = 0l;
        if(vipLevelList != null && vipLevelList.size()>0){
            list = new ArrayList<LevelNeedVipExp>();
            for(int i = 0, len = vipLevelList.size(); i < len; i++){
                vipExpStart = vipExpByLevel(i, vipLevelList);
                vipExpEnd = (i == len-1)? vipExpByLevel(i, vipLevelList) : vipExpByLevel(i+1, vipLevelList);
                list.add(new LevelNeedVipExp(i+1, vipExpStart, vipExpEnd));
            }
        }
        
        return list;
    }

    @Override
    public long getExpByLevel(int vipLevel, long curVipExp) {
        long levelExp = vipExpByLevel(vipLevel, getVipLevelList());
        return levelExp + curVipExp;
    }
    
    private long vipExpByLevel(int level, List<VipLevelInfo> vipLevelList){
        long vipExp = 0l;
        if(vipLevelList != null && vipLevelList.size()>0){
            for(int i = 0, len = vipLevelList.size(); i < len; i++){
                if(level < (i+1)) break;
                vipExp += vipLevelList.get(i).getVipExp();
            }
        }
        return vipExp;
    }

    @Override
    public long getCurExpByVipExp(long vipExp) {
        int level = getLevelByExp(vipExp);
        LevelNeedVipExp levelNeedVipExp = getLevelNeedVipExpByLevel(level);
        if(levelNeedVipExp != null && vipExp >= levelNeedVipExp.getVipExpStart()){
            return vipExp - levelNeedVipExp.getVipExpStart();
        }
        return 0;
    }
}

package com.game.vip.strategy;

import java.util.Collections;
import java.util.List;

import com.game.vip.data.vip.VipLevelInfo;
import com.game.vip.data.vip.VipLevelReward;

/**
 * @author Administrator
 * vip等級策略接口
 */
public abstract class VipLevelStrategy {
    private List<VipLevelReward> rewardList;
    private List<VipLevelInfo> vipLevelList;
    private List<LevelNeedVipExp> levelNeedVipExpList;
    
    public VipLevelStrategy(List<VipLevelInfo> vipLevelList) {
        super();
        this.vipLevelList = vipLevelList;
        this.levelNeedVipExpList = initLevelNeedVipExp(vipLevelList);
        Collections.sort(this.levelNeedVipExpList);
    }

    /**
     * 經過VIP經驗獲取對應的等級
     * @param vipExp
     * @return
     */
    public int getLevelByExp(long vipExp){
        int level = getMinLevel();
        List<LevelNeedVipExp> levelNeedVipExpList = getLevelNeedVipExpList();
        LevelNeedVipExp levelNeedVipExp = null;
        for (int i=0, len = levelNeedVipExpList.size(); i<len; i++) {
            levelNeedVipExp = levelNeedVipExpList.get(i);
            if(vipExp >= levelNeedVipExp.vipExpStart && vipExp < levelNeedVipExp.vipExpEnd){
                level = levelNeedVipExp.level;
                break;
            }else if(i == len-1 && vipExp > levelNeedVipExp.vipExpEnd){
                level = levelNeedVipExp.level;
            }
        }
        return level;
    }
    
    /**
     * 獲取VIP最大等級
     * @return
     */
    public int getMaxLevel(){
        int len = 0;
        List<LevelNeedVipExp> list = getLevelNeedVipExpList();
        len = list.size();
        return list.get(len-1).getLevel();
    }
    
    /**
     * 獲取VIP最小等級
     * @return
     */
    public int getMinLevel(){
        int len = 0;
        List<LevelNeedVipExp> list = getLevelNeedVipExpList();
        len = list.size();
        return len > 0? list.get(0).getLevel() : 1;
    }
    
    /**
     * 是否升級
     * @param curLevel
     * @param curVipExp
     * @return
     */
    public boolean isGrowUp(int curLevel, long curVipExp){
        long vipExp = getExpByLevel(curLevel, curVipExp);
        int vipLevel = getLevelByExp(vipExp);
        return vipLevel != curLevel;
    }
    
    /**
     * 升級到下一級所需的VIP經驗
     * @param curVipLevel
     * @param curVipExp
     * @return
     */
    public long getNextLevelNeedExp(int curVipLevel, long curVipExp) {
        long vipExp = getExpByLevel(curVipLevel, curVipExp);
        long nextLevelExp = getExpByLevel(curVipLevel+1, 0l);
        return nextLevelExp - vipExp;
    }
    
    /**
     * 經過VIP等級獲取LevelNeedVipExp
     * @param level
     * @return
     */

    public LevelNeedVipExp getLevelNeedVipExpByLevel(int level){
        List<LevelNeedVipExp> list = getLevelNeedVipExpList();
        for(LevelNeedVipExp item : list){
            if(level == item.getLevel()){
                return item;
            }
        }
        return null;
    }
    
    /**
     * 根據VIP等級獲取相應的獎勵
     * @param level
     * @return
     */
    public VipLevelReward getLevelReward(int level){
        List<VipLevelReward> list = getRewardList();
        if(list == null || list.size() == 0)
            return null;
        for(VipLevelReward reward : list){
            if(reward.getVipLevel() == level){
                return reward;
            }
        }
        return null;
    }
    /**
     * 經過總VIP經驗獲取當前等級所對應剩餘經驗
     * @param vipExp
     * @return
     */
    public abstract long getCurExpByVipExp(long vipExp);
    /**
     * 經過VIP等級和當前VIP經驗獲取總VIP經驗
     * @param vipLevel
     * @param curVipExp
     * @return
     */
    public abstract long getExpByLevel(int vipLevel, long curVipExp);
    
    /**
     * @param vipLevelList
     * @return
     */
    public abstract List<LevelNeedVipExp> initLevelNeedVipExp(List<VipLevelInfo> vipLevelList); 
    
    /**
     * @author Administrator
     * 每一個等級所對應的vip經驗區段
     */
    public static class LevelNeedVipExp implements Comparable<LevelNeedVipExp>{
        private int level;
        private long vipExpStart;
        private long vipExpEnd;
        
        public LevelNeedVipExp(int level, long vipExpStart, long vipExpEnd) {
            super();
            this.level = level;
            this.vipExpStart = vipExpStart;
            this.vipExpEnd = vipExpEnd;
        }
        
        public int getLevel() {
            return level;
        }
        public void setLevel(int level) {
            this.level = level;
        }
        public long getVipExpStart() {
            return vipExpStart;
        }
        public void setVipExpStart(long vipExpStart) {
            this.vipExpStart = vipExpStart;
        }
        public long getVipExpEnd() {
            return vipExpEnd;
        }
        public void setVipExpEnd(long vipExpEnd) {
            this.vipExpEnd = vipExpEnd;
        }

        @Override
        public int compareTo(LevelNeedVipExp o) {
            return this.level-o.level;
        }
    }

    public List<VipLevelInfo> getVipLevelList() {
        return vipLevelList;
    }

    public List<LevelNeedVipExp> getLevelNeedVipExpList() {
        return levelNeedVipExpList;
    }

    public List<VipLevelReward> getRewardList() {
        return rewardList;
    }

    public void setRewardList(List<VipLevelReward> rewardList) {
        this.rewardList = rewardList;
    }
}

package com.game.vip.test;

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

import com.game.vip.data.user.User;
import com.game.vip.data.user.UserLoginLog;
import com.game.vip.data.user.UserVipInfo;
import com.game.vip.data.vip.VipLevelInfo;
import com.game.vip.data.vip.VipLevelReward;
import com.game.vip.data.vip.product.VipProduct;
import com.game.vip.manager.VipManager;
import com.game.vip.manager.impl.VipManagerImpl1;
import com.game.vip.strategy.VipLevelStrategy;
import com.game.vip.strategy.impl.VipLevelStrategyImpl1;
import com.game.vip.util.DateUtil;

/**
 * @author Administrator
 * 測試類
 */
public class VipTest {

    public static void main(String[] args) {
        VipManager vipManager = new VipManagerImpl1();
        
        User user = initUser();
        
        List<VipProduct> productList = initVipProduct();
        //購買VIP卡[i = 0：月卡；i = 1：季卡；i = 2：年卡]
        vipManager.buyVipProduct(user, productList.get(1));
        user.getUserLoginLog().setLastLoginTime(new Date().getTime());
        
        //1: 上次登錄前VIP已過時
        //2: VIP已過時,上次登錄VIP超級會員已過時
        //3: VIP超級會員、VIP普通會員都已過時
        //4: VIP普通會員未過時，上次登錄前VIP超級會員過時
        //5: VIP超級會員已過時，成爲VIP普通會員
        //6: VIP超級會員
        int type = 1;
        updateUserVipInfo(user, type);
        //登錄
        vipManager.userLogin(user);
        
        //獎勵
        vipManager.rewardVipUser(user);
    }
    
    public static List<VipLevelInfo> initVipLevelInfo(){
        List<VipLevelInfo> list = new ArrayList<VipLevelInfo>();
        list.add(new VipLevelInfo(1, 0));
        list.add(new VipLevelInfo(2, 16));
        list.add(new VipLevelInfo(3, 68));
        list.add(new VipLevelInfo(4, 158));
        list.add(new VipLevelInfo(5, 618));
        list.add(new VipLevelInfo(6, 1236));
        list.add(new VipLevelInfo(7, 2472));
        return list;
    }
    
    public static List<VipProduct> initVipProduct(){
        List<VipProduct> list = new ArrayList<VipProduct>();
        list.add(new VipProduct(1, "月卡", 30, 10));
        list.add(new VipProduct(1, "季卡", 90, 30));
        list.add(new VipProduct(1, "年卡", 360, 50));
        return list;
    }
    
    public static List<VipLevelReward> initVipLevelReward(){
        List<VipLevelReward> list = new ArrayList<VipLevelReward>();
        list.add(new VipLevelReward(1, "1級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(2, "2級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(3, "3級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(4, "4級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(5, "5級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(6, "6級VIP等級獎勵", "獎勵"));
        list.add(new VipLevelReward(7, "7級VIP等級獎勵", "獎勵"));
        return list;
    }
    
    public static User initUser(){
        User user = new User();
        user.setUserId(1l);
        user.setName("小學生三號");
        
        //登錄日誌
        UserLoginLog loginLog = new UserLoginLog();
        loginLog.setUserId(user.getUserId());
        //13天以前登錄了
        loginLog.setLastLoginTime(DateUtil.getNDayTimeByNow(-13));

        //用戶VIP信息
        UserVipInfo userVipInfo = new UserVipInfo();
        userVipInfo.setUserId(user.getUserId());
        List<VipLevelInfo> vipLevelList = initVipLevelInfo();
        VipLevelStrategy vipLevelStrategy1 = new VipLevelStrategyImpl1(vipLevelList);
//        VipLevelStrategy vipLevelStrategy2 = new VipLevelStrategyImpl2(vipLevelList);
        
        //設置VIP等級獎勵
        vipLevelStrategy1.setRewardList(initVipLevelReward());
        //設置VIP等級策略
        userVipInfo.setVipLevelStrategy(vipLevelStrategy1);
        
        user.setUserLoginLog(loginLog);
        user.setUserVipInfo(userVipInfo);
        
        return user;
    }
    
    public static void updateUserVipInfo(User user, int type){
        System.out.println("=========================");
        long lastLoginTime = DateUtil.getNDayTimeByNow(-13);
        long vipEndTime = 0l;
        long superVipEndTime = 0l;
        
        UserLoginLog loginLog = user.getUserLoginLog();
        loginLog.setLastLoginTime(lastLoginTime);
        
        UserVipInfo userVipInfo = user.getUserVipInfo();
        switch(type){
        case 1:
            //上次登錄前VIP已過時
            System.out.println("更新類型：上次登錄前VIP已過時！");
            vipEndTime = DateUtil.getNDayTimeByNow(-14);
            superVipEndTime = DateUtil.getNDayTimeByNow(-50);
            break;
        case 2:
            //VIP已過時,上次登錄VIP超級會員已過時
            System.out.println("更新類型：VIP已過時,上次登錄VIP超級會員已過時！");
            vipEndTime = DateUtil.getNDayTimeByNow(-10);
            superVipEndTime = DateUtil.getNDayTimeByNow(-50);
            break;
        case 3:
            //VIP超級會員、VIP普通會員都已過時
            System.out.println("更新類型：VIP超級會員、VIP普通會員都已過時！");
            vipEndTime = DateUtil.getNDayTimeByNow(-5);
            superVipEndTime = DateUtil.getNDayTimeByNow(-10);
            break;
        case 4:
            //VIP普通會員未過時，上次登錄前VIP超級會員過時
            System.out.println("更新類型：VIP普通會員未過時，上次登錄前VIP超級會員過時！");
            vipEndTime = DateUtil.getNDayTimeByNow(5);
            superVipEndTime = DateUtil.getNDayTimeByNow(-20);
            break;
        case 5:
            //VIP超級會員已過時，成爲VIP普通會員
            System.out.println("更新類型：VIP超級會員已過時，成爲VIP普通會員！");
            vipEndTime = DateUtil.getNDayTimeByNow(20);
            superVipEndTime = DateUtil.getNDayTimeByNow(-5);
            break;
        case 6:
            //VIP超級會員
            System.out.println("更新類型：VIP超級會員！");
            vipEndTime = DateUtil.getNDayTimeByNow(10);
            superVipEndTime = DateUtil.getNDayTimeByNow(40);
            break;
        }
        System.out.println("更新上次登錄時間爲：" + DateUtil.format(lastLoginTime));
        System.out.println("更新VIP普通會員到期時間爲：" + DateUtil.format(vipEndTime));
        System.out.println("更新VIP超級會員到期時間爲：" + DateUtil.format(superVipEndTime));
        userVipInfo.setVipEndTime(vipEndTime);
        userVipInfo.setSuperVipEndTime(superVipEndTime);
        System.out.println("=========================");
    }
}

package com.game.vip.util;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

public class DateUtil {

    public static final long ONE_DAY_TIME = 24*60*60*1000; 
    /**
     * 獲取指定日期凌晨的時間
     * @param time
     * @return
     */
    public static long getZeroHourTimeOfDay(long time){
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(time);
        int y = calendar.get(Calendar.YEAR);
        int m = calendar.get(Calendar.MONTH);
        int d = calendar.get(Calendar.DATE);
        calendar.clear();
        calendar.set(y,m,d);
        return calendar.getTimeInMillis();
    }
    
    public static Date getWeekFristDay() {
        Calendar c = new GregorianCalendar();
        c.setFirstDayOfWeek(Calendar.SUNDAY);
        c.setTime(new Date());
        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); 
        return c.getTime();
    }
    
    /**
     * 過去下個星期幾的時間
     * 如獲取下個星期一的9：30的時間：getTimeOfNextWeekByTime(1, 9,30,0)
     * @param day 星期數【1：一；2：二；3：三；4：四；5：五；6：六；0：日】
     * @param hour 
     * @param minute
     * @param second
     * @return
     */
    public static Date getTimeOfWeekByTime(int day, int hour,int minute,int second){
        Date curWeekFirstDay = getWeekFristDay();
        Calendar c = Calendar.getInstance();
        c.setTime(curWeekFirstDay);
        //對應星期幾就加幾天
        c.add(Calendar.DAY_OF_WEEK, day);
        c.set(Calendar.HOUR_OF_DAY, hour);
        c.set(Calendar.MINUTE, minute);
        c.set(Calendar.SECOND, second);
        return c.getTime();
    }
    
    /**
     * 過去下個星期幾的時間
     * 如獲取下個星期一的9：30的時間：getTimeOfNextWeekByTime(1, 9,30,0)
     * @param day 星期數【1：一；2：二；3：三；4：四；5：五；6：六；0：日】
     * @param hour 
     * @param minute
     * @param second
     * @return
     */
    public static Date getTimeOfNextWeekByTime(int day, int hour,int minute,int second){
        Date curWeekFirstDay = getWeekFristDay();
        Calendar c = Calendar.getInstance();
        c.setTime(curWeekFirstDay);
        //下一週加七天
        c.add(Calendar.DAY_OF_WEEK, 7);
        //對應星期幾就加幾天
        c.add(Calendar.DAY_OF_WEEK, day);
        c.set(Calendar.HOUR_OF_DAY, hour);
        c.set(Calendar.MINUTE, minute);
        c.set(Calendar.SECOND, second);
        return c.getTime();
    }
    
    public static Date getMonthFirstDay() {
        Calendar c = new GregorianCalendar();
        c.setTime(new Date());
        c.set(Calendar.DAY_OF_MONTH, 1); 
        return c.getTime();
    }

    public static Date getYearFirstDay() {
        Calendar c = new GregorianCalendar();
        c.setTime(new Date());
        c.set(Calendar.DAY_OF_YEAR, 1); 
        return c.getTime();
    }
    
    public static long getNowTime()
    {
        Calendar c = Calendar.getInstance();
        int y = c.get(Calendar.YEAR);
        int m = c.get(Calendar.MONTH);
        int d = c.get(Calendar.DATE);
        c.clear();
        c.set(y, m, d);
        return c.getTimeInMillis();
    }
    
    public static long getDayTime(long time){
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(time);
        int y = c.get(Calendar.YEAR);
        int m = c.get(Calendar.MONTH);
        int d = c.get(Calendar.DATE);
        c.clear();
        c.set(y, m, d);
        return c.getTimeInMillis();
    }
    public static long getYesterdayTime()
    {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, -1);
        int y = c.get(Calendar.YEAR);
        int m = c.get(Calendar.MONTH);
        int d = c.get(Calendar.DATE);
        c.clear();
        c.set(y, m, d);
        return c.getTimeInMillis();
    }
    
    public static long getNDayTimeByNow(int n)
    {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, n);
        int y = c.get(Calendar.YEAR);
        int m = c.get(Calendar.MONTH);
        int d = c.get(Calendar.DATE);
        c.clear();
        c.set(y, m, d);
        return c.getTimeInMillis();
    }
    
    public static int getDateNumByNow(){
        Calendar c = Calendar.getInstance();
        int y = c.get(Calendar.YEAR);
        int m = c.get(Calendar.MONTH)+1;
        int d = c.get(Calendar.DATE);
        String mStr = m+"";
        String dStr = d+"";
        if(m<10){
            mStr = "0"+m;
        }
        if(d<10){
            dStr = "0"+d;
        }
        String num = y+mStr+dStr;
        return Integer.parseInt(num);
    }
    
    
    /**
     * 獲取兩個時間相差的天數
     * @param time1
     * @param time2
     * @return
     */
    public static int getBetweenDays(long time1, long time2){
//        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        long ztime1 = getZeroHourTimeOfDay(time1);
        long ztime2 = getZeroHourTimeOfDay(time2);
//        System.out.println(dateFormat.format(time1));
//        System.out.println(dateFormat.format(ztime1));
//        System.out.println(dateFormat.format(time2));
//        System.out.println(dateFormat.format(ztime2));
        return (int) ((ztime1 - ztime2)/ONE_DAY_TIME);
    }
    
    /**
     * 
     * @param time
     * @return
     */
    public static int getBetweenDays(long time){
        return (int) ((getZeroHourTimeOfDay(time) - getZeroHourTimeOfDay(new Date().getTime()))/ONE_DAY_TIME);
    }
    
    /**
     * 根據時間段獲取天數
     * @param time
     * @return
     */
    public static int getDays(long time){
        return (int) (time/ONE_DAY_TIME);
    }
    
    /**
     * 根據天數獲取對應天數的時間
     * @param days
     * @return
     */
    public static long getTimeByDays(int days){
        return days*ONE_DAY_TIME;
    }
    
    /**
     * 格式化時間
     * yyyy-MM-dd HH:mm:ss
     * @param time
     * @return
     */
    public static String format(Object time){
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return dateFormat.format(time);
    }
    public static void main(String[] args) {
//        Date date = new Date();
////        long time = date.getTime();
//        long time1 = 1375127200200l;
//        long time2 = 1374029202000l;
////        System.out.println(ONE_DAY_TIME);
////        System.out.println(getZeroHourTimeOfDay(time));
////        System.out.println(new Date(getZeroHourTimeOfDay(time)));
//        System.out.println("time1:" + new Date(time1));
//        System.out.println("time2:" + new Date(time2));
//        System.out.println(getBetweenDays(time1, time2));
//        System.out.println(getBetweenDays(time1));
        
        System.out.println(getDays(6*ONE_DAY_TIME));
    }
}

測試輸出

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：上次登錄前VIP已過時！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-07-17 00:00:00
更新VIP超級會員到期時間爲：2013-06-11 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-07-17 00:00:00
VIP超級會員到期時間：2013-06-11 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：-130
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：0
更新後VIP等級：1
當前VIP等級：1
當前VIP經驗：0
當前升級到下一級所須要的VIP經驗：16
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶不是VIP用戶或VIP已過時！
------------------------獎勵VIP用戶 End----------------------------

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：VIP已過時,上次登錄VIP超級會員已過時！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-07-21 00:00:00
更新VIP超級會員到期時間爲：2013-06-11 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-07-21 00:00:00
VIP超級會員到期時間：2013-06-11 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：-70
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：0
更新後VIP等級：1
當前VIP等級：1
當前VIP經驗：0
當前升級到下一級所須要的VIP經驗：16
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶不是VIP用戶或VIP已過時！
------------------------獎勵VIP用戶 End----------------------------

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：VIP超級會員、VIP普通會員都已過時！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-07-26 00:00:00
更新VIP超級會員到期時間爲：2013-07-21 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-07-26 00:00:00
VIP超級會員到期時間：2013-07-21 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：45
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：75
更新後VIP等級：3
當前VIP等級：3
當前VIP經驗：75
當前升級到下一級所須要的VIP經驗：83
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶不是VIP用戶或VIP已過時！
------------------------獎勵VIP用戶 End----------------------------

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：VIP普通會員未過時，上次登錄前VIP超級會員過時！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-08-05 00:00:00
更新VIP超級會員到期時間爲：2013-07-11 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-08-05 00:00:00
VIP超級會員到期時間：2013-07-11 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：130
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：160
更新後VIP等級：4
當前VIP等級：4
當前VIP經驗：160
當前升級到下一級所須要的VIP經驗：458
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶：小學生三號
VIP等級：4
獲取VIP獎勵：4級VIP等級獎勵(獎勵)
------------------------獎勵VIP用戶 End----------------------------

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：VIP超級會員已過時，成爲VIP普通會員！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-08-20 00:00:00
更新VIP超級會員到期時間爲：2013-07-26 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-08-20 00:00:00
VIP超級會員到期時間：2013-07-26 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：170
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：200
更新後VIP等級：4
當前VIP等級：4
當前VIP經驗：200
當前升級到下一級所須要的VIP經驗：418
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶：小學生三號
VIP等級：4
獲取VIP獎勵：4級VIP等級獎勵(獎勵)
------------------------獎勵VIP用戶 End----------------------------

------------------------購買VIP產品 Start----------------------------
普通會員轉成VIP會員
更新用戶VIP時間信息
購買的VIP卡的天數：90
更新前VIP普通會員時間：2013-07-31 00:00:00
更新前VIP超級會員時間：2013-07-31 00:00:00
更新後VIP普通會員時間：2013-10-29 00:00:00
更新後VIP超級會員時間：2013-08-30 00:00:00
贈送VIP經驗點：30
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：0
更新前VIP等級：1
更新後VIP經驗：30
更新後VIP等級：2
當前VIP等級：2
當前VIP經驗：30
當前升級到下一級所須要的VIP經驗：38
------------------------購買VIP產品 End----------------------------
=========================
更新類型：VIP超級會員！
更新上次登錄時間爲：2013-07-18 00:00:00
更新VIP普通會員到期時間爲：2013-08-10 00:00:00
更新VIP超級會員到期時間爲：2013-09-09 00:00:00
=========================
------------------------用戶登錄 Start----------------------------
當前用戶：小學生三號
當前VIP等級：2
當前VIP經驗：30
VIP普通會員到期時間：2013-08-10 00:00:00
VIP超級會員到期時間：2013-09-09 00:00:00
當前升級到下一級所須要的VIP經驗：38
上次登錄時間：2013-07-18 00:00:00
更新VIP信息
VIP經驗成長值：195
更新用戶VIP經驗信息
用戶所使用的VIP等級策略：VipLevelStrategyImpl1
更新前VIP經驗：30
更新前VIP等級：2
更新後VIP經驗：225
更新後VIP等級：4
當前VIP等級：4
當前VIP經驗：225
當前升級到下一級所須要的VIP經驗：393
------------------------用戶登錄 End----------------------------
------------------------獎勵VIP用戶 Start----------------------------
當前用戶：小學生三號
VIP等級：4
獲取VIP獎勵：4級VIP等級獎勵(獎勵)
------------------------獎勵VIP用戶 End----------------------------