APP版本控制问题

现在很多公司APP版本不断迭代，需要兼容旧版本，有了版本控制。

升级版本，我们可以添加新接口进行支持，但是，如果改动较小，只需要传入版本号，进行版本控制。

但是当版本数量较多，老版的使用率极低，没必要做兼容，减少维护成本，我们需要进行强制升级。

强制升级的版本做成可控制的，方便后台操作；

强制升级，字段定义，版本号，版本状态，平台

UpgradeStatus: " + appVersionBean.getUpgrade_status() + " FirstChannel: " + appVersionBean.getFirst_channel() + " LvVersion: " + appVersionBean.getLv_version()

增加强制升级拦截器：

package com.lvtu.service.api.rop.intercept;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONObject;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts2.ServletActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;

import com.lvmama.allin.common.services.updateversion.UpgradeVersionInfoService;
import com.lvmama.allin.po.updatedversion.AppVersionBean;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;

/**
 * 强制升级拦截
 * iPhone&Android≤V5.3.1
 * iPad≤V2.3.0
 * WP≤V1.2
 *
 */
public class ForceUpgradeInterceptor extends AbstractInterceptor {
    
    private static final Log logger = LogFactory.getLog(ForceUpgradeInterceptor.class);

    private static final long serialVersionUID = 5281673513519486408L;
    
    private static Map<String, Object> upgradeVersionInfoServiceCache = new HashMap<String, Object>();
    
