JPA框架基本用法-SpringBoot框架（一）

￡神魔★判官ぃ 2023-10-12 10:26 25阅读 0赞

#### 依赖 ####

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    </dependency>

#### 1、DAO层 ####

import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.Modifying;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.data.repository.query.Param;
    import org.springframework.stereotype.Repository;
    import com.example.demo.entity.User;
    
    @Repository
    public interface UserRepository extends JpaRepository<User, Long> {
        
    
        /**
         * 根据用户名查询用户
         * @param username 用户名
         * @return 用户对象
         */
        User findByUsername(String username);
    
        /**
         * 根据用户状态查询用户列表
         * @param status 用户状态
         * @return 用户列表
         */
        List<User> findByStatus(Integer status);
    
        /**
         * 根据用户ID更新用户状态
         * @param userId 用户ID
         * @param status 用户状态
         * @return 受影响的行数
         */
        @Modifying
        @Query("update User u set u.status = :status where u.id = :userId")
        int updateUserStatus(@Param("userId") Long userId, @Param("status") Integer status);
    
        /**
         * 根据用户ID删除用户
         * @param userId 用户ID
         */
        void deleteById(Long userId);
    
        /**
         * 多表关联查询
         * @return 用户和订单列表
         */
        @Query("select u, o from User u left join Order o on u.id = o.userId")
        List<Object[]> findUserAndOrderList();
    
        /**
         * 分组查询
         * @return 每个状态对应的用户数量
         */
        @Query("select u.status, count(*) from User u group by u.status")
        List<Object[]> findUserCountByStatus();
    
        /**
         * 视图查询
         * @return 用户视图列表
         */
        @Query("select uv.id, uv.username, uv.status from UserView uv")
        List<Object[]> findUserViewList();
    
        /**
         * 存储过程查询
         * @param userId 用户ID
         * @param status 用户状态
         */
        @Procedure(name = "update_user_status")
        void updateUserStatusByProcedure(Long userId, Integer status);
    
    }

#### 2、服务层 ####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import com.example.demo.entity.User;
    import com.example.demo.repository.UserRepository;
    
    @Service
    public class UserService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        /**
         * 根据用户名查询用户
         * @param username 用户名
         * @return 用户对象
         */
        public User getUserByUsername(String username) {
        
            return userRepository.findByUsername(username);
        }
    
        /**
         * 根据用户状态查询用户列表
         * @param status 用户状态
         * @return 用户列表
         */
        public List<User> getUserListByStatus(Integer status) {
        
            return userRepository.findByStatus(status);
        }
    
        /**
         * 根据用户ID更新用户状态
         * @param userId 用户ID
         * @param status 用户状态
         * @return 受影响的行数
         */
        public int updateUserStatus(Long userId, Integer status) {
        
            return userRepository.updateUserStatus(userId, status);
        }
    
        /**
         * 根据用户ID删除用户
         * @param userId 用户ID
         */
        public void deleteUserById(Long userId) {
        
            userRepository.deleteById(userId);
        }
    
        /**
         * 多表关联查询
         * @return 用户和订单列表
         */
        public List<Object[]> getUserAndOrderList() {
        
            return userRepository.findUserAndOrderList();
        }
    
        /**
         * 分组查询
         * @return 每个状态对应的用户数量
         */
        public List<Object[]> getUserCountByStatus() {
        
            return userRepository.findUserCountByStatus();
        }
    
        /**
         * 视图查询
         * @return 用户视图列表
         */
        public List<Object[]> getUserViewList() {
        
            return userRepository.findUserViewList();
        }
    
        /**
         * 存储过程查询
         * @param userId 用户ID
         * @param status 用户状态
         */
        public void updateUserStatusByProcedure(Long userId, Integer status) {
        
            userRepository.updateUserStatusByProcedure(userId, status);
        }
    
    }

#### 3、SQL脚本 ####

