public interface UserMapperextends BaseMapper<User> {
    //一定要指定一个实体类范型<>!!!!
}

@TableName("tb_user")
public class User {
    @Tableld(value="id",type="") //主键相当重要，如果你无法遵守规定，那一定要记得加注解
	private Long id;
    @TableField("username")   //成员变量名与数据库字段名不一致
    private String name;
    @TableField("is_married") //成员变量名以is开头，且是布尔值
    private Boolean isMarried;
    @TableField("`order`")  //成员变量名与数据库关键字冲突
    private Integer order;
    @TableField(exis=false)   //成员变量不是数据库字段
    private String address;
}

UPDATE user SET balance = balance-200 WHERE id in(l，2，4)     //SQL
    
@Test    
void testUpdateWrapper(){
    List<Long> ids = List.of(1L，2L，4L);
    UpdateWrapper<User> wrapper = new UpdateWrapper<>()
        .setSql("balance = balance-200")
        .in("id",ids);
    //3.执行更新
    userMapper.update(null,wrapper);
}

@Test
void testLambdaQueryWrapper(){
	LambdaOuerywrapper<User> wrapper=new Lambdaouerywrapper<User>()
        .select(User::getId,User::getUsername,User::getInfo,User::getBalance)
        .like(User::getUsername,"o")
        .ge(UserBalance,1000);
	List<User> users = userMapper.selectList(wrapper);
	users.forEach(System.out::println);
}

public interface IUserService extends IService <User> {
	
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements IUserService {
	User user = new User();
	// user.setId(5L);
	user.setUsername("LiLei");
	user.setPassword("123");
	user.setPhone("18688990013");
	user.setBalance(200);
	user.setInfo（"{\"age\"：24，\"intro\"：\"英文老师\"，\"gender\"：\"female\"}");
	user.setCreateTime(LocalDateTime.now());
	user.setUpdateTime(LocalDateTime.now());
	userservice.save(user) ;
}

