Spring Boot:从入门到实践的全面指南

文章目录

    • 1. Spring Boot简介及特性
      • 1.1 简介:什么是Spring Boot
      • 1.2 特性:Spring Boot的优势与特点
      • 1.3 四大核心:Spring Boot的核心组成
    • 2. Spring Boot入门案例
      • 2.1 Spring Boot项目创建
      • 2.2 创建一个Spring MVC的Spring Boot Controller
      • 2.3 深入理解Spring Boot Controller的工作机制
      • 2.4 Spring Boot核心配置文件解析
        • 2.4.1 application.properties
        • 2.4.2 application.yml
        • 2.4.3 自定义配置
      • 2.5 在Spring Boot中使用JSP
        • 2.5.1 添加依赖
        • 2.5.2 配置视图解析器
        • 2.5.3 创建JSP页面
        • 2.5.4 控制器中返回视图名称
      • 3.1 集成MyBatis:在Spring Boot中使用MyBatis
      • 3.2 DAO开发策略:探索DAO的多种开发方式
      • 3.3 事务支持:理解Spring Boot的事务处理方式
      • 3.4 注解式Spring MVC:Spring MVC在Spring Boot中的应用
        • 3.4.1 控制器(Controller)
        • 3.4.2 请求映射(RequestMapping)
        • 3.4.3 参数绑定(Parameter Binding)
      • 3.5 实现RESTful:在Spring Boot中构建RESTful API
        • 3.5.1 创建User实体
        • 3.5.2 创建UserController
        • 3.5.3 测试
      • 3.6 集成Redis:在Spring Boot中使用Redis
        • 3.6.1 引入依赖
        • 3.6.2 配置Redis
        • 3.6.3 使用RedisTemplate
        • 3.6.4 示例代码

1. Spring Boot简介及特性

1.1 简介:什么是Spring Boot

Spring Boot 是一个基于 Spring 框架的开源项目,它的主要设计目标是使开发者能够快速启动和部署 Spring 应用程序。Spring Boot 对 Spring 平台和第三方库采用了"习惯优于配置"的理念,减少了开发人员对配置的需求。

1.2 特性:Spring Boot的优势与特点

Spring Boot具备以下特性,使得应用程序开发过程更为简单和快速:

  1. 独立运行:Spring Boot应用程序可以作为一个独立的JAR包运行,这让Java应用程序的发布和部署变得非常简单。

  2. 嵌入式Servlet容器:你不再需要部署WAR文件,因为Spring Boot可以使用内嵌的Tomcat、Jetty或Undertow来运行你的Web应用程序。

  3. 自动配置:Spring Boot可以自动为你的项目进行各种配置,减少了手工编写配置的工作量。

  4. 无需代码生成和XML配置:Spring Boot采用Java配置,避免了繁琐的XML配置文件,也无需通过代码生成工具生成项目基础框架代码。

1.3 四大核心:Spring Boot的核心组成

Spring Boot的四大核心组件:

  1. 自动配置:Spring Boot会自动配置你的Spring应用程序,基于你添加的jar依赖,Spring Boot会做出合理的默认配置。

  2. 起步依赖:Spring Boot提供了一种新的依赖解决方案 - 起步依赖(Starters),它将常用的库聚合在一起,提供给开发者,避免了版本冲突和引入大量依赖的麻烦。

  3. 命令行界面:这是Spring Boot的可选特性,借助Spring Boot CLI,你可以使用Groovy编写Spring应用程序。

  4. Actuator:Actuator提供了生产级的功能,帮助监视和管理Spring Boot应用程序,如健康检查、审计、统计和HTTP追踪等。

以上就是Spring Boot的简介和主要特性,接下来我们将通过实际的案例,进一步探讨Spring Boot的使用。

2. Spring Boot入门案例

2.1 Spring Boot项目创建

  1. 在你的IDEA界面,选择 “File” -> “New” -> “Module”。然后在弹出的窗口中选择 “Spring Initializr”。通过Spring Initializr工具进行创建,选择你需要的构建工具(Maven/Gradle),语言(Java/Kotlin/Groovy)及Java JDK。

