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

<dependencyManagement>
	<dependencies>
		<dependency>
			<!-- Import dependency management from Spring Boot -->
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-dependencies</artifactId>
			<version>4.0.0-RC2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

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

@RestController
public class HelloController {

    @GetMapping("/index")
    public String hello(){
        return "Hello Spring Boot 4.0版本";
    }
}

public final class WebMvcAutoConfiguration {
    public static final String DEFAULT_PREFIX = "";
    public static final String DEFAULT_SUFFIX = "";
    private static final String SERVLET_LOCATION = "/";

    public WebMvcAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean({HiddenHttpMethodFilter.class})
    @ConditionalOnBooleanProperty({"spring.mvc.hiddenmethod.filter.enabled"})
    OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
        return new OrderedHiddenHttpMethodFilter();
    }
    //.........................
}

@Component
public class RedisManager {
    
    public void set(String key, String value) {
        // redis 操作
    }
}

@RestController
public class HelloController {

    @GetMapping("/index")
    public String hello(){
        return "Hello Spring Boot 4.0版本";
    }
}

@Service
public class UserServiceImpl {
    
    public void addUser(User user) {
        // 添加用户业务逻辑
    }
}

@Configuration
public class DataSourceConfig {

    @Bean
    public Connection dataSource(){
        DataSource ds = new PooledDataSource();
        try {
            Connection connection = ds.getConnection("zhangsan", "suier23");
            return connection;
        } catch (SQLException e) {
           e.printStackTrace();
        }
        return null;

    }
}

@Configuration
@Import({Student.class} )
public class ApplicationConfig {
    // 其他声明bean的代码
}

public class OffLineDiscountService {

    //八折
    private int discount = 8;

    public int compute(Integer price){
        return discount * price / 10;
    }
}

//线上商品折扣
public class OnLineDiscountService {

    //6折
    private int discount = 6;

    public int compute(Integer price){
        return discount * price / 10;
    }
}

public class ManagerBeanRegistrar implements BeanRegistrar {
    @Override
    public void register(BeanRegistry registry, Environment env) {
        System.out.println("==============Registered Bean===============");
        registry.registerBean("offLineDiscountService", OffLineDiscountService.class);

        if( env.matchesProfiles("online")){
            System.out.println("=============online=Registered Bean===============");
            registry.registerBean("onLineDiscountService", OnLineDiscountService.class , spe->{
                spe.description("电商渠道使用的折扣对象")
                        .lazyInit()
                        .order(-1);
            });
        }
    }
}

@Configuration
@Import(ManagerBeanRegistrar.class)
public class MyConfiguration {
}

spring:
  profiles:
    active: online

@SpringBootTest
class Boot06RegistBeanApplicationTests {


    @Resource
    private ApplicationContext ac;

    @Test
    void testRegistBean() {
        System.out.println("myUserService = " + myUserService);

        OnLineDiscountService online = ac.getBean(OnLineDiscountService.class);
        System.out.println("online = " + online);

        OffLineDiscountService offLine = ac.getBean(OffLineDiscountService.class);
        System.out.println("offLine = " + offLine);

    }
}

spring.application.name=MyFirstWebApp
server.port=8888
server.servlet.context-path=/myweb
#我是注释

spring:
  application:
     name: MyFirstWebApp
server:
  port: 8888
  servlet:
    context-path: /myweb
#我是注释    

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

spring:
  application:
     name: MyFirstWebApp
server:
  port: 8888
  servlet:
    context-path: /myweb
#我是注释
app.info: 掌握外部配置

@RestController
public class HelloController {

    @Value("${server.servlet.context-path}")
    private String path;

    @Value("${server.port:9090}")
    private Integer port;

    @Value("${app.info}")
    private String appInfo;

    @GetMapping("/index")
    public String hello(@Value("${spring.application.name}") String appName){
        return "Hello Spring Boot 4.0版本: 应用名称：" + appName + ", info: " + appInfo;
    }
}

    @Resource
    private Environment env;
    @GetMapping("/env")
    public String env(){
        String appName = env.getProperty("spring.application.name");
        String appPort = env.getProperty("server.port");
        String javaPath = env.getProperty("JAVA_HOME");
        return "Hello Spring Boot 4.0版本: 应用名称："
                + appName + ", 运行端口号: " + appPort
                + ", JAVA_HOME: " + javaPath;
    }

zhang:
  name: 张三
  age: 18

@ConfigurationProperties(prefix = "zhang")
public class Student {
    private String name;
    private int age;
    // set | get | toString

@EnableConfigurationProperties({Student.class})
@SpringBootApplication
public class Course01QuickApplication {

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

}

@Resource
private Student student;

@GetMapping("/student")
public String configStudent(){
    return student.toString();
}

# 在 application.yml 中指定激活的 profile
spring.profiles.active=dev

# 或通过命令行参数
--spring.profiles.active=prod

# 或通过环境变量
SPRING_PROFILES_ACTIVE=test

zhang:
  name: 张三-测试
  age: 28

zhang:
  name: 张三-开发
  age: 30

spring:
  application:
     name: MyFirstWebApp
server:
  port: 8808
  servlet:
    context-path: /myweb
#我是注释
app.info: 掌握外部配置

@Resource
private Student student;

@GetMapping("/student")
public String configStudent(){
    return student.toString();
}

spring:
  application:
     name: MyFirstWebApp
  profiles:
    active: dev

@Component
@Profile("dev")
public class DevService {
}


@Component
@Profile("!prod")
public class ProdService {
    // 除了 prod 环境都生效
}

@Autowired(required = false)
private DevService devService;

@Autowired
private ProdService prodService;

@GetMapping("/profile")
public String profile(){
    return devService + " | " + prodService;
}

@Component
public class InitCache implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        String dbName = args[0];
        System.out.println("从数据库["+dbName+"]读取 字典数据 放入内存");
    }
}

@Component
@Order(2)
public class InitRedis implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("初始化redis数据" + args.getNonOptionArgs().get(0));
    }
}

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

@RestController
public class WebController {

    @RequestMapping("/index")
    public String index(){
        return "SpringMVC模块创建http协议的Web应用";
    }
}

protected static class DispatcherServletConfiguration {
    protected DispatcherServletConfiguration() {
    }

    @Bean(
        name = {"dispatcherServlet"}
    )
    DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
        DispatcherServlet dispatcherServlet = new DispatcherServlet();
        dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
        dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
        dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
        dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
        return dispatcherServlet;
    }
    //...
}

