package com.coderdream.generator;

public interface CodeGenerator {
    /**
     * 产生的code
     *
     * @return
     */
    String generateCode();

}

package com.coderdream.generator;

import com.coderdream.utils.Constants;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * 功能描述
 *
 * @since 2022-05-05
 */
@Slf4j
public class StringGenerator implements CodeGenerator {

    private ArrayBlockingQueue<String> queue;

    @Override
    public String generateCode() {
        return queue.poll();
    }

    public StringGenerator() {

        Integer queueSizeConfig = Constants.CHARS.toCharArray().length;
        queue = new ArrayBlockingQueue<>(queueSizeConfig);
        List<String> charList = new ArrayList<>();
        for (int i = 0; i < queueSizeConfig; i++) {
            Character character = Constants.CHARS.toCharArray()[i];
            charList.add(character.toString());
        }

        //后台线程
        Thread thread = new Thread(() -> {
            int index = 0;
            while (index < queueSizeConfig) {
                // if (this.low >= this.highMax) {
                //     log.error("已用尽号码,停止后台线程,id={},low={},high={},step={},highMax={}", id, low, high, step, highMax);
                //     return;
                // }
                // //如果低水位达到高水位,高水位上移
                // if (low >= high) {
                //     high += step;
                //     //高水位不可越过最高水位
                //     if (high >= highMax) {
                //         high = highMax;
                //     }
                //     //todo 持久化记录high
                // }
                // try {
                //     //采用阻塞方式放入元素
                //     queue.put(charList.get(index));
                // } catch (InterruptedException e) {
                //     log.info("[CacheQueueNumberGenerator] daemon thread interrupted", e);
                // }
                //低水位移动
                index++;
                //todo 可以加提前预警，比如low>highMax*0.8
            }
        });
        thread.setDaemon(true);
        thread.start();

        int index = 0;
        while (index < queueSizeConfig) {
            // if (this.low >= this.highMax) {
            //     log.error("已用尽号码,停止后台线程,id={},low={},high={},step={},highMax={}", id, low, high, step, highMax);
            //     return;
            // }
            // //如果低水位达到高水位,高水位上移
            // if (low >= high) {
            //     high += step;
            //     //高水位不可越过最高水位
            //     if (high >= highMax) {
            //         high = highMax;
            //     }
            //     //todo 持久化记录high
            // }
            try {
                //采用阻塞方式放入元素
                queue.put(charList.get(index));
            } catch (InterruptedException e) {
                log.info("[CacheQueueNumberGenerator] daemon thread interrupted", e);
            }
            //低水位移动
            index++;
            //todo 可以加提前预警，比如low>highMax*0.8
        }

        System.out.println(queue.size());
    }

}

package com.coderdream.service.impl;

import com.coderdream.bean.ShortLinkBean;
import com.coderdream.generator.StringGenerator;
import com.coderdream.helper.BloomFilterHelper;
import com.coderdream.helper.FileOperateHelper;
import com.coderdream.helper.GeneratorHelper;
import com.coderdream.helper.GuavaCacheHelper;
import com.coderdream.service.LinkService;
import com.coderdream.utils.Config;
import com.coderdream.utils.Constants;
import com.coderdream.utils.DuplicatedEnum;
import com.coderdream.helper.ShortLinkHelper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigInteger;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

@Service
@Slf4j
public class LinkServiceImpl implements LinkService {
    @Resource
    private Config config;

    @Resource
    private FileOperateHelper fleOperateHelper;

    @Resource
    private ShortLinkHelper shortLinkHelper;

    @Resource
    private GuavaCacheHelper guavaCacheHelper;

    @Resource
    private BloomFilterHelper bloomFilterHelper;

    @Resource
    private GeneratorHelper generatorHelper;

    /**
     * 号码生成器列表
     */
    @Resource
    private StringGenerator stringGenerator;

    private String generateCode;

    @PostConstruct
    public void init() {
        //stringGeneratorList = generatorHelper.createStringGenerator();
        generateCode =stringGenerator.generateCode();
      //  machineId = Long.parseLong(fileOperateAbility.readFile("machineId"));
    }

