package com.yourcompany.yourproject;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class YourProjectApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourProjectApplication.class, args);
    }
}

package com.yourcompany.yourproject.model.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.thinkboot.mybatis.base.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper = true)
@TableName("sys_user")
public class User extends BaseEntity {
    private String username;
    private String password;
    private String nickname;
    private String email;
    private String phone;
    private Integer status;
}

// Mapper - 继承 BaseMapper，自动拥有 CRUD 方法
package com.yourcompany.yourproject.mapper;

import com.thinkboot.mybatis.base.BaseMapper;
import com.yourcompany.yourproject.model.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

// Service 接口 - 继承 BaseService
package com.yourcompany.yourproject.service;

import com.thinkboot.mybatis.base.BaseService;
import com.yourcompany.yourproject.model.entity.User;

public interface UserService extends BaseService<User> {
    User getByUsername(String username);
}

// Service 实现 - 继承 BaseServiceImpl
package com.yourcompany.yourproject.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.thinkboot.mybatis.base.BaseServiceImpl;
import com.yourcompany.yourproject.mapper.UserMapper;
import com.yourcompany.yourproject.model.entity.User;
import com.yourcompany.yourproject.service.UserService;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends BaseServiceImpl<UserMapper, User> implements UserService {
    
    @Override
    public User getByUsername(String username) {
        return getOne(new LambdaQueryWrapper<User>().eq(User::getUsername, username));
    }
}

package com.yourcompany.yourproject.controller;

import com.thinkboot.auth.annotation.IgnoreAuth;
import com.thinkboot.auth.context.UserContext;
import com.thinkboot.common.result.R;
import com.yourcompany.yourproject.model.entity.User;
import com.yourcompany.yourproject.service.UserService;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    // 默认需要登录（无需添加任何注解）
    @GetMapping("/{id}")
    public R<User> getById(@PathVariable Long id) {
        User user = userService.getById(id);
        if (user == null) {
            return R.error(404, "用户不存在");
        }
        return R.success(user);
    }

    // 不需要登录（使用 @IgnoreAuth 注解）
    @IgnoreAuth
    @GetMapping("/public/info")
    public R<String> publicInfo() {
        return R.success("这是公开信息");
    }

    // 获取当前登录用户（默认需要登录）
    @GetMapping("/me")
    public R<String> getCurrentUser() {
        String userId = UserContext.getCurrentUserId();
        return R.success("当前用户ID: " + userId);
    }
}

// 成功响应（带数据）
return R.success(user);

// 成功响应（无数据）
return R.success();

// 错误响应（自定义状态码）
return R.error(404, "资源不存在");

// 错误响应（默认500）
return R.error("服务器异常");

@GetMapping("/list")
public PageResponse<User> list(@RequestParam(defaultValue = "1") int pageNo,
                                @RequestParam(defaultValue = "10") int pageSize) {
    // 创建分页对象
    Page<User> page = PageUtils.toPage(pageNo, pageSize);
    // 执行分页查询
    Page<User> result = userService.page(page);
    // 返回分页结果
    return PageUtils.toPageResponse(result);
}

@IgnoreAuth
@PostMapping("/login")
public R<LoginResponse> login(@RequestBody LoginRequest request) {
    // 免认证接口
}

// 方式1：使用 UserContext（推荐）
@GetMapping("/me")
public R<User> getCurrentUser() {
    String userId = UserContext.getCurrentUserId();
    User user = userService.getById(Long.valueOf(userId));
    return R.success(user);
}

// 方式2：使用 @CurrentUserId 注解（更简洁）
@GetMapping("/me")
public R<User> getCurrentUser(@CurrentUserId String userId) {
    User user = userService.getById(Long.valueOf(userId));
    return R.success(user);
}

package com.yourcompany.orderservice.feign;

import com.thinkboot.common.result.R;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", path = "/api/users")
public interface UserFeignClient {
    
    @GetMapping("/{id}")
    R<User> getUserById(@PathVariable Long id);
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    private final UserFeignClient userFeignClient;

    public OrderController(UserFeignClient userFeignClient) {
        this.userFeignClient = userFeignClient;
    }
    
    @GetMapping("/{id}")
    public R<Order> getOrder(@PathVariable Long id) {
        // Token 会自动传递到 user-service
        R<User> userResult = userFeignClient.getUserById(1L);
        
        Order order = orderService.getById(id);
        return R.success(order);
    }
}

@SentinelResource(value = "getUserById", blockHandler = "handleBlock")
@GetMapping("/{id}")
public R<User> getById(@PathVariable Long id) {
    return R.success(userService.getById(id));
}