<html lang="en">
  <head>
    <meta charset="UTF-8">
    <title>显示用户列表</title>
  </head>
  <body>
    <h1>显示用户列表的页面</h1>
    <div>
      第一个用户... <br/>
      第二个用户... <br/>
    </div>
  </body>
</html>

@Controller
public class UserController {
    @RequestMapping("/list")
    public String userList(){
        return "/users.html";
    }
}

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/list")
    public String userList(){
        return "/users.html";
    }
}

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public String userList(){
        return "/users.html";
    }
}

<form action="/user/add" method="post">
  用户姓名：<input type="text" name="name">
  用户年龄：<input type="text" name="age">
  <input type="submit" value="提交">
</form>

@RestController
@RequestMapping("/user")
public class SysUserController {
    @RequestMapping(value = "/add",method = RequestMethod.POST)
    public String userList(String name,Integer age){
        String msg="注册的用户是：" + name + "，年龄是：" + age;
        return msg;
    }
}

<form action="/user/edit" method="post" enctype="application/x-www-form-urlencoded">
  用户姓名：<input type="text" name="username">
  用户年龄：<input type="text" name="userage">
  <input type="submit" value="提交">
</form>

@PostMapping(value = "/edit")
public String userEdit(@RequestParam("username") String name,
                       @RequestParam("userage") Integer age){
    String msg="编辑的用户是：" + name + "，年龄是：" + age;
    return msg;
}

<form action="/user/query" method="get" enctype="application/x-www-form-urlencoded">
  用户姓名：<input type="text" name="userName">
  用户年龄：<input type="text" name="userAge">
  <input type="submit" value="提交">
</form>

@GetMapping("/query")
public String userQuery(UserQuery userQuery){
    String msg="查询条件是：" + userQuery.getUserName()
             + "，年龄是：" + userQuery.getUserAge();
    return msg;
}

<button onclick="fetchJson()">点击获取用户列表</button>

<script>

  function fetchJson() {
    fetch('http://localhost:8080/user/json', {
      body: JSON.stringify({
        userName: '张三',
        userAge: 18
      }),
      headers: {
        //告诉服务器本次提交json格式数据
        'Content-Type': 'application/json'
      },
      method: 'post',
    }).then(function (response) {
      //return response.json();
      console.log(response.body)
    }).then(function (json) {
      console.log(json);
    })
  }

</script>

@PostMapping("/json")
public String receiveJson(@RequestBody UserQuery userQuery){
    return "接收到的JSON数据是：" + userQuery.getUserName()
    + "，年龄是：" + userQuery.getUserAge();
}

@PostMapping("/json")
public String receiveJson(@RequestBody UserQuery userQuery){
    return "接收到的JSON数据是：" + userQuery.getUserName()
    + "，年龄是：" + userQuery.getUserAge();
}

@PostMapping("/json")
public void receiveJson(@RequestBody UserQuery userQuery, HttpServletResponse response) throws IOException {
    String msg = "接收到的JSON数据是：" + userQuery.getUserName()
    + "，年龄是：" + userQuery.getUserAge();

    response.setContentType("text/html;charset=utf-8");
    PrintWriter writer = response.getWriter();
    writer.println(msg);
    writer.flush();
    writer.close();

}

public class UserVo {
    private String name;
    private String sex;
    private String birthday;
    // set | get方法
}

@GetMapping("/detail")
public UserVo queryUser(String id){
    UserVo userVo = new UserVo();
    userVo.setName("张三");
    userVo.setSex("男");
    userVo.setBirthday("1990-01-01");
    return userVo;
}

{"birthday":"1990-01-01","name":"张三","sex":"男"}

