Spring Boot：从入门到实践的全面指南(2)-阿里云开发者社区

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>
    <!-- 其他依赖 -->
    <!-- 添加JSP支持 -->
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
        <scope>provided</scope>
    </dependency>
    <!-- 添加JSTL支持 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
    </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.prefix和spring.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"%>
<!DOCTYPE html>
<html>
<head>
<title>Home</title>
</head>
<body>
<h1>Welcome to Spring Boot!</h1>
</body>
</html>

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完美地集成在一起，下面将简单介绍一下步骤：

在pom.xml文件中添加mybatis-spring-boot-starter依赖：

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

在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是实体类所在的包。

创建对应的Mapper接口：

@Mapper
public interface UserMapper {
    User selectUser(Integer id);
}

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

创建对应的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接口中的方法名相对应。

在服务类或控制器中注入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等。

下面简要介绍一下这两种方式：JPA是Java Persistence API的简称，是Java EE和Java SE环境中的持久层技术标准。其主要作用就是简化持久层的开发，让开发者用面向对象的思维来操作数据库。

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

在pom.xml中添加依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</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：设置事务的超时时间。

rollbackFor和noRollbackFor：用来设置哪些异常会触发事务回滚。

例如：

@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.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</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：从入门到实践的全面指南(2)

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 示例代码

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring Boot：从入门到实践的全面指南(2)

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 示例代码

热门文章

最新文章

相关课程

相关电子书

相关实验场景