@Override
public void deductBalance(Long id, Integer money) {
    // 1.查询用户
    User user = getById(id);
    // 2.校验用户状态
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 3.校验余额是否充足
    if (user.getBalance() < money) {
        throw new RuntimeException("用户余额不足！");
    }
    // 4.扣减余额 update tb_user set balance = balance - ?
    baseMapper.deductBalance(id, money);
}
//Mapper
@Update（"UPDATE tb_userSETbalance=balance-#{money}WHEREid=#{id}")
void deductBalance(@Param("id"）Longid，@Param("money")Integermoney);

//如果mapper过于简单，还是建议自己写mapper的SQL

@Override
public List<User> queryUsers(String name, Integer status, Integer minBalance, Integer maxBalance) {
    return lambdaQuery()
            .like(name != null, User::getUsername, name)
            .eq(status != null, User::getStatus, status)
            .ge(minBalance != null, User::getBalance, minBalance)
            .le(maxBalance != null, User::getBalance, maxBalance)
            .list();
}

@Transactional
@Override
public void deductBalance(Long id, Integer money) {
    // 1.查询用户
    User user = getById(id);
    // 2.校验用户状态
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 3.校验余额是否充足
    if (user.getBalance() < money) {
        throw new RuntimeException("用户余额不足！");
    }
    // 4.扣减余额 update tb_user set balance = balance - ?
    int remainBalance = user.getBalance() - money;
    lambdaUpdate()
            .set(User::getBalance, remainBalance)
            .set(remainBalance == 0, User::getStatus, 2)
            .eq(User::getId, id)
        	.eq(User::getBalance，user·getBalance())      //乐观锁
            .update();
}

private User buildUser(int i) {
    User user = new User();
    user.setUsername("user_" + i);
    user.setPassword("123");
    user.setPhone("" + (18688190000L + i));
    user.setBalance(2000);
    user.setInfo("{\"age\": 24, \"intro\": \"英文老师\", \"gender\": \"female\"}");
    user.setCreateTime(LocalDateTime.now());
    user.setUpdateTime(user.getCreateTime());
    return user;
}

@Test
void testSaveOneByOne() {
    Long b = System.currentTimeMillis();
    for (int i = 1; i <= 100000; i++) {
        userService.save(buildUser(i));
    }
    Long e = System.currentTimeMillis();
    System.out.println("耗时：" + (e - b));
}

@Test
void testSaveBatch() {
    // 我们每次批量插入1000条，插入100次即10万条数据
    // 1.准备一个容量为1000的集合
    List<User> list = new ArrayList<>(1000);
    Long b = System.currentTimeMillis();
    for (int i = 1; i <= 100000; i++) {
        // 2.添加一个user
        list.add(buildUser(i));
        // 3.每1000条批量插入一次
        if (i % 1000 == 0) {
            userService.saveBatch(list);
            // 4.清空集合，准备下一批数据
            list.clear();
        }
    }
    Long e = System.currentTimeMillis();
    System.out.println("耗时：" + (e - b));
}

@Override
public UserVO queryUserAndAddressById(Long id) {
    // 1.查询用户
    User user = getById(id);
    if (user == null || user.getStatus() == 2) {
        throw new RuntimeException("用户状态异常！");
    }
    // 2.查询地址
    List<Address> addresses = Db.lambdaQuery(Address.class).eq(Address::getUserId, id).list();
    // 3.封装VO
    // 3.1.转User的PO为VO
    UserVO userVO = BeanUtil.copyProperties(user, UserVO.class);
    // 3.2.转地址VO
    if (CollUtil.isNotEmpty(addresses)) {
        userVO.setAddresses(BeanUtil.copyToList(addresses, AddressVO.class));
    }
    return userVO;
}

@Override
public List<UserVO> queryUserAndAddressByIds(List<Long> ids) {
    // 1. 根据传入的用户ID列表批量查询用户（使用MyBatis-Plus的listByIds方法，高效批量查询）
    List<User> users = listByIds(ids);
    // 1.1 如果没有查询到任何用户，直接返回空列表（避免后续无效操作）
    if (CollUtil.isEmpty(users)) {
        return Collections.emptyList();
    }

    // 2. 批量查询用户对应的地址（优化：避免循环查库，采用一次批量查询）
    // 2.1 从查询到的用户列表中提取所有用户ID（用于批量查询地址）
    List<Long> userIds = users.stream().map(User::getId).collect(Collectors.toList());
    // 2.2 根据用户ID批量查询地址（使用Db工具的lambdaQuery，简化代码；in条件匹配所有用户ID）
    List<Address> addresses = Db.lambdaQuery(Address.class).in(Address::getUserId, userIds).list();
    // 2.3 将地址PO（持久化对象）转换为VO（视图对象）（隐藏敏感字段，只返回前端需要的信息）
    List<AddressVO> addressVoList = BeanUtil.copyToList(addresses, AddressVO.class);
    // 2.4 将地址VO按用户ID分组（key：用户ID，value：该用户的所有地址VO列表）
    // 目的：后续给用户VO设置地址时，可快速通过用户ID获取对应的地址列表
    Map<Long, List<AddressVO>> addressMap = new HashMap<>(0); // 初始化容量为0，后续会自动扩容
    if (CollUtil.isNotEmpty(addressVoList)) {
        addressMap = addressVoList.stream()
                .collect(Collectors.groupingBy(AddressVO::getUserId)); // 按userId分组
    }

    // 3. 将用户PO转换为VO，并关联对应的地址VO（最终返回给前端的DTO）
    List<UserVO> userVoList = new ArrayList<>(users.size()); // 初始化容量为用户列表大小，避免扩容
    for (User user : users) {
        // 3.1 将用户PO转换为VO（复制属性，如id、username等）
        UserVO userVo = BeanUtil.copyProperties(user, UserVO.class);
        // 3.2 从地址分组map中获取该用户的地址列表（如果没有地址，会返回null，可设置为空列表避免NPE）
        List<AddressVO> userAddresses = addressMap.getOrDefault(user.getId(), Collections.emptyList());
        // 3.3 将地址列表设置到用户VO中
        userVo.setAddresses(userAddresses);
        // 3.4 将用户VO添加到结果列表
        userVoList.add(userVo);
    }

    // 返回最终的用户VO列表（包含每个用户的地址信息）
    return userVoList;
}

@Getter
public enum UserStatus {
    NORMAL(value: 1, desc: "正常"),
    FROZEN(value: 2, desc: "冻结"),
    ;

    @EnumValue
    private final int value;

    @JsonValue //Jackson 注解，指定 JSON 序列化时返回的字段（此处序列化为 desc 的值，如 "正常"/"冻结"，而非枚举名）。
    private final String desc;

    UserStatus(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }
}

@Configuration
public class MybatisConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        // 1.初始化核心插件
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 2.添加分页插件
        PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        pageInterceptor.setMaxLimit(1000L); // 设置分页数上限
        interceptor.addInnerInterceptor(pageInterceptor);
        return interceptor;
    }
}