Spring Boot:从入门到实践的全面指南_第1张图片

  1. 选择的Spring Boot版本并添加所需的Spring Boot起步依赖,比如Web、JPA、Security等。
    Spring Boot:从入门到实践的全面指南_第2张图片
    3.SpringBoot项目结构:

Spring Boot:从入门到实践的全面指南_第3张图片

在一个典型的Spring Boot项目中,通常会遵循一种标准的项目结构,以便组织和管理代码。下面是一个常见的Spring Boot项目结构示例:

- src
  - main
    - java
      - com.example.project
        - controller          // 控制器层,处理请求和响应
        - service             // 服务层,处理业务逻辑
        - repository          // 数据访问层,与数据库交互
        - model               // 数据模型层,定义实体类和数据传输对象
        - exception           // 异常处理
        - config              // 配置类,包括Spring配置和其他配置
        - Application.java    // 项目启动入口
    - resources
      - static               // 静态资源,如CSS、JavaScript等
      - templates            // 视图模板,如Thymeleaf、Freemarker等
      - application.properties  // 项目配置文件
  - test
    - java                   // 测试代码
      - com.example.project
        - controller
        - service
        - repository
        - model
        - ApplicationTests.java  // 单元测试入口
- pom.xml                    // Maven项目配置文件

上述项目结构的说明如下:

  • src/main/java:Java源代码文件夹,包含了项目的主要代码。
    • com.example.project:项目的根包名,根据实际情况进行命名。
      • controller:控制器层,负责处理请求和响应。
      • service:服务层,处理业务逻辑。
      • repository:数据访问层,与数据库交互。
      • model:数据模型层,定义实体类和数据传输对象。
      • exception:异常处理,用于处理自定义的异常。
      • config:配置类,包括Spring配置和其他配置。
      • Application.java:项目的启动入口,包含main方法。
  • src/main/resources:资源文件夹,包含了配置文件和静态资源。
    • static:静态资源文件夹,存放图片、CSS、JavaScript等文件。
    • templates:视图模板文件夹,存放 Web 页面的模板文件,如Thymeleaf、Freemarker等。
    • application.properties:项目的配置文件,如 服务端口、数据库配置、日志配置等。
  • src/test/java:测试代码文件夹,包含了单元测试和集成测试的代码。
    • com.example.project:项目测试代码的根包名,与主代码包结构相同。
      • controller:控制器层的测试代码。
      • service:服务层的测试代码。
      • repository:数据访问层的测试代码。
      • model:数据模型层的测试代码。
      • ApplicationTests.java:项目的单元测试入口。
  • pom.xml:Maven项目配置文件,包含了项目的依赖管理和构建配置。

2.2 创建一个Spring MVC的Spring Boot Controller

在Spring Boot中,我们通常使用Controller来处理HTTP请求。这些Controller类通常会包含一个或多个公开的方法,这些方法会被映射到特定的HTTP请求。现在,让我们来创建一个简单的Spring MVC Controller。

首先,我们需要创建一个新的Java类。在Spring Boot中,Controller通常会被放在一个名为controller的包中。因此,我们可以创建一个名为GreetingController的新类,路径为src/main/java/com/example/demo/controller/GreetingController.java

然后,我们需要为这个类添加@Controller注解,以告诉Spring这是一个Controller类。同时,我们还需要为这个类添加一个或多个公开的方法,这些方法会被映射到特定的HTTP请求。例如,我们可以添加一个greeting方法,它会被映射到/greeting的GET请求:

package com.example.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class GreetingController {

    @GetMapping("/greeting")
    public String greeting() {
        return "Hello, Spring Boot!";
    }
}

在上面的代码中,@GetMapping注解告诉Spring当一个GET请求被发送到/greeting时,应该调用greeting方法。greeting方法返回的字符串(在这个例子中是"Hello, Spring Boot!")将会被用作HTTP响应的主体。

2.3 深入理解Spring Boot Controller的工作机制