-- 建表
    CREATE TABLE `user` (
      `id` bigint(20) NOT NULL AUTO_INCREMENT,
      `username` varchar(50) NOT NULL,
      `password` varchar(50) NOT NULL,
      `status` int(11) NOT NULL DEFAULT '1',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    
    -- 建视图
    CREATE VIEW `user_view` AS
    SELECT `id`, `username`, `status` FROM `user`;
    
    -- 建存储过程
    CREATE PROCEDURE `update_user_status`(IN `user_id` BIGINT, IN `status` INT)
    BEGIN
        UPDATE `user` SET `status` = `status` WHERE `id` = `user_id`;
    END;
    
    -- 数据插入
    INSERT INTO `user` (`id`, `username`, `password`, `status`) VALUES (1, 'admin', '123456', 1);

#### 4、YML文件 ####

server:
      port: 8080
    
    spring:
      datasource:
        url: jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&characterEncoding=utf-8
        username: root
        password: root
        driver-class-name: com.mysql.cj.jdbc.Driver
      jpa:
        hibernate:
          ddl-auto: update # 自动根据实体类更新表结构
        show-sql: true # 显示SQL语句
        properties:
          hibernate:
            format_sql: true # 格式化SQL语句

*  `server.port` 配置服务器端口号为8080
 *  `spring.datasource` 配置数据源相关信息，包括url、用户名、密码和驱动类名
 *  `jpa.hibernate.ddl-auto` 配置自动根据实体类更新表结构
 *  `jpa.show-sql` 配置显示SQL语句
 *  `jpa.properties.hibernate.format_sql` 配置格式化SQL语句

#### 5、实体类 ####

import javax.persistence.*;
    
    @Entity
    @Table(name = "user")
    public class User {
        
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        @Column(nullable = false)
        private String username;
    
        @Column(nullable = false)
        private String password;
    
        @Column(nullable = false)
        private Integer status;
    
        // getter和setter省略
    
    }

*  `@Entity` 注解表示该类是一个实体类
 *  `@Table` 注解表示对应的数据库表名
 *  `@Id` 注解表示该属性是主键
 *  `@GeneratedValue` 注解表示主键自动生成策略
 *  `@Column` 注解表示对应的数据库列名
 *  getter和setter方法省略

import javax.persistence.*;
    
    @Entity
    @Table(name = "order")
    public class Order {
        
    
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
    
        @Column(nullable = false)
        private Long userId;
    
        @Column(nullable = false)
        private String orderNo;
    
        // getter和setter省略
    
    }

#### 6、启动类（可不看） ####

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
    
    @SpringBootApplication
    @EnableJpaRepositories(basePackages = "com.example.demo.repository")
    public class DemoApplication {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

*  `@SpringBootApplication` 注解表示该类是一个Spring Boot应用程序的启动类
 *  `@EnableJpaRepositories` 注解表示启用JPA仓库，指定扫描的包路径

#### 7、其他Repository接口（可不看） ####

import com.example.demo.entity.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    public interface UserRepository extends JpaRepository<User, Long> {
        
    
    }

*  `extends JpaRepository<User, Long>` 表示该接口继承自JpaRepository接口，其中User表示实体类，Long表示实体类主键的数据类型
 *  不需要实现该接口，Spring Data JPA会自动为该接口生成实现类，包括基础的CRUD方法和分页查询方法等

#### 8、其他Service接口（可不看） ####

import com.example.demo.entity.User;
    
    import java.util.List;
    
    public interface UserService {
        
    
        User createUser(User user);
    
        List<User> getAllUsers();
    
        User getUserById(Long id);
    
        User updateUser(User user);
    
        void deleteUser(Long id);
    
    }

import com.example.demo.entity.User;
    import com.example.demo.repository.UserRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    import java.util.Optional;
    
    @Service
    public class UserServiceImpl implements UserService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        @Override
        public User createUser(User user) {
        
            return userRepository.save(user);
        }
    
        @Override
        public List<User> getAllUsers() {
        
            return userRepository.findAll();
        }
    
        @Override
        public User getUserById(Long id) {
        
            Optional<User> optionalUser = userRepository.findById(id);
            return optionalUser.orElse(null);
        }
    
        @Override
        public User updateUser(User user) {
        
            return userRepository.save(user);
        }
    
        @Override
        public void deleteUser(Long id) {
        
            userRepository.deleteById(id);
        }
    
    }

*  `UserService` 接口定义了创建、获取、更新和删除用户的方法
 *  `UserServiceImpl` 实现了`UserService`接口，通过`@Service`注解声明该类是一个Spring Bean，并通过`@Autowired`注解注入`UserRepository`对象，实现了UserService接口中定义的方法

#### 9、Controller类（可不看） ####

import com.example.demo.entity.User;
    import com.example.demo.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.*;
    
    import java.util.List;
    
    @RestController
    @RequestMapping("/users")
    public class UserController {
        
    
        @Autowired
        private UserService userService;
    
        @PostMapping
        public ResponseEntity<User> createUser(@RequestBody User user) {
        
            User createdUser = userService.createUser(user);
            return new ResponseEntity<>(createdUser, HttpStatus.CREATED);
        }
    
        @GetMapping
        public ResponseEntity<List<User>> getAllUsers() {
        
            List<User> users = userService.getAllUsers();
            return new ResponseEntity<>(users, HttpStatus.OK);
        }
    
        @GetMapping("/{id}")
        public ResponseEntity<User> getUserById(@PathVariable Long id) {
        
            User user = userService.getUserById(id);
            if (user == null) {
        
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            } else {
        
                return new ResponseEntity<>(user, HttpStatus.OK);
            }
        }
    
        @PutMapping("/{id}")
        public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        
            User existingUser = userService.getUserById(id);
            if (existingUser == null) {
        
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            } else {
        
                user.setId(id);
                User updatedUser = userService.updateUser(user);
                return new ResponseEntity<>(updatedUser, HttpStatus.OK);
            }
        }
    
        @DeleteMapping("/{id}")
        public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        
            User existingUser = userService.getUserById(id);
            if (existingUser == null) {
        
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            } else {
        
                userService.deleteUser(id);
                return new ResponseEntity<>(HttpStatus.NO_CONTENT);
            }
        }
    
    }

