JAVA实现生成短链接

短链接
短链接就是将长度较长的链接压缩成较短的链接。

好处：便于发布、传播。

短链跳转访问原理

其实就是在后台保存有短链和长链的映射关系，然后进行重定向，让浏览器跳转到对应的长链接。首先访问短链接，根据短链接查询数据库获取完整长链接，返回301或者302，让浏览器重定向到目标地址，浏览器跳转到长链接。

例子：当访问短链接，https://域名/xxx时，后端返回了302，同时多了一个Location响应头，值就是原始链接地址。

关于重定向：

301 永久重定向
302 临时重定向 （很多短链生成平台其实都是走的302重定向

1、controller                        

    /**
     * API生成短链接
     */
    @PostMapping(value = "/getBatchShortLinkConfig")
    public ShopShortLinkResult<ShortLinkVo> getBatchShortLinkConfig(@RequestBody Map<String, Object> batchShortLinkConfigMap) {
        log.info("API生成短链接配置---入参={}", JSON.toJSONString(batchShortLinkConfigMap));
        return ShopShortLinkResult.success(shortLinkService.getBatchShortLinkConfig(batchShortLinkConfigMap));
    }

    /**
     * 生成短链
     */
    private String sortUrl(String url, Integer num) {
        long longLinkHash = Hashing.murmur3_32_fixed().hashString(url, StandardCharsets.UTF_8).padToLong();
        // 这个工具类是 雪花算法的工具类
        SnowFlakeUtils snowFlakeUtil = new SnowFlakeUtils();
        // 雪花算法 生成主键id
        long id = snowFlakeUtil.nextId();
        long uniqueIdHash = Hashing.murmur3_32_fixed().hashLong(id).padToLong();
        // 相减主要是为了让哈希值更小
        log.info("相减值={},hash值={},雪花hash={}", Math.abs(longLinkHash - uniqueIdHash), longLinkHash, uniqueIdHash);
        String shortLink = Base62Utils.encodeToBase62String(Math.abs(longLinkHash - uniqueIdHash));
        //查询
        Boolean exist = exist(RedisConstantPrefix.BOOLFILTER_KEY, shortLink);
        log.info("雪花生成短链key:{},num:{},布隆过滤器exist:{}",shortLink,num,exist);
        //存在，重新获取短链
        if (exist) {
            num += num;
            if (num >= 5) {
                return null;
            }
            sortUrl(url, num);
        }
        return shortLink;
    }




=========================================================================







/**
 * @program: myStudy
 * @ClassName Base62Utils
 * @description:
 * @author: wff
 * @create: 2023-09-20 11:28
 * @Version 1.0
 **/

import java.net.URLEncoder;
import java.util.Base64;

/**
 * 短链接 - 工具类
 */
public class Base62Utils {
    private static final int SCALE = 62;
    // 下面的字符，可以随便打乱，安全性更高
    private static final char[] BASE_62_ARRAY = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
    };
    private static final String BASE_62_CHARACTERS = String.valueOf(BASE_62_ARRAY);

    /**
     * 将long类型编码成Base62字符串
     *
     * @param num
     * @return
     */
    public static String encodeToBase62String(long num) {
        StringBuilder sb = new StringBuilder();
        while (num > 0 || sb.length() < 6) {
            sb.insert(0, BASE_62_ARRAY[(int) (num % SCALE)]);
            num /= SCALE;
        }
        return sb.toString();
    }

    /**
     * 将Base62字符串解码成long类型
     *
     * @param base62Str
     * @return
     */
    public static long decodeToLong(String base62Str) {
        long num = 0, coefficient = 1;
        String reversedBase62Str = new StringBuilder(base62Str).reverse().toString();
        for (char base62Character : reversedBase62Str.toCharArray()) {
            num += BASE_62_CHARACTERS.indexOf(base62Character) * coefficient;
            coefficient *= SCALE;
        }
        return num;
    }

    public static void main(String[] args) {
        String data = "6s3brYkS9OQp7YpY7RHR+GOJUdp//tdRrVPyiUcuJhJZPaHS9dStwDCdOWNWuHk=";
        Base64.Encoder encoder = Base64.getEncoder();
        System.out.println(encoder.encodeToString(data.getBytes()));
        Base64.Encoder encoder2 = Base64.getUrlEncoder();
        System.out.println(encoder2.encodeToString(data.getBytes()));
        // 编码 这个编码后 有 url的特殊字符
        System.out.println(URLEncoder.encode(data));
    }
}
======================================================================
使用布隆过滤器防止生成的短链接重复


    /**
     * 容量
     */
    protected Long expectedInsertions = 1000000L;
    /**
     * 误差
     */
    protected Double falseProbability = 0.001;

    @Resource
    private Redisson redisson;

    /**
     * 添加布隆过滤器
     */
    public void add(String key, String data) {
        log.info("添加布隆过滤器key={} value={}", key, data);
        RBloomFilter bloomFilter = redisson.getBloomFilter(key);
        bloomFilter.tryInit(expectedInsertions, falseProbability);
        bloomFilter.add(data);
    }

    /**
     * 判断布隆过滤器是否存在
     */
    public Boolean exist(String key, String data) {
        log.info("判断布隆过滤器key是否存在={} value={}", key, data);
        RBloomFilter bloomFilter = redisson.getBloomFilter(key);
        bloomFilter.tryInit(expectedInsertions, falseProbability);
        boolean isExist = bloomFilter.contains(data);
        return isExist;
    }