1
2
3
4
5
6
@SpringBootApplication
public class MainApp {
  public static void main(String[] args) {
    SpringApplication.run(MainApp.class, args);
  }
}

1
2
3
4
5
6
7
8
@Controller
public class HelloController {
  @RequestMapping("/hello")
  @ResponseBody
  public String hello() {
    return "hello boot!";
  }
}

1
2
3
ConfigurableApplicationContext ctx = SpringApplication.run(MainApp.class, args);
String[] definitionNames = ctx.getBeanDefinitionNames();
Arrays.stream(definitionNames).forEach(System.out::println);

1
2
@Value("${my.website}")
private String bdUrl;

1
2
ClassPathXmlApplicationContext xmlContext = new ClassPathXmlApplicationContext("beans.xml");
Monster monster = xmlContext.getBean(Monster.class);

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class BeanConfig {
  // 把monsterBeanName作为id, Monster作为value放入到容器中
  // 默认把方法名作为id
  // 也可以指定id
  // 默认是单例的, 使用Scope注解可指定为多例
  @Bean(name = "monster01")
  @Scope("prototype")
  public Monster monsterBeanName() {
    return new Monster(1, "黑马喽", "立棍", 500);
  }
}

1
2
3
4
BeanConfig beanConfig = ctx.getBean(BeanConfig.class);
Monster monster = beanConfig.monsterBeanName();
Monster monster2 = beanConfig.monsterBeanName();
System.out.println(monster2 == monster);

1
2
3
4
5
6
@Bean
// 表示只有当容器注入了id=monster01的bean时才进行注入
@ConditionalOnBean(name = "monster01")
public Dog dog01() {
  return new Dog();
}

1
2
@ImportResource({"classpath:beans.xml"})
public class BeanConfig {}

1
2
3
4
5
6
7
8
@Data
@ConfigurationProperties(prefix = "zangxin.dog")
@Component
public class Dog {
  private Integer id;
  private String name;
  private String color;
}

1
2
3
4
5
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
  </dependency>

1
2
3
4
5
6
7
8
9
@EnableConfigurationProperties(Dog.class)
@Data
@ConfigurationProperties(prefix = "zangxin.dog")
// @Component
public class Dog {
  private Integer id;
  private String name;
  private String color;
}

1
2
3
@EnableConfigurationProperties({Dog.class})
@Configuration(proxyBeanMethods = true)
public class BeanConfig {}

1
2
3
4
5
6
7
8
9
10
11
//MyConfig

@Configuration
@ComponentScan("org.xxx.myboot")
public class MyConfig {
  // 注入bean到容器中
  @Bean
  public Duck duck() {
    return new Duck();
  }
}

1
2
3
4
5
6
7
//MyApp