首先,我们需要理解的是,Spring Boot应用程序在启动时,会自动扫描所有的Java类,并查找包含特定注解的类。在我们的例子中,GreetingController类被@Controller注解修饰,因此,Spring Boot会把它识别为一个Controller,并把它加入到Spring的应用上下文中。

其次,每一个公开的方法都可以被映射到一个或多个HTTP请求。在我们的例子中,greeting方法被@GetMapping注解修饰,这意味着它会响应所有发送到/greeting的GET请求。当一个匹配的请求被接收时,Spring MVC会自动调用这个方法,并把方法的返回值作为HTTP响应的主体。在我们的例子中,greeting方法返回的是"Hello, Spring Boot!",因此,当我们访问http://localhost:8080/greeting时,我们会看到这个字符串。

最后,我们需要理解的是,Spring MVC的工作方式极大地简化了Web应用程序的开发。在传统的Java Web应用程序中,我们需要手动解析HTTP请求,并根据请求的内容生成HTTP响应。而在Spring MVC中,这一切都被自动化了。我们只需要定义Controller和方法,然后用注解来描述它们应该如何响应HTTP请求,剩下的工作就交给Spring MVC来处理了。

2.4 Spring Boot核心配置文件解析

在Spring Boot应用中,大部分的配置信息都存储在application.propertiesapplication.yml文件中。这些配置文件通常位于src/main/resources目录下,Spring Boot会在启动时自动加载这些配置文件。现在,我们就来详细解析一下这些配置文件的格式。

2.4.1 application.properties

application.properties是最常用的配置文件格式,它采用“键=值”的格式来存储配置信息。例如:

server.port=8081
spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass

在上面的配置文件中,server.port配置了应用程序的运行端口,而spring.datasource.*配置了数据源的连接信息。

2.4.2 application.yml

另一种常用的配置文件格式是application.yml,它采用YAML(YAML Ain’t Markup Language)语言来描述配置信息。YAML的语法更加简洁,更适合描述复杂的数据结构。例如,上面的配置信息在application.yml中可以写成:

server:
  port: 8081

spring:
  datasource:
    url: jdbc:mysql://localhost/test
    username: dbuser
    password: dbpass
2.4.3 自定义配置

除了Spring Boot内置的配置项之外,我们还可以在application.propertiesapplication.yml中添加自定义的配置项。例如,我们可以添加一个app.message的配置项:

app.message=Hello, Spring Boot!

然后,我们可以在任意一个Spring Bean中注入这个配置项:

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

在上面的代码中,@Value注解告诉Spring要把app.message的值注入到message变量中。

2.5 在Spring Boot中使用JSP

尽管Spring Boot推荐使用Thymeleaf作为其模板引擎,但在某些情况下,我们可能仍然需要在Spring Boot应用中使用JSP。在这一节中,我们将详细介绍如何在Spring Boot中配置和使用JSP。

2.5.1 添加依赖

要在Spring Boot中使用JSP,我们首先需要在pom.xml中添加相关的依赖。由于Spring Boot的默认内嵌容器(Embedded Tomcat)并不支持JSP,我们还需要添加tomcat-embed-jasper依赖来提供JSP的支持:

<dependencies>
    
    
    
    <dependency>
        <groupId>org.apache.tomcat.embedgroupId>
        <artifactId>tomcat-embed-jasperartifactId>
        <scope>providedscope>
    dependency>
    
    
    <dependency>
        <groupId>javax.servletgroupId>
        <artifactId>jstlartifactId>
    dependency>
dependencies>
2.5.2 配置视图解析器

接下来,我们需要在application.properties中配置Spring MVC的视图解析器,以便它能正确地找到和渲染JSP页面:

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

在上面的配置中,spring.mvc.view.prefixspring.mvc.view.suffix定义了JSP页面的位置和扩展名。例如,如果一个视图的名字是home,那么Spring MVC会尝试渲染/WEB-INF/jsp/home.jsp这个JSP页面。

2.5.3 创建JSP页面