@Test
void testPageQuery() {
    // 1.1.分页参数
    int pageNo = 1, pageSize = 5;
    // 1.2.排序参数，通过OrderItem来指定
    Page<User> page = Page.of(pageNo, pageSize);
    page.addOrder(new OrderItem("balance", false)); // 按balance降序排列
    // 1.3.分页查询
    Page<User> p = userService.page(page);
    
    // 2.总条数
    System.out.println("total = " + p.getTotal());
    // 3.总页数
    System.out.println("pages = " + p.getPages());
    // 4.分页数据
    List<User> records = p.getRecords();
    records.forEach(System.out::println);
}

@Data
@ApiModel(description = "分页查询实体")
public class PageQuery {
    @ApiModelProperty("页码")
    private Integer pageNo;
    
    @ApiModelProperty("页码")
    private Integer pageSize;
    
    @ApiModelProperty("排序字段")
    private String sortBy;
    
    @ApiModelProperty("是否升序")
    private Boolean isAsc;
}

@Data
@ApiModel(description="分页结果")
public class PageDTO <T> {
    @ApiModeLProperty("总条数")
	private Integer total;
	@ApiModelProperty("总页数")
	private Integer pages;
	@ApiModelProperty("集合")
	private List<T> list;
}

@Override
public PageDTO<UserVO> queryUsersPage(UserQuery query) {
    // 从查询参数中提取需要的条件（用户名模糊查询、状态精确查询）
    String name = query.getName();
    Integer status = query.getStatus();

    // 1. 构建分页条件（MyBatis-Plus的Page对象，封装页码和页大小）
    // Page.of(pageNo, pageSize)：创建分页对象，pageNo是当前页码，pageSize是每页显示条数
    Page<User> page = Page.of(query.getPageNo(), query.getPageSize());

    // 2. 构建排序条件（动态处理，优先使用传入的排序字段，否则用默认规则）
    if (StrUtil.isNotBlank(query.getSortBy())) {
        // 如果传入了排序字段（sortBy），则按该字段和排序方式（isAsc）排序
        // OrderItem：MyBatis-Plus的排序项，参数1是排序字段（数据库字段名或实体属性名），参数2是是否升序（true=升序，false=降序）
        page.addOrder(new OrderItem(query.getSortBy(), query.getIsAsc()));
    } else {
        // 如果未传入排序字段，默认按数据库的`update_time`字段降序排序（展示最新更新的用户）
        // column="update_time"：数据库中的更新时间字段名；asc: false：降序排列
        page.addOrder(new OrderItem(column: "update_time", asc: false));
    }

    // 3. 执行分页查询（使用MyBatis-Plus的LambdaQueryWrapper构建查询条件）
    // lambdaQuery()：获取Lambda查询构造器（支持Lambda表达式，避免硬编码字段名）
    // like(condition: name != null, User::getUsername, name)：模糊查询用户名（只有当name不为null时才添加该条件）
    // eq(condition: status != null, User::getStatus, status)：精确查询用户状态（只有当status不为null时才添加该条件）
    // page(page)：执行分页查询，将查询结果封装到page对象中（包含总条数、总页数、当前页数据等）
    Page<User> p = lambdaQuery()
            .like(/* condition */ name != null, /* column */ User::getUsername, /* value */ name)
            .eq(/* condition */ status != null, /* column */ User::getStatus, /* value */ status)
            .page(page);

    // 4. 转换结果为前端需要的VO（View Object），避免返回实体类暴露敏感信息
    // PageDTO：自定义的分页响应DTO（封装总条数、总页数、当前页数据等）
    PageDTO<UserVO> dto = new PageDTO<>();
    dto.setTotal(p.getTotal()); // 设置总记录数（从分页结果中获取）
    dto.setPages(p.getPages()); // 设置总页数（从分页结果中获取）

    // 获取当前页的用户实体列表（从分页结果中获取）
    List<User> records = p.getRecords();
    if (CollUtil.isEmpty(records)) {
        // 如果没有数据，设置空列表并返回（避免返回null，前端处理更友好）
        dto.setList(Collections.emptyList());
        return dto;
    }

    // 将User实体列表转换为UserVO列表（使用工具类复制属性，如Hutool的BeanUtil）
    // UserVO：视图对象，只包含前端需要的字段（如隐藏密码、创建时间等敏感信息）
    dto.setList(BeanUtil.copyToList(records, UserVO.class));

    // 5. 返回封装好的分页响应DTO
    return dto;
}

