你真的会写Hello World吗

概要

起因A3项目发展2年后，功能较为稳定后 ，准备合并进EagleEye主体项目，遇到了个问题，代码很难merge进EagleEye。暴露了一个问题，代码写得太差。模块化。重新认识一下，如何写代码

入门版Hello World

下面这段经典代码，开始学习的时候，觉得非常的优美。工作6年后，回头再看看这段代码，却发现漏洞很多。
1:逻辑通过静态对象和静态代码组织
2:难以分析依赖
3:代码散乱，扩展性差，无模块化，很难组织进大型项目

public class HelloWorld {
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

学徒版Hello World

应该思考一下这段逻辑有哪些依赖？
1:将业务逻辑调用通过 handler 包装。
2:在handler执行后将返回值传递给 一个Result对象
3:将参数传递给一个Param对象，传递给业务逻辑

类似下面的伪代码

public class HelloWorldV2 {
    
    Handler handler;
    Param param;
    Result result;
    
    public static void main(String[] args){
        param.setName("Hello World");
        handler.run();
        Object rtn = result.get();
    }
}

实战HelloWorld

优化前的A3逻辑里的限流功能，通过几个静态方法组成限流模块，代码难以维护，主要是难以迁入EagleEye
通过学徒版的形式，重写这个静态方法的逻辑。

限流逻辑

限流模块，主要的逻辑，给各个api接口设置一个token身份，同一个身份最多同时只能保持N个请求上限，对重要的业务方，如aone发布平台不做身份限流上限，保证每次发布都能完整坚持，并且整个系统包含一个固定QPS水位的上限，防止系统崩溃。当系统达到上限后，对触发上限的token身份，触发熔断机制（在一定的时间内不接受这个token的请求）。

思考依赖

1:首先应该有个 Limiter对象，负责同一个身份的验证 Limiter
2:需要有一个可以管理身份的对象，可以判断身份，重要或者一般或者不合法 TokenChecker
3:需要有个固定QPS上限的对象，防止系统崩溃 RateLimiterGuave
4:需要有个熔断器，对高频调用身份做惩罚。RateLimiterPunish

抽出下面4个接口，然后由 Limiter依赖（TokenChecker，RateLimiterGuave，RateLimiterPunish）三个依赖

public interface Limiter {
    boolean pass(String tokenId);
    boolean pass(String tokenId, String start);
    void unlock(String tokenId);
}

public interface TokenChecker {
    boolean isBlackList(String tokenId);
    boolean isWhiteList(String tokenId);
    boolean exist(String tokenId);
}

public interface RateLimiterGuave {
    public boolean pass();
}

public interface RateLimiterPunish {
      boolean isPunish(String tokenId);
      void punish(String tokenId);
}

配置依赖实现类

public class LimitModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(Limiter.class).to(LimiterImpl.class);
        bind(RateLimiterGuave.class).to(RateLimiterGuaveImpl.class);
        bind(RateLimiterPunish.class).to(RateLimiterPunishImpl.class);
        bind(TokenChecker.class).to(TokenCheckerImpl.class);
    }

核心限流逻辑

LimiterImpl 主要通过注入3个依赖。

@Singleton
public class LimiterImpl implements Limiter {


    private final RateLimiterGuave rateLimiterGuave;
    private final RateLimiterPunishImpl rateLimiterPunish;
    private final TokenChecker tokenChecker;

    @Inject
    public LimiterImpl(
            RateLimiterGuave rateLimiterGuave,
            RateLimiterPunishImpl rateLimiterPunish,
            TokenChecker tokenChecker) {
        this.rateLimiterGuave = rateLimiterGuave;
        this.rateLimiterPunish = rateLimiterPunish;
        this.tokenChecker = tokenChecker;
        boolean isProd = EnvUtils.isProd();
        if (!isProd) MAX_FLOW_UPPER = 0l;
    }