    @Autowired
    private UpgradeVersionInfoService upgradeVersionInfoService;
    
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        AppVersionBean appVersionBean = getUpgradeInfo();
        if(appVersionBean != null) {
            Map<String,Object> resultMap = new HashMap<String,Object>();
            resultMap.put("code","-1");
            resultMap.put("errorMessage", appVersionBean.getContent_text());
            resultMap.put("message", appVersionBean.getContent_text());
            this.sendAjaxResultByJson(resultMap);
            return null;
        }
        return invocation.invoke();
    }
    
    private AppVersionBean getUpgradeInfo() {
        String uri = this.getRequest().getRequestURI();
        if(StringUtils.isBlank(uri) || !uri.contains("router")){
            return null;
        }
        String lvversion = this.getRequest().getParameter("lvversion");
        String firstChannel = this.getRequest().getParameter("firstChannel");
        if(StringUtils.isBlank(lvversion) || StringUtils.isBlank(firstChannel)){
            return null;
        }
        @SuppressWarnings("unchecked")
        List<AppVersionBean> appVersionBeanList = (List<AppVersionBean>) upgradeVersionInfoServiceCache.get("data");
        try {
            if(appVersionBeanList == null) {
                appVersionBeanList = upgradeVersionInfoService.selectUpgradeListByParams();
                upgradeVersionInfoServiceCache.put("data", appVersionBeanList);
                upgradeVersionInfoServiceCache.put("date", new Date().getTime());
                logger.debug("强制升级，初始化强制升级信息！");
            }
            long time = (Long) upgradeVersionInfoServiceCache.get("date");
            if(new Date().getTime() > 1000*60 + time) {
                appVersionBeanList = upgradeVersionInfoService.selectUpgradeListByParams();
                upgradeVersionInfoServiceCache.put("data", appVersionBeanList);
                upgradeVersionInfoServiceCache.put("date", new Date().getTime());
                logger.debug("强制升级，缓存到期，刷新缓存！");
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return null;
        }
        if(CollectionUtils.isEmpty(appVersionBeanList)) {
            logger.debug("强制升级，从CMS获取数据为空，不进行强制升级校验");
            return null;
        }
        int version = Integer.valueOf(lvversion.replace(".", "").trim());
        for (AppVersionBean appVersionBean : appVersionBeanList) {
            if(logger.isDebugEnabled()) {
                logger.debug("强制升级，UpgradeStatus: " + appVersionBean.getUpgrade_status() + " FirstChannel: " + appVersionBean.getFirst_channel() + " LvVersion: " + appVersionBean.getLv_version());
            }
            // 需要升级的版本
            int upgradeVersion = Integer.valueOf(appVersionBean.getLv_version().replace(".", "").trim());
            if("Y".equals(appVersionBean.getUpgrade_status())) {
                if(firstChannel.equalsIgnoreCase(appVersionBean.getFirst_channel()) && upgradeVersion >= version) {
                    return appVersionBean;
                }
            }
        }
        return null;
    }
    
    /**
     * 发送Ajax请求结果json
     *
     * @throws ServletException
     * @throws IOException
     */
    public void sendAjaxResultByJson(Map<String,Object> resultMap) {
        this.getResponse().setContentType("application/json;charset=UTF-8");
        this.getResponse().setCharacterEncoding("UTF-8");
        try {
            PrintWriter out = this.getResponse().getWriter();
            JSONObject jsonObj = JSONObject.fromObject(resultMap);
            out.write(jsonObj.toString());
            out.flush();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取HttpRequest
     *
     * @return
     */
    private HttpServletRequest getRequest() {
        return ServletActionContext.getRequest();
    }
    
    private HttpServletResponse getResponse() {
        return ServletActionContext.getResponse();
    }
}

由于版本数量较多，我们需要进行版本的统一管理，需要统一一套枚举，及比较工具，

eg：

package com.lvtu.csa.framework.utils.version;

import org.springframework.util.Assert;

/**
 * 版本判断辅助类
 */
public class VersionHelper {

    public static boolean gt(EnumVersion left, EnumVersion right) {
        Assert.notNull(left, "版本号判断左边参数为空");
        Assert.notNull(right, "版本号判断右边参数为空");

        return left.getCode() > right.getCode();
    }

    public static boolean lt(EnumVersion left, EnumVersion right) {
        Assert.notNull(left, "版本号判断左边参数为空");
        Assert.notNull(right, "版本号判断右边参数为空");

        return left.getCode() < right.getCode();
    }

    public static boolean gte(EnumVersion left, EnumVersion right) {
        Assert.notNull(left, "版本号判断左边参数为空");
        Assert.notNull(right, "版本号判断右边参数为空");

        return left.getCode() >= right.getCode();
    }

    public static boolean lte(EnumVersion left, EnumVersion right) {
        Assert.notNull(left, "版本号判断左边参数为空");
        Assert.notNull(right, "版本号判断右边参数为空");

        return left.getCode() <= right.getCode();
    }

    public static boolean eq(EnumVersion left, EnumVersion right) {
        Assert.notNull(left, "版本号判断左边参数为空");
        Assert.notNull(right, "版本号判断右边参数为空");

        return left.getCode() == right.getCode();
    }

    public static void main(String[] args) {
        System.out.println(VersionHelper.gte(EnumVersion.V132, EnumVersion.UNKNOWN));
        System.out.println(VersionHelper.lt(EnumVersion.V793, EnumVersion.INFINITY));
        System.out.println(VersionHelper.lte(EnumVersion.V780, EnumVersion.V782));
        System.out.println(VersionHelper.lte(EnumVersion.V784, EnumVersion.V784));
        System.out.println(VersionHelper.gte(EnumVersion.V790, EnumVersion.V790));
        System.out.println(VersionHelper.gt(EnumVersion.V792, EnumVersion.V790));
    }

}

package com.lvtu.csa.framework.utils.version;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

/**
 * APP版本
 */
public enum EnumVersion {

    UNKNOWN(0),
    V100(10000), V110(10100), V120(10200), V130(10300), V131(10301), V132(10302),
    V200(20000), V210(20100),
    V300(30000),
    V400(40000),
    V500(50000), V510(50100), V520(50200), V521(50201), V530(50300), V531(50301),
    V600(60000), V610(60100), V611(60101), V620(60200), V630(60300), V631(60301), V632(60302),
    V700(70000), V701(70001), V710(70100), V715(70105), V720(70200), V730(70300), V731(70301), V732(70302), V740(70400), V741(70401), V742(70402),
    V750(70500), V760(70600), V761(70601), V762(70602), V763(70603),
    V770(70700), V771(70701), V772(70702), V773(70703),
    V780(70800), V781(70801), V782(70802), V783(70803), V784(70804), V785(70805),
    V790(70900), V791(70901), V792(70902), V793(70903), V794(70904), V795(70905),
    INFINITY(Integer.MAX_VALUE);

    private final int code;

    EnumVersion(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public static EnumVersion create(String lvversion) {
        if (StringUtils.isBlank(lvversion)) {
            return EnumVersion.UNKNOWN;
        }

        String[] split = lvversion.split("\\.");
        int code = 0;
        int level = 2;
        for (String term : split) {
            if (!NumberUtils.isDigits(term)) {
                return EnumVersion.UNKNOWN;
            }

            if (level < 0) break;

            code += Integer.parseInt(term) * Math.pow(100, level);
            level--;
        }

        EnumVersion version = getByCode(code);
        if (version == null) {
            return EnumVersion.UNKNOWN;
        }

        return version;
    }

    private static EnumVersion getByCode(int code) {
        for (EnumVersion version : EnumVersion.values()) {
            if (code == version.getCode()) {
                return version;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println(EnumVersion.create("7.8.4").toString());
    }

}