public class Result<T> {
    //自定义响应code
    private String code;
    //自定义响应msg
    private String msg;
    //自定义响应业务数据
    private T data;
    public Result() {
    }
    public Result(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    public Result(String code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    public static Result<String> success() {
        return new Result<>("200", "操作成功");
    }

    public static <T> Result<T> success(T data) {
        return new Result<>("200", "操作成功",data);
    }

    public static <T> Result<T> fail(String code, String msg) {
        return new Result<>(code, msg );
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    public T getData() {
        return data;
    }
}

@GetMapping("/getUser")
public Result<UserVo> getUser(String id){
    UserVo userVo = new UserVo();
    userVo.setName("张三");
    userVo.setSex("男");
    userVo.setBirthday("1990-01-01");
    return Result.success(userVo);
}

{"code":"200","data":{"birthday":"1990-01-01","name":"张三","sex":"男"},"msg":"操作成功"}

@GetMapping("/resp1")
public ResponseEntity<UserVo> actionOne(){
    UserVo userVo = new UserVo();
    userVo.setName("张三");
    userVo.setSex("男");
    userVo.setBirthday("1990-01-01");

    return ResponseEntity.ok(userVo);
}

@GetMapping("/resp1")
public ResponseEntity<String> actionTwo(String id){
    if( id == null ){
        // 400 ,请求参数错误
        return ResponseEntity.badRequest().build();
    }
    
    if ( !id.equals("1")){
        // 403 权限不足
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body("权限不足");
    }
    
    return ResponseEntity.ok("查询成功");
}

public ResponseEntity(@Nullable T body, @Nullable HttpHeaders headers, int rawStatus) {
    this(body, headers, HttpStatusCode.valueOf(rawStatus));
}

@GetMapping("/resp3")
public ResponseEntity<UserVo> actionThree(String id){
    UserVo userVo = new UserVo();
    userVo.setName("张三");
    userVo.setSex("男");
    userVo.setBirthday("1990-01-01");
    
    //增加应答header
    HttpHeaders headers = new HttpHeaders();
    headers.add("token", "123456");
    //响应头名称：只能包含 A-Z/a-z/0-9/-/_ 等可打印 ASCII 字符，不能包含中文、空格、特殊符号（如：、；、= 等）；
    //headers.add("name", "张三"); 无效，会被tomcat自动删除
    headers.add("name", "zhangsan");
    //构造方法，参数1：响应体，参数2：响应头，参数3：状态码
    return new ResponseEntity(userVo, headers, HttpStatus.OK );
}

@GetMapping("/resp4")
public ResponseEntity<Result<UserVo>> actionFour(String id){
UserVo userVo = new UserVo();
userVo.setName("张三");
userVo.setSex("男");
userVo.setBirthday("1990-01-01");

//增加应答header
HttpHeaders headers = new HttpHeaders();
headers.add("token", "123456");
headers.add("name", "zhangsan");

//构造方法，参数1：响应体，参数2：响应头，参数3：状态码
return new ResponseEntity(Result.success(userVo), headers, HttpStatus.OK );
}

{
  "timestamp": "2025-11-26T11:10:55.702Z",
  "status": 500,
  "error": "Internal Server Error",
  "path": "/user/getUser"
}

import java.net.URI;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler( { ArithmeticException.class, NullPointerException.class})
    public Result<String> handleException(Exception e){
        e.printStackTrace();
        return Result.fail("500","服务器异常");
    }

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<Result<String>> handleRuntimeException(RuntimeException e){
        e.printStackTrace();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                         .body(Result.fail("500","服务器异常"));
    }

    @ExceptionHandler(ArrayIndexOutOfBoundsException.class)
    public ResponseEntity<ProblemDetail> handleMethodArgumentNotValid(ArrayIndexOutOfBoundsException e, HttpServletRequest request) {

        ProblemDetail problemDetail = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        problemDetail.setTitle("数组越界了异常");
        problemDetail.setDetail("访问数组元素不在范围内容");
        problemDetail.setInstance( URI.create(request.getRequestURI()));
        problemDetail.setProperty("errorCode", "VALIDATE_001");
        return ResponseEntity.badRequest().body(problemDetail);
    }
}

{
  "detail": "访问数组元素不在范围内容",
  "instance": "/user/getUser",
  "status": 400,
  "title": "数组越界了异常",
  "errorCode": "VALIDATE_001"
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
    private String id;
    private String name;
}

@RestController
public class ScmController {

    @RequestMapping(value = "/orders",version = "1.0")
    public ResponseEntity<Order> listOrdersByV1(){
        Order order = new Order("A001","杭州3日自由行");
        return ResponseEntity.ok(order);
    }

    @RequestMapping(value = "/orders",version = "2.0")
    public ResponseEntity<Order> listOrdersByV2(){
        Order order = new Order("A002","15日游轮欧洲游AA");
        return ResponseEntity.ok(order);
    }
}

@Configuration
public class WebMvcConfig  implements WebMvcConfigurer {
    @Override
    public void configureApiVersioning(ApiVersionConfigurer configurer) {
       configurer.useRequestHeader("X-API-VERSION");
    }
}

configurer.usePathSegment(index);

@RestController
public class ScmController {

    @RequestMapping(value = "/api/{version}/orders",version = "v1")
    public ResponseEntity<Order> listOrdersByV1(){
        Order order = new Order("A001","杭州3日自由行");
        return ResponseEntity.ok(order);
    }

    @RequestMapping(value = "/api/{version}/orders",version = "v2")
    public ResponseEntity<Order> listOrdersByV2(){
        Order order = new Order("A002","15日游轮欧洲游AA");
        return ResponseEntity.ok(order);
    }
}

@Configuration
public class WebMvcConfig  implements WebMvcConfigurer {
    @Override
    public void configureApiVersioning(ApiVersionConfigurer configurer) {
        //路径包含版本参数
        configurer.usePathSegment(1);
    }
}

@RestController
public class ScmController {

    @RequestMapping(value = "/api/orders",version = "v1")
    public ResponseEntity<Order> listOrdersByV1(){
        Order order = new Order("A001","杭州3日自由行");
        return ResponseEntity.ok(order);
    }

    @RequestMapping(value = "/api/orders",version = "v2")
    public ResponseEntity<Order> listOrdersByV2(){
        Order order = new Order("A002","15日游轮欧洲游AA");
        return ResponseEntity.ok(order);
    }
}

@Configuration
public class WebMvcConfig  implements WebMvcConfigurer {
    @Override
    public void configureApiVersioning(ApiVersionConfigurer configurer) {
        //请求参数ver表示版本参数
        configurer.useQueryParam("ver");
    }
}

@RestController
public class AdminController {
    @GetMapping("/admin/index")
    public String listAdmin(){
        return "管理员页面";
    }
}

@Component
public class AuthInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String role = request.getParameter("role");
        String uri = request.getRequestURI();
        if ("/admin/index".equals(uri) && "admin".equals(role)) {
            return true;
        }
        return false;
    }
}

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    private static final String[] EXCLUDE_PATH = {"/", "/index", "/login",
                                                  "/css/**", "/js/**", "/fonts/**", "/img/**", "/error"};
    private static final String[] INCLUDE_PATH = { "/**"};

    @Resource
    private AuthInterceptor authInterceptor;

    /**
     * 添加拦截器
     * @param registry 协助添加拦截器的对象
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor)
        .addPathPatterns(INCLUDE_PATH)  //拦截uri，对这些uri请求应用拦截的preHandle()
        .excludePathPatterns(EXCLUDE_PATH);  //这些地址不拦截

    }
}

server:
  # 基础Web配置
  port: 8080 # 服务端口（默认8080，修改为0则随机端口）
  servlet:
    context-path: /demo # 应用上下文路径（默认/，访问路径变为 http://localhost:8080/demo/xxx）
  # Tomcat专属配置
  tomcat:
    # 字符编码（与server.servlet.encoding配合，双重保障）
    uri-encoding: UTF-8
    # 线程池配置（核心！影响并发能力）
    threads:
      max: 200 # 最大工作线程数（默认200，根据服务器CPU核数调整：核数*2+1）
      min-spare: 10 # 核心线程数（默认10，保持一定空闲线程，减少创建开销）
      max-queue-capacity: 100 # 请求队列最大容量（默认无界，建议设置，避免OOM）
    # 连接配置
    connection-timeout: 20000ms # 连接超时时间（默认20秒，单位ms/s/m/h）
    keep-alive-timeout: 5000ms # 长连接超时时间（默认5秒，0表示禁用）
    max-connections: 10000 # 最大连接数（默认8192，包括同步+异步连接）
    # 访问日志配置
    accesslog:
      enabled: true # 开启访问日志
      directory: d:/logs/tomcat # 日志存储目录（默认tomcat/logs）
      prefix: access_log # 日志文件名前缀
      suffix: .log # 日志文件名后缀
      # 日志格式（记录IP、请求、状态、耗时等）
      pattern: "%h %l %u %t \"%r\" %s %b \"%{Referer}i\" \"%{User-Agent}i\" %D"
      rotate: true # 按天轮转日志（默认true）
    # 其他优化
    max-swallow-size: 1MB # 最大请求体大小（默认2MB，超出则断开连接）
    accept-count: 100 # 连接接受队列大小（默认100，超出则拒绝连接）

<!-- 引入 Jetty 嵌入式容器依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

public class SysUser {
    private String id;
    private String realName;
    private String loginAccount;
    private String loginPassword;
    private LocalDate birthday;
    private LocalDateTime createTime;
    // set |get | toString
}

@RestController
public class SysUserController {

    @GetMapping("/user/detail")
    public SysUser getUser(){
        SysUser user = new SysUser();
        user.setId("8209");
        user.setRealName("张三");
        user.setLoginAccount("zhangsan");
        user.setLoginPassword("123456");
        user.setBirthday(LocalDate.of(1990, 1, 1));
        user.setCreateTime(LocalDateTime.now());
        return user;

    }
}

{"birthday":"1990-01-01","createTime":"2025-12-11T11:44:09.7067537","id":"8209","loginAccount":"zhangsan","loginPassword":"123456","realName":"张三"}

//@JsonIgnoreProperties(ignoreUnknown = true) // 忽略未知字段
@JsonIgnoreProperties(
    ignoreUnknown = true,
    value = {"loginPassword","realName"}
)
public class SysUser {
    private String id;
    private String realName;
    private String loginAccount;

    //@JsonIgnore
    private String loginPassword;
    private LocalDate birthday;
    private LocalDateTime createTime; 
    // set | get | toString()
}

public class SysUser {
    private String id;

    @JsonProperty("username")
    private String realName;

    @JsonProperty("useraccount")
    private String loginAccount;

    @JsonIgnore
    private String loginPassword;
    private LocalDate birthday;
    private LocalDateTime createTime;
    // set | get | toString()
}

import tools.jackson.core.JacksonException;
import tools.jackson.core.JsonGenerator;
import tools.jackson.databind.SerializationContext;
import tools.jackson.databind.ValueSerializer;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

public class CustomDateSerializer extends ValueSerializer<LocalDate> {
    @Override
    public void serialize(LocalDate value, JsonGenerator gen, SerializationContext ctxt) throws JacksonException {
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy年-MM月-dd日");
        String dateString = dateTimeFormatter.format(value);
        gen.writeString(  dateString +"("+ (value.isLeapYear() ?"闰年":"平年") +")");
    }
}

public class SysUser {
    private String id;

    @JsonProperty("username")
    private String realName;

    @JsonProperty("useraccount")
    private String loginAccount;

    @JsonIgnore
    private String loginPassword;

    // CustomDateSerializer自定义序列化类
    @JsonSerialize(using = CustomDateSerializer.class)
    private LocalDate birthday;


    //格式化是LocalDateTime类型
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    // set | get | toString
}

@JsonPropertyOrder(alphabetic = true)
@JsonNaming(PropertyNamingStrategies.UpperSnakeCaseStrategy.class)
public class SysUser {
    private String id;

    @JsonProperty("username")
    private String realName;

    @JsonProperty("useraccount")
    private String loginAccount;

    @JsonIgnore
    private String loginPassword;

    // CustomDateSerializer自定义序列化类
    @JsonSerialize(using = CustomDateSerializer.class)
    private LocalDate birthday;


    //格式化是LocalDateTime类型
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
   // set | get | toString
}

spring:
  jackson:
    # 全局日期格式化
    date-format: "yyyy-MM-dd HH:mm:ss"
    # 全局时区
    time-zone: "Asia/Shanghai"
    # 全局空值处理
    default-property-inclusion: non_null
    #忽略未知字段 , 字段非null进行序列化
    fail-on-unknown-properties: true
    # 字段命名策略
    property-naming-strategy: SNAKE_CASE

public interface SysUserView {

    // 用户简单信息
    interface SysUserSimpleView {
    }

    // 用户详细信息
    interface SysUserDetailView extends SysUserSimpleView {
    }
}

public class SysUser {

    @JsonView(SysUserView.SysUserSimpleView.class)
    private String id;
    @JsonView(SysUserView.SysUserSimpleView.class)
    private String realName;
    @JsonView(SysUserView.SysUserSimpleView.class)
    private String loginAccount;

    @JsonIgnore
    private String loginPassword;

    @JsonView(SysUserView.SysUserDetailView.class)
    @JsonSerialize(using = CustomDateSerializer.class)
    private LocalDate birthday;

    @JsonView(SysUserView.SysUserDetailView.class)
    //格式化是LocalDateTime类型
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
    // set | get | toString()
}

@RestController
public class SysUserController {

    @JsonView(SysUserView.SysUserSimpleView.class)
    @GetMapping("/user/detail")
    public SysUser getUser(){
        SysUser user = new SysUser();
        user.setId("8209");
        user.setRealName("张三");
        user.setLoginAccount("zhangsan");
        user.setLoginPassword("123456");
        user.setBirthday(LocalDate.of(1990, 1, 1));
        user.setCreateTime(LocalDateTime.now());
        return user;

    }

    @JsonView(SysUserView.SysUserDetailView.class)
    @GetMapping("/user/detail/all")
    public SysUser getUserAll(){
        SysUser user = new SysUser();
        user.setId("8209");
        user.setRealName("张三");
        user.setLoginAccount("zhangsan");
        user.setLoginPassword("123456");
        user.setBirthday(LocalDate.of(1990, 1, 1));
        user.setCreateTime(LocalDateTime.now());
        return user;

    }
}

CREATE TABLE `t_order` (
  `id` VARCHAR(50) NULL DEFAULT NULL COMMENT '订单id' COLLATE 'utf8mb4_bs_0900_ai_ci',
  `stock` INT NULL DEFAULT NULL COMMENT '商品数量',
  `code` VARCHAR(50) NULL DEFAULT NULL COMMENT '商品code' COLLATE 'utf8mb4_bs_0900_ai_ci',
  `money` DECIMAL(10,2) NULL DEFAULT NULL COMMENT '订单金额'
)

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>3.0.5</version>
</dependency>

<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

public class TOrder {
    private String id;
    private String code;
    private Integer stock;
    private BigDecimal money;
    // set | get | toString
}

public interface TOrderMapper {

    int insertOrder(TOrder order);

    TOrder selectOrderById(String id);
}

@MapperScan("com.bjpowernode.mapper")
@SpringBootApplication
public class Course02MybatisApplication {

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

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.mapper.TOrderMapper">
  <insert id="insertOrder" parameterType="com.bjpowernode.domain.TOrder">
    insert into t_order(id,code,stock,money) values(#{id},#{code},#{stock},#{money})
  </insert>

  <select id="selectOrderById" parameterType="String"
    resultType="com.bjpowernode.domain.TOrder">
    select * from t_order where id = #{id}
  </select>
</mapper>

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    #数据库连接池类型
    type: com.zaxxer.hikari.HikariDataSource

mybatis:
  # xml文件存储位置
  mapper-locations: classpath:/mapper/**/*.xml