*  `@RestController` 注解表示该类是一个Spring MVC的控制器，同时返回的数据是JSON格式的
 *  `@RequestMapping("/users")` 注解表示该控制器处理的请求路径都以`/users`开头
 *  `@Autowired` 注解注入`UserService`对象
 *  `@PostMapping` 注解表示处理HTTP POST请求的方法，`@RequestBody`注解表示从请求体中获取参数
 *  `@GetMapping` 注解表示处理HTTP GET请求的方法
 *  `@PathVariable` 注解表示获取路径变量的值
 *  `@PutMapping` 注解表示处理HTTP PUT请求的方法
 *  `@DeleteMapping` 注解表示处理HTTP DELETE请求的方法
 *  `ResponseEntity` 表示响应实体，包括响应状态码和响应体数据

#### 10、异常处理类（可不看） ####

import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    
    @ControllerAdvice
    public class ExceptionControllerAdvice {
        
    
        @ExceptionHandler(value = {
        IllegalArgumentException.class})
        public ResponseEntity<Object> handleIllegalArgumentException(IllegalArgumentException ex) {
        
            return new ResponseEntity<>(ex.getMessage(), HttpStatus.BAD_REQUEST);
        }
    
        @ExceptionHandler(value = {
        Exception.class})
        public ResponseEntity<Object> handleException(Exception ex) {
        
            return new ResponseEntity<>(ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
        }
    
    }

*  `@ControllerAdvice` 注解表示该类是一个全局异常处理类
 *  `@ExceptionHandler` 注解表示处理指定类型的异常
 *  `IllegalArgumentException` 表示参数不合法异常，返回状态码为400 Bad Request
 *  `Exception` 表示其他异常，返回状态码为500 Internal Server Error

#### 11、Spring Boot使用JdbcTemplate进行数据库操作 ####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserDao {
        
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        public User getUserById(Long id) {
        
            String sql = "select * from user where id = ?";
            return jdbcTemplate.queryForObject(sql, new Object[]{
        id}, new UserRowMapper());
        }
    
        public void saveUser(User user) {
        
            String sql = "insert into user (name, age) values (?, ?)";
            jdbcTemplate.update(sql, user.getName(), user.getAge());
        }
    
        public void updateUser(User user) {
        
            String sql = "update user set name = ?, age = ? where id = ?";
            jdbcTemplate.update(sql, user.getName(), user.getAge(), user.getId());
        }
    
        public void deleteUserById(Long id) {
        
            String sql = "delete from user where id = ?";
            jdbcTemplate.update(sql, id);
        }
    
    }

*  `@Repository` 注解表示该类是持久层组件
 *  `@Autowired` 注解表示自动注入`JdbcTemplate`组件
 *  `jdbcTemplate.queryForObject` 方法用于查询单条记录，第一个参数为SQL语句，第二个参数为占位符参数，第三个参数为结果集映射器
 *  `jdbcTemplate.update` 方法用于更新数据，第一个参数为SQL语句，第二个参数为占位符参数

#### 12、Spring Boot使用Spring Security进行身份认证和授权（） ####

