分布式框架灰度发布实现

userId match 19767 , 16852 , 16695 => ip"10.100.226.227" 
otherwise => ip"10.100.45.116"

    /**
     * 根据host连接zk
     *
     * @param host
     * @return
     * @throws Exception
     */
    public static ZooKeeper createZkByHost(String host) throws Exception {
        CountDownLatch semaphore = new CountDownLatch(1);
        ZooKeeper zkClient = null;
        try {
            /*
             * ZooKeeper客户端和服务器会话的建立是一个异步的过程
             * 构造函数在处理完客户端的初始化工作后立即返回，在大多数情况下，并没有真正地建立好会话
             * 当会话真正创建完毕后，Zookeeper服务器会向客户端发送一个事件通知
             */
            zkClient = new ZooKeeper(host, 500, (event) -> {
                LOGGER.info("waiting  连接 Zk ....");
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    semaphore.countDown();
                }
            });
            LOGGER.info("build zk connect state1[{}]...", zkClient.getState());
            //semaphore.await();
            semaphore.await(1000, TimeUnit.MILLISECONDS);
            LOGGER.info("build zk connect state2[{}]...", zkClient.getState());
            LOGGER.info("build zk connect on [{}]...", host);
        } catch (Exception e) {
            LOGGER.info(e.getMessage(), e);
        }
        if (Objects.nonNull(zkClient) && zkClient.getState() == CONNECTED) {
            return zkClient;
        } else {
            if (zkClient != null) {
                zkClient.close();
            }
            LOGGER.info("ZK build connect on [{}] failed ...", host);
            throw new Exception("ZK build connect on [" + host + "] failed ...");
        }
    }

/**
     * 执行发布（服务）
     *
     * @param cid
     * @throws Exception
     */
    private void processPublish(String host, ConfigInfoDto cid) throws Exception {
        ZooKeeper zk = createZkByHost(host);
        String service = cid.getServiceName();

        String routerConfig = "userId match 19767 , 16852 , 16695 => ip\"10.100.226.227\" \n" +
        "otherwise => ip\"10.100.45.116\"";

        // 路由 
        ZkUtil.createData(zk, "/soa/config/routes/" + service,routerConfig); 

        ZkUtil.closeZk(zk); 
    }

import com.github.dapeng.core.InvocationContext;
import com.github.dapeng.core.InvocationContextImpl;
import com.github.dapeng.core.SoaException;
import com.github.dapeng.core.helper.DapengUtil;
import com.github.dapeng.core.helper.SoaSystemEnvProperties;
import com.github.dapeng.openapi.utils.PostUtil;
import com.today.api.admin.enums.StaffManagerEnum;
import com.today.domain.LoginUser;
import com.today.domain.ResponseData;
import com.today.enums.ResponseStatus;
import com.today.soa.idgen.IDServiceClient;
import com.today.soa.idgen.domain.GenIDRequest;
import com.today.util.JSONUtil;
import com.today.util.UserSessionHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.stream.Collectors;

/**
 * @author ever
 * @date 2018-01-29
 */
@RestController
@RequestMapping("api")
public class OpenApiController {
    private Logger logger = LoggerFactory.getLogger(OpenApiController.class);
    private IDServiceClient idServiceClient = new IDServiceClient();
    private final static String BARCODE = "sku_barcode";

    @PostMapping(value = "{service}/{version}/{method}")
    @ResponseBody
    public String rest(@PathVariable(value = "service") String service,
                       @PathVariable(value = "version") String version,
                       @PathVariable(value = "method") String method,
                       @RequestParam(value = "parameter") String parameter,
                       HttpServletRequest req) {
        try {
            InvocationContext invocationContext = InvocationContextImpl.Factory.currentInstance();
            String sessionTid = invocationContext.sessionTid().map(DapengUtil::longToHexStr).orElse("0");
            MDC.put(SoaSystemEnvProperties.KEY_LOGGER_SESSION_TID, sessionTid);
            //接口鉴权
            LoginUser loginUser = UserSessionHelper.getCurrentLoginUser();

            if(loginUser.getManager() == StaffManagerEnum.SUPPER_MANAGER){ //超级管理员 不鉴权
                return PostUtil.post(service, version, method, parameter, req);
            }else{
                String serviceCode = service.substring(service.lastIndexOf(".")+1);
                logger.info("检测权限code"+serviceCode+"."+method + "===="+loginUser.getPermissionList().size());
                boolean bool = loginUser.getPermissionList().stream().
                        filter(item -> (serviceCode+"."+method).equals(item.code)).collect(Collectors.toList()).isEmpty();
                if(!bool){
                    return PostUtil.post(service, version, method, parameter, req);
                }else{
                    ResponseData responseData = new ResponseData();
                    responseData.setStatus(ResponseStatus.NO_PERMISSION);
                    responseData.setResponseMsg("["+serviceCode+"."+method+"]权限不足");
                    return JSONUtil.toJson(responseData);
                }
            }
        } finally {
            MDC.remove(SoaSystemEnvProperties.KEY_LOGGER_SESSION_TID);
        }
    }
}

