/**
 * 使用欧几里得算法计算两个数的最大公约数（GCD）
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 两个数的最大公约数
 */
public static int gcd(int a, int b) {
    // 取绝对值以处理负数
    a = Math.abs(a);
    b = Math.abs(b);
    
    // 欧几里得算法核心逻辑
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

/**
 * 计算两个数的最小公倍数（LCM）
 * LCM(a,b) = |a*b| / GCD(a,b)
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 两个数的最小公倍数
 */
public static int lcm(int a, int b) {
    if (a == 0 || b == 0) {
        return 0; // 0和任何数的最小公倍数为0
    }
    return Math.abs(a * b) / gcd(a, b);
}

/**
 * 判断一个数是否为素数
 * @param n 要判断的整数
 * @return 如果n是素数返回true，否则返回false
 */
public static boolean isPrime(int n) {
    if (n <= 1) {
        return false; // 0和1不是素数
    }
    if (n <= 3) {
        return true; // 2和3是素数
    }
    if (n % 2 == 0 || n % 3 == 0) {
        return false; // 能被2或3整除的数不是素数
    }
    
    // 检查从5开始到sqrt(n)的所有数，跳过偶数和3的倍数
    // 只需要检查形式为6k±1的数
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) {
            return false;
        }
    }
    return true;
}

/**
 * 获取一个数的所有素因数
 * @param n 要分解的整数
 * @return n的素因数列表
 */
public static List<Integer> primeFactors(int n) {
    List<Integer> factors = new ArrayList<>();
    
    // 处理负数情况
    if (n < 0) {
        n = Math.abs(n);
        factors.add(-1);
    }
    
    // 分解2的因数
    while (n % 2 == 0) {
        factors.add(2);
        n = n / 2;
    }
    
    // 分解奇数因数
    for (int i = 3; i * i <= n; i += 2) {
        while (n % i == 0) {
            factors.add(i);
            n = n / i;
        }
    }
    
    // 如果最后剩下的数大于2，它本身就是一个素因数
    if (n > 2) {
        factors.add(n);
    }
    
    return factors;
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 使用埃拉托斯特尼筛法生成小于等于n的所有素数
 * @param n 上限值
 * @return 小于等于n的素数列表
 */
public static List<Integer> sieveOfEratosthenes(int n) {
    List<Integer> primes = new ArrayList<>();
    
    if (n < 2) {
        return primes; // 小于2的数没有素数
    }
    
    // 创建布尔数组标记是否为素数
    boolean[] isPrime = new boolean[n + 1];
    Arrays.fill(isPrime, true); // 初始假设所有数都是素数
    
    // 0和1不是素数
    isPrime[0] = isPrime[1] = false;
    
    // 筛选过程
    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) { // 如果i是素数
            // 标记i的所有倍数为非素数
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
    
    // 收集所有素数
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.add(i);
        }
    }
    
    return primes;
}

/**
 * 计算一个数的欧拉函数值（小于n且与n互质的正整数的个数）
 * @param n 输入整数
 * @return n的欧拉函数值
 */
public static int eulerTotient(int n) {
    if (n <= 0) {
        return 0;
    }
    
    int result = n;
    
    // 分解质因数并应用欧拉函数公式
    for (int p = 2; p * p <= n; p++) {
        if (n % p == 0) {
            // p是素因数
            while (n % p == 0) {
                n = n / p;
            }
            result -= result / p;
        }
    }
    
    // 如果n本身是素数
    if (n > 1) {
        result -= result / n;
    }
    
    return result;
}

/**
 * 判断两个数是否互质
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 如果a和b互质返回true，否则返回false
 */
public static boolean areCoprime(int a, int b) {
    return gcd(a, b) == 1;
}

/**
 * 贝祖定理：对于任何整数a和b，存在整数x和y，使得ax + by = gcd(a,b)
 * 使用扩展欧几里得算法求解贝祖系数
 * @param a 第一个整数
 * @param b 第二个整数
 * @return 包含gcd(a,b)和系数x,y的数组 [gcd, x, y]
 */