@SpringBootTest
class Course02MybatisApplicationTests {

    @Resource
    private TOrderMapper orderMapper;

    @Test
    void testInsert(){
        TOrder order = new TOrder();
        order.setId(UUID.randomUUID().toString());
        order.setCode("DQ2032");
        order.setMoney(new BigDecimal(100));
        order.setStock(1);

        int insert =  orderMapper.insertOrder(order);
        System.out.println("创建新的订单 = " + insert);
    }

    @Test
    void testSelect(){
        TOrder order = orderMapper.selectOrderById("db8842b9-cc86-4090-8d40-1803867c4670");
        System.out.println("查询结果 = " + order);
    }

}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    #数据库连接池类型
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
      #最大连接数，默认是10,  cpu核心数量*2+1
      maximum-pool-size: 30
      #最小空闲连接，默认是10
      minimum-idle: 30
      #等待连接池分配连接的最大时长，超过该时长还没有可用连接则发生超时异常（单位毫秒）
      connection-timeout: 5000
      #空闲连接的最大时长，空闲多久就备释放回收，设置为0不让连接回收
      idle-timeout: 0
      #一个连接的最大生命时间，超过该时间还没有使用就回收掉（单位毫秒）
      max-lifetime: 18000000

<!-- Spring 核心 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>6.1.0</version>
</dependency>
<!-- MyBatis 核心 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.15</version>
</dependency>
<!-- MyBatis 整合 Spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>3.0.3</version>
</dependency>
<!-- MySQL 驱动 -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <version>8.0.33</version>
</dependency>
<!-- 数据源（Druid 示例） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.18</version>
</dependency

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 1. 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/test_db?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

    <!-- 2. 配置 MyBatis SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- MyBatis 核心配置文件路径 -->
        <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
        <!-- XML 映射文件路径 -->
        <property name="mapperLocations" value="classpath:mybatis/mapper/**/*.xml"/>
        <!-- 实体类别名包 -->
        <property name="typeAliasesPackage" value="com.example.entity"/>
    </bean>

    <!-- 3. 配置 Mapper 扫描器（自动创建 Mapper 代理对象） -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 扫描 Mapper 接口包 -->
        <property name="basePackage" value="com.example.mapper"/>
        <!-- 关联 SqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!-- 4. 扫描 Service 层（自动注入 Mapper） -->
    <context:component-scan base-package="com.example.service"/>

