Springboot2.x使用JPA整合Redis

你的名字 2023-02-16 04:28 42阅读 0赞

SpringBoot2.3，使用MySQL数据库，通过JPA实现ORM，再用Redis实现数据库的缓存。

# 代码实现： #

## pom.xml ##

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

## application.properties ##

#数据库索引（默认为0）
    spring.redis.database=0
    spring.redis.host=localhost
    spring.redis.port=6379
    # Redis服务器连接密码（默认为空）
    spring.redis.password=
    #连接超时时间
    spring.redis.timeout=10000
    #最大连接数
    spring.redis.jedis.pool.max-active=8
    #最大阻塞等待时间(负数表示没限制)
    spring.redis.jedis.pool.max-wait=-1
    #最大空闲
    spring.redis.jedis.pool.max-idle=8
    #最小空闲
    spring.redis.jedis.pool.min-idle=0
    #==================mysql========================
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/woxiang_test?setUnicode=true&characterEncoding=utf8&useSSL=false
    spring.datasource.username=root
    spring.datasource.password=000000
    #====================jps======================
    # 数据库类型
    spring.jpa.database=mysql
    # 输出日志
    spring.jpa.show-sql=true
    # JPA配置
    spring.jpa.hibernate.ddl-auto=update

## 在Springboot2TestApplication添加注解（@EnableCaching） ##

一定要注意加上该注解，否则不生效！！！

@SpringBootApplication
    @EnableCaching
    public class Springboot2TestApplication {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Springboot2TestApplication.class, args);
    	}
    
    }

## RedisConfig ##

import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    
    import java.lang.reflect.Method;
    import java.time.Duration;
    
    /**
     * Redis 缓存配置类
     */
    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {
    
    	/**
    	 * 缓存对象集合中，缓存是以 key-value 形式保存的。
    	 * 当不指定缓存的 key 时，SpringBoot 会使用 SimpleKeyGenerator 生成 key。
    	 */
    //  @Bean
    	public KeyGenerator wiselyKeyGenerator() {
    		// key前缀，用于区分不同项目的缓存，建议每个项目单独设置
    		final String PRE_KEY = "test";
    		final char sp = ':';
    		return new KeyGenerator() {
    			@Override
    			public Object generate(Object target, Method method, Object... params) {
    				StringBuilder sb = new StringBuilder();
    				sb.append(PRE_KEY);
    				sb.append(sp);
    				sb.append(target.getClass().getSimpleName());
    				sb.append(sp);
    				sb.append(method.getName());
    				for (Object obj : params) {
    					sb.append(sp);
    					sb.append(obj.toString());
    				}
    				return sb.toString();
    			}
    		};
    	}
    
    	@Bean
    	public CacheManager cacheManager(RedisConnectionFactory factory) {
    		// 更改值的序列化方式，否则在Redis可视化软件中会显示乱码。默认为JdkSerializationRedisSerializer
    		RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair
    				.fromSerializer(new GenericJackson2JsonRedisSerializer());
    		RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration
    				.defaultCacheConfig()
    				.serializeValuesWith(pair)      // 设置序列化方式
    				.entryTtl(Duration.ofHours(1)); // 设置过期时间
    
    		return RedisCacheManager
    				.builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory))
    				.cacheDefaults(defaultCacheConfig).build();
    	}
    }

## 实体类User（实现Serializable接口） ##

import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import java.io.Serializable;
    
    @Entity
    public class User implements Serializable {
    
    	private static final long serialVersionUID = 1l;
    
    	@Id
    	@GeneratedValue(strategy = GenerationType.IDENTITY)
    	private Integer id;
    	private String username;
    	private String password;
    
    	public User() {
    	}
    
    	public User(Integer id, String username, String password) {
    		this.id = id;
    		this.username = username;
    		this.password = password;
    	}
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	public String getPassword() {
    		return password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    }

## UserMapper ##

import com.test.springboot2_test.domain.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface UserMapper extends JpaRepository<User, Integer> {
    
    }

## UserService ##

import com.test.springboot2_test.domain.User;
    
    public interface UserService {
    
    	User findById(Integer id);
    
    	void save(User user);
    
    }

## UserServiceImpl（`cacheNames`与`value`作用一样） ##

import com.test.springboot2_test.domain.User;
    import com.test.springboot2_test.repository.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CacheConfig;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    
    import java.util.Optional;
    
    
    @Service
    @CacheConfig(cacheNames = "userService")
    public class UserServiceImpl implements UserService {
    
    	@Autowired
    	private UserMapper userMapper;
    
    	@Override
    	@Cacheable(value = "user", key = "#p0")
    	public User findById(Integer id) {
    		Optional<User> _User = userMapper.findById(id);
    		return Optional.ofNullable(_User).get().orElse(null);
    	}
    
    	@Override
    	public void save(User user) {
    		userMapper.save(user);
    	}
    
    }

## UserController ##

import com.test.springboot2_test.domain.AjaxResponse;
    import com.test.springboot2_test.domain.User;
    import com.test.springboot2_test.service.UserService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.*;
    
    @Slf4j
    @RestController
    @Api(description = "用户接口")
    public class UserController {
    
    	@Autowired
    	private UserService userService;
    
    	@GetMapping("/users/{id}")
    	@ApiOperation(value = "获取用户", notes = "根据id查询一个用户")
    	public AjaxResponse toHello(@PathVariable("id") Integer id) {
    		System.out.println("只有第一次才会打印sql语句");
    		User u = userService.findById(id);
    		return AjaxResponse.success(u);
    	}
    
    	@PostMapping("/users")
    	@ApiOperation(value = "增加用户", notes = "增加一个用户")
    	public AjaxResponse saveUser(@RequestBody User user) {
    		log.info("User:" + user);
    		userService.save(user);
    		return AjaxResponse.success();
    	}
    
    }

# 测试： #

启动服务后，可以看到 JPA框架自动生成user表。

## 使用swagger-ui对接口进行操作 ##

1）添加几个用户

2）根据id查找用户

使用Redis客户端命令登录redis：

redis-cli -h 127.0.0.1 -p 6379

查看数据：

127.0.0.1:6379> keys *
    1) "user::4"
    127.0.0.1:6379> get user::4
    "{\"@class\":\"com.test.springboot2_test.domain.User\",\"id\":4,\"username\":\"wangnian\",\"password\":\"wang\"}"
    127.0.0.1:6379>

此时查看控制台的信息，第一次调用的时候会打印一句话，随后会显示自动生成的查询语句：

只有第一次才会打印sql语句
    Hibernate: select user0_.id as id1_0_0_, user0_.password as password2_0_0_, user0_.username as username3_0_0_ from user user0_ where user0_.id=?

第二次调用的时候只会打印一句话，并不会显示查询语句，此时，缓存生效。