public class MyApp {
  public static void main(String[] args) {
    MySpringApplication.run();
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// MySpringApplication
public class MySpringApplication {
  // 创建tomcat对象, 并关联spring容器
  public static void run() {
    try {
      Tomcat tomcat = new Tomcat();
      tomcat.setPort(43999);
      // 1.让tomcat将请求转发到SpringWeb容器, 因此需要关联
      // 2. context path: /myboot
      // 3.项目的路径: tomcat在这个路径找到MyWebApplicationInitializer调用onStartup方法
      tomcat.addWebapp("/myboot", "/Users/qingsongcai/IdeaProjects/j2025/Spring Boot_/boot_base");
      // 启动tomcat
      tomcat.start();
      // 等待请求
      tomcat.getServer().await();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyWebApplicationInitializer implements WebApplicationInitializer {
  @Override
  public void onStartup(ServletContext servletContext) throws ServletException {
    System.out.println("startup.....启动");
    // 创建容器
    AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
    // 在容器中注册MyConfig类, 让容器知道在哪里扫包
    ctx.register(MyConfig.class);
ctx.refresh();// 完成bean的创建和依赖注入
    // 创建dispatcherServlet, 并让其持有容器
    DispatcherServlet dispatcherServlet = new DispatcherServlet(ctx);
    ServletRegistration.Dynamic registration = servletContext.addServlet("app", dispatcherServlet);

    // 当tomcat启动时,加载dispatcherServlet
    registration.setLoadOnStartup(1);
    // tomcat拦截所有请求,并进行分发处理
    registration.addMapping("/*");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Data
@ConfigurationProperties(prefix = "monster")
@Component
public class Monster {
  private Integer id;
  private String name;
  private String skill;
  private Integer age;
  private Boolean isMale;
  private Date birth;
  private Car car;
  private String[] skills;
  private List<String> hobby;
  private Map<String, Object> wife;
  private Set<Double> salaries;
  private Map<String, List<Car>> cars;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@RestController
@RequestMapping("/rest")
public class RestStyleController {
  @GetMapping
  public String getById() {
    return "查询根据id";
  }

  @PostMapping
  public String insert() {
    return "新增操作";
  }

  @PutMapping
  public String update() {
    return "修改操作";
  }

  @DeleteMapping
  public String delete() {
    return "删除操作";
  }
}

1
2
3
4
5
// /para/100/king
@RequestMapping("/para/{id}/{name}")
public String pathVariable(@PathVariable("id") Integer id,
                           @PathVariable("name") String name,
                           @PathVariable Map<String, String> map) {}

1
2
3
@GetMapping("/requestHeader")
public String requestHeader(@RequestHeader("HOST") String host,
                            @RequestHeader Map<String, String> header) {}

1
2
3
4
@GetMapping("/requestParam")
public String requestParam(@RequestParam("name") String name,
                           @RequestParam("version") List<String> versions,
                           @RequestParam Map<String, String> map)

1
2
3
@GetMapping("/cookieValue")
public String cookieValue(@CookieValue(value = "cookie_key") String cook_value,
                          @CookieValue(value = "username", required = false) Cookie cookie) {}

1
2
3
@PostMapping(value = "/requestBody")
// conten这样接收的是: name=xxx&age=22
public String requestBody(@RequestBody String content) {}

1
2
3
4
5
@GetMapping("/login")
public String login(HttpServletRequest request) {
  request.setAttribute("user", "zangxin");
  return "forward:/ok";
}

1
2
3
4
5
6
7
8
9
@GetMapping("/ok")
@ResponseBody
public String loginOk(@RequestAttribute(value = "user", required = false) String user,
                      HttpServletRequest request) {
  // 这样的效果和@RequestAttribute一样
  Object user2 = request.getAttribute("user");
  log.info("user={},user2={}", user, user2);
  return "success";
}

1
2
3
4
5
6
7
8
9
@GetMapping("/ok")
@ResponseBody
public String loginOk(@RequestAttribute(value = "user", required = false) String user,
                      HttpServletRequest request) {
  // 这样的效果和@RequestAttribute一样
  Object user2 = request.getAttribute("user");
  log.info("user={},user2={}", user, user2);
  return "success";
}

1
2
3
4
5
6
7
8
9
10
11
// 响应一个register请求
@GetMapping("/register")
public String register(Map<String, Object> map, Model model, HttpServletResponse response) {
  // map和model中数据会放入到请求域中
  map.put("user", "zangxin");
  map.put("age", 22);
  model.addAttribute("gender", "male");
  // 还可以设置cookie
  response.addCookie(new Cookie("hobby", "gal"));
  return "forward:/registerOk";
}

1
2
3
4
5
6
7
8
9
10
@GetMapping("/registerOk")
@ResponseBody
public String registerOk(HttpServletRequest request) {
  // 从这里可以之前放入map和model中数据
  Object user = request.getAttribute("user");
  Object age = request.getAttribute("age");
  Object gender = request.getAttribute("gender");
  log.info("{},{},{},{}", user, age, gender, request.getCookies()[1].getName());
  return "" + user + age + gender;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Data
public class Monster {
  private Integer id;
  private String name;
  private Integer age;
  private Boolean isMarried;
  private Date birth;
  private Car car;
  @Data
  public static class Car {
    private String name;
    private Double price;
  }
}

1
2
3
4
5
6
7
// 接收pojo对象
@PostMapping("/saveMonster")
@ResponseBody
public String saveMonster(Monster monster) {
  log.info("monster={}", monster);
  return "success";
}

1
2
3
4
5
6
private Car car;
@Data
public static class Car {
  private String name;
  private Double price;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Configuration(proxyBeanMethods = false)
public class WebConfig {
  //  注入bean WebMvcConfigurer
  @Bean
  public WebMvcConfigurer webMvcConfigurer() {
    return new WebMvcConfigurer() {
      @Override
      public void addFormatters(FormatterRegistry registry) {
        // 增加一个自定义的转换器
        // 把String类型的:法拉利,99999.9 转换成Car对象
        // 增加的自定义转换器会注册到converts容器中
        // converters 底层是ConcurrentHashMap内置有124个转换器
        registry.addConverter(new Converter<String, Monster.Car>() {
          @Override
          public Monster.Car convert(String source) {
            if (ObjectUtils.isEmpty(source)) return null;
            // 把String类型的:法拉利,99999.9 转换成Car对象
            String[] split = source.split(",");
            Monster.Car car = new Monster.Car();
            car.setName(split[0]);
            car.setPrice(Double.valueOf(split[1]));
            return car;
          }
        });
      }
    };
  }
}

1
2
3
4
5
6
7
8
9
10
11
@Override
protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)
  throws IOException, HttpMessageNotWritableException {

  MediaType contentType = outputMessage.getHeaders().getContentType();
  JsonEncoding encoding = getJsonEncoding(contentType);

  Class<?> clazz = (object instanceof MappingJacksonValue ?
                    ((MappingJacksonValue) object).getValue().getClass() : object.getClass());
  ObjectMapper objectMapper = selectObjectMapper(clazz, contentType);
  Assert.state(objectMapper != null, "No ObjectMapper for " + clazz.getName());

1
2
3
MediaType contentType = outputMessage.getHeaders().getContentType();
ObjectMapper objectMapper = selectObjectMapper(clazz, contentType);
JsonGenerator generator = objectMapper.getFactory().createGenerator(outputStream, encoding)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String requestURI = request.getRequestURI();
    log.info("uri:{}", requestURI);
    // 从Session中获取登录信息
    Object admin = request.getSession().getAttribute("admin");
    if (admin instanceof Admin a) {
      log.info("{}登录成功, ", a.getName());
      return true;// 放行
    } else { // 返回null时,说明未登录
      log.error("未登录!");
      request.setAttribute("msg", "请登录之后再访问");
      request.getRequestDispatcher("/login").forward(request, response);
      return false;
    }
  }

1
2
3
4
5
6
7
8
9
@Configuration
public class Config implements WebMvcConfigurer {
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(new LoginInterceptor())
      .addPathPatterns("/**")
      .excludePathPatterns("/", "/login", "/images/**","/favicon.ico");
  }
}

1
.addPathPatterns("/**")

1
.excludePathPatterns("/", "/login", "/images/**", "/favicon.ico");

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class WebConfig {
  @Bean
  public WebMvcConfigurer webMvcConfigurer() {
    return new WebMvcConfigurer() { @Override
      public void addInterceptors(InterceptorRegistry registry) {
        //加入我们的拦截器
        registry.addInterceptor(new LoginInterceptor())
          .addPathPatterns("/**")
          .excludePathPatterns("/", "/login", "/images/**","/favicon.ico");
      }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@PostMapping("/upload")
@ResponseBody
public String upload(
  @RequestParam("name") String name,
  @RequestParam("email") String email,
  @RequestParam("age") String age,
  @RequestParam("job") String job,
  @RequestParam("header") MultipartFile header,
  @RequestParam("photos") MultipartFile[] photos
) throws Exception {
  log.info("入参:name={}, email = {}, age = {}, job = {}, header = {}, photos = {}", name, email, age, job, header, photos);
  // 如果信息都成功得到, 那么就保存文件
  File uploadDir = getUploadDir();
  // 单个上传文件
  if (header != null && !header.isEmpty()) {
    String originalFilename = header.getOriginalFilename();
    header.transferTo(new File(uploadDir, originalFilename));
  }
  // 处理多个上传文件
  if (photos != null && photos.length > 0) {
    for (MultipartFile photo : photos) {
      if (!photo.isEmpty()) {
        String originalFilename = photo.getOriginalFilename();
        photo.transferTo(new File(uploadDir, originalFilename));
      }
    }
  }
  return "注册/上传成功";
}

// 获取上传目录路径
// 上传目录在类路径/static/images/upload
private File getUploadDir() {
  try {
    File path = ResourceUtils.getFile("classpath:");
    // 路径也可以卸载配置文件中,用@Autowired注入
    File file = new File(path, "static/images/upload");
    if (!file.exists()) {
      file.mkdir();
    }
    log.info("upload dir={}", file.getAbsolutePath());
    return file;
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}

1
2
3
4
5
6
7
8
9
10
11
@Slf4j
@ControllerAdvice // 标识一个全局异常处理器
public class GlobalExceptionHandler {
  @ExceptionHandler({ArithmeticException.class, NullPointerException.class})
  public String ArithmeticExceptionHandler(Exception e, Model model) {
    log.info("捕获到了异常~~😁: {}", e.getMessage());
    // 放入错误消息给, 给前端展示使用
    model.addAttribute("msg", e.getMessage());
    return "/error/global"; // templates/error/global.html
  }
}

1
2
3
4
5
6
7
8
9
// 403异常状态码
@ResponseStatus(HttpStatus.FORBIDDEN)
public class AccessException extends RuntimeException {
  public AccessException(String message) {
    super(message);
  }
  public AccessException() {
  }
}

1
2
3
4
5
6
7
@GetMapping("err403")
public String forbidden(String name) {
  if (!"tom".equals(name)) {
    throw new AccessException();
  }
  return "forward:/manage.html";
}

1
2
3
4
5
6
7
@ExceptionHandler({AccessException.class})
public String accessExceptionHandler(Exception e, Model model, HandlerMethod handlerMethod) {
  log.info("捕获到了非法访问异常~~😁: {},{},{}", e.getMessage(), model, handlerMethod.getMethod().getName());
  // 放入错误消息给, 给前端展示使用
  model.addAttribute("msg", e.getMessage());
  return "/error/global";
}

1
2
3
@SpringBootApplication
@ServletComponentScan(basePackages = {"org.xxx.boothyme.servlet"})
public class App {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Configuration
public class RegisterConfig_ {
  // 注册servlet
  @Bean
  public ServletRegistrationBean servlet_() {
    BootAndServlet bootAndServlet = new BootAndServlet();
    return new ServletRegistrationBean(bootAndServlet, "/servlet01", "/servlet02");
  }

  // 注册过滤器
  @Bean
  public FilterRegistrationBean filter_() {
    Filter_ filter = new Filter_();
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(filter);
    filterRegistrationBean.setUrlPatterns(Arrays.asList("/css/*", "/images/*"));
    return filterRegistrationBean;
  }

  // 注册listener
  @Bean
  public ServletListenerRegistrationBean listener_() {
    Listener listener = new Listener();
    return new ServletListenerRegistrationBean(listener);
  }

}

1
2
3
4
5
6
@WebServlet(name = "BootAndServlet", value = "/BootAndServlet")
public class BootAndServlet extends HttpServlet {
  @Override
  protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.getWriter().write("BootAndServlet~~ 在boot中Servlet 完成OK~~~");
  }

1
2
3
4
5
6
7
8
9
@Slf4j
@WebFilter(urlPatterns = {"/css/*","/images/*"})
public class Filter_ implements Filter {
  @Override
  public void doFilter(ServletRequest req, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) req;
    log.info("doFilter调用, 过滤uri是: " + request.getRequestURI());
    chain.doFilter(request, response);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
@Slf4j
@WebListener
public class Listener implements ServletContextListener {
  @Override
  public void contextInitialized(ServletContextEvent sce) {
    // 加入项目初始化相关的业务代码
    log.info("项目初始化OK~");
  }
  @Override
  public void contextDestroyed(ServletContextEvent sce) {
    log.info("项目销毁了");
  }
}

1
2
3
4
5
6
7
8
@Component
public class CustomizationTomcat
  implements WebServerFactoryCustomizer<ConfigurableWebServerFactory> {
  @Override
  public void customize(ConfigurableWebServerFactory factory) {
    factory.setPort(8848);
  }
}

1
2
3
4
5
6
7
8
9
@Configuration
public class DruidDataSourceConfig {
  @Bean
  @ConfigurationProperties(prefix = "spring.datasource")
  public DataSource druidDataSource() {
    DruidDataSource ds = new DruidDataSource();
    return ds;
  }
}

1
2
3
4
5
6
7
// DataSourceAutoConfiguration类
@Configuration(proxyBeanMethods = false)
@Conditional(PooledDataSourceCondition.class)
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
protected static class PooledDataSourceConfiguration {}

@ConditionalOnMissingBean({ DataSource.class指出当Datasource缺失时才会注入, 现在我们有druidDatasource, 就会不会注入hikari了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource druidDataSource() throws SQLException {
  DruidDataSource ds = new DruidDataSource();
  ds.setFilters("stat");
  return ds;
}
@Bean
public ServletRegistrationBean statViewServlet() {
  // druid ui servlet
  StatViewServlet statViewServlet = new StatViewServlet();
  ServletRegistrationBean<StatViewServlet> registrationBean =
    // 参数:servlet,urlPattern
    new ServletRegistrationBean<>(statViewServlet, "/druid/*");
  registrationBean.addInitParameter("loginUsername", "root");
  registrationBean.addInitParameter("loginPassword", "root");
  return registrationBean;
}

1
2
3
4
5
6
7
8
@Bean
public FilterRegistrationBean webStatFilter() {
  WebStatFilter webStatFilter = new WebStatFilter();
  FilterRegistrationBean<WebStatFilter> registrationBean = new FilterRegistrationBean<>(webStatFilter);
  registrationBean.setUrlPatterns(Arrays.asList("/*"));
  registrationBean.addInitParameter("exclusions", "*.js,*.webp,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
  return registrationBean;
}

1
2
3
4
5
6
7
8
9
10
11
// App.class是启动类
@SpringBootTest(classes = App.class)
public class CrudTest {
  @Autowired
  private JdbcTemplate jdbcTemplate;
  @Test
  void SelectAll() throws Exception {
    String sql = "select * from furn";
    List<Furn> furnList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Furn.class));
    furnList.forEach(System.out::println);
  }

1
2
3
4
@Mapper
public interface FurnMapper {
  Furn getFurnById(Integer id);
}

1
2
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
private Timestamp createTime;

1
2
3
4
@Mapper
public interface FurnMapper extends BaseMapper<Furn> {
  Furn getFurnById(Integer id);
}

1
public interface FurnService extends IService<Furn> {}

1
public class FurnServiceImpl extends ServiceImpl<FurnMapper,Furn> implements FurnService {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Configuration
public class MyBatisPlusConfig {
  /**

 * 添加分页插件
   */
  @Bean
  public MyBatis-PlusInterceptor MyBatisPlusInterceptor() {
    MyBatis-PlusInterceptor interceptor = new MyBatis-PlusInterceptor();
    PaginationInnerInterceptor pi = new PaginationInnerInterceptor(DbType.MYSQL);
    interceptor.addInnerInterceptor(pi); // 如果配置多个插件, 切记分页最后添加
    // 如果有多数据源可以不配具体类型, 否则都建议配上具体的 DbType
    return interceptor;
  }
}

1
2
3
4
5
6
7
8
9
10
@GetMapping("/page")
public Result page(
  @RequestParam(value = "pageNum", defaultValue = "1") Integer pageNum,
  @RequestParam(value = "pageSize", defaultValue = "5") Integer pageSize,
  @RequestParam(value = "name", defaultValue = "") String name) {
  LambdaQueryWrapper<Furn> lw = new LambdaQueryWrapper<>();
  lw.like(StringUtils.hasText(name), Furn::getName, name);
  Page<Furn> page = furnService.page(new Page<>(pageNum, pageSize), lw);
  return Result.ok(page);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@Configuration
@EnableCaching
@SuppressWarnings("all")
public class RedisConfig {
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    System.out.println("template=>" + template);
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    template.setConnectionFactory(factory);
    // key 序列化方式
    template.setKeySerializer(redisSerializer);
    // value 序列化
    template.setValueSerializer(jackson2JsonRedisSerializer);
    // value hashmap 序列化
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    return template;
  }

  @Bean
  public CacheManager cacheManager(RedisConnectionFactory factory) {
    RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    // 解决查询缓存转换异常的问题
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    // 配置序列化(解决乱码的问题),过期时间 600 秒
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
      .entryTtl(Duration.ofSeconds(600))
      .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
      .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
      .disableCachingNullValues();
    RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
      .cacheDefaults(config)
      .build();
    return cacheManager;
  }
}

1
2
redisTemplate.opsForValue().set("book", "金瓶梅");
String book = (String) redisTemplate.opsForValue().get("book");

1
2
3
4
5
6
7
redisTemplate.opsForList().leftPush("books", "水浒传");
redisTemplate.opsForList().leftPush("books", "三国演义");
// 一次性放多个
redisTemplate.opsForList().leftPushAll("books", "西游记", "红楼梦", "道德经");
// list-取出
List<String> books = redisTemplate.opsForList().range("books", 0, -1);
return String.join(",", books);