@Data
@ApiModel(description = "分页查询实体")
public class PageQuery {
    @ApiModelProperty("页码")
    private Integer pageNo=1;
    
    @ApiModelProperty("页码")
    private Integer pageSize=5;
    
    @ApiModelProperty("排序字段")
    private String sortBy;
    
    @ApiModelProperty("是否升序")
    private Boolean isAsc=true;
    
    //可变参数（Variable Arguments，简称 Varargs）是 Java 5 引入的特性，
    //允许方法接受零个或多个相同类型的参数。它简化了需要处理不定数量参数的方法设计。
    public <T> Page<T> toMpPage(OrderItem ... items){
    	// 1.分页条件
    	Page<T> page = Page.of(pageNo, pageSize);
    	// 2.排序条件
    	if(StrUtil.isNotBlank(sortBy)){
        	// 不为空
        	page.addOrder(new OrderItem(sortBy, isAsc));
    	}else if(items !=null){
        	// 为空，默认按照更新时间排序
        	page.addOrder(items);
    	}
        return page;
	}
    
	public <T> Page<T> toMpPage(String defaultSortBy, Boolean defaultAsc) {
    	return toMpPage(new OrderItem(defaultSortBy, defaultAsc));
	}
	public <T> Page<T> toMpPageDefaultSortByCreateTime() {
    	return toMpPage(new OrderItem(column: "create_time", asc: false));
	}
	public <T> Page<T> toMpPageDefaultSortByUpdateTime() {
    	return toMpPage(new OrderItem(column: "update_time", asc: false));
	} 
}

@Data
@ApiModel(description="分页结果")
public class PageDTO <T> {
    @ApiModeLProperty("总条数")
	private Integer total;
	@ApiModelProperty("总页数")
	private Integer pages;
	@ApiModelProperty("集合")
	private List<T> list;
    
    public static <PO, VO> PageDTO<VO> of(Page<PO> p, Class<VO> clazz) {
    	PageDTO<VO> dto = new PageDTO<>();
    	// 1.总条数
    	dto.setTotal(p.getTotal());
    	// 2.总页数
    	dto.setPages(p.getPages());
    	// 3.当前页数据
    	List<PO> records = p.getRecords();
    	if (CollUtil.isEmpty(records)) {
        	dto.setList(Collections.emptyList());
        	return dto;
   	 	}
    	// 4.拷贝user的VO
    	dto.setList(BeanUtil.copyToList(records, clazz));
    	// 5.返回
    	return dto;
	}
}

@Override
public PageDTo <UserVo> queryUsersPage(UserQuery query) {
	String name = query.getName();
    Integer status = query.getstatus();
    //1.构建分页条件
	Page<User> page = query.toMpPageDefaultSortByUpdateTime();
	//2.分页查询
	Page<User>p = lambdaQuery()
        .like(name != null，，User::getUsername，name)
		.eq(status != null,，User::getStatus，status)
		.page(page);
	//3.封装V0结果
	return PageDTo.of(p,UserVo.class);
}

public static <PO, VO> PageDTO<VO> of(Page<PO> p, Class<VO> clazz) {
    PageDTO<VO> dto = new PageDTO<>();
    // 1.总条数
    dto.setTotal(p.getTotal());
    // 2.总页数
    dto.setPages(p.getPages());
    // 3.当前页数据
    List<PO> records = p.getRecords();
    if (CollUtil.isEmpty(records)) {
        dto.setList(Collections.emptyList());
        return dto;
    }
    // 4.拷贝user的VO
    dto.setList(BeanUtil.copyToList(records, clazz));
    // 5.返回
    return dto;
}