现在,我们可以在src/main/webapp/WEB-INF/jsp/目录下创建JSP页面。例如,我们可以创建一个home.jsp页面:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>



Home


Welcome to Spring Boot!

2.5.4 控制器中返回视图名称

最后,我们可以在控制器中返回JSP页面的名称。Spring MVC会自动使用配置的视图解析器来找到和渲染这个JSP页面:

@Controller
public class HomeController {

    @RequestMapping("/")
    public String home() {
        return "home";
    }
}

在上面的代码中,home方法返回了"home"这个视图名称,Spring MVC会渲染/WEB-INF/jsp/home.jsp这个JSP页面。

至此,我们已经完成了在Spring Boot中使用JSP的所有配置。在下一节中,我们将介绍Spring Boot框架Web开发的相关内容。

3.1 集成MyBatis:在Spring Boot中使用MyBatis

MyBatis是一款优秀的持久层框架,支持自定义SQL、存储过程以及高级映射。Spring Boot能够与MyBatis完美地集成在一起,下面将简单介绍一下步骤:

  1. pom.xml文件中添加mybatis-spring-boot-starter依赖:
<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.1.4version>
dependency>
  1. application.properties文件中配置MyBatis和数据库相关属性:
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false
spring.datasource.username=root
spring.datasource.password=root
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.example.demo.entity

这些配置中,spring.datasource.*是数据源相关的配置,mybatis.mapper-locations是mapper映射文件的位置,mybatis.type-aliases-package是实体类所在的包。

  1. 创建对应的Mapper接口:
@Mapper
public interface UserMapper {
    User selectUser(Integer id);
}

在Mapper接口中定义你需要执行的操作,比如这里我们定义了一个selectUser方法用于查询用户。

  1. 创建对应的Mapper映射文件:
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="selectUser" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    select>
mapper>

在映射文件中编写具体的SQL语句。这里的namespace应与Mapper接口的全类名相对应,id应与Mapper接口中的方法名相对应。

  1. 在服务类或控制器中注入Mapper接口并使用:
@Autowired
private UserMapper userMapper;

public User getUser(Integer id) {
    return userMapper.selectUser(id);
}

至此,你就完成了Spring Boot与MyBatis的集成。现在你可以在应用中通过MyBatis进行数据的持久化操作了。

3.2 DAO开发策略:探索DAO的多种开发方式

在实际的Spring Boot项目开发中,我们除了可以使用上述的MyBatis作为数据持久层框架外,还可以使用其他一些方式来进行数据库操作,例如使用JPA(Java Persistence API)或者使用Spring Data JPA等。

下面简要介绍一下这两种方式:

1. 使用JPA

JPA是Java Persistence API的简称,是Java EE和Java SE环境中的持久层技术标准。其主要作用就是简化持久层的开发,让开发者用面向对象的思维来操作数据库。

在Spring Boot中使用JPA,主要是以下几个步骤:

  • 在pom.xml中添加依赖:
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-jpaartifactId>
dependency>
  • 配置application.properties:
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
  • 创建实体类,并使用JPA注解进行配置:
@Entity
public class User {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;

    private String name;

    // getter and setter...
}
  • 创建Repository接口,继承JpaRepository:
public interface UserRepository extends JpaRepository<User, Integer> {
}
  • 在需要的地方,注入UserRepository使用:
@Autowired
private UserRepository userRepository;

2. 使用Spring Data JPA

Spring Data JPA是在JPA的基础上进行了一定的封装,提供了一整套的数据访问层解决方案,能大大简化数据访问层的开发。

在Spring Boot中使用Spring Data JPA,主要步骤与使用JPA基本一致,不同的是在创建Repository接口时,可以定义一些复杂的查询方法:

public interface UserRepository extends JpaRepository<User, Integer> {
    List<User> findByName(String name);
    User findByNameAndId(String name, Integer id);
}

在Spring Data JPA中,你只需要按照一定的命名规则来定义方法,无需编写实现,Spring Data JPA会自动帮你完成方法的实现。

以上就是Spring Boot中DAO的其他开发方式。具体使用哪种方式,需要根据项目的实际需求来决定。