public static int[] extendedGcd(int a, int b) {
    if (b == 0) {
        // 基本情况：a * 1 + 0 * 0 = a
        return new int[]{a, 1, 0};
    }
    
    int[] result = extendedGcd(b, a % b);
    int gcd = result[0];
    int x1 = result[1];
    int y1 = result[2];
    
    // 推导当前系数
    int x = y1;
    int y = x1 - (a / b) * y1;
    
    return new int[]{gcd, x, y};
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 数论工具类，提供常用的数论算法实现
 */
public class NumberTheoryUtils {
    
    // 所有方法实现...
    
    // 测试主函数
    public static void main(String[] args) {
        // 测试最大公约数
        System.out.println("GCD(48, 18) = " + gcd(48, 18)); // 应该输出6
        
        // 测试最小公倍数
        System.out.println("LCM(4, 6) = " + lcm(4, 6)); // 应该输出12
        
        // 测试素数判断
        System.out.println("Is 17 prime? " + isPrime(17)); // 应该输出true
        System.out.println("Is 15 prime? " + isPrime(15)); // 应该输出false
        
        // 测试素因数分解
        System.out.println("Prime factors of 100: " + primeFactors(100)); // 应该输出[2, 2, 5, 5]
        
        // 测试埃拉托斯特尼筛法
        System.out.println("Primes <= 30: " + sieveOfEratosthenes(30)); // 应该输出所有小于等于30的素数
        
        // 测试欧拉函数
        System.out.println("Euler's totient of 10: " + eulerTotient(10)); // 应该输出4
        
        // 测试互质判断
        System.out.println("Are 8 and 15 coprime? " + areCoprime(8, 15)); // 应该输出true
        
        // 测试扩展欧几里得算法
        int[] extendedResult = extendedGcd(48, 18);
        System.out.println("Extended GCD(48, 18): " + 
                          "gcd=" + extendedResult[0] + 
                          ", x=" + extendedResult[1] + 
                          ", y=" + extendedResult[2]);
    }
}

@Service
public class UserServiceImpl implements UserService {
    
    @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1. 校验手机号格式
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误！");
        }
        
        // 2. 生成6位随机验证码
        String code = RandomUtil.randomNumbers(6);
        
        // 3. 保存验证码到Session
        session.setAttribute("code", code);
        
        // 4. 发送验证码（实际项目中调用短信服务）
        log.debug("发送短信验证码成功，验证码：{}", code);
        
        return Result.ok();
    }
}

@Service
public class UserServiceImpl implements UserService {
    
    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1. 校验手机号格式
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误！");
        }
        
        // 2. 校验验证码
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        if (cacheCode == null || !cacheCode.toString().equals(code)) {
            return Result.fail("验证码错误");
        }
        
        // 3. 根据手机号查询用户
        User user = query().eq("phone", phone).one();
        
        // 4. 用户不存在则创建新用户
        if (user == null) {
            user = createUserWithPhone(phone);
        }
        
        // 5. 保存用户信息到Session
        session.setAttribute("user", user);
        
        return Result.ok();
    }
    
    private User createUserWithPhone(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName("user_" + RandomUtil.randomString(6));
        userService.save(user);
        return user;
    }
}

@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) throws Exception {
        // 1. 获取Session
        HttpSession session = request.getSession();
        
        // 2. 获取Session中的用户信息
        Object user = session.getAttribute("user");
        
        // 3. 判断用户是否登录
        if (user == null) {
            // 4. 用户未登录，返回401状态码
            response.setStatus(401);
            return false;
        }
        
        // 5. 用户已登录，保存用户信息到ThreadLocal
        UserHolder.saveUser((User) user);
        
        // 6. 放行请求
        return true;
    }
}

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // Token刷新拦截器 - 拦截所有路径
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate))
                .addPathPatterns("/**")
                .order(0);
        
        // 登录拦截器 - 拦截需要登录的路径
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",           // 店铺信息
                        "/voucher/**",        // 优惠券
                        "/shop-type/**",      // 店铺类型
                        "/upload/**",        // 文件上传
                        "/blog/hot",         // 热门博客
                        "/user/code",        // 发送验证码
                        "/user/login"        // 用户登录
                )
                .order(1);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserDTO {
    private Long id;
    private String nickName;
    private String icon;
    // 注意：不包含敏感信息如password、phone、email等
}

// 保存用户信息到Session（使用DTO脱敏）
session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));

// 保存用户信息到ThreadLocal（使用DTO）
UserHolder.saveUser((UserDTO) user);

public class UserHolder {
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

    public static void saveUser(UserDTO user) {
        tl.set(user);
    }

    public static UserDTO getUser() {
        return tl.get();
    }

    public static void removeUser() {
        tl.remove();
    }
}

// 使用UUID生成随机token
String token = UUID.randomUUID().toString(true);
String key = LOGIN_USER_KEY + token;

@GetMapping("/{id}")
public Result queryShopById(@PathVariable("id") Long id) {
    // 直接查询数据库 - 性能瓶颈
    return shopService.queryById(id);
}