</beans>

<dependency>
  <groupId>org.mybatis.spring.boot</groupId>
  <artifactId>mybatis-spring-boot-starter</artifactId>
  <version>3.0.5</version>
</dependency>

<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration

CREATE TABLE `t_order` (
  `id` VARCHAR(50) NULL DEFAULT NULL COMMENT '订单id' COLLATE 'utf8mb4_bs_0900_ai_ci',
  `stock` INT NULL DEFAULT NULL COMMENT '商品数量',
  `code` VARCHAR(50) NULL DEFAULT NULL COMMENT '商品code' COLLATE 'utf8mb4_bs_0900_ai_ci',
  `money` DECIMAL(10,2) NULL DEFAULT NULL COMMENT '订单金额'
)

<!--
Spring Boot4 (自3.5.13开始)
-->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-spring-boot4-starter</artifactId>
  <version>3.5.15</version>
</dependency>

<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <scope>runtime</scope>
</dependency>

@TableName("t_order")
public class TOrder {
    @TableId
    private String id;

    @TableField("code")
    private String code;

    @TableField("stock")
    private Integer stock;

    @TableField("money")
    private BigDecimal money; 
    // set | get方法
}

public interface OrderMapper extends BaseMapper<TOrder> {
}

@MapperScan("com.bjpowernode.mapper")
@SpringBootApplication
public class Prj01MybatisplusApplication {

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

}

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/plus?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource

#mybatis-plus配置
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true

@SpringBootTest
class Prj01MybatisplusApplicationTests {

    @Resource
    private OrderMapper orderMapper;


    @Test
    void insert() {
        TOrder order = new TOrder();
        order.setId(UUID.randomUUID().toString());
        order.setCode("DQ5601");
        order.setMoney(new BigDecimal(100));
        order.setStock(1);
        int add = orderMapper.insert(order);
        System.out.println("添加记录的行数：" + add);
    }

    @Test
    void select() {
        TOrder order = orderMapper.selectById("DQ5601");
        System.out.println(order);
    }

    @Test
    void selectColumn() {
        QueryWrapper<TOrder> wrapper = new QueryWrapper<>();
        wrapper.eq("code", "DQ5601")
        .orderByAsc("id");
        List<TOrder> orderList = orderMapper.selectList(wrapper);

        System.out.println("orderList = " + orderList);
    }

    @Test
    void selectLambda() {
        LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TOrder::getCode, "DQ5601")
        .orderByAsc(TOrder::getId);