3.3 事务支持:理解Spring Boot的事务处理方式

在数据库操作中,事务是一种非常重要的机制,它可以保证一系列数据库操作要么全部成功,要么全部失败,从而保证数据的一致性。Spring Boot也提供了对事务的支持。

在Spring Boot中,可以通过使用@Transactional注解来声明一个方法或者类需要被事务管理。当标记在类上时,表示类中所有的public方法都会被事务管理。

例如,我们在UserService类中的updateUser方法上添加@Transactional注解:

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void updateUser(Integer id, String name) {
        User user = userRepository.findById(id).orElseThrow(() -> new RuntimeException("User not found"));
        user.setName(name);
        userRepository.save(user);
    }
}

在上述代码中,updateUser方法会被Spring的事务管理器管理,如果在方法执行过程中发生了任何未捕获的异常,那么Spring的事务管理器会自动将事务进行回滚,也就是说,这个方法中的所有数据库操作都不会被实际执行。

另外,@Transactional注解也提供了一些属性来进行更细粒度的控制,例如:

  • isolation:用来设置事务的隔离级别,如读已提交(READ_COMMITTED)、可重复读(REPEATABLE_READ)、串行化(SERIALIZABLE)等。

  • propagation:用来设置事务的传播行为,如支持当前事务(SUPPORTS)、创建新事务(REQUIRES_NEW)、嵌套事务(NESTED)等。

  • readOnly:设置事务是否只读。当事务只读时,数据库可以进行一些优化。

  • timeout:设置事务的超时时间。

  • rollbackFornoRollbackFor:用来设置哪些异常会触发事务回滚。

例如:

@Transactional(isolation = Isolation.REPEATABLE_READ, 
              propagation = Propagation.REQUIRED, 
              readOnly = false, 
              timeout = 3, 
              rollbackFor = RuntimeException.class)

以上就是Spring Boot对事务支持的基本介绍,事务管理是保证数据一致性的重要手段,在进行数据库操作时,适当的使用事务管理是非常有必要的。

3.4 注解式Spring MVC:Spring MVC在Spring Boot中的应用

Spring MVC是一种基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架,通过分离模型(Model),视图(View)和控制器(Controller)的方式,简化了Web开发。在Spring Boot环境下,Spring MVC可以更方便的进行配置和使用。

3.4.1 控制器(Controller)

在Spring MVC中,控制器是处理用户请求的核心部分。在Spring Boot环境下,我们可以通过添加@Controller或者@RestController注解来声明一个控制器类,然后在类中定义处理请求的方法。

@Controller@RestController这两个注解的区别在于,@Controller通常用于返回一个视图,而@RestController通常用于返回一个对象作为HTTP响应体。

例如,下面这个类定义了一个简单的RESTful API,它处理GET请求,并返回一个字符串:

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}
3.4.2 请求映射(RequestMapping)

在Spring MVC中,通过@RequestMapping注解来将一个请求映射到一个处理器方法。在Spring 4.3版本以后,也可以使用如@GetMapping@PostMapping@PutMapping@DeleteMapping等注解来分别处理GET、POST、PUT、DELETE等类型的请求。

例如,下面这个类定义了一个处理POST请求的方法:

@RestController
public class UserController {
    @PostMapping("/user")
    public User createUser(@RequestBody User user) {
        // 处理创建新用户的请求
    }
}
3.4.3 参数绑定(Parameter Binding)

在处理请求的方法中,可以通过添加@PathVariable@RequestParam@RequestBody等注解来绑定请求的参数。

  • @PathVariable:用来绑定路径参数,例如/users/{id}中的id参数。

  • @RequestParam:用来绑定请求参数,例如/users?name=John中的name参数。

  • @RequestBody:用来绑定请求体,通常用于处理POST或PUT请求。

例如,下面这个方法接受一个路径参数和一个请求体:

@RestController
public class UserController {
    @PutMapping("/user/{id}")
    public User updateUser(@PathVariable Integer id, @RequestBody User user) {
        // 处理更新用户的请求
    }
}