// 限流后的降级方法
public R<User> handleBlock(Long id, BlockException ex) {
    return R.error(429, "请求过于频繁，请稍后再试");
}

// 设置缓存（30分钟过期）
RedisUtils.set("user:1", userObject, 30, TimeUnit.MINUTES);

// 获取缓存
User user = (User) RedisUtils.get("user:1");

// 删除缓存
RedisUtils.delete("user:1");

// 判断是否存在
boolean exists = RedisUtils.hasKey("user:1");

// 设置过期时间
RedisUtils.expire("user:1", 1, TimeUnit.HOURS);

// 方式1：手动加锁解锁
RLock lock = DistributedLock.tryLock("lock:order:create", 3, 10, TimeUnit.SECONDS);
try {
    if (lock != null) {
        // 执行业务逻辑
    }
} finally {
    DistributedLock.unlock("lock:order:create");
}

// 方式2：函数式API（推荐）
String result = DistributedLock.executeWithLock(
    "lock:order:create",
    () -> {
        // 执行业务逻辑
        return "success";
    },
    3,   // 等待时间（秒）
    10,  // 锁持有时间（秒）
    TimeUnit.SECONDS
);

import com.thinkboot.mq.rabbitmq.core.RabbitMessageSender;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    
    @Autowired
    private RabbitMessageSender messageSender;
    
    // 发送普通消息
    public void createOrder(Order order) {
        // 1. 创建订单（你的业务逻辑）
        saveOrder(order);
        
        // 2. 发送消息（框架自动序列化）
        messageSender.send("order.created", order);
    }
    
    // 发送延迟消息（30分钟后超时取消）
    public void sendTimeoutMessage(Order order) {
        messageSender.sendDelay(
            "order.timeout", 
            order, 
            30 * 60 * 1000  // 30分钟，单位毫秒
        );
    }
    
    // 发送到自定义交换机
    public void sendToCustom(String exchange, String routingKey, Object data) {
        messageSender.send(exchange, routingKey, data);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class OrderMessageConsumer {
    
    // 消费订单创建消息
    @RabbitListener(queues = "thinkboot.order.created")
    public void handleOrderCreated(Order order) {
        log.info("收到订单创建消息: {}", order);
        // 处理订单创建后的业务逻辑（如发送通知、更新库存等）
    }
    
    // 消费订单超时消息
    @RabbitListener(queues = "thinkboot.order.timeout")
    public void handleOrderTimeout(Order order) {
        log.info("收到订单超时消息: {}", order);
        // 处理订单超时取消业务逻辑
    }
}

import com.thinkboot.mq.rocketmq.core.RocketMessageSender;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    
    private final RocketMessageSender sender;
    
    public OrderService(RocketMessageSender sender) {
        this.sender = sender;
    }
    
    // 发送普通消息
    public void createOrder(Order order) {
        saveOrder(order);
        sender.send("order-topic", order);
    }
    
    // 发送带 Tag 的消息
    public void sendWithTag(Order order) {
        sender.send("order-topic", order, "TagA");
    }
    
    // 发送顺序消息（保证同一订单的消息顺序消费）
    public void sendOrderly(Order order) {
        sender.sendOrderly("order-topic", order, String.valueOf(order.getId()));
    }
    
    // 发送延迟消息（延迟级别 1-18，对应不同延迟时间）
    // 级别3 = 10秒，级别4 = 30秒，级别5 = 1分钟，...
    public void sendDelay(Order order) {
        sender.sendDelay("delay-topic", order, 3);  // 10秒后消费
    }
    
    // 发送异步消息
    public void sendAsync(Order order) {
        sender.sendAsync("async-topic", order);
    }
    
    // 发送单向消息（不等待响应，适合日志收集等场景）
    public void sendOneway(String logData) {
        sender.sendOneway("log-topic", logData);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RocketMQMessageListener(
    topic = "order-topic",
    consumerGroup = "order-consumer-group"
)
public class OrderMessageConsumer implements RocketMQListener<Order> {
    
    @Override
    public void onMessage(Order order) {
        log.info("收到订单消息: {}", order);
    }
}

@Slf4j
@Component
@RocketMQMessageListener(
    topic = "order-topic",
    consumerGroup = "order-consumer-group",
    selectorExpression = "TagA || TagB"  // 只消费指定 Tag 的消息
)
public class OrderTagConsumer implements RocketMQListener<Order> {
    
    @Override
    public void onMessage(Order order) {
        log.info("收到指定 Tag 的订单消息: {}", order);
    }
}

@Slf4j
@Component
@RocketMQMessageListener(
    topic = "order-topic",
    consumerGroup = "order-orderly-consumer-group",
    consumeMode = ConsumeMode.ORDERLY  // 顺序消费
)
public class OrderOrderlyConsumer implements RocketMQListener<Order> {
    
    @Override
    public void onMessage(Order order) {
        log.info("按顺序收到订单消息: {}", order);
    }
}

import com.thinkboot.common.idempotent.Idempotent;

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    // 防止订单重复提交
    @Idempotent(key = "create_order", expire = 5, message = "订单正在处理中，请勿重复提交")
    @PostMapping
    public R<Order> createOrder(@RequestBody OrderDTO dto) {
        Order order = orderService.createOrder(dto);
        return R.success(order);
    }
}

import com.thinkboot.feign.fallback.ExampleFeignFallbackFactory;

@FeignClient(
    name = "user-service",
    path = "/api/users",
    fallbackFactory = UserFeignFallbackFactory.class
)
public interface UserFeignClient {
    @GetMapping("/{id}")
    R<User> getUserById(@PathVariable Long id);
}

@Component
public class UserFeignFallbackFactory implements FallbackFactory<UserFeignClient> {
    private static final Logger log = LoggerFactory.getLogger(UserFeignFallbackFactory.class);

    @Override
    public UserFeignClient create(Throwable cause) {
        return new UserFeignClient() {
            @Override
            public R<User> getUserById(Long id) {
                log.error("getUserById fallback, id={}, error={}", id, cause.getMessage());
                return R.error(503, "用户服务暂时不可用");
            }
        };
    }
}

import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.CacheEvict;

@Service
public class ProductService {

    // 查询时缓存结果
    @Cacheable(value = "product", key = "#id", unless = "#result == null")
    public Product getById(Long id) {
        return productMapper.selectById(id);
    }

    // 更新时刷新缓存
    @CachePut(value = "product", key = "#product.id")
    public Product update(Product product) {
        productMapper.updateById(product);
        return product;
    }

    // 删除时清除缓存
    @CacheEvict(value = "product", key = "#id")
    public void delete(Long id) {
        productMapper.deleteById(id);
    }

    // 批量清除缓存
    @CacheEvict(value = "product", allEntries = true)
    public void clearCache() {
        // 清除 product 缓存下所有条目
    }
}

package com.yourcompany.yourproject;

import com.baomidou.mybatisplus.annotation.IdType;
import com.thinkboot.codegen.ThinkBootCodeGenerator;

public class CodeGenerator {

    public static void main(String[] args) {
        ThinkBootCodeGenerator generator = new ThinkBootCodeGenerator();
        
        generator.url("jdbc:mysql://localhost:3306/your_db?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai")
                .username("root")
                .password("your_password")
                .tableName("tb_user", "tb_order")
                .moduleName("system")
                .author("YourName")
                .outputPath("D:/project/your-project/src/main/java")
                .parentPackage("com.yourcompany")
                .useBaseEntity(true)
                .useLogicDelete(true)
                .logicDeleteField("deleted")
                .idType(IdType.ASSIGN_ID)
                .ignoreTablePrefix("tb_")
                .generate();
    }
}

generator.tableName("tb_user")
         .disableController()
         .disableService()
         .disableServiceImpl()
         .generate();

@Service
public class UserServiceImpl extends BaseServiceImpl<UserMapper, User> {
    
    // 默认使用主库（写操作）
    public void createUser(User user) {
        this.save(user);
    }
    
    // 使用从库（读操作）
    @DS("slave_1")
    public User getUserById(Long id) {
        return this.getById(id);
    }
}

@Service
@DS("order_db")                    // 整个类使用订单库
public class OrderServiceImpl extends BaseServiceImpl<OrderMapper, Order> {
    public Order createOrder(Order order) {
        this.save(order);          // 使用 order_db
        return order;
    }
}

import cn.hutool.crypto.SecureUtil;
import cn.hutool.codec.Base64;

String key = SecureUtil.generateKey("HmacSHA256").toString();
String base64Key = Base64.encode(key.getBytes());
System.out.println(base64Key);

@IgnoreAuth
@GetMapping("/public/info")
public R<String> publicInfo() {
    return R.success("这是公开信息");
}

// 修改 PageRequest 中的默认限制
public class CustomPageRequest extends PageRequest {
    @Override
    public int getPageSize() {
        return pageSize < 1 ? 10 : (pageSize > 500 ? 500 : pageSize);
    }
}

@GetMapping("/me")
public R<User> getCurrentUser() {
    String userId = UserContext.getCurrentUserId();
    User user = userService.getById(Long.valueOf(userId));
    return R.success(user);
}