        List<TOrder> orderList = orderMapper.selectList(wrapper);
        System.out.println("orderList = " + orderList);
    }

        // 自定义处理结果集
    @Test
    void selectSQL() {
        QueryWrapper<TOrder> wrapper = new QueryWrapper<>();
        wrapper.eq("code", "DQ5601")
                .orderByAsc("id");
        orderMapper.selectList(wrapper, resultContext->{
            int count = resultContext.getResultCount();
            TOrder order = resultContext.getResultObject();
            System.out.println("count = " + count);
            System.out.println("order = " + order);
        });
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.mapper.OrderMapper">

  <select id="selectOrderById" parameterType="String"
    resultType="com.bjpowernode.domain.TOrder">
    select * from t_order where id = #{id}
  </select>
</mapper>

public interface OrderMapper extends BaseMapper<TOrder> {

    TOrder selectOrderById(String id);
}

#mybatis-plus配置
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
  mapper-locations: classpath:/mapper/**/*.xml

@RestController
public class EmpController {

    @GetMapping("/emp/{name}")
    public Emp queryEmp(@PathVariable String name){
        Emp emp = new Emp();
        emp.setName(name);
        emp.setJob("程序员");
        return emp;
    }
}

@Test
void testGet(){
    RestClient restClient = RestClient.create();
    Emp emp = restClient.get().uri("http://localhost:8080/emp/{name}", "lisi")
    .retrieve()  //执行请求，检索应答
    .onStatus(response -> {
        boolean isError = false;
        if (response.getStatusCode().is2xxSuccessful()) {
            System.out.println("请求成功");
        } else {
            isError = true;
            System.out.println("请求失败" + response.getStatusText());
        }
        return isError;
    })
    .body(Emp.class);  // 应答体转为结果类型

    System.out.println("emp = " + emp);
}

@RestController
public class EmpController {

    @GetMapping("/emp/{name}")
    public Emp queryEmp(@PathVariable String name){
        Emp emp = new Emp();
        emp.setName(name);
        emp.setJob("程序员");
        return emp;
    }


    @PostMapping("/emp/create")
    public String createEmp(@RequestBody Emp emp){
        System.out.println("emp = " + emp);
        return "创建员工成功！";
    }
}

public class Emp implements Serializable {
    private String name;
    private String job;
    // set | get | toString
}

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

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

public class Emp implements Serializable {
    private String name;
    private String job;
    // set | get | toString
}

@HttpExchange(url = "http://localhost:8080")
public interface EmpHttpClient {

    // GET 请求 /emp/xxxx
    @GetExchange("/emp/{empName}")
    Emp queryEmpByName(@PathVariable("empName") String name);


    // POST 请求 /emp/create
    @PostExchange("/emp/create")
    String createEmp(@RequestBody Emp emp);
}

@Configuration
public class HttpClientConfig {

    @Bean
    public RestClient restClient(){
        //通过配置RestClient增加http请求的功能
        return RestClient.builder()
        .build();
    }


    @Bean
    public EmpHttpClient empHttpClient(RestClient restClient){
        HttpServiceProxyFactory factory =
        HttpServiceProxyFactory.builderFor(RestClientAdapter.create(restClient)).build();

        return factory.createClient(EmpHttpClient.class);
    }
}

@SpringBootTest
class Prj03DeptServiceApplicationTests {

    @Resource
    private EmpHttpClient empHttpClient;

    @Test
    void testQueryEmpByName() {
        Emp emp  = empHttpClient.queryEmpByName("lisi");
        System.out.println("emp = " + emp);
    }

    @Test
    void createEmp(){
        Emp emp = new Emp();
        emp.setName("张三");
        emp.setJob("项目经理");
        String res  = empHttpClient.createEmp(emp);
        System.out.println("res = " + res);

    }

}

@HttpExchange(url = "http://localhost:8080")
public interface DeptHttpClient {

    // GET 请求 /dept/xxxx
    @GetExchange("/dept/{id}")
    Emp queryEmpByName(@PathVariable("id") Integer deptId);


    // POST 请求 /dept/create
    @PostExchange("/dept/create")
    String createEmp(@RequestBody Dept dept);
}

@Configuration
public class HttpClientConfigBatch {

    @Bean
    public RestClient restClient(){
        //通过配置RestClient增加http请求的功能
        return RestClient.builder()
        .build();
    }


    @Bean
    public HttpServiceProxyFactory httpServiceProxyFactory(RestClient restClient){
        HttpServiceProxyFactory factory =
        HttpServiceProxyFactory.builderFor(RestClientAdapter.create(restClient)).build();

        return factory;
    }

    @Bean
    public EmpHttpClient empHttpClient(HttpServiceProxyFactory factory){
        return factory.createClient(EmpHttpClient.class);
    }

    @Bean
    public DeptHttpClient deptHttpClient(HttpServiceProxyFactory factory){
        return factory.createClient(DeptHttpClient.class);
    }
}

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

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(ImportHttpServices.Container.class)
@Import(ImportHttpServiceRegistrar.class)
public @interface ImportHttpServices {


    /**
     * 对Http服务代理分组， 每个组单独配置http服务的url，超时等等
     */
    String group() default HttpServiceGroup.DEFAULT_GROUP_NAME;

    /**
     * 要扫描的类/接口所在的包（通过类指定包路径）
     */
    Class<?>[] basePackageClasses() default {};

    /**
     * 要扫描的包（多个），与 basePackageClasses 二选一/同时使用
     */
    String[] basePackages() default {};
}

package com.bjpowernode.dept.service;


@HttpExchange(url = "http://localhost:8080")
public interface DeptHttpClient {

    // GET 请求 /dept/xxxx
    @GetExchange("/dept/{id}")
    Dept getById(@PathVariable("id") Integer deptId);

}

// 两个接口位于不同的包


package com.bjpowernode.emp.service;

@HttpExchange(url = "http://localhost:8080")
public interface EmpHttpClient {

    // GET 请求 /emp/xxxx
    @GetExchange("/emp/{empName}")
    Emp queryEmpByName(@PathVariable("empName") String name);


    // POST 请求 /emp/create
    @PostExchange("/emp/create")
    String createEmp(@RequestBody Emp emp);
}

@Configuration
@ImportHttpServices(
    basePackages = {
        "com.bjpowernode.dept.service",
        "com.bjpowernode.emp.service"
    }
)

/*
 或者指定类所在包
 @ImportHttpServices(
        basePackageClasses = {
                EmpHttpClient.class,
                DeptHttpClient.class
        }
)*/
public class HttpClientConfig {


    @Bean
    public HttpServiceProxyFactory httpServiceProxyFactory(){

        RestClient restClient = RestClient.builder()
        .baseUrl("http://localhost:8080")
        .defaultHeader("Accept", "application/json")
        .build();
        return HttpServiceProxyFactory.builderFor(RestClientAdapter.create(restClient)).build();
    }
}

@SpringBootTest
class Prj03DeptServiceApplicationTests {

    @Resource
    private EmpHttpClient empHttpClient;

    @Test
    void testQueryEmpByName() {
        Emp emp  = empHttpClient.queryEmpByName("lisi");
        System.out.println("emp = " + emp);
    }


    @Resource
    private DeptHttpClient deptHttpClient;
    @Test
    void testQueryDept(){
        Dept dept = deptHttpClient.getById(1);
        System.out.println("dept = " + dept);
    }


}

@Override
public final void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry beanRegistry) {

    registerHttpServices(new DefaultGroupRegistry(), metadata);

    if (this.groupsMetadata.isEmpty()) {
        return;
    }

    RootBeanDefinition proxyRegistryBeanDef = createOrGetRegistry(beanRegistry);
    mergeGroups(proxyRegistryBeanDef);

    this.groupsMetadata.forEachRegistration((groupName, types) -> types.forEach(type -> {
        RootBeanDefinition proxyBeanDef = new RootBeanDefinition();
        proxyBeanDef.setBeanClassName(type);
        proxyBeanDef.setAttribute(HTTP_SERVICE_GROUP_NAME_ATTRIBUTE, groupName);
        proxyBeanDef.setInstanceSupplier(() -> getProxyInstance(groupName, type));
        String beanName = (groupName + "#" + type);
        if (!beanRegistry.containsBeanDefinition(beanName)) {
             //注册 BeanDefinition 到 Spring 容器
            beanRegistry.registerBeanDefinition(beanName, proxyBeanDef);
        }
    }));
}