public static String post(String service, String version, String method, String parameter, HttpServletRequest req, boolean clearInvocationContext) {
        InvocationContextImpl invocationCtx = (InvocationContextImpl)createInvocationCtx(service, version, method, req);
        OptimizedService bizService = ServiceCache.getService(service, version);
        if (bizService == null) {
            LOGGER.error("bizService not found[service:" + service + ", version:" + version + "]");
            return String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", SoaCode.NoMatchedService.getCode(), SoaCode.NoMatchedService.getMsg(), "{}");
        } else {
            Set<String> parameters = req.getParameterMap().keySet();
            if (parameters.contains("userId")) {
                invocationCtx.userId(Long.valueOf(req.getParameter("userId")));
            }
            InvocationContextProxy invocationCtxProxy = Factory.getInvocationContextProxy();
            invocationCtx.cookies(invocationCtxProxy.cookies());
            
            JsonPost jsonPost = new JsonPost(service, version, method, true);

            String var10;
            try {
                String var9 = jsonPost.callServiceMethod(parameter, bizService);
                return var9;
            } catch (SoaException var15) {
                LOGGER.error(var15.getMsg(), var15);
                var10 = String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", var15.getCode(), var15.getMsg(), "{}");
            } catch (Exception var16) {
                LOGGER.error(var16.getMessage(), var16);
                var10 = String.format("{\"responseCode\":\"%s\", \"responseMsg\":\"%s\", \"success\":\"%s\", \"status\":0}", "9999", "系统繁忙，请稍后再试[9999]！", "{}");
                return var10;
            } finally {
                if (clearInvocationContext) {
                    Factory.removeCurrentInstance();
                }

            }

            return var10;
        }
    }

    <filter>
        <filter-name>addUserIdFilter</filter-name>
        <filter-class>com.today.filter.AddUserIdFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>addUserIdFilter</filter-name>
        <url-pattern>/api/*</url-pattern>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>FORWARD</dispatcher>
    </filter-mapping>

import com.today.domain.LoginUser;
import com.today.util.UserSessionHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * 类功能描述：添加用户ID过滤链
 *
 * @author WangXueXing create at 19-5-22 上午8:38
 * @version 1.0.0
 */
public class AddUserIdFilter implements Filter {
    private static final Logger logger = LoggerFactory.getLogger(AddUserIdFilter.class);
    /**
     * 通过过滤器添加当前登录用户ID, 为了后续通过用户ID进行灰度
     * @param request
     * @param response
     * @param chain
     * @throws IOException
     * @throws ServletException
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        ModifyRequestParameterWrapper requestWrapper = new ModifyRequestParameterWrapper((HttpServletRequest)request);
        try{
            LoginUser loginUser = UserSessionHelper.getCurrentLoginUser();
            if(loginUser != null){
                requestWrapper.addParameter("userId", loginUser.getStaffId());
            }
        } catch (Exception e) {
            logger.error("添加userId报错", e);
        } finally {
            chain.doFilter(requestWrapper, response);
        }
    }

    @Override
    public void destroy() {}

    @Override
    public void init(FilterConfig fConfig) {}
}

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.util.HashMap;
import java.util.Map;

/**
 * 类功能描述：HttpServletRequest修改参数
 *
 * @author WangXueXing create at 19-5-22 上午8:26
 * @version 1.0.0
 */
public class ModifyRequestParameterWrapper extends HttpServletRequestWrapper {
    private Map<String, String[]> params = new HashMap<String, String[]>();

    public ModifyRequestParameterWrapper(HttpServletRequest request) {
        // 将request交给父类，以便于调用对应方法的时候，将其输出，其实父亲类的实现方式和第一种new的方式类似
        super(request);
        //将参数表，赋予给当前的Map以便于持有request中的参数
        this.params.putAll(request.getParameterMap());
    }

