Rides在spring中应用
一. redis的简介
2008 年，意大利一家创业公司 Merzia 的创始人 Salvatore Sanfilippo 为了避免 MySQL的低性能，亲自定做一个数据库，并于 2009 年开发完成，这个就是 Redis。
从 2010 年 3 月 15 日起，Redis 的开发工作由 VMware 主持。
从 2013 年 5 月开始，Redis 的开发由 Pivotal 赞助。
说明：Pivotal 公司是由 EMC 和 VMware 联合成立的一家新公司。Pivotal 希望为新一代的应用提供一个原生的基础，建立在具有领导力的云和网络公司不断转型的IT特性之上。
Pivotal 的使命是推行这些创新，提供给企业 IT 架构师和独立软件提供商.
二. redis在linux服务器中的安装
1. 上传压缩包到服务器.
2. 解压压缩包:tar zxvf redis-5.0.3.tar.gz
3. 安装依赖:yum -y install gcc-c++ autoconf automake
4. 进行预编译:切换到解压目录cd redis-5.0.3/make
5. 创建安装目录:mkdir -p /usr/local/redis(注意解压目录和安装目分开)
6. 启动:安装的默认目标路径：/usr/local/redis/bin
7. 修改前台启动为后台启动:复制 redis.conf 至安装路径下cp redis.conf /usr/local/redis/bin/
8. 修改防火墙(建议防火墙永久关闭),防火墙启动命令:systemctl start/restart iptables.service 或者 service iptables start 或者 service iptables restart
9. 在Windows系统中安装redis的客户端
10. 修改配置文件 redis.conf:注释掉 bind 127.0.0.1 可以使所有的 ip 访问 redis，若是想指定多个 ip 访问，但并不是全部的 ip 访问，可以 bind 设置
11. 重启redis:修改后 kill -9 XXXX 杀死 redis 进程，重启 redis
12. 查看进程的命令:ps -ef | grep redis
三. redis-cli 命令操作 Redis 五种数据类型
1. redis-cli 连接 redis
2. 操作 String:Set:添加一条 String 类型数据;Get:获取一条 String 类型数据;Mset:添加多条 String 类型数据;Mget:获取多条 String 类型数据
3. 操作 hash:Hset:添加一条 hash 类型数据;Hget:获取一条 hash 类型数据;Hmset:添加多条 hash 类型数据;Hmget:获取多条 hash 类型数据;HgetAll:获取指定所有 hash 类型数据;hdel:删除指定 hash 类型数据(一条或多条)
4. 操作 list:Lpush:左添加(头)list 类型数据;Rpush:右添加(尾)类型数据;Lrange: 获取 list 类型数据 start 起始下标 end 结束下标 包含关系;llen:获取条数;lrem:删除列表中几个指定 list 类型数据
5. 操作 set:Sadd:添加 set 类型数据;Smembers:获取 set 类型数据;scard:获取条数;srem:删除数据
6. 操作 sorted set:sorted set 是通过分数值来进行排序的，分数值越大，越靠后。Zadd:添加 sorted set 类型数据;Zrange:获取 sorted set 类型数据;zcard:获取条数;zrem:删除数据;Zadd 需要将 Float 或者 Double 类型分数值参数，放置在值参数之前.
7. Redis 中以层级关系、目录形式存储数据:即就是在建立语句时前面添加”:”
8. 设置 key 的失效时间:Redis 有四个不同的命令可以用于设置键的生存时间(键可以存在多久)或过期时间(键什么时候会被删除) :
EXPlRE <key> <ttl> 命令用于将键 key 的生存时间设置为 ttl 秒。
PEXPIRE <key> <ttl> 命令用于将键 key 的生存时间设置为 ttl 毫秒。 EXPIREAT <key> < timestamp> 命令用于将键 key 的过期时间设置为 timestamp 所指定的秒数时间戳。
PEXPIREAT <key> < timestamp > 命令用于将键 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳。 TTL:获取的值为-1 说明此 key 没有设置有效期，当值为-2 时证明过了有效期。
9. 删除:Del:用于删除数据（通用，适用于所有数据类型）;Hdel:用于删除 hash 类型数据
四. Java 操作 Redis 五种数据类型
1. 创建maven项目
2. 添加依赖
3. Java连接jedis: Jedis jedis = new Jedis(IP,端口);
Jedis.auth(“设置认证密码”);// 指定数据库 默认是 0
jedis.select(1);
// 使用 ping 命令，测试连接是否成功
String result = jedis.ping();
System.out.println(result);// 返回 PONG
// 添加一条数据
jedis.set("username", "zhangsan");
// 获取一条数据
String username = jedis.get("username");
System.out.println(username);
// 释放资源if (jedis != null)
jedis.close();
}
4. 通过 Redis 连接池获取连接对象并操作服务器 :JedisPool jedisPool = new JedisPool(new JedisPoolConfig(),
"192.168.10.100", 6379, 10000, "root");
// 从连接池获取连接
Jedis jedis = jedisPool.getResource();
// 指定数据库 默认是 0
jedis.select(2);
// 使用 ping 命令，测试连接是否成功
String result = jedis.ping();
System.out.println(result);// 返回 PONG
// 添加一条数据
jedis.set("username", "zhangsan");
// 获取一条数据
String username = jedis.get("username");
System.out.println(username);
// 释放资源
if (jedis != null)
jedis.close();
}
5. 封装 JedisUtil 对外提供连接对象获取方法://Redis 服务器 IP
private static String ADDR = "192.168.10.100";
//Redis 的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = "root";
//可用连接实例的最大数目，默认值为 8；
//如果赋值为-1，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则
此时 pool 的状态为 exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个 pool 最多有多少个状态为 idle(空闲的)的 jedis 实例，默认值也是 8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时
间，则直接抛出 JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true，则得到
的 jedis 实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/**
* 初始化 Redis 连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取 Jedis 实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null)
return jedisPool.getResource();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 释放 jedis 资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.close();
}
}
}
6.//Redis 服务器 IP
private static String ADDR = "192.168.10.100";
//Redis 的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = "root";
//可用连接实例的最大数目，默认值为 8；
//如果赋值为-1，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则
此时 pool 的状态为 exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个 pool 最多有多少个状态为 idle(空闲的)的 jedis 实例，默认值也是 8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时
间，则直接抛出 JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true，则得到
的 jedis 实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/**
* 初始化 Redis 连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取 Jedis 实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null)
return jedisPool.getResource();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 释放 jedis 资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.close();
}
}
}
7.获取所有 key&事务&删除
// 获取所有 key
@Test
public void testAllKeys() {
// 当前库 key 的数量
System.out.println(jedis.dbSize());
// 当前库 key 的名称
Set<String> keys = jedis.keys("*");
for (String key: keys) {
System.out.println(key);
}
}
// 操作事务
@Test
public void testMulti() {
Transaction tx = jedis.multi();
// 开启事务
tx.set("tel", "10010");
// 提交事务
// tx.exec();
// 回滚事务
tx.discard();
}
// 删除
@Test
public void testDelete() {
// 删除 通用 适用于所有数据类型
jedis.del("score");
}
8、操作 byte
SerializeUtil.java
package com.shsxt.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 序列化工具类
*/
public class SerializeUtil {
/**
* 将 java 对象转换为 byte 数组 序列化过程
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将 byte 数组转换为 java 对象 反序列化
*/
public static Object unserialize(byte[] bytes) {
if(bytes == null)return null;
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
User.java
package com.shsxt.entity;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 9148937431079191022L;
private Integer id;
private String username;
private String 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
JedisTest.java
// 操作 byte
@Test
public void testByte() {
User user = new User();
user.setId(2);
user.setUsername("zhangsan");
user.setPassword("123");
// 序列化
byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
byte[] userValue = SerializeUtil.serialize(user);
jedis.set(userKey, userValue);
// 获取数据
byte[] userResult = jedis.get(userKey);
// 反序列化
User u = (User) SerializeUtil.unserialize(userResult);
System.out.println(u);
}
五. Redis 搭建主从复用-读写分离
1.创建三个目录（数据文件、日志文件、配置文件）
2.复制 redis.conf 至/opt/redis/conf 目录下
3.修改 redis-common.conf 公共配置文件:注释掉 bind 127.0.0.1 ;关闭保护模式，修改为 no;注释公共配置端口;修改为后台启动;注释进程编号记录文件;注释公共配置日志文件;注释公共配置数据文件、修改数据文件路径;添加从服务器访问主服务器认证;添加访问认证;注释公共配置追加文件;从服务器默认是只读不允许写操作(不用修改);
4.添加3个服务的私有配置文件
5.运行3个redis进程
6.查看 redis 服务器主从状态
六.Redis 搭建主从复用-主备切换
1.redis节点准备:单台服务器不同端口模拟多台服务器配置
127.0.0.1 6379(master-主节点)
127.0.0.1 6380(slave-从节点)
127.0.0.1 6381(slave-从节点)
2.主从节点 redis.conf 配置:参照上面的《Redis 搭建主从复用-读写分离》进行配置
3.修改 sentinel-common.conf 哨兵公共配置文件:从 redis 解压目录下复制 sentinel.conf 至/opt/redis/conf/(cp sentinel.conf /opt/redis/conf/sentinel-common.conf);指示 Sentinel 去监视一个名为 master 的主服务器，这个主服务器的 IP 地址为127.0.0.1，端口号为 6379，而将这个主服务器判断为失效至少需要 1 个(一般设置为2个)。Sentinel 同意 （只要同意 Sentinel 的数量不达标，自动故障迁移就不会执行）。这个要配局域网 IP，否则远程连不上。注释哨兵监听进程端口号;设置 master 和 slaves 的密码;Sentinel 认为服务器已经断线所需的毫秒数;若 sentinel 在该配置值内未能完成 failover 操作（即故障时 master/slave 自动切换），则认为本次 failover 失败;关闭保护模式，修改为 no;修改为后台启动(为了方便查看日志，先注释掉，搭好环境后再打开)
4.添加 3 个哨兵的私有配置文件
5.启动进行测试:
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6379.conf
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6380.conf
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6381.conf
6.启动哨兵服务
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26379.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26380.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26381.conf
7. 查看主从状态
七.Spring Data Redis操作Redis五种数据类型
1. 项目添加依赖:
dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring test 依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!-- Redis 依赖 2.9.1 版本为了兼容 springdata-redis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.1</version>
</dependency>
<!-- spring data redis 依赖使用 1+最新版本因为 2+需要 spring5+版本 -->
<dependency>
2. 添加 applicationContext-redis.xml 配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="1024"/>
<!-- 最大 空闲连接数 -->
<property name="maxIdle" value="200"/>
<!-- 获取连接时最大等待毫秒数 -->
<property name="maxWaitMillis" value="10000"/>
<!-- 在获取连接时检查有效性 -->
<property name="testOnBorrow" value="true"/>
</bean>
<!-- 客户端连接工厂 -->
<bean id="jedisConnFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:use-pool="true" p:host-name="192.168.10.100" p:port="6379" p:password="root">
<!-- 连接池引用 -->
<constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
</bean>
<!-- redisTemplate 配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnFactory">
<!-- 配置序列化操作 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
</bean>
</beans>
3. 借助spring测试环境测试环境是否搭建成功
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.*;
import java.util.Map.Entry;
/*
* @RunWith 就是一个运行器
* @RunWith(JUnit4.class)就是指用 JUnit4 来运行
* @RunWith(SpringJUnit4ClassRunner.class)，让测试运行于 Spring 测试环境
*/
@RunWith(SpringJUnit4ClassRunner.class)
/*
* @ContextConfiguration Spring 整合 JUnit4 测试时，使用注解引入多个配置文件
* 单个文件 @ContextConfiguration(locations = "classpath:spring/applicationContext.xml")
* 多个文件 @ContextConfiguration(locations = {"classpath:spring/spring1.xml",
"classpath:mybatis/config.xml"})
*/
@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")
public class SpringDateRedisTest {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* redisTemplate.opsForValue() -> ValueOperations<String, Object>;// 操作字符串
* redisTemplate.opsForHash() -> HashOperations<String, String, String>;// 操作 hash
* redisTemplate.opsForList() -> ListOperations<String, Object>;// 操作 list
* redisTemplate.opsForSet() -> SetOperations<String, Object>;// 操作 set
* redisTemplate.opsForZSet() -> ZSetOperations<String, Object>;// 操作 SortedSet
*/
}
4. 操作五种数据类型
4.1.操作 String
@Test
public void testString() {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
// 添加一条数据
valueOperations.set("username", "zhangsan");
valueOperations.set("age", "18");
// redis 中以层级关系、目录形式存储数据
valueOperations.set("user:01", "lisi");
valueOperations.set("user:02", "wangwu");
// 添加多条数据
Map<String, String> userMap = new HashMap<>();
userMap.put("address", "bj");
userMap.put("sex", "1");
valueOperations.multiSet(userMap);
// 获取一条数据
Object username = valueOperations.get("username");
System.out.println(username);
// 获取多条数据
List<String> keys = new ArrayList<>();
keys.add("username");
keys.add("age");
keys.add("address");
keys.add("sex");
List<Object> resultList = valueOperations.multiGet(keys);
for (Object str : resultList) {
System.out.println(str);
}
// 删除
redisTemplate.delete("username");
}
4.2、 操作 hash
// 2.操作 Hash
@Test
public void testHash() {
HashOperations<String, String, String> hashOperations =
redisTemplate.opsForHash();
/*
* 添加一条数据
* 参数一：redis 的 key
* 参数二：hash 的 key
* 参数三：hash 的 value
*/
hashOperations.put("userInfo","name","lisi");
// 添加多条数据
Map<String, String> map = new HashMap();
map.put("age", "20");
map.put("sex", "1");
hashOperations.putAll("userInfo", map);
// 获取一条数据
String name = hashOperations.get("userInfo", "name");
System.out.println(name);
// 获取多条数据
List<String> keys = new ArrayList<>();
keys.add("age");
keys.add("sex");
List<String> resultlist =hashOperations.multiGet("userInfo", keys);
for (String str : resultlist) {
System.out.println(str);
}
// 获取 Hash 类型所有的数据
Map<String, String> userMap = hashOperations.entries("userInfo");
for (Entry<String, String> userInfo : userMap.entrySet()) {
System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
}
// 删除 用于删除 hash 类型数据
hashOperations.delete("userInfo", "name");
}
4.3、 操作 list
// 3.操作 list
@Test
public void testList() {
ListOperations<String, Object> listOperations =
redisTemplate.opsForList();
// 左添加(上)
// listOperations.leftPush("students", "Wang Wu");
// listOperations.leftPush("students", "Li Si");
// 左添加(上) 把 value 值放到 key 对应列表中 pivot 值的左面，如果 pivot 值存在的话
//listOperations.leftPush("students", "Wang Wu", "Li Si");
// 右添加(下)
// listOperations.rightPush("students", "Zhao Liu");
// 获取 start 起始下标 end 结束下标 包含关系
List<Object> students = listOperations.range("students", 0,2);
for (Object stu : students) {
System.out.println(stu);
}
// 根据下标获取
Object stu = listOperations.index("students", 1);
System.out.println(stu);
// 获取总条数
Long total = listOperations.size("students");
System.out.println("总条数：" + total);
// 删除单条 删除列表中存储的列表中几个出现的 Li Si。
listOperations.remove("students", 1, "Li Si");
// 删除多条
redisTemplate.delete("students");
}
4.4、 操作 set
// 4.操作 set-无序
@Test
public void testSet() {
SetOperations<String, Object> setOperations = redisTemplate.opsForSet();
// 添加数据
String[] letters = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
//setOperations.add("letters", "aaa", "bbb", "ccc", "ddd", "eee");
setOperations.add("letters", letters);
// 获取数据
Set<Object> let = setOperations.members("letters");
for (Object letter: let) {
System.out.println(letter);
}
// 删除
setOperations.remove("letters", "aaa", "bbb");
}
4.5、 操作 sorted set
// 5.操作 sorted set-有序
@Test
public void testSortedSet() {
ZSetOperations<String, Object> zSetOperations =
redisTemplate.opsForZSet();
ZSetOperations.TypedTuple<Object> objectTypedTuple1 =
new DefaultTypedTuple<Object>("zhangsan", 7D);
ZSetOperations.TypedTuple<Object> objectTypedTuple2 =
new DefaultTypedTuple<Object>("lisi", 3D);
ZSetOperations.TypedTuple<Object> objectTypedTuple3 =
new DefaultTypedTuple<Object>("wangwu", 5D);
ZSetOperations.TypedTuple<Object> objectTypedTuple4 =
new DefaultTypedTuple<Object>("zhaoliu", 6D);
ZSetOperations.TypedTuple<Object> objectTypedTuple5 =
new DefaultTypedTuple<Object>("tianqi", 2D);
Set<ZSetOperations.TypedTuple<Object>> tuples = new
HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
tuples.add(objectTypedTuple3);
tuples.add(objectTypedTuple4);
tuples.add(objectTypedTuple5);
// 添加数据
zSetOperations.add("score", tuples);
// 获取数据
Set<Object> scores = zSetOperations.range("score", 0, 4);
for (Object score: scores) {
System.out.println(score);
}
// 获取总条数
Long total = zSetOperations.size("score");
System.out.println("总条数：" + total);
// 删除
zSetOperations.remove("score", "zhangsan", "lisi");
}
4.6、 获取所有 key&删除
// 获取所有 key
@Test
public void testAllKeys() {
// 当前库 key 的名称
Set<String> keys = redisTemplate.keys("*");
for (String key: keys) {
System.out.println(key);
}
}
// 删除
@Test
public void testDelete() {
// 删除 通用 适用于所有数据类型
redisTemplate.delete("score");
}
4.7、 设置 key 的失效时间
@Test
public void testEx() {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
// 方法一：插入一条数据并设置失效时间
valueOperations.set("code", "abcd", 180, TimeUnit.SECONDS);
// 方法二：给已存在的 key 设置失效时间
boolean flag = redisTemplate.expire("code", 180, TimeUnit.SECONDS);
// 获取指定 key 的失效时间
Long l = redisTemplate.getExpire("code");
}
5. SpringDataRedis 整合使用哨兵机制
配置applicationContext-redis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="1024"/>
<!-- 最大 空闲连接数 -->
<property name="maxIdle" value="200"/>
<!-- 获取连接时最大等待毫秒数 -->
<property name="maxWaitMillis" value="10000"/>
<!-- 在获取连接时检查有效性 -->
<property name="testOnBorrow" value="true"/>
</bean>
<!-- 哨兵配置 -->
<bean id="redisSentinelConfiguration"
class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
<property name="sentinels">
<set>
<bean name="sentinelNode1" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26379"/>
</bean>
<bean name="sentinelNode2" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26380"/>
</bean>
<bean name="sentinelNode3" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26381"/>
</bean>
</set>
</property>
<property name="master">
<bean name="masterNode" class="org.springframework.data.redis.connection.RedisNode">
<!-- 必须指定主节点名称 -->
<property name="name" value="mymaster"/>
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="6380"/>
</bean>
</property>
</bean>
<!-- 客户端连接工厂 设置主节点信息 -->
<bean id="jedisConnFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:use-pool="true" p:host-name="192.168.10.24" p:port="6380" p:password="root">
<!-- 连接池引用 -->
<constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
<!-- 哨兵引用 -->
<constructor-arg name="sentinelConfig" ref="redisSentinelConfiguration"/>
</bean>
<!-- redisTemplate 配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnFactory">
<!-- 配置序列化操作 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
</bean>
</beans>
6. 项目中集成 Redis 缓存数据
6.1pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.shsxt</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0-SNAPSHOT</version>
<name>spring-data-redis</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring 核心 jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring 测试 jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring 事物 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- aspectj 切面编程的 jar -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
<!-- c3p0 连接池 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.1</version>
</dependency>
<!-- 添加 mybatis 与 Spring 整合的核心包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<!-- mysql 驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
<!-- 日志打印相关的 jar -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.2</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.2</version>
</dependency>
<!-- springmvc 依赖 jar -->
<!-- spring web -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring mvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- 添加 json 依赖 jar 包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support </artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.21</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
</dependency>
<!-- Redis 依赖 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.1</version>
</dependency>
<!-- spring data redis 依赖 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.18.RELEASE</version>
</dependency>
</dependencies>
<build>
<!-- 读取配置文件 -->
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.properties</include>
<include>**/*.tld</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
</project>
6.2jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/p2p?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root
6.3log4j.properties
log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c]
- %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
6.4applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:property-placeholder location="classpath:jdbc.properties"/>
<context:component-scan base-package="com.shsxt.service"></context:component-scan>
<!-- 配置数据源 -->
<!-- 配置 c3p0 数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 设置事务增强 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="query*" read-only="true"/>
<tx:method name="load*" read-only="true"/>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="save*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- aop 切面配置 -->
<aop:config>
<aop:pointcut id="servicePointcut" expression="execution(*
com.shsxt.service.impl.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut"/>
</aop:config>
<!-- 配置 sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations" value="classpath:com/shsxt/mapper/*.xml"/>
</bean>
<!-- 配置扫描器 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 扫描 com.shsxt.dao 这个包以及它的子包下的所有映射接口类 -->
<property name="basePackage" value="com.shsxt.dao"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>
</beans>
6.5代码
6.5.1JsonUtil.java
package com.shsxt.util;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* Json 转换工具类
*/
public class JsonUtil {
private static ObjectMapper objectMapper = new ObjectMapper();
/**
* 将对象转换成 json 字符串
* @param obj
* @return
*/
public static String object2JsonStr(Object obj){
try {
return objectMapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
//打印异常信息
e.printStackTrace();
}
return null;
}
/**
* 将字符串转换为对象
* @param <T> 泛型
*/
public static <T> T jsonStr2Object(String jsonStr, Class<T> clazz){
try {
return objectMapper.readValue(jsonStr.getBytes("UTF-8"), clazz);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
6.5.2UserDaoI.java
package com.shsxt.dao;
import com.shsxt.entity.User;
public interface UserDaoI {
public User queryUserById(Integer userId);
}
6.5.3User.java
package com.shsxt.entity;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 5751725238117698007L;
private Integer id;
private String username;
private String 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
6.5.4UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.shsxt.dao.UserDaoI">
<select id="queryUserById" resultType="com.shsxt.entity.User">
SELECT id,
username,
password
FROM bas_user
WHERE id = #{userId}
</select>
</mapper>
6.5.5.UserServiceI.java
package com.shsxt.service;
import com.shsxt.entity.User;
public interface UserServiceI {
public User queryUserById(Integer userId);
}
6.5.6.UserServiceImpl.java
package com.shsxt.service.impl;
import com.shsxt.dao.UserDaoI;
import com.shsxt.entity.User;
import com.shsxt.service.UserServiceI;
import com.shsxt.util.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserServiceI {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private UserDaoI userDao;
@Override
public User queryUserById(Integer userId) {
// return doQueryUserById(userId);
return doQueryUserById2Json(userId);
}
public User doQueryUserById(Integer userId) {
// 先从 Redis 查询
User user = (User) redisTemplate.opsForValue().get("user:id_" + userId);
if(null != user){
return user;
}
// Redis 没有再从 mysql 查询
user = userDao.queryUserById(userId);
if(null != user){
redisTemplate.opsForValue().set("user:id_" + userId, user);
return user;
}
return null;
}
public User doQueryUserById2Json(Integer userId) {
// 先从 Redis 查询
Object jsonUser = redisTemplate.opsForValue().get("user:id_" + userId);
User user = null;
if(null != user){
user = JsonUtil.jsonStr2Object((String) jsonUser, User.class);
return user;
}
// Redis 没有再从 mysql 查询
user = userDao.queryUserById(userId);
if(null != user){
redisTemplate.opsForValue().set("user:id_" + userId,
JsonUtil.object2JsonStr(user));
return user;
}
return null;
}
}
6.5.7.UserServiceTest.java
package com.shsxt.service;
import com.shsxt.entity.User;
import com.shsxt.service.UserServiceI;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import
org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/*
* @RunWith 就是一个运行器
* @RunWith(JUnit4.class)就是指用 JUnit4 来运行
* @RunWith(SpringJUnit4ClassRunner.class)，让测试运行于 Spring 测试环境
*/
@RunWith(SpringJUnit4ClassRunner.class)
/*
* @ContextConfiguration Spring 整合 JUnit4 测试时，使用注解引入多个配置文
件
* 单个文件 @ContextConfiguration(locations =
"classpath:spring/applicationContext.xml")
* 多个文件 @ContextConfiguration(locations =
{"classpath:spring/spring1.xml", "classpath:mybatis/config.xml"})
*/
@ContextConfiguration(locations = {"classpath:applicationContext.xml",
"classpath:applicationContext-redis.xml"})
public class UserServiceTest {
@Autowired
private UserServiceI userService;
@Test
public void test() {
User user = userService.queryUserById(1);
System.out.println(user);
}
}
八. 缓存雪崩,缓存击穿,缓存穿透
1.缓存穿透
描述：
缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。
解决方案：
(1).接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
(2).从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击.
2.缓存击穿
描述：
缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
解决方案：
(1).设置热点数据永远不过期。
(2).加互斥锁，互斥锁
3.缓存雪崩
描述：
缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
解决方案：
(1).缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
(2).设置热点数据永远不过期。
Rides在spring中应用
一. redis的简介
2008 年，意大利一家创业公司 Merzia 的创始人 Salvatore Sanfilippo 为了避免 MySQL的低性能，亲自定做一个数据库，并于 2009 年开发完成，这个就是 Redis。
从 2010 年 3 月 15 日起，Redis 的开发工作由 VMware 主持。
从 2013 年 5 月开始，Redis 的开发由 Pivotal 赞助。
说明：Pivotal 公司是由 EMC 和 VMware 联合成立的一家新公司。Pivotal 希望为新一代的应用提供一个原生的基础，建立在具有领导力的云和网络公司不断转型的IT特性之上。
Pivotal 的使命是推行这些创新，提供给企业 IT 架构师和独立软件提供商.
二. redis在linux服务器中的安装
1. 上传压缩包到服务器.
2. 解压压缩包:tar zxvf redis-5.0.3.tar.gz
3. 安装依赖:yum -y install gcc-c++ autoconf automake
4. 进行预编译:切换到解压目录cd redis-5.0.3/make
5. 创建安装目录:mkdir -p /usr/local/redis(注意解压目录和安装目分开)
6. 启动:安装的默认目标路径：/usr/local/redis/bin
7. 修改前台启动为后台启动:复制 redis.conf 至安装路径下cp redis.conf /usr/local/redis/bin/
8. 修改防火墙(建议防火墙永久关闭),防火墙启动命令:systemctl start/restart iptables.service 或者 service iptables start 或者 service iptables restart
9. 在Windows系统中安装redis的客户端
10. 修改配置文件 redis.conf:注释掉 bind 127.0.0.1 可以使所有的 ip 访问 redis，若是想指定多个 ip 访问，但并不是全部的 ip 访问，可以 bind 设置
11. 重启redis:修改后 kill -9 XXXX 杀死 redis 进程，重启 redis
12. 查看进程的命令:ps -ef | grep redis
三. redis-cli 命令操作 Redis 五种数据类型
1. redis-cli 连接 redis
2. 操作 String:Set:添加一条 String 类型数据;Get:获取一条 String 类型数据;Mset:添加多条 String 类型数据;Mget:获取多条 String 类型数据
3. 操作 hash:Hset:添加一条 hash 类型数据;Hget:获取一条 hash 类型数据;Hmset:添加多条 hash 类型数据;Hmget:获取多条 hash 类型数据;HgetAll:获取指定所有 hash 类型数据;hdel:删除指定 hash 类型数据(一条或多条)
4. 操作 list:Lpush:左添加(头)list 类型数据;Rpush:右添加(尾)类型数据;Lrange: 获取 list 类型数据 start 起始下标 end 结束下标 包含关系;llen:获取条数;lrem:删除列表中几个指定 list 类型数据
5. 操作 set:Sadd:添加 set 类型数据;Smembers:获取 set 类型数据;scard:获取条数;srem:删除数据
6. 操作 sorted set:sorted set 是通过分数值来进行排序的，分数值越大，越靠后。Zadd:添加 sorted set 类型数据;Zrange:获取 sorted set 类型数据;zcard:获取条数;zrem:删除数据;Zadd 需要将 Float 或者 Double 类型分数值参数，放置在值参数之前.
7. Redis 中以层级关系、目录形式存储数据:即就是在建立语句时前面添加”:”
8. 设置 key 的失效时间:Redis 有四个不同的命令可以用于设置键的生存时间(键可以存在多久)或过期时间(键什么时候会被删除) :
EXPlRE <key> <ttl> 命令用于将键 key 的生存时间设置为 ttl 秒。
PEXPIRE <key> <ttl> 命令用于将键 key 的生存时间设置为 ttl 毫秒。 EXPIREAT <key> < timestamp> 命令用于将键 key 的过期时间设置为 timestamp 所指定的秒数时间戳。
PEXPIREAT <key> < timestamp > 命令用于将键 key 的过期时间设置为 timestamp 所指定的毫秒数时间戳。 TTL:获取的值为-1 说明此 key 没有设置有效期，当值为-2 时证明过了有效期。
9. 删除:Del:用于删除数据（通用，适用于所有数据类型）;Hdel:用于删除 hash 类型数据
四. Java 操作 Redis 五种数据类型
1. 创建maven项目
2. 添加依赖
3. Java连接jedis: Jedis jedis = new Jedis(IP,端口);
Jedis.auth(“设置认证密码”);// 指定数据库 默认是 0
jedis.select(1);
// 使用 ping 命令，测试连接是否成功
String result = jedis.ping();
System.out.println(result);// 返回 PONG
// 添加一条数据
jedis.set("username", "zhangsan");
// 获取一条数据
String username = jedis.get("username");
System.out.println(username);
// 释放资源if (jedis != null)
jedis.close();
}
4. 通过 Redis 连接池获取连接对象并操作服务器 :JedisPool jedisPool = new JedisPool(new JedisPoolConfig(),
"192.168.10.100", 6379, 10000, "root");
// 从连接池获取连接
Jedis jedis = jedisPool.getResource();
// 指定数据库 默认是 0
jedis.select(2);
// 使用 ping 命令，测试连接是否成功
String result = jedis.ping();
System.out.println(result);// 返回 PONG
// 添加一条数据
jedis.set("username", "zhangsan");
// 获取一条数据
String username = jedis.get("username");
System.out.println(username);
// 释放资源
if (jedis != null)
jedis.close();
}
5. 封装 JedisUtil 对外提供连接对象获取方法://Redis 服务器 IP
private static String ADDR = "192.168.10.100";
//Redis 的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = "root";
//可用连接实例的最大数目，默认值为 8；
//如果赋值为-1，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则
此时 pool 的状态为 exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个 pool 最多有多少个状态为 idle(空闲的)的 jedis 实例，默认值也是 8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时
间，则直接抛出 JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true，则得到
的 jedis 实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/**
* 初始化 Redis 连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取 Jedis 实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null)
return jedisPool.getResource();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 释放 jedis 资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.close();
}
}
}
6.//Redis 服务器 IP
private static String ADDR = "192.168.10.100";
//Redis 的端口号
private static int PORT = 6379;
//访问密码
private static String AUTH = "root";
//可用连接实例的最大数目，默认值为 8；
//如果赋值为-1，则表示不限制；如果 pool 已经分配了 maxActive 个 jedis 实例，则
此时 pool 的状态为 exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;
//控制一个 pool 最多有多少个状态为 idle(空闲的)的 jedis 实例，默认值也是 8。
private static int MAX_IDLE = 200;
//等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时
间，则直接抛出 JedisConnectionException；
private static int MAX_WAIT = 10000;
private static int TIMEOUT = 10000;
//在 borrow 一个 jedis 实例时，是否提前进行 validate 操作；如果为 true，则得到
的 jedis 实例均是可用的；
private static boolean TEST_ON_BORROW = true;
private static JedisPool jedisPool = null;
/**
* 初始化 Redis 连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取 Jedis 实例
*
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null)
return jedisPool.getResource();
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 释放 jedis 资源
*
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.close();
}
}
}
7.获取所有 key&事务&删除
// 获取所有 key
@Test
public void testAllKeys() {
// 当前库 key 的数量
System.out.println(jedis.dbSize());
// 当前库 key 的名称
Set<String> keys = jedis.keys("*");
for (String key: keys) {
System.out.println(key);
}
}
// 操作事务
@Test
public void testMulti() {
Transaction tx = jedis.multi();
// 开启事务
tx.set("tel", "10010");
// 提交事务
// tx.exec();
// 回滚事务
tx.discard();
}
// 删除
@Test
public void testDelete() {
// 删除 通用 适用于所有数据类型
jedis.del("score");
}
8、操作 byte
SerializeUtil.java
package com.shsxt.util;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 序列化工具类
*/
public class SerializeUtil {
/**
* 将 java 对象转换为 byte 数组 序列化过程
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 将 byte 数组转换为 java 对象 反序列化
*/
public static Object unserialize(byte[] bytes) {
if(bytes == null)return null;
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
User.java
package com.shsxt.entity;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 9148937431079191022L;
private Integer id;
private String username;
private String 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
JedisTest.java
// 操作 byte
@Test
public void testByte() {
User user = new User();
user.setId(2);
user.setUsername("zhangsan");
user.setPassword("123");
// 序列化
byte[] userKey = SerializeUtil.serialize("user:" + user.getId());
byte[] userValue = SerializeUtil.serialize(user);
jedis.set(userKey, userValue);
// 获取数据
byte[] userResult = jedis.get(userKey);
// 反序列化
User u = (User) SerializeUtil.unserialize(userResult);
System.out.println(u);
}
五. Redis 搭建主从复用-读写分离
1.创建三个目录（数据文件、日志文件、配置文件）
2.复制 redis.conf 至/opt/redis/conf 目录下
3.修改 redis-common.conf 公共配置文件:注释掉 bind 127.0.0.1 ;关闭保护模式，修改为 no;注释公共配置端口;修改为后台启动;注释进程编号记录文件;注释公共配置日志文件;注释公共配置数据文件、修改数据文件路径;添加从服务器访问主服务器认证;添加访问认证;注释公共配置追加文件;从服务器默认是只读不允许写操作(不用修改);
4.添加3个服务的私有配置文件
5.运行3个redis进程
6.查看 redis 服务器主从状态
六.Redis 搭建主从复用-主备切换
1.redis节点准备:单台服务器不同端口模拟多台服务器配置
127.0.0.1 6379(master-主节点)
127.0.0.1 6380(slave-从节点)
127.0.0.1 6381(slave-从节点)
2.主从节点 redis.conf 配置:参照上面的《Redis 搭建主从复用-读写分离》进行配置
3.修改 sentinel-common.conf 哨兵公共配置文件:从 redis 解压目录下复制 sentinel.conf 至/opt/redis/conf/(cp sentinel.conf /opt/redis/conf/sentinel-common.conf);指示 Sentinel 去监视一个名为 master 的主服务器，这个主服务器的 IP 地址为127.0.0.1，端口号为 6379，而将这个主服务器判断为失效至少需要 1 个(一般设置为2个)。Sentinel 同意 （只要同意 Sentinel 的数量不达标，自动故障迁移就不会执行）。这个要配局域网 IP，否则远程连不上。注释哨兵监听进程端口号;设置 master 和 slaves 的密码;Sentinel 认为服务器已经断线所需的毫秒数;若 sentinel 在该配置值内未能完成 failover 操作（即故障时 master/slave 自动切换），则认为本次 failover 失败;关闭保护模式，修改为 no;修改为后台启动(为了方便查看日志，先注释掉，搭好环境后再打开)
4.添加 3 个哨兵的私有配置文件
5.启动进行测试:
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6379.conf
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6380.conf
/usr/local/redis/bin/redis-server/opt/redis/conf/redis-6381.conf
6.启动哨兵服务
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26379.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26380.conf
/usr/local/redis/bin/redis-sentinel /opt/redis/conf/sentinel-26381.conf
7. 查看主从状态
七.Spring Data Redis操作Redis五种数据类型
1. 项目添加依赖:
dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring test 依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>
<!-- Redis 依赖 2.9.1 版本为了兼容 springdata-redis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.1</version>
</dependency>
<!-- spring data redis 依赖使用 1+最新版本因为 2+需要 spring5+版本 -->
<dependency>
2. 添加 applicationContext-redis.xml 配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="1024"/>
<!-- 最大 空闲连接数 -->
<property name="maxIdle" value="200"/>
<!-- 获取连接时最大等待毫秒数 -->
<property name="maxWaitMillis" value="10000"/>
<!-- 在获取连接时检查有效性 -->
<property name="testOnBorrow" value="true"/>
</bean>
<!-- 客户端连接工厂 -->
<bean id="jedisConnFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:use-pool="true" p:host-name="192.168.10.100" p:port="6379" p:password="root">
<!-- 连接池引用 -->
<constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
</bean>
<!-- redisTemplate 配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnFactory">
<!-- 配置序列化操作 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
</bean>
</beans>
3. 借助spring测试环境测试环境是否搭建成功
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.*;
import java.util.Map.Entry;
/*
* @RunWith 就是一个运行器
* @RunWith(JUnit4.class)就是指用 JUnit4 来运行
* @RunWith(SpringJUnit4ClassRunner.class)，让测试运行于 Spring 测试环境
*/
@RunWith(SpringJUnit4ClassRunner.class)
/*
* @ContextConfiguration Spring 整合 JUnit4 测试时，使用注解引入多个配置文件
* 单个文件 @ContextConfiguration(locations = "classpath:spring/applicationContext.xml")
* 多个文件 @ContextConfiguration(locations = {"classpath:spring/spring1.xml",
"classpath:mybatis/config.xml"})
*/
@ContextConfiguration(locations = "classpath:applicationContext-redis.xml")
public class SpringDateRedisTest {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* redisTemplate.opsForValue() -> ValueOperations<String, Object>;// 操作字符串
* redisTemplate.opsForHash() -> HashOperations<String, String, String>;// 操作 hash
* redisTemplate.opsForList() -> ListOperations<String, Object>;// 操作 list
* redisTemplate.opsForSet() -> SetOperations<String, Object>;// 操作 set
* redisTemplate.opsForZSet() -> ZSetOperations<String, Object>;// 操作 SortedSet
*/
}
4. 操作五种数据类型
4.1.操作 String
@Test
public void testString() {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
// 添加一条数据
valueOperations.set("username", "zhangsan");
valueOperations.set("age", "18");
// redis 中以层级关系、目录形式存储数据
valueOperations.set("user:01", "lisi");
valueOperations.set("user:02", "wangwu");
// 添加多条数据
Map<String, String> userMap = new HashMap<>();
userMap.put("address", "bj");
userMap.put("sex", "1");
valueOperations.multiSet(userMap);
// 获取一条数据
Object username = valueOperations.get("username");
System.out.println(username);
// 获取多条数据
List<String> keys = new ArrayList<>();
keys.add("username");
keys.add("age");
keys.add("address");
keys.add("sex");
List<Object> resultList = valueOperations.multiGet(keys);
for (Object str : resultList) {
System.out.println(str);
}
// 删除
redisTemplate.delete("username");
}
4.2、 操作 hash
// 2.操作 Hash
@Test
public void testHash() {
HashOperations<String, String, String> hashOperations =
redisTemplate.opsForHash();
/*
* 添加一条数据
* 参数一：redis 的 key
* 参数二：hash 的 key
* 参数三：hash 的 value
*/
hashOperations.put("userInfo","name","lisi");
// 添加多条数据
Map<String, String> map = new HashMap();
map.put("age", "20");
map.put("sex", "1");
hashOperations.putAll("userInfo", map);
// 获取一条数据
String name = hashOperations.get("userInfo", "name");
System.out.println(name);
// 获取多条数据
List<String> keys = new ArrayList<>();
keys.add("age");
keys.add("sex");
List<String> resultlist =hashOperations.multiGet("userInfo", keys);
for (String str : resultlist) {
System.out.println(str);
}
// 获取 Hash 类型所有的数据
Map<String, String> userMap = hashOperations.entries("userInfo");
for (Entry<String, String> userInfo : userMap.entrySet()) {
System.out.println(userInfo.getKey() + "--" + userInfo.getValue());
}
// 删除 用于删除 hash 类型数据
hashOperations.delete("userInfo", "name");
}
4.3、 操作 list
// 3.操作 list
@Test
public void testList() {
ListOperations<String, Object> listOperations =
redisTemplate.opsForList();
// 左添加(上)
// listOperations.leftPush("students", "Wang Wu");
// listOperations.leftPush("students", "Li Si");
// 左添加(上) 把 value 值放到 key 对应列表中 pivot 值的左面，如果 pivot 值存在的话
//listOperations.leftPush("students", "Wang Wu", "Li Si");
// 右添加(下)
// listOperations.rightPush("students", "Zhao Liu");
// 获取 start 起始下标 end 结束下标 包含关系
List<Object> students = listOperations.range("students", 0,2);
for (Object stu : students) {
System.out.println(stu);
}
// 根据下标获取
Object stu = listOperations.index("students", 1);
System.out.println(stu);
// 获取总条数
Long total = listOperations.size("students");
System.out.println("总条数：" + total);
// 删除单条 删除列表中存储的列表中几个出现的 Li Si。
listOperations.remove("students", 1, "Li Si");
// 删除多条
redisTemplate.delete("students");
}
4.4、 操作 set
// 4.操作 set-无序
@Test
public void testSet() {
SetOperations<String, Object> setOperations = redisTemplate.opsForSet();
// 添加数据
String[] letters = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
//setOperations.add("letters", "aaa", "bbb", "ccc", "ddd", "eee");
setOperations.add("letters", letters);
// 获取数据
Set<Object> let = setOperations.members("letters");
for (Object letter: let) {
System.out.println(letter);
}
// 删除
setOperations.remove("letters", "aaa", "bbb");
}
4.5、 操作 sorted set
// 5.操作 sorted set-有序
@Test
public void testSortedSet() {
ZSetOperations<String, Object> zSetOperations =
redisTemplate.opsForZSet();
ZSetOperations.TypedTuple<Object> objectTypedTuple1 =
new DefaultTypedTuple<Object>("zhangsan", 7D);
ZSetOperations.TypedTuple<Object> objectTypedTuple2 =
new DefaultTypedTuple<Object>("lisi", 3D);
ZSetOperations.TypedTuple<Object> objectTypedTuple3 =
new DefaultTypedTuple<Object>("wangwu", 5D);
ZSetOperations.TypedTuple<Object> objectTypedTuple4 =
new DefaultTypedTuple<Object>("zhaoliu", 6D);
ZSetOperations.TypedTuple<Object> objectTypedTuple5 =
new DefaultTypedTuple<Object>("tianqi", 2D);
Set<ZSetOperations.TypedTuple<Object>> tuples = new
HashSet<ZSetOperations.TypedTuple<Object>>();
tuples.add(objectTypedTuple1);
tuples.add(objectTypedTuple2);
tuples.add(objectTypedTuple3);
tuples.add(objectTypedTuple4);
tuples.add(objectTypedTuple5);
// 添加数据
zSetOperations.add("score", tuples);
// 获取数据
Set<Object> scores = zSetOperations.range("score", 0, 4);
for (Object score: scores) {
System.out.println(score);
}
// 获取总条数
Long total = zSetOperations.size("score");
System.out.println("总条数：" + total);
// 删除
zSetOperations.remove("score", "zhangsan", "lisi");
}
4.6、 获取所有 key&删除
// 获取所有 key
@Test
public void testAllKeys() {
// 当前库 key 的名称
Set<String> keys = redisTemplate.keys("*");
for (String key: keys) {
System.out.println(key);
}
}
// 删除
@Test
public void testDelete() {
// 删除 通用 适用于所有数据类型
redisTemplate.delete("score");
}
4.7、 设置 key 的失效时间
@Test
public void testEx() {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
// 方法一：插入一条数据并设置失效时间
valueOperations.set("code", "abcd", 180, TimeUnit.SECONDS);
// 方法二：给已存在的 key 设置失效时间
boolean flag = redisTemplate.expire("code", 180, TimeUnit.SECONDS);
// 获取指定 key 的失效时间
Long l = redisTemplate.getExpire("code");
}
5. SpringDataRedis 整合使用哨兵机制
配置applicationContext-redis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大连接数 -->
<property name="maxTotal" value="1024"/>
<!-- 最大 空闲连接数 -->
<property name="maxIdle" value="200"/>
<!-- 获取连接时最大等待毫秒数 -->
<property name="maxWaitMillis" value="10000"/>
<!-- 在获取连接时检查有效性 -->
<property name="testOnBorrow" value="true"/>
</bean>
<!-- 哨兵配置 -->
<bean id="redisSentinelConfiguration"
class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
<property name="sentinels">
<set>
<bean name="sentinelNode1" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26379"/>
</bean>
<bean name="sentinelNode2" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26380"/>
</bean>
<bean name="sentinelNode3" class="org.springframework.data.redis.connection.RedisNode">
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="26381"/>
</bean>
</set>
</property>
<property name="master">
<bean name="masterNode" class="org.springframework.data.redis.connection.RedisNode">
<!-- 必须指定主节点名称 -->
<property name="name" value="mymaster"/>
<constructor-arg name="host" value="192.168.10.24"/>
<constructor-arg name="port" value="6380"/>
</bean>
</property>
</bean>
<!-- 客户端连接工厂 设置主节点信息 -->
<bean id="jedisConnFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
p:use-pool="true" p:host-name="192.168.10.24" p:port="6380" p:password="root">
<!-- 连接池引用 -->
<constructor-arg name="poolConfig" ref="jedisPoolConfig"/>
<!-- 哨兵引用 -->
<constructor-arg name="sentinelConfig" ref="redisSentinelConfiguration"/>
</bean>
<!-- redisTemplate 配置 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
p:connection-factory-ref="jedisConnFactory">
<!-- 配置序列化操作 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
</bean>
</beans>
6. 项目中集成 Redis 缓存数据
6.1pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.shsxt</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.0-SNAPSHOT</version>
<name>spring-data-redis</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring 核心 jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring 测试 jar -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring 事物 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- aspectj 切面编程的 jar -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
<!-- c3p0 连接池 -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<!-- mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.1</version>
</dependency>
<!-- 添加 mybatis 与 Spring 整合的核心包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<!-- mysql 驱动包 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>
<!-- 日志打印相关的 jar -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.2</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.2</version>
</dependency>
<!-- springmvc 依赖 jar -->
<!-- spring web -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- spring mvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<!-- 添加 json 依赖 jar 包 -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support </artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.freemarker</groupId>
<artifactId>freemarker</artifactId>
<version>2.3.21</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
</dependency>
<!-- Redis 依赖 -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.1</version>
</dependency>
<!-- spring data redis 依赖 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.18.RELEASE</version>
</dependency>
</dependencies>
<build>
<!-- 读取配置文件 -->
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.properties</include>
<include>**/*.tld</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
</build>
</project>
6.2jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/p2p?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root
6.3log4j.properties
log4j.rootLogger=DEBUG, Console
#Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c]
- %m%n
log4j.logger.java.sql.ResultSet=INFO
log4j.logger.org.apache=INFO
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
6.4applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<context:property-placeholder location="classpath:jdbc.properties"/>
<context:component-scan base-package="com.shsxt.service"></context:component-scan>
<!-- 配置数据源 -->
<!-- 配置 c3p0 数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 配置事务管理器 -->
<bean id="txManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 设置事务增强 -->
<tx:advice id="txAdvice" transaction-manager="txManager">
<tx:attributes>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="query*" read-only="true"/>
<tx:method name="load*" read-only="true"/>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="save*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- aop 切面配置 -->
<aop:config>
<aop:pointcut id="servicePointcut" expression="execution(*
com.shsxt.service.impl.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="servicePointcut"/>
</aop:config>
<!-- 配置 sqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations" value="classpath:com/shsxt/mapper/*.xml"/>
</bean>
<!-- 配置扫描器 -->
<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 扫描 com.shsxt.dao 这个包以及它的子包下的所有映射接口类 -->
<property name="basePackage" value="com.shsxt.dao"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>
</beans>
6.5代码
6.5.1JsonUtil.java
package com.shsxt.util;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* Json 转换工具类
*/
public class JsonUtil {
private static ObjectMapper objectMapper = new ObjectMapper();
/**
* 将对象转换成 json 字符串
* @param obj
* @return
*/
public static String object2JsonStr(Object obj){
try {
return objectMapper.writeValueAsString(obj);
} catch (JsonProcessingException e) {
//打印异常信息
e.printStackTrace();
}
return null;
}
/**
* 将字符串转换为对象
* @param <T> 泛型
*/
public static <T> T jsonStr2Object(String jsonStr, Class<T> clazz){
try {
return objectMapper.readValue(jsonStr.getBytes("UTF-8"), clazz);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
6.5.2UserDaoI.java
package com.shsxt.dao;
import com.shsxt.entity.User;
public interface UserDaoI {
public User queryUserById(Integer userId);
}
6.5.3User.java
package com.shsxt.entity;
import java.io.Serializable;
public class User implements Serializable {
private static final long serialVersionUID = 5751725238117698007L;
private Integer id;
private String username;
private String 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;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
}
6.5.4UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.shsxt.dao.UserDaoI">
<select id="queryUserById" resultType="com.shsxt.entity.User">
SELECT id,
username,
password
FROM bas_user
WHERE id = #{userId}
</select>
</mapper>
6.5.5.UserServiceI.java
package com.shsxt.service;
import com.shsxt.entity.User;
public interface UserServiceI {
public User queryUserById(Integer userId);
}
6.5.6.UserServiceImpl.java
package com.shsxt.service.impl;
import com.shsxt.dao.UserDaoI;
import com.shsxt.entity.User;
import com.shsxt.service.UserServiceI;
import com.shsxt.util.JsonUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class UserServiceImpl implements UserServiceI {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private UserDaoI userDao;
@Override
public User queryUserById(Integer userId) {
// return doQueryUserById(userId);
return doQueryUserById2Json(userId);
}
public User doQueryUserById(Integer userId) {
// 先从 Redis 查询
User user = (User) redisTemplate.opsForValue().get("user:id_" + userId);
if(null != user){
return user;
}
// Redis 没有再从 mysql 查询
user = userDao.queryUserById(userId);
if(null != user){
redisTemplate.opsForValue().set("user:id_" + userId, user);
return user;
}
return null;
}
public User doQueryUserById2Json(Integer userId) {
// 先从 Redis 查询
Object jsonUser = redisTemplate.opsForValue().get("user:id_" + userId);
User user = null;
if(null != user){
user = JsonUtil.jsonStr2Object((String) jsonUser, User.class);
return user;
}
// Redis 没有再从 mysql 查询
user = userDao.queryUserById(userId);
if(null != user){
redisTemplate.opsForValue().set("user:id_" + userId,
JsonUtil.object2JsonStr(user));
return user;
}
return null;
}
}
6.5.7.UserServiceTest.java
package com.shsxt.service;
import com.shsxt.entity.User;
import com.shsxt.service.UserServiceI;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import
org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/*
* @RunWith 就是一个运行器
* @RunWith(JUnit4.class)就是指用 JUnit4 来运行
* @RunWith(SpringJUnit4ClassRunner.class)，让测试运行于 Spring 测试环境
*/
@RunWith(SpringJUnit4ClassRunner.class)
/*
* @ContextConfiguration Spring 整合 JUnit4 测试时，使用注解引入多个配置文
件
* 单个文件 @ContextConfiguration(locations =
"classpath:spring/applicationContext.xml")
* 多个文件 @ContextConfiguration(locations =
{"classpath:spring/spring1.xml", "classpath:mybatis/config.xml"})
*/
@ContextConfiguration(locations = {"classpath:applicationContext.xml",
"classpath:applicationContext-redis.xml"})
public class UserServiceTest {
@Autowired
private UserServiceI userService;
@Test
public void test() {
User user = userService.queryUserById(1);
System.out.println(user);
}
}
八. 缓存雪崩,缓存击穿,缓存穿透
1.缓存穿透
描述：
缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。
解决方案：
(1).接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；
(2).从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击.
2.缓存击穿
描述：
缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力
解决方案：
(1).设置热点数据永远不过期。
(2).加互斥锁，互斥锁
3.缓存雪崩
描述：
缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
解决方案：
(1).缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中。
(2).设置热点数据永远不过期。