@Override
public PageDTo <UserVo> queryUsersPage(UserQuery query) {
	String name = query.getName();
    Integer status = query.getstatus();
    //1.构建分页条件
	Page<User> page = query.toMpPageDefaultSortByUpdateTime();
	//2.分页查询
	Page<User>p = lambdaQuery()
        .like(name != null，，User::getUsername，name)
		.eq(status != null,，User::getStatus，status)
		.page(page);
	//3.封装V0结果
	return PageDTo.of(p,user->{
		//自己的处理逻辑
	});
}

@MapperScan("com.hmall.cart.mapper")
@SpringBootApplication
public class CartApplication {
    public static void main(String[] args) {
        SpringApplication.run(CartApplication.class, args);
    }

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

@Service
/*自动生成构造器 （@RequiredArgsConstructor）
        为类中所有 final 字段 和 标记为 @NonNull 的字段 生成一个包含这些参数的构造器。

        简化依赖注入
        特别适用于 Spring 的构造器注入（无需手动写 @Autowired 构造器）。

        强制初始化
        确保 final 或 @NonNull 字段在对象创建时被明确赋值（避免 NullPointerException）*/
@RequiredArgsConstructor
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements ICartService {
    
    private final RestTemplate restTemplate;
    
    private void handleCartItems(List<CartVO> vos) {
        // TODO 获取商品信息
        // 1.获取商品id
        Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());

        // 2.查询商品
        // 2.1 利用restTemplate发起http请求，得到http的响应
        ResponseEntity<List<ItemDTO>> response = restTemplate.exchange(
                "http://localhost:8081/items?ids={ids}",
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<List<ItemDTO>>() {
                },
                Map.of("ids", CollUtil.join(itemIds, ","))
        );

        // 2.2 解析响应
        if (!response.getStatusCode().is2xxSuccessful()){
            return;
        }
        List<ItemDTO> items = response.getBody();
        if(CollUtils.isEmpty(items)){
            return;
        }

//        // 2.查询商品
//        List<ItemDTO> items = itemService.queryItemByIds(itemIds);
//        if (CollUtils.isEmpty(items)) {
//            return;
//        }
        // 3.转为 id 到 item的map
        Map<Long, ItemDTO> itemMap = items.stream().collect(Collectors.toMap(ItemDTO::getId, Function.identity()));
        // 4.写入vo
        for (CartVO v : vos) {
            ItemDTO item = itemMap.get(v.getItemId());
            if (item == null) {
                continue;
            }
            v.setNewPrice(item.getPrice());
            v.setStatus(item.getStatus());
            v.setStock(item.getStock());
        }
    }
}

private final DiscoveryClient discoveryClient;

private void handleCartItems(List<CartVO> vos) {
    // 1. 根据服务名称，拉取服务的实例列表
    List<ServiceInstance> instances = discoveryClient.getInstances("item-service");
    // 2. 负载均衡，挑选一个实例（随机策略）
    ServiceInstance instance = instances.get(RandomUtil.randomInt(instances.size()));
    // 3. 获取实例的IP和端口（通过URI）
    URI uri = instance.getUri();
    // ... 略（后续可通过uri调用服务，如httpClient或RestTemplate）
}

@EnableFeignClients  // 启用 OpenFeign 客户端
@SpringBootApplication
public class CartApplication {  // 启动类（示例为购物车服务）
    // ... 略（无需额外配置，自动扫描 Feign 接口）
}

@FeignClient(value = "itgm-service") // 指定目标服务名称（需与注册中心中的服务名一致）
public interface ItemClient {
    // 声明远程服务的API（与服务端接口完全一致）
    @GetMapping("/items") // 服务端的请求路径（需与服务端控制器路径匹配）
    List<ItemDTO> queryItemByIds(
        @RequestParam("ids") Collection<Long> ids // 请求参数（需与服务端参数名、类型一致）
    );
}

// 在业务类中注入FeignClient代理对象（Spring自动生成）
@Autowired
private ItemClient itemClient;

// 像调用本地方法一样调用远程服务
List<ItemDTO> items = itemClient.queryItemByIds(List.of(1, 2, 3)); // 传递参数（示例为1、2、3）

@EnableFeignClients(basePackages="com.hmall.api.clients")

@EnableFeignClients(clients ={UserClient.class})

package com.hmall.api.config;

public class DefaultFeignConfig {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.FULL;
    }
}