public HttpServiceProxyFactory build() {
    Assert.notNull(this.exchangeAdapter, "HttpClientAdapter is required");
    HttpExchangeAdapter adapterToUse = this.exchangeAdapterDecorator.apply(this.exchangeAdapter);

    return new HttpServiceProxyFactory(
        adapterToUse, initArgumentResolvers(), this.requestValuesProcessors,
        this.embeddedValueResolver);
}

public <S> S createClient(Class<S> serviceType) {

    List<HttpServiceMethod> httpServiceMethods =
    MethodIntrospector.selectMethods(serviceType, this::isExchangeMethod).stream()
    .map(method -> createHttpServiceMethod(serviceType, method))
    .toList();

    return getProxy(serviceType, httpServiceMethods);
}

<!--Redis依赖-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<!--Web依赖-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webmvc</artifactId>
</dependency>

@SpringBootTest
class Prj02NosqlRedisApplicationTests {


    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void testAddString(){
        redisTemplate.opsForValue().set("name","张三");

        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);

    }

}

spring:
  data:
    redis:
      host: localhost
      port: 6379

@Test
void testAddString(){

    // 设置key序列化
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    // 设置 hash之外类型的序列化
    redisTemplate.setValueSerializer(new StringRedisSerializer());
    // hash类型 field 的序列化
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    // hash类型 value 的序列化
    redisTemplate.setHashValueSerializer(new StringRedisSerializer());

    redisTemplate.opsForValue().set("myname","张三");
    Object name = redisTemplate.opsForValue().get("name");
    System.out.println("name = " + name);
}

@Resource
private StringRedisTemplate stringRedisTemplate;
@Test
void testAddString2(){
    stringRedisTemplate.opsForValue().set("myaddress","北京市朝阳区");
    Object name = stringRedisTemplate.opsForValue().get("myaddress");
    System.out.println("name = " + name);
}

public class Dept implements Serializable {
    private String name;
    private Integer deptId;
    private Integer count;
    private List<Emp> empList;
    // set | get | toString
}
     

public class Emp implements Serializable {
    private String name;
    private String job;
    // set | get | toString
}

@Test
void testJsonSerializable(){

    // 设置key序列化
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    // 设置 hash之外类型的序列化
    redisTemplate.setValueSerializer(RedisSerializer.json());

    // hash类型 field 的序列化
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    // hash类型 value 的序列化
    redisTemplate.setHashValueSerializer(RedisSerializer.json());

    Emp emp1 = new Emp();
    emp1.setName("张三");
    emp1.setJob("程序员");
    redisTemplate.opsForValue().set("emp_dev",emp1);


    Emp emp2 = new Emp();
    emp2.setName("李四");
    emp2.setJob("配置管理");

    Dept dept = new Dept();
    dept.setName("开发部");
    dept.setDeptId(1);
    dept.setCount(2);
    dept.setEmpList(Arrays.asList(emp1,emp2));
    redisTemplate.opsForValue().set("dept_dev",dept);


    HashOperations hashOperations = redisTemplate.opsForHash();
    hashOperations.put("dept_members","zhangsan",emp1);
    hashOperations.put("dept_members","lisi",emp2);

    System.out.println("====操作完成===");

}

{
    "@class": "com.bjpowernode.Dept",
    "count": 2,
    "deptId": 1,
    "empList": [
        "java.util.Arrays$ArrayList",
        [
            {
                "@class": "com.bjpowernode.Emp",
                "job": "程序员",
                "name": "张三"
            },
            {
                "@class": "com.bjpowernode.Emp",
                "job": "配置管理",
                "name": "李四"
            }
        ]
    ],
    "name": "开发部"
}

@Test
void testJsonToObject(){
    // 设置key序列化
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    // 设置 hash之外类型的序列化
    redisTemplate.setValueSerializer(RedisSerializer.json());

    // hash类型 field 的序列化
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    // hash类型 value 的序列化
    redisTemplate.setHashValueSerializer(RedisSerializer.json());

    Emp emp = (Emp) redisTemplate.opsForValue().get("emp_dev");
    Dept dept = (Dept) redisTemplate.opsForValue().get("dept_dev");


    System.out.println("emp = " + emp);
    System.out.println("dept = " + dept);

    System.out.println("操作完成");

}

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>3.5.8</version>
  <relativePath/> <!-- lookup parent from repository -->
</parent>

<!-- MessagePack -->
<dependency>
  <groupId>org.msgpack</groupId>
  <artifactId>msgpack-core</artifactId>
  <version>0.9.0</version>
</dependency>
<dependency>
  <groupId>org.msgpack</groupId>
  <artifactId>jackson-dataformat-msgpack</artifactId>
  <version>0.9.0</version>
</dependency>

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

@Configuration
public class RedisConfig {

    /**
     * 创建 MessagePack 序列化器
     */
    @Bean
    @ConditionalOnMissingBean
    public RedisSerializer<Object> messagePackRedisSerializer() {
        // 创建 MessagePack 的 ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());

        // 激活默认类型信息，用于反序列化时识别具体类型
        objectMapper.activateDefaultTyping(
            LaissezFaireSubTypeValidator.instance,
            ObjectMapper.DefaultTyping.NON_FINAL,
            com.fasterxml.jackson.annotation.JsonTypeInfo.As.PROPERTY
        );

        return new Jackson2JsonRedisSerializer<>(objectMapper, Object.class);
    }