    @Override
    public String getShortLink(String longLink) {
        // 校验longLink
        if(longLink == null || "".equals(longLink)) {
            // 记录日志
            log.error("入参错误，不能为空：" + longLink);
            return "";
        }
        // 获取机器ID，这里写在文件中，后期通过ZooKeeper管理
        String machineId = fleOperateHelper.readFile("machineId");
        // 生成短链接
        String code = shortLinkHelper.createShortLinkCode(longLink);

        Integer guavaCacheSize = guavaCacheHelper.size() ;
        Integer initSize = Constants.MAXIMUM_SIZE;

        // 记录日志
        log.error("缓存大小：" + guavaCacheHelper.size());

        if (null == generateCode) {
            generateCode = stringGenerator.generateCode();
        }

        // 机器ID作为前缀
        code = machineId + generateCode + code;

        // 创建短链接Bean
        ShortLinkBean shortLinkBean = new ShortLinkBean();
        shortLinkBean.setShortLink(code);
        shortLinkBean.setLongLink(longLink);
        shortLinkBean.setExpireTime(System.currentTimeMillis() + config.EXPIRE_SEC * 1000);
        // 如果存在（可能误判）
        if (bloomFilterHelper.mightContain(code)) {
            // 从缓存中取对象
            ShortLinkBean oldShortLinkBean = (ShortLinkBean) guavaCacheHelper.get(code);
            // 如果不存在误判为存在，则直接将新的数据写入缓存中
            if (oldShortLinkBean == null) {
                // 把短链接放入Guava缓存中
                guavaCacheHelper.put(code, shortLinkBean);
                // 把短链接放入布隆过滤器
                bloomFilterHelper.put(code);
                // 记录日志
                log.warn("布隆过滤器误判： new code: " + code + " ; new link: " + longLink);
            }
            // 如果确实存在
            else {
                String oldLongLink = oldShortLinkBean.getLongLink();
                // 判断是否Hash冲突了(code相同，长链接url不同)
                if (code.equals(oldShortLinkBean.getShortLink()) && !longLink.equals(oldLongLink)) {
                    // 记录日志
                    log.warn("Hash冲突, old and new code: " + code + "; old link: " + oldLongLink + " ; new link: "
                            + longLink);
                    // 构造新code、新link
                    // code加上枚举前缀后再取Hash，生成新的短链接
                    code = machineId + shortLinkHelper.createShortLinkCode(DuplicatedEnum.DUPLICATED.getKey() + "_" + code);
                    // 长链接加上前缀
                    String newLongLink = DuplicatedEnum.DUPLICATED.getKey() + "_" + longLink;
                    log.error("Hash冲突解决： new code: " + code + "; old link: " + oldShortLinkBean.getLongLink()
                            + " ; new link: " + newLongLink);
                    // 设置新的短链接
                    shortLinkBean.setShortLink(code);
                    // 设置新的长链接
                    shortLinkBean.setLongLink(newLongLink);
                    // 把短链接放入Guava缓存中
                    guavaCacheHelper.put(code, shortLinkBean);
                    // 把短链接放入布隆过滤器
                    bloomFilterHelper.put(code);
                }
                // 未冲突，已存在数据，不做处理，既不放到缓存中，也不放到过滤器中
                else {
                    // 记录日志
                    log.info("已存在： code " + code + " ; longLink: " + longLink);
                }
            }
        }
        // 通过布隆过滤器判断：如果不存在（100%正确），则直接放入缓存中
        else {
            // 把短链接放入Guava缓存中
            guavaCacheHelper.put(code, shortLinkBean);
            // 把短链接放入布隆过滤器
            bloomFilterHelper.put(code);
        }
        // 将短链接返回给调用方
        return code;
    }

    @Override
    public String getLongLink(String shortLink) {
        // 校验
        if(shortLink == null || "".equals(shortLink)) {
            // 记录日志
            log.error("入参错误，不能为空：" + shortLink);
            return "";
        }
        // 从缓存中获取对象
        ShortLinkBean shortLinkBean = (ShortLinkBean) guavaCacheHelper.get(shortLink);
        // 如果不存在，则记日志，然后返回空
        if (shortLinkBean == null) {
            log.warn("缓存中不存在 " + shortLink + " 对应的长链接");
            return "";
        }
        // 如果存在，处理长链接
        else {
            // 取出长链接
            String longLink = shortLinkBean.getLongLink();
            // 如果不存在Hash冲突标记，则直接返回长链接
            if (!longLink.startsWith(DuplicatedEnum.DUPLICATED.getKey())) {
                return longLink;
            }
            // 否则去掉冲突标记后再返回
            else {
                log.warn("去掉冲突标记后再返回：" + longLink);
                longLink = longLink.replace(DuplicatedEnum.DUPLICATED.getKey() + "_", "");
            }
            // 将长链接返回给调用方
            return longLink;
        }
    }
}