@FeignClient(value = "item-service", configuration = DefaultFeignConfig.class)

@EnableFeignClients(defaultConfiguration = DefaultFeignConfig.class)

public class MyGlobalFilter implements GlobalFilter , Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // TODO: 模拟登录校验
        // 获取当前请求对象（包含HTTP请求的所有信息）
        ServerHttpRequest request = exchange.getRequest();

        // 从请求对象中提取请求头信息（包含Authorization、Content-Type等所有header）
        HttpHeaders headers = request.getHeaders();

        // 打印请求头信息（调试用，生产环境建议改用日志框架）
        System.out.println("headers = " + headers);

        // 放行请求：将请求传递给过滤器链中的下一个处理器
        // 若不调用此方法，请求将被拦截在此过滤器
        return chain.filter(exchange);
    }
    // 设置过滤器的执行顺序
    @Override
    public int getOrder() {
        //过滤器执行顺序，值越小，优先级越高
        return 0;
    }
}

@Component
@RequiredArgsConstructor
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    private final AuthProperties authProperties;

    private final JwtTool jwtTool;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1. 获取请求头
        ServerHttpRequest request = exchange.getRequest();
        //2。判断是否要进行登录拦截
        if(isExclude(request.getPath().toString())){
            // 不需要登录, 直接放行
            return chain.filter(exchange);
        }
        //3. 获取请求头中的token
        String token = null;
        List<String> headers = request.getHeaders().get("authorization");
        if(headers !=null && !headers.isEmpty()){
            token = headers.get(0);
        }
        //4. 校验并解析token
        Long userId = null;
        try {
            userId = jwtTool.parseToken(token);
        } catch (UnauthorizedException e) {
            //拦截，设置状态码为401
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        // TODO 5.传递用户信息
        System.out.println("userId = " + userId);
        //6. 放行
        return chain.filter(exchange);
    }

    private boolean isExclude(String path) {
        for (String pathPattern :authProperties.getExcludePaths()){
            if (antPathMatcher.match(pathPattern,path)){
                return true;
            }
        }
        return false;
    }

    @Override
    public int getOrder() {
        return 0;
    }

}

String userInfo = userId.toString();
ServerWebExchange swe = exchange.mutate()
                .request(builder -> builder.header("user-info", userInfo))
                .build();

public class UserInfoInterceptor implements HandlerInterceptor{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取用户信息
        String userInfo = request.getHeader("user-info");
        //判断是否获取了用户信息，如果有，存入ThreadLocal
        if(StrUtil.isNotBlank(userInfo)){
            // 获取用户信息放入ThreadLocal
            UserContext.setUser(Long.valueOf(userInfo));
        }
        // 放行
        return true;
    }
    @Override
    public void afterCompletion (HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 清理用户，删除是为了防止oom
        UserContext.removeUser();
    }

}




@Configuration
@ConditionalOnClass(DispatcherServlet.class)
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new UserInfoInterceptor());
    }
}

@ConditionalOnClass(DispatcherServlet.class)

@EnableFeignClients(basePackages = "com.hmall.api.client",defaultConfiguration = DefaultFeignConfig.class)
@MapperScan("com.hmall.trade.mapper")
@SpringBootApplication
public class TradeApplication {
    public static void main(String[] args) {
        SpringApplication.run(TradeApplication.class, args);
    }
}

public String getConfig(String dataId, String group, long timeoutMs) throws NacosException

try {
	String serverAddr = "{serverAddr}";
	String dataId = "{dataId}";
	String group = "{group}";
	Properties properties = new Properties();
	properties.put("serverAddr", serverAddr);
	ConfigService configService = NacosFactory.createConfigService(properties);
	String content = configService.getConfig(dataId, group, 5000);
	System.out.println(content);
} catch (NacosException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

private final NacosConfigManager nacosConfigManager;

public void initRouteConfigListener() throws NacosException {
    // 1.注册监听器并首次拉取配置
    String configInfo = nacosConfigManager.getConfigService()
            .getConfigAndSignListener(dataId, group, 5000, new Listener() {
                @Override
                public Executor getExecutor() {
                    return null;
                }

                @Override
                public void receiveConfigInfo(String configInfo) {
                    // TODO 监听到配置变更，更新一次配置
                }
            });
    // TODO 2.首次启动时，更新一次配置
}