    /**
     * 配置 RedisTemplate，使用 MessagePack 序列化
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(
        RedisConnectionFactory connectionFactory,
        RedisSerializer<Object> messagePackRedisSerializer) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        // 设置 Key 的序列化器
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        // 设置 Value 的序列化器（使用 MessagePack）
        template.setValueSerializer(messagePackRedisSerializer);
        template.setHashValueSerializer(messagePackRedisSerializer);

        // 设置默认序列化器
        template.setDefaultSerializer(messagePackRedisSerializer);

        // 启用事务支持
        template.setEnableTransactionSupport(true);

        template.afterPropertiesSet();
        return template;
    }

    /**
     * 可选的：创建专用的 Emp RedisTemplate
     */
    @Bean
    public RedisTemplate<String, Emp> userRedisTemplate(
        RedisConnectionFactory connectionFactory,
        RedisSerializer<Object> messagePackRedisSerializer) {

        RedisTemplate<String, Emp> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);

        // 专用类型的序列化器
        ObjectMapper objectMapper = new ObjectMapper(new MessagePackFactory());
        Jackson2JsonRedisSerializer<Emp> userSerializer =
        new Jackson2JsonRedisSerializer<>(objectMapper, Emp.class);

        template.setValueSerializer(userSerializer);
        template.setHashValueSerializer(userSerializer);

        template.afterPropertiesSet();
        return template;
    }
}

spring:
  data:
    redis:
      host: localhost
      port: 6379

@Resource
private RedisTemplate<String,Object> redisTemplate;

@Test
void testJsonSerializable(){


    Emp emp1 = new Emp();
    emp1.setName("张三");
    emp1.setJob("程序员");
    redisTemplate.opsForValue().set("emp_dev",emp1);


    Emp emp2 = new Emp();
    emp2.setName("李四");
    emp2.setJob("配置管理");

    Dept dept = new Dept();
    dept.setName("开发部");
    dept.setDeptId(1);
    dept.setCount(2);
    dept.setEmpList(Arrays.asList(emp1,emp2));
    redisTemplate.opsForValue().set("dept_dev",dept);


    HashOperations hashOperations = redisTemplate.opsForHash();
    hashOperations.put("dept_members","zhangsan",emp1);
    hashOperations.put("dept_members","lisi",emp2);

    System.out.println("====操作完成===");

}


@Test
void testJsonToObject(){


    Emp emp = (Emp) redisTemplate.opsForValue().get("emp_dev");
    Dept dept = (Dept) redisTemplate.opsForValue().get("dept_dev");


    System.out.println("emp = " + emp);
    System.out.println("dept = " + dept);

    System.out.println("操作完成");

}

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

package com.bjpowernode.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CustomRedisTemplateConfig {

    
    /**
     * 自定义 RedisTemplate<String, Object>
     * 核心：Key/HashKey 用 String 序列化，Value/HashValue 用 Jackson JSON 序列化
     */
    @Bean
    public RedisTemplate<String, Object> customRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 1. 创建 RedisTemplate 实例
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 绑定连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 2. 配置 Jackson 序列化器（处理 Value/HashValue）
        Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();

        // 2.1 配置类型校验器（安全控制，避免恶意类型注入）
        PolymorphicTypeValidator ptv = BasicPolymorphicTypeValidator.builder()
                .allowIfSubType("com.bjpowernode") // 仅允许业务包下的类序列化类型信息
                .allowIfSubType("java.util")       // 允许集合类（List/Map 等）
                .build();

        // 2.2 保留类型信息（反序列化时不丢失对象类型）
        objectMapper.activateDefaultTyping(
                ptv,
                ObjectMapper.DefaultTyping.NON_FINAL // 非 final 类保留类型信息
        );

        // 2.3 基础配置：允许访问所有字段、支持时间类型
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.registerModule(new JavaTimeModule()); // 支持 LocalDateTime/LocalDate
        objectMapper.configure(com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); // 忽略未知字段

        jacksonSerializer.setObjectMapper(objectMapper);

        // 3. 配置 String 序列化器（处理 Key/HashKey，保证可读性）
        StringRedisSerializer stringSerializer = new StringRedisSerializer();

        // 4. 绑定序列化器到 RedisTemplate
        redisTemplate.setKeySerializer(stringSerializer);          // Key 序列化
        redisTemplate.setValueSerializer(jacksonSerializer);       // Value 序列化
        redisTemplate.setHashKeySerializer(stringSerializer);       // Hash Key 序列化
        redisTemplate.setHashValueSerializer(jacksonSerializer);   // Hash Value 序列化

        // 5. 初始化 RedisTemplate（必须调用，否则序列化配置不生效）
        redisTemplate.afterPropertiesSet();

        // 可选：开启事务支持（根据业务需求） @Transaction
        redisTemplate.setEnableTransactionSupport(true);

        return redisTemplate;
    }
}

@ConfigurationProperties("spring.data.redis")
public class RedisProperties {
    .............
}

<!-- 连接池核心依赖（commons-pool2） -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: ""  # 无密码留空
      database: 0
      timeout: 10000ms  # 连接超时

      # Lettuce 连接池配置
      lettuce:
        pool:
          max-active: 16    # 最大活跃连接数（根据并发量调整，建议不超过 Redis 最大连接数）
          max-idle: 8       # 最大空闲连接数（空闲时保留的连接数）
          min-idle: 2       # 最小空闲连接数（避免频繁创建连接）
          max-wait: 5000ms  # 获取连接的最大等待时间（超时则抛出异常）
        shutdown-timeout: 100ms  # 客户端关闭时的超时时间（确保连接优雅关闭）

@Resource(name="redisTemplate")
private RedisOperations<String,Object> redisOperations;

@Test
void test01(){
    redisOperations.opsForValue().set("welcome", "hello world");
    Object welcome = redisOperations.opsForValue().get("welcome");
    System.out.println("welcome = " + welcome);
}

@Test
void testTrans(){
    Emp user = new Emp();
    user.setName("lisi");
    user.setJob("程序员");

    List<Object> txResults = redisOperations.execute(new SessionCallback<List<Object>>() {
        public List<Object> execute(RedisOperations operations) throws DataAccessException {
            try{
                //事务开始
                operations.multi();
                operations.opsForValue().set("user:" + user.getName(), user);
                operations.opsForSet().add("users:job", user.getJob());
                operations.opsForValue().increment("user:count", 1);

                //执行事务
                return operations.exec();
            }catch (RuntimeException e){
                /**
                 * 如果在multi()和exec()之间发生异常（例如，如果Redis在超时时间内未响应，则会发生超时异常），
                 * 那么连接可能会陷入事务状态。为了防止这种情况，需要放弃事务状态以清除连接：
                 */
                operations.discard(); //取消事务
                e.printStackTrace();
            }
            return List.of();

        }
    });

    //打印事务执行结果
    txResults.forEach( obj-> System.out.println("obj = " + obj));
}