游戏中VIP会员模块的简单实现

哈哈  今天周末有时间，再整理一篇博文上来，虽然已经不做游戏老长时间了，但还是要把以前做过的东西总结一下，借此可以回顾以前的东西，也可以分享给大家。

今天说一下游戏中VIP会员模块的实现思路。每款游戏的消费体系中必不可缺少的一个模块就是VIP，VIP用户可以获得额外的奖励，比如每日登陆奖励，游戏中各个功能针对VIP和普通用户都有所差异，这样可以使游戏运作更加良好，如果一款商业游戏不赚钱，那么这款游戏的路肯定不好走。本文的VIP模块的类似于QQ会员的成长体系，大家可去QQ会员网站中看看。

接下来进入正题：

成长体系图

VIP经验等级成长方案

VIP经验等级成长方案配置表1				VIP经验等级成长方案配置表2
VIP等级	VIP经验	VIP经验区段		VIP等级	VIP经验	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----------------------------

哈哈  求代码的童鞋 发个评论留个邮箱 我发代码到邮箱中

透露下 哈 下一期打算写 游戏中竞技场或爬塔的实现 哈哈 敬请期待哦