可不看

##### 12.1、配置Spring Security #####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
    import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
    import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
    import org.springframework.security.crypto.password.PasswordEncoder;
    
    @Configuration
    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private MyUserDetailsService myUserDetailsService;
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        
            auth.userDetailsService(myUserDetailsService).passwordEncoder(passwordEncoder());
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.authorizeRequests()
                    .antMatchers("/public/**").permitAll()
                    .antMatchers("/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
                    .and()
                    .formLogin().loginPage("/login").permitAll()
                    .and()
                    .logout().permitAll();
        }
    
        @Bean
        public PasswordEncoder passwordEncoder() {
        
            return new BCryptPasswordEncoder();
        }
    
    }

*  `@Configuration` 表示该类是配置类
 *  `@EnableWebSecurity` 表示启用Web安全功能
 *  `MyUserDetailsService` 是自定义的用户信息服务，用于从数据库中获取用户信息
 *  `passwordEncoder` 方法用于创建密码编码器，这里使用了BCrypt算法进行密码加密
 *  `configure(AuthenticationManagerBuilder auth)` 方法用于配置用户认证信息，这里通过`myUserDetailsService`获取用户信息，然后使用`passwordEncoder`进行密码验证
 *  `configure(HttpSecurity http)` 方法用于配置HTTP请求的安全策略，这里定义了URL的访问权限和登录相关的配置

##### 12.2、自定义用户信息服务 #####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.core.authority.SimpleGrantedAuthority;
    import org.springframework.security.core.userdetails.User;
    import org.springframework.security.core.userdetails.UserDetails;
    import org.springframework.security.core.userdetails.UserDetailsService;
    import org.springframework.security.core.userdetails.UsernameNotFoundException;
    import org.springframework.stereotype.Service;
    
    import java.util.ArrayList;
    import java.util.List;
    
    @Service
    public class MyUserDetailsService implements UserDetailsService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            com.example.demo.entity.User user = userRepository.findByUsername(username);
            if (user == null) {
        
                throw new UsernameNotFoundException("用户名不存在!");
            }
            List<GrantedAuthority> authorities = new ArrayList<>();
            authorities.add(new SimpleGrantedAuthority(user.getRole()));
            return new User(user.getUsername(), user.getPassword(), authorities);
        }
    
    }

*  `@Service` 表示该类是服务组件
 *  `UserDetailsService` 是Spring Security提供的用户信息服务接口，用于获取用户信息
 *  `UserDetails` 是Spring Security提供的用户信息接口，用于封装用户信息
 *  `userRepository` 是自定义的JpaRepository，用于从数据库中获取用户信息
 *  `loadUserByUsername` 方法用于根据用户名获取用户信息，并将其封装成`UserDetails`对象返回

#### 13、Spring Boot集成Swagger2进行API文档管理（可不看） ####

##### 13.1、添加Swagger2依赖 #####

<dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger2</artifactId>
      <version>2.9.2</version>
    </dependency>
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger-ui</artifactId>
      <version>2.9.2</version>
    </dependency>

##### 13.2、配置Swagger2 #####

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import springfox.documentation.builders.ApiInfoBuilder;
    import springfox.documentation.builders.PathSelectors;
    import springfox.documentation.builders.RequestHandlerSelectors;
    import springfox.documentation.service.ApiInfo;
    import springfox.documentation.spi.DocumentationType;
    import springfox.documentation.spring.web.plugins.Docket;
    import springfox.documentation.swagger2.annotations.EnableSwagger2;
    
    @Configuration
    @EnableSwagger2
    public class Swagger2Config {
        
    
        @Bean
        public Docket createRestApi() {
        
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.basePackage("com.example.demo.controller"))
                    .paths(PathSelectors.any())
                    .build();
        }
    
        private ApiInfo apiInfo() {
        
            return new ApiInfoBuilder()
                    .title("Spring Boot集成Swagger2")
                    .description("Spring Boot集成Swagger2")
                    .version("1.0")
                    .build();
        }
    
    }

*  `@Configuration` 表示该类是配置类
 *  `@EnableSwagger2` 表示启用Swagger2
 *  `createRestApi` 方法用于创建Docket对象，Docket是Swagger2的主配置对象，用于配置各种Swagger2相关的参数
 *  `apiInfo` 方法用于创建API文档的基本信息，包括文档标题、描述和版本等信息
 *  `RequestHandlerSelectors.basePackage` 方法用于指定扫描的包路径
 *  `PathSelectors.any` 方法用于指定所有的URL都进行文档管理

