springboot整合redis（jedis方式）
Redis笔记
安装Redis
- Windows版
1、下载Windows版安装包：https://github.com/tporadowski/redis/releases
2、无脑安装
3、打开命令行输入：redis-cli（这是无密码的）
- Linux版
1、 安装gcc
由于redis是用C语言开发，安装前必须确认Linux的gcc环境（gcc -V），如果没有安装则运行
yum -install -y gcc
2、 下载redis（下载网址：https://redis.io/download/）
3、 传入sentos7（我用xshell7）
usr/local 是 unix shared resources(共享资源) 的缩写，这是一个非常重要的目录，用户的很多应用程序和文件都放在这个目录下，类似于 windows 下的 program files 目录。
4、 解压安装
解压：tar -zxvf redis-7.0.9.tar.gz
执行编译命令：make
再执行：make PREFIX=/usr/local/redis install
5、 测试是否安装成功
6、 后台启动（配置过来就不需要配置了，直接启动）
从 redis 的源码目录中复制 redis.conf 到 redis 的安装目录
cp /usr/local/redis-7.0.9/redis.conf /usr/local/redis/bin/
修改 redis.conf 文件，把 daemonize no 改为 daemonize yes
vi redis.conf
将redis-cli拷贝到bin下，让redis-cli指令可以在任意目录下直接使用
cp /opt/redis-6.2.5/src/redis-cli.c /usr/local/redis/bin
进入redis/bin目录启动、
./redis-server redis.conf
./redis-cli
之后把压缩包、解压包删除（也可以不删，我Linux存储空间小，删了）
服务操作命令
常用命令：
systemctl start redis.service #启动redis服务
systemctl stop redis.service #停止redis服务
systemctl restart redis.service #重新启动服务
systemctl status redis.service #查看服务当前状态
systemctl enable redis.service #设置开机自启动
systemctl disable redis.service #停止开机自启动
Redis基础命令
Redis基本数据类型：
String（字符串）
hash（哈希）
list（列表）
set（集合）
zset（有序集合）
总：
Springboot+redis+mybatis整合
最终的目录结构：
创建springboot（本人已经创建好了，创建方法百度自己找）
导入依赖
<!--redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--jedis-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.1.0</version>
</dependency>
<!-- 用来序列化的 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.67_noneautotype2</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.28</version>
</dependency>
<!--阿里数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.11</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.2</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
整合mybatis
编写配置文件（redis、mysql、mybatis都写好了）
server:
port: 9000
spring:
# redis配置
redis:
# 使用redis默认的端口，如果改过端口的，用更改的端口
port: 6379
database: 0
# 连接IP，因为我用本地的redis所以用localhost，如果用非本地的请填写具体IP
host: localhost
# redis密码，如果没有密码留空
password: redis
# 数据库配置
datasource:
# 驱动
driver-class-name: com.mysql.cj.jdbc.Driver
# 数据库连接地址，如果是本地数据库把IP改成localhost
url: jdbc:mysql://192.9.206.31:3306/sx_test_1?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=UTC
# 数据库名字
username: sxtest
# 数据库密码
password: sxtest
# 数据源
type: com.alibaba.druid.pool.DruidDataSource
hikari:
minimum-idle: 2
maximum-pool-size: 10
auto-commit: true
idle-timeout: 30000
pool-name: TutorialsHikariCP
max-lifetime: 1800000
connection-timeout: 30000
connection-test-query: SELECT 1
# mybatis配置
mybatis:
# 实体类位置
type-aliases-package: com.taiji.redispractise.domain
# xml位置
mapper-locations: classpath:/mapper/**/*.xml
整合redis
jedis方法整合
1、 编写redis链接工具类（类名：RedisUtil）
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class RedisUtil {
private JedisPool jedisPool;
public void initPool(String host,int port ,int database,String password){
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(200);
poolConfig.setMaxIdle(30);
poolConfig.setBlockWhenExhausted(true);
poolConfig.setMaxWaitMillis(10*1000);
poolConfig.setTestOnBorrow(true);
jedisPool=new JedisPool(poolConfig,host,port,20*1000,password);
}
public Jedis getJedis(){
return jedisPool.getResource();
}
}
2、 编写配置类（类名RedisConfig）
import com.taiji.redispractise.util.RedisUtil;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RedisConfig {
//读取配置文件中的redis的ip地址
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port:0}")
private int port;
@Value("${spring.redis.database:0}")
private int database;
@Value("${spring.redis.password}")
private String password;
@Bean
public RedisUtil getRedisUtil(){
if(host.equals("disabled")){
return null;
}
RedisUtil redisUtil =new RedisUtil();
redisUtil.initPool(host,port,database,password);
return redisUtil;
}
}
3、 封装redis常用操作（我只写了一部分）
接口
public interface RedisService {
/**
* redis string类型，获取单个对象
*
* @param key 键
* @param clazz 取出的数据类型
* @param
* @return
*/
public <T> T get(String key, Class<T> clazz);
/**
* redis string类型，存储单个对象
*
* @param key 键
* @param value 键值
* @return
*/
public <T> boolean set(String key, T value);
/**
* redis hash类型，存储单个对象
*
* @param key 键
* @param value 值
* @param
* @return
*/
public <T> boolean hset(String key,String field, T value);
/**
* redis hash类型，获取单个对象
*
* @param key 键
* @param clazz 取出的数据类型
* @param
* @return
*/
public <T> T hget(String key, String field, Class<T> clazz);
/**
* 为给定得key设置时间，以秒计
* @param key 键
* @param seconds 秒
* @return
*/
public boolean pexpire(String key,int seconds);
/**
* 删除key
*
* @param key 键，一个或多个
* @return
*/
public boolean del(String... key);
/**
* redis list类型，存储单个对象
*
* @param key 键
* @param value 值
* @param
* @return
*/
public <T> boolean lpust(String key, T value);
/**
* redis list类型，获取列表元素
* @param key 键
* @param
* @return
*/
public <T> T lindex(String key, Integer index,Class<T> clazz);
/**
* 判断是否存在
*
* @param key
* @param
* @return
*/
public <T> boolean exists(String key);
}
实现
import com.alibaba.fastjson.JSON;
import com.taiji.redispractise.service.RedisService;
import com.taiji.redispractise.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;
/**
* redis操作封装类
*/
@Service
public class RedisServiceImpl implements RedisService {
/*redis工具类，用于获取jedis连接，进行redis数据库的操作*/
@Autowired
private RedisUtil redisUtil;
/**
* redis string类型，获取单个对象
*
* @param key 键
* @param clazz 取出的数据类型
* @param
* @return
*/
public <T> T get(String key, Class<T> clazz) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = jedis.get(key);
return stringToBean(str, clazz);
} finally {
returnToPool(jedis);
}
}
/**
* redis string类型，存储对象
*
* @param key 键
* @param value 键值
* @return
*/
public <T> boolean set(String key, T value) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = beanToString(value);
if (str == null || str.length() <= 0)
return false;
jedis.set(key, str);
return true;
} finally {
returnToPool(jedis);
}
}
/**
* 删除key
*
* @param key 键，一个或多个
* @return
*/
public boolean del(String... key) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
jedis.del(key);
if (jedis.exists(key) == 0) {
return true;
} else {
return false;
}
} catch (Exception e) {
return false;
} finally {
returnToPool(jedis);
}
}
/**
* 为给定得key设置时间，以秒计
* @param key 键
* @param seconds 秒
* @return
*/
public boolean pexpire(String key,int seconds) {
Jedis jedis=null;
try {
jedis = redisUtil.getJedis();
jedis.expire(key, seconds);
return true;
} catch (Exception e) {
return false;
} finally {
returnToPool(jedis);
}
}
/**
* redis hash类型，存储单个对象
*
* @param key 键
* @param value 值
* @return
*/
@Override
public <T> boolean hset(String key, String field, T value) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = beanToString(value);
if (str == null || str.length() <= 0)
return false;
jedis.hset(key, field, str);
return true;
} finally {
returnToPool(jedis);
}
}
/**
* redis hash类型，获取单个对象
*
* @param key 键
* @param clazz 取出的数据类型
* @return
*/
@Override
public <T> T hget(String key, String field, Class<T> clazz) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = jedis.hget(key, field);
return stringToBean(str, clazz);
} finally {
returnToPool(jedis);
}
}
/**
* redis list类型，存储单个对象
*
* @param key 键
* @param value 值
* @return
*/
@Override
public <T> boolean lpust(String key, T value) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = beanToString(value);
if (str == null || str.length() <= 0)
return false;
jedis.lpush(key, str);
return true;
} finally {
returnToPool(jedis);
}
}
/**
* redis list类型，获取指定下标元素
*
* @param key 键
* @return
*/
@Override
public <T> T lindex(String key, Integer index, Class<T> clazz) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
String str = jedis.lindex(key, index);
return stringToBean(str, clazz);
} finally {
returnToPool(jedis);
}
}
/**
* 判断是否存在
*
* @param key
* @param
* @return
*/
public <T> boolean exists(String key) {
Jedis jedis = null;
try {
jedis = redisUtil.getJedis();
return jedis.exists(key);
} finally {
returnToPool(jedis);
}
}
/**
* 把bean转换成json
*
* @param value
* @param
* @return
*/
private <T> String beanToString(T value) {
if (value == null)
return null;
Class<?> aClass = value.getClass();
if (aClass == Integer.class) {
return "" + value;
} else if (aClass == String.class) {
return (String) value;
} else if (aClass == Long.class) {
return "" + value;
} else {
return JSON.toJSONString(value);
}
}
/**
* 把json转换成bean
*/
private <T> T stringToBean(String str, Class<T> aClass) {
if (str == null || str.length() <= 0 || aClass == null)
return null;
if (aClass == int.class || aClass == Integer.class) {
return (T) Integer.valueOf(str);
} else if (aClass == String.class) {
return (T) str;
} else if (aClass == long.class || aClass == Long.class) {
return (T) Long.valueOf(str);
} else {
return JSON.parseObject(str, aClass);
}
}
/**
* 关闭jedis
*
* @param jedis
*/
private void returnToPool(Jedis jedis) {
if (jedis != null) {
jedis.close();
}
}
}