    //重载一个构造方法
    public ModifyRequestParameterWrapper(HttpServletRequest request, Map<String, Object> extendParams) {
        this(request);
        addAllParameters(extendParams);//这里将扩展参数写入参数表
    }

    @Override
    public String getParameter(String name) {//重写getParameter，代表参数从当前类中的map获取
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }

    public String[] getParameterValues(String name) {//同上
        return params.get(name);
    }

    public void addAllParameters(Map<String, Object> otherParams) {//增加多个参数
        for (Map.Entry<String, Object> entry : otherParams.entrySet()) {
            addParameter(entry.getKey(), entry.getValue());
        }
    }

    public void addParameter(String name, Object value) {//增加参数
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
}

private SoaConnection findConnection(final ZkServiceInfo serviceInfo,
                                         final String version,
                                         final String method) throws SoaException {

        InvocationContextImpl context = (InvocationContextImpl) InvocationContextImpl.Factory.currentInstance();

        //设置慢服务检测时间阈值
        /*Optional<Long> maxProcessTime = getZkProcessTime(method, zkInfo);
        context.maxProcessTime(maxProcessTime.orElse(null));*/
        // TODO: 2018-10-12 慢服务时间 取自超时时间[TimeOut]
        context.maxProcessTime(getTimeout(serviceInfo, method));

        //如果设置了calleeip 和 calleport 直接调用服务 不走路由
        if (context.calleeIp().isPresent() && context.calleePort().isPresent()) {
            return SubPoolFactory.getSubPool(IPUtils.transferIp(context.calleeIp().get()), context.calleePort().get()).getConnection();
        }

        //当zk上服务节点发生变化的时候, 可能会导致拿到不存在的服务运行时实例或者根本拿不到任何实例.
        List<RuntimeInstance> compatibles = serviceInfo.runtimeInstances();
        if (compatibles == null || compatibles.isEmpty()) {
            return null;
        }

        // checkVersion
        List<RuntimeInstance> checkVersionInstances = new ArrayList<>(8);
        for (RuntimeInstance rt : compatibles) {
            if (checkVersion(version, rt.version)) {
                checkVersionInstances.add(rt);
            }
        }

        if (checkVersionInstances.isEmpty()) {
            logger.error(getClass().getSimpleName() + "::findConnection[service: " + serviceInfo.serviceName() + ":" + version + "], not found available version of instances");
            throw new SoaException(NoMatchedService, "服务 [ " + serviceInfo.serviceName() + ":" + version + "] 无可用实例:没有找到对应的服务版本");
        }
        // router
        // 把路由需要用到的条件放到InvocationContext中
        capsuleContext(context, serviceInfo.serviceName(), version, method);

        List<RuntimeInstance> routedInstances = router(serviceInfo, checkVersionInstances);

        if (routedInstances == null || routedInstances.isEmpty()) {
            logger.error(getClass().getSimpleName() + "::findConnection[service: " + serviceInfo.serviceName() + "], not found available instances by routing rules");
            throw new SoaException(NoMatchedRouting, "服务 [ " + serviceInfo.serviceName() + " ] 无可用实例:路由规则没有解析到可运行的实例");
        }

        //loadBalance
        RuntimeInstance inst = loadBalance(method, serviceInfo, routedInstances);
        if (inst == null) {
            // should not reach here
            throw new SoaException(NotFoundServer, "服务 [ " + serviceInfo.serviceName() + " ] 无可用实例:负载均衡没有找到合适的运行实例");
        }

        inst.increaseActiveCount();

        // TODO: 2018-08-04  服务端需要返回来正确的版本号
        context.versionName(inst.version);

        return SubPoolFactory.getSubPool(inst.ip, inst.port).

                getConnection();

    }

/**
     * 执行 路由规则 匹配， 返回 经过路由后的 实例列表
     */
    public static List<RuntimeInstance> executeRoutes(InvocationContextImpl ctx, List<Route> routes, List<RuntimeInstance> instances) {
        if (logger.isDebugEnabled()) {
            StringBuilder logAppend = new StringBuilder();
            instances.forEach(ins -> logAppend.append(ins.toString()).append(" "));
            logger.debug(RoutesExecutor.class.getSimpleName() + "::executeRoutes开始过滤：过滤前 size  {}，实例: {}", instances.size(), logAppend.toString());
        }
        boolean isMatched;
        for (Route route : routes) {
            try {
                isMatched = matchCondition(ctx, route.getLeft());
                // 匹配成功，执行右边逻辑
                if (isMatched) {
                    instances = matchThenRouteIp(instances, route);

                    if (logger.isDebugEnabled()) {
                        StringBuilder append = new StringBuilder();
                        instances.forEach(ins -> append.append(ins.toString()).append(" "));
                        logger.debug(RoutesExecutor.class.getSimpleName() + "::route left " + route.getLeft().toString() +
                                        "::executeRoutes过滤结果 size: {}, 实例: {}",
                                instances.size(), append.toString());
                    }
                    break;
                } else {
                    if (logger.isDebugEnabled()) {
                        logger.debug(RoutesExecutor.class.getSimpleName() + "::route left " + route.getLeft().toString() + "::executeRoutes路由没有过滤, size {}", instances.size());
                    }
                }
            } catch (Throwable ex) {
                logger.error(ex.getMessage(), ex);
            }
        }
        return instances;
    }