    private static final Logger log = LoggerFactory.getLogger(LimiterImpl.class);
    private final ConcurrentMap<String, AtomicInteger> flowControlTokens = new ConcurrentHashMap<String, AtomicInteger>();
    private final String DEFAULT_TOKEN = "DEFAULT_TOKEN";
    private static long MAX_FLOW_UPPER = 3l;//最多给 3 个查询
    private final static long MAX_FLOW_WHITE_UPPER = 30l;//重要用户最多给 300 个查询





    public int getCurrentConnectted(String tokenId) {
        tokenId = getRealToken(tokenId);
        AtomicInteger atomicInteger = flowControlTokens.get(tokenId);
        int count = atomicInteger == null ? 0 : atomicInteger.intValue();
        return count;
    }


    private StatLogger statErrorDetailLogger = EagleEye.statLoggerBuilder("a3_flow_token")
            .intervalSeconds(10).buildSingleton();
    private StatLogger tokenCountErrorDetailLogger = EagleEye.statLoggerBuilder("a3_flow_token_count")
            .intervalSeconds(10).buildSingleton();

    @Override
    public boolean pass(String tokenId) {
        return pass(tokenId, null);
    }

    /**
     * @param tokenId
     * @return
     */
    @Override
    public boolean pass(String tokenId, String start) {
        tokenId = getRealToken(tokenId);
        boolean passDiy = passInn(tokenId, start);
        if (passDiy) {
            return passGuava(tokenId);
        }
        log.warn("passInn fail . pass fail  tokenId:" + tokenId);
        return false;
    }

    private boolean passGuava(String tokenId) {
        boolean isPunish = rateLimiterPunish.isPunish(tokenId);
        if (isPunish) {
            return limitByPunish(tokenId);
        }
        boolean queryPass = rateLimiterGuave.pass();
        if (queryPass) {
            log.info("pass success . pass guava tokenId:" + tokenId);
            return true;
        }
        rateLimiterPunish.punish(tokenId);
        return limit(tokenId);
    }


    private boolean limit(String tokenId) {
        log.warn("guava limit . query fail pass guava tokenId:" + tokenId);
        unlock(tokenId);
        return false;
    }

    private boolean limitByPunish(String tokenId) {
        log.warn("punish limit . query fail pass punish tokenId:" + tokenId);
        unlock(tokenId);
        return false;
    }

    /**
     * @param tokenId
     * @return
     */
    public boolean passInn(String tokenId, String start) {
        if (!EnvUtils.isProd()) {
            return false;//日常不提供api服务了。
        }

//        tokenId = getRealToken(tokenId);
        //2:
        if (!flowControlTokens.containsKey(tokenId)) {
            flowControlTokens.putIfAbsent(tokenId, new AtomicInteger(0));
        }
        tokenCountErrorDetailLogger.stat(tokenId).minMax(getCurrentConnectted(tokenId));

        long max = MAX_FLOW_UPPER;
//        max = 10;
        if (tokenChecker.isWhiteList(tokenId)) {
            if (EnvUtils.isProd()) {
                //TODO:在这里加上通用令牌桶的限流
                statErrorDetailLogger.stat(tokenId, "whiteInPro").count();
                max = MAX_FLOW_WHITE_UPPER;
                return true;//打开全流量

            } else {//日常
                statErrorDetailLogger.stat(tokenId, "white").count();
                max = MAX_FLOW_WHITE_UPPER;
            }
        }

        if (tokenChecker.isBlackList(tokenId) && limitByDate(tokenId, start)) return false;

        AtomicInteger tokens = flowControlTokens.get(tokenId);


        if (tokens.incrementAndGet() > max) {
            tokens.decrementAndGet();
            statErrorDetailLogger.stat(tokenId, "flowCont").count();
            return false;//不让通过
        } else {
            return true;
        }

    }