以上就是在Spring Boot下使用Spring MVC的基本介绍,通过使用Spring MVC,我们可以更方便的开发Web应用。

3.5 实现RESTful:在Spring Boot中构建RESTful API

RESTful架构是一种设计风格,它将Web服务视为资源,并通过URI来指定,使用HTTP的动词(GET、POST、PUT、DELETE等)来描述操作。Spring Boot非常适合创建满足RESTful风格的Web服务。

接下来,我们将通过一个简单的用户管理系统,来展示如何在Spring Boot中实现RESTful服务。

3.5.1 创建User实体

首先,我们创建一个User实体类:

public class User {
    private Integer id;
    private String name;
    private String email;
    
    // getters and setters...
}
3.5.2 创建UserController

然后,我们创建一个UserController类,该类将处理有关用户的所有HTTP请求:

@RestController
@RequestMapping("/users")
public class UserController {
    private List<User> users = new ArrayList<>(); // 模拟数据库

    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }

    @GetMapping("/{id}")
    public User getUser(@PathVariable Integer id) {
        return users.stream()
            .filter(user -> user.getId().equals(id))
            .findFirst()
            .orElse(null);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        users.add(user);
        return user;
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Integer id, @RequestBody User newUser) {
        users.stream()
            .filter(user -> user.getId().equals(id))
            .findFirst()
            .ifPresent(user -> {
                users.remove(user);
                users.add(newUser);
            });
        return newUser;
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Integer id) {
        users.removeIf(user -> user.getId().equals(id));
    }
}

在这个例子中,我们定义了以下几个RESTful API:

  • 获取所有用户:GET /users
  • 获取一个用户:GET /users/{id}
  • 创建一个用户:POST /users
  • 更新一个用户:PUT /users/{id}
  • 删除一个用户:DELETE /users/{id}
3.5.3 测试

最后,我们可以使用任何HTTP客户端(例如Postman或curl)来测试我们的RESTful服务。

以上就是在Spring Boot中实现RESTful服务的一个简单例子。通过使用Spring MVC的注解,我们可以很方便的创建满足RESTful风格的Web服务。

3.6 集成Redis:在Spring Boot中使用Redis

Redis是一个开源的使用ANSI C语言编写、遵循BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。Spring Boot对其有着非常好的支持,让我们一起来看看如何进行集成。

3.6.1 引入依赖

首先,在我们的项目的pom.xml中加入Spring Boot对Redis的支持:

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>
3.6.2 配置Redis

然后,在application.properties(或application.yml)中配置Redis的信息:

spring.redis.host=localhost
spring.redis.port=6379

这里我们假设Redis服务器安装在本地,端口号为默认的6379。

3.6.3 使用RedisTemplate

接下来,我们可以使用RedisTemplate对象进行Redis操作:

@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setKey(String key, Object value){
        redisTemplate.opsForValue().set(key, value);
    }

    public Object getKey(String key){
        return redisTemplate.opsForValue().get(key);
    }

    // 更多的操作...
}

RedisTemplate是Spring提供的用于操作Redis的工具类,我们可以使用它进行各种各样的Redis操作。

3.6.4 示例代码

下面是一个简单的示例,展示如何在一个controller中使用RedisService:

@RestController
public class RedisController {
    @Autowired
    private RedisService redisService;

    @GetMapping("/redis/set")
    public String set(@RequestParam("key") String key, @RequestParam("value") String value){
        redisService.setKey(key, value);
        return "Success";
    }

    @GetMapping("/redis/get")
    public String get(@RequestParam("key") String key){
        return String.valueOf(redisService.getKey(key));
    }
}

在这个例子中,我们定义了两个接口,一个用于设置键值对,另一个用于获取指定键的值。

以上就是在Spring Boot中集成Redis的基本步骤。实际上,Spring还提供了其他更强大的功能,例如Redis的序列化和反序列化、事务支持等,你可以根据实际需求进行探索和学习。

你可能感兴趣的:(spring,boot,spring,java)