#### 14、Spring Boot使用WebSocket实现实时通信（可不看） ####

##### 14.1、添加WebSocket依赖 #####

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

##### 14.2、配置WebSocket #####

import org.springframework.context.annotation.Configuration;
    import org.springframework.messaging.simp.config.MessageBrokerRegistry;
    import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
    import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
    import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
    import org.springframework.web.socket.config.annotation.WebSocketTransportRegistration;
    
    @Configuration
    @EnableWebSocketMessageBroker
    public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
        
    
        @Override
        public void configureMessageBroker(MessageBrokerRegistry registry) {
        
            registry.enableSimpleBroker("/topic");
            registry.setApplicationDestinationPrefixes("/app");
        }
    
        @Override
        public void registerStompEndpoints(StompEndpointRegistry registry) {
        
            registry.addEndpoint("/websocket").setAllowedOrigins("*").withSockJS();
        }
    
        @Override
        public void configureWebSocketTransport(WebSocketTransportRegistration registry) {
        
            registry.setMessageSizeLimit(1024 * 1024);
        }
    
    }

*  `@Configuration` 表示该类是配置类
 *  `@EnableWebSocketMessageBroker` 表示启用WebSocket消息代理
 *  `configureMessageBroker` 方法用于配置消息代理，这里使用的是简单的内存消息代理，用于支持`/topic`前缀的消息订阅和发送，以及`/app`前缀的消息处理
 *  `registerStompEndpoints` 方法用于注册Stomp协议的WebSocket端点，这里使用的是`/websocket`端点，并支持跨域请求
 *  `configureWebSocketTransport` 方法用于配置WebSocket传输参数，这里限制了消息大小为1MB

##### 14.3、发送消息 #####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.messaging.simp.SimpMessagingTemplate;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    @Controller
    @RequestMapping("/websocket")
    public class WebSocketController {
        
    
        @Autowired
        private SimpMessagingTemplate messagingTemplate;
    
        @GetMapping("/send")
        @ResponseBody
        public String send() {
        
            messagingTemplate.convertAndSend("/topic/message", "Hello, World!");
            return "OK";
        }
    
    }

*  `@Controller` 表示该类是控制器组件
 *  `@RequestMapping` 表示该类的请求路径
 *  `SimpMessagingTemplate` 是Spring提供的用于发送WebSocket消息的工具类
 *  `send` 方法用于发送WebSocket消息，这里将消息发送到`/topic/message`频道

#### 15、Spring Boot使用Redis实现缓存（可不看） ####

##### 15.1、添加Redis依赖 #####

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

##### 15.2、配置Redis #####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
        
    
        @Autowired
        private RedisConnectionFactory redisConnectionFactory;
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
        
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
            return redisTemplate;
        }
    
    }

*  `@Configuration` 表示该类是配置类
 *  `RedisConnectionFactory` 是Spring提供的连接Redis的工厂类
 *  `redisTemplate` 方法用于创建RedisTemplate对象，这里使用了Jackson2JsonRedisSerializer序列化器进行序列化和反序列化，这样可以将对象存储为JSON格式的字符串
 *  `setKeySerializer` 方法用于设置Redis键的序列化器
 *  `setValueSerializer` 方法用于设置Redis值的序列化器
 *  `setHashKeySerializer` 方法用于设置Redis哈希键的序列化器
 *  `setHashValueSerializer` 方法用于设置Redis哈希值的序列化器

##### 15.3、使用Redis #####

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
        
    
        @Autowired
        private UserRepository userRepository;
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        public User getUserById(Long id) {
        
            User user = (User) redisTemplate.opsForValue().get("user:" + id);
            if (user == null) {
        
                user = userRepository.findById(id).orElse(null);
                if (user != null) {
        
                    redisTemplate.opsForValue().set("user:" + id, user);
                }
            }
            return user;
        }
    
    }

*  `@Service` 表示该类是服务组件
 *  `userRepository` 是自定义的JpaRepository，用于从数据库中获取用户信息
 *  `redisTemplate` 是自定义的RedisTemplate，用于操作Redis
 *  `getUserById` 方法用于根据用户ID获取用户信息，首先尝试从Redis中获取缓存数据，如果没有则从数据库中获取，并将其缓存到Redis中