    /**
     * 是否匹配左边
     *
     * @param ctx
     * @param left
     * @return
     */
    protected static boolean matchCondition(InvocationContextImpl ctx, Condition left) {
        if (left instanceof Otherwise) {
            return true;
        }
        Matchers matcherCondition = (Matchers) left;
        List<Matcher> matchers = matcherCondition.matchers;
        /**
         * left = matcher(;matcher)*
         * matcher = id match patterns
         * patterns = pattern(,pattern)*
         * matcher之间是与的关系
         * pattern之间是或的关系
         */
        for (Matcher matcher : matchers) {
            String actuallyConditionValue = getValueFromInvocationCtx(ctx, matcher);
            List<Pattern> patterns = matcher.getPatterns();

            boolean isMatch = false;
            for (Pattern pattern : patterns) {
                boolean result = matcherPattern(pattern, actuallyConditionValue);
                if (result) {
                    isMatch = true;
                    break;
                }
            }
            if (!isMatch) {
                return false;
            }
        }
        return true;

    }

    /**
     * 路由规则的值和 ctx值 是否匹配
     *
     * @param pattern
     * @param value
     * @return
     */
    private static boolean matcherPattern(Pattern pattern, String value) {
        if (value == null || value.trim().equals("")) {
            return false;
        }

        if (pattern instanceof StringPattern) {
            String content = ((StringPattern) pattern).content;
            return content.equals(value);
        } else if (pattern instanceof NotPattern) {
            Pattern pattern1 = ((NotPattern) pattern).pattern;
            return !matcherPattern(pattern1, value);
        } else if (pattern instanceof IpPattern) {
            IpPattern ipPattern = ((IpPattern) pattern);
            return matchIpWithMask(ipPattern.ip, Integer.parseInt(value), ipPattern.mask);
        } else if (pattern instanceof RegexPattern) {
            /**
             * 使用缓存好的 pattern 进行 正则 匹配
             */
            java.util.regex.Pattern regex = ((RegexPattern) pattern).pattern;
            return regex.matcher(value).matches();

        } else if (pattern instanceof RangePattern) {
            RangePattern range = ((RangePattern) pattern);
            long from = range.from;
            long to = range.to;

            long valueAsLong = Long.parseLong(value);
            return valueAsLong <= to && valueAsLong >= from;

        } else if (pattern instanceof ModePattern) {
            ModePattern mode = ((ModePattern) pattern);
            try {
                long valueAsLong = Long.valueOf(value);
                long result = valueAsLong % mode.base;
                Optional<Long> from = mode.from;
                long to = mode.to;

                if (from.isPresent()) {
                    return result >= from.get() && result <= to;
                } else {
                    return result == to;
                }
            } catch (NumberFormatException e) {
                logger.error("[ModePattern]::输入参数 value 应为数字类型的id ，but get {}", value);
            } catch (Exception e) {
                logger.error("[ModePattern]::throw exception:" + e.getMessage(), e);
            }
            return false;
        } else if (pattern instanceof NumberPattern) {
            try {
                NumberPattern number = ((NumberPattern) pattern);
                long valueAsLong = Long.parseLong(value);
                long numberLong = number.number;
                return valueAsLong == numberLong;
            } catch (Exception e) {
                logger.error("[NumberPattern]::throw exception:" + e.getMessage(), e);
            }
            return false;
        }

        return false;
    }