    @Override
    public void unlock(String tokenId) {
        tokenId = getRealToken(tokenId);

        if (tokenChecker.isWhiteList(tokenId)) {
            return;
        }
        AtomicInteger tokens = flowControlTokens.get(tokenId);
        tokens.decrementAndGet();
        statErrorDetailLogger.stat(tokenId, "success").count();
    }

    private boolean limitByDate(String tokenId, String date) {
        if (date == null) {
            return false;
        }

        statErrorDetailLogger.stat(tokenId, "limitByDate").count();

        boolean limit = System.currentTimeMillis() - Long.parseLong(date)
                > 3 * 24 * 60 * 60 * 1000;
        return limit;
    }

    public Object getLock(String tokenId) {
        tokenId = getRealToken(tokenId);
        AtomicInteger tokens = flowControlTokens.get(tokenId);
        return tokens;
    }


    private String getRealToken(String tokenId) {
        if (tokenId == null || tokenId.trim().equals("")) {
            tokenId = DEFAULT_TOKEN;
        } else {//不存在的token乱写的话，也使用公用的流量
            if (!tokenChecker.exist(tokenId)) tokenId = DEFAULT_TOKEN;
        }
        return tokenId;
    }

}

@Singleton
public class RateLimiterGuaveImpl implements RateLimiterGuave {


    RateLimiter rateLimiter = RateLimiter.create(100);//

    /**
     * @return
     */
    @Override
    public boolean pass() {
        boolean acquire = rateLimiter.tryAcquire();
        return acquire;
    }


}

@Singleton
public class RateLimiterPunishImpl implements RateLimiterPunish {

    static int PUNISH_MINUTES = 3;

    private static final Logger log = LoggerFactory.getLogger(RateLimiterPunishImpl.class);


    private static LoadingCache<String, Boolean> badGuys = CacheBuilder.newBuilder()
//            .maximumSize(10000)
            .expireAfterWrite(PUNISH_MINUTES, TimeUnit.MINUTES)
            .concurrencyLevel(4)
            .build(new CacheLoader<String, Boolean>() {
                @Override
                public Boolean load(String token) throws Exception {
                    return false;
                }
            });

    /**
     * @return
     */
    @Override
    public boolean isPunish(String tokenId) {
        Boolean isPunish = badGuys.getUnchecked(tokenId);
        if (isPunish) log.error("badGuy true.tokenId:" + tokenId);
        return isPunish;
    }


    @Override
    public void punish(String tokenId) {
        badGuys.put(tokenId, true);
        log.warn("badGuys false -> true.tokenId:" + tokenId);
    }
}

public class TokenCheckerImpl implements TokenChecker {

    private final List<String> vips;
    private final  List<String> allowTokens;
    private final  List<String> illegalTokens;
    @Inject
    TokenCheckerImpl(@VipToken List<String> vips,
                     @AllowToken List<String> allowTokens,
                     @IllegalToken List<String> illegalTokens){
        this.vips = vips;
        this.allowTokens = allowTokens;
        this.illegalTokens = illegalTokens;
    }

    @Override
    public boolean isBlackList(String tokenId) {
        if (illegalTokens.contains(tokenId)) {
            return true;
        }
        return false;
    }

    @Override
    public boolean isWhiteList(String tokenId) {
        if (vips.contains(tokenId)) {
            return true;
        }
        return false;
    }

    @Override
    public boolean exist(String tokenId) {
        if (allowTokens.contains(tokenId)) {
            return true;
        }
        return false;
    }

}

使用限流模块

通过清理依赖，模块化后，就很容易集成到各个系统里了。
1:通过 install 将上面整个模块加载进另一个系统
2:通过injector获取对应的实现。（和Spring也有成熟的交互方式）

public class BModule extends AbstractModule{
    @Override
    protected void configure() {
       install(new LimitModule());
    }

}

 static Limiter limiter;

    static {
        Injector injector = Guice.createInjector(new LimitModule());
        limiter = injector.getInstance(Limiter.class);
    }

    public static boolean pass(String tokenId) {
        return limiter.pass(tokenId);
    }