<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.1.0</version>
</parent>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1.1-jre</version>
</dependency>

server:
  port: 8888
spring:
  application:
    name: shorten-service
  datasource:
    url: jdbc:mysql://localhost:3306/shorten_db?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
    username: root
    password: xxxx #修改成自己的密碼
  jpa:
    hibernate:
      ddl-auto: create-drop
    properties:
      hibernate:
        show_sql: true
        format_sql: true

package org.shortenservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ShortenServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShortenServiceApplication.class, args);
    }
}

public class ResponseResult<T> {
    private String code;
    private String msg;
    private T data;
 }

package org.shortenservice.common;
public class ResultUtils {
    private ResultUtils() {}
    public static <T> ResponseResult success(T data) {
        return build("200", "success", data);
    }
    public static ResponseResult success() {
        return build("200", "success", null);
    }
    public static boolean isSuccess(String code) {
        return "200".equals(code);
    }
    public static ResponseResult failure(String msg) {
        return build("500", msg, null);
    }
    public static ResponseResult failure(String code, String msg) {
        return build(code, msg, null);
    }
    public static <T> ResponseResult failure(String code, String msg, T data) {
        return build(code, msg, data);
    }
    public static  <T> ResponseResult<T> build(String code, String msg, T data) {
        return new ResponseResult<>(code, msg, data);
    }
}

package org.shortenservice.utils;
public class Base62Utils {
    private static final String BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
    private Base62Utils() {
    }
    public static String idToShortKey(long id) {
        StringBuilder stringBuilder = new StringBuilder();
        while (id > 0) {
            stringBuilder.append(BASE62.charAt((int) (id % 62)));
            id = id / 62;
        }
        while (stringBuilder.length() < 6) {
            stringBuilder.append(0);
        }
        return stringBuilder.reverse().toString();
    }
    public static long shortKeyToId(String shortKey) {
        long id = 0;
        for (int i = 0; i < shortKey.length(); i++) {
            id = id * 62 + BASE62.indexOf(shortKey.charAt(i));
        }
        return id;
    }
}

package org.shortenservice.model;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Index;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.annotations.CreationTimestamp;
import java.time.Instant;
@Entity
@Table(name = "t_url_map", indexes = {@Index(columnList = "longUrl", unique = true),
@Index(columnList = "expireTime", unique = false)})
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UrlMap {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String longUrl;
    private Instant expireTime;
    @CreationTimestamp
    private Instant creationTime;
}

package com.shorten.dao;
import com.shorten.model.UrlMap;
import org.springframework.data.repository.CrudRepository;
import java.time.Instant;
import java.util.List;
public interface UrlMapDao extends CrudRepository<UrlMap, Long> {
    UrlMap findFirstByLongUrl(String longUrl);
    List<UrlMap> findByExpireTimeBefore(Instant instant);
}

package org.shortenservice.service;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.shortenservice.dao.UrlMapDao;
import org.shortenservice.model.UrlMap;
import org.shortenservice.utils.Base62Utils;
import org.springframework.stereotype.Service;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Optional;
@Service
@Slf4j
public class UrlMapService {
    @Resource
    UrlMapDao urlMapDao;
    public String encode(String longUrl) {
        UrlMap urlMap = urlMapDao.findFirstByLongUrl(longUrl);
        if (urlMap == null) {
            urlMap = urlMapDao.save(UrlMap.builder()
                    .longUrl(longUrl)
                    .expireTime(Instant.now().plus(30, ChronoUnit.DAYS))
                    .build());
            log.info("create urlMap:{}", urlMap);
        }
        return Base62Utils.idToShortKey(urlMap.getId());
    }
    public Optional<String> decode(String shortKey) {
        long id = Base62Utils.shortKeyToId(shortKey);
        return urlMapDao.findById(id).map(UrlMap::getLongUrl);
    }
}

package org.shortenservice.controller;
import jakarta.annotation.Resource;
import org.shortenservice.common.ResponseResult;
import org.shortenservice.common.ResultUtils;
import org.shortenservice.service.UrlMapService;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.view.RedirectView;
import java.util.Map;
@RestController
public class UrlMapController {
    private static final String DOMAIN = "http://127.0.0.1:8888/";
    @Resource
    private UrlMapService urlMapService;
    /***
     * 長(zhǎng)鏈接轉(zhuǎn)短鏈接
     * @param longUrl 長(zhǎng)鏈接
     * @return ResponseResult
     */
    @PostMapping("/shorten")
    public ResponseResult<Map> shorten(@RequestParam("longUrl") String longUrl) {
        String encode = urlMapService.encode(longUrl);
        return ResultUtils.success(Map.of("shortKey", encode,
                "shortUrl", DOMAIN + encode));
    }
    /***
     * 短鏈接重定向
     * @param shortKey 短鏈接
     * @return RedirectView
     */
    @GetMapping("/{shortKey}")
    public RedirectView redirect(@PathVariable("shortKey") String shortKey) {
        return urlMapService.decode(shortKey).map(RedirectView::new)
                .orElse(new RedirectView("/sorry"));
    }
    @GetMapping("/sorry")
    public String sorry() {
        return "抱歉，未找到頁(yè)面！";
    }
}

#將長(zhǎng)鏈接轉(zhuǎn)為短鏈接
curl -XPOST "localhost:8888/shorten?longUrl=https://i.csdn.net/#/user-center/profile?spm=1011.2415.3001.5111"
#訪問(wèn)短鏈接重定向到目標(biāo)網(wǎng)站
curl -i "http://127.0.0.1:8888/000003"

package org.shortenservice.service;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.shortenservice.dao.UrlMapDao;
import org.shortenservice.model.UrlMap;
import org.shortenservice.utils.Base62Utils;
import org.springframework.stereotype.Service;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Optional;
@Service
@Slf4j
public class UrlMapService {
    @Resource
    UrlMapDao urlMapDao;
    @Resource
    LoadingCache<String, String> loadingCache;
    @PostConstruct
    public void init() {
        CacheLoader<String, String> cacheLoader = new CacheLoader<String, String>() {
            @Override
            public String load(String s) throws Exception {
                long id = Base62Utils.shortKeyToId(s);
                log.info("load cache: {}", s);
                return urlMapDao.findById(id).map(UrlMap::getLongUrl).orElse(null);
            }
        };
        loadingCache = CacheBuilder.newBuilder()
                .maximumSize(1000000) // 設(shè)置最大緩存大小
                .build(cacheLoader);
    }
    public String encode(String longUrl) {
        UrlMap urlMap = urlMapDao.findFirstByLongUrl(longUrl);
        if (urlMap == null) {
            urlMap = urlMapDao.save(UrlMap.builder()
                    .longUrl(longUrl)
                    .expireTime(Instant.now().plus(30, ChronoUnit.DAYS))
                    .build());
            log.info("create urlMap:{}", urlMap);
        }
        return Base62Utils.idToShortKey(urlMap.getId());
    }
    public Optional<String> decode(String shortKey) {
        return Optional.ofNullable(loadingCache.getUnchecked(shortKey));
    }
}