转载请表明出处 https://blog.csdn.net/Amor_Leo/article/details/85039461 谢谢
Springboot2集成redis集群
添加依赖
parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.9</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
yml配置
spring:
datasource:
druid:
# 数据库访问配置, 使用druid数据源
name: test
driverClassName: com.mysql.jdbc.Driver
db-type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://192.168.1.156:3306/dap?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: root
initial-size: 5
min-idle: 5
max-active: 20
# 连接等待超时时间
max-wait: 30000
# 配置检测可以关闭的空闲连接间隔时间
time-between-eviction-runs-millis: 60000
# 配置连接在池中的最小生存时间
min-evictable-idle-time-millis: 300000
validation-query: select '1' from dual
test-while-idle: true
test-on-borrow: false
test-on-return: false
# 打开PSCache,并且指定每个连接上PSCache的大小
pool-prepared-statements: true
max-open-prepared-statements: 20
max-pool-prepared-statement-per-connection-size: 20
redis:
cluster:
nodes: 192.168.1.132:7000,192.168.1.132:7001,192.168.1.132:7002,192.168.1.133:7003,192.168.1.133:7004,192.168.1.133:7005
timeout: 10000
database: 0
jedis:
pool:
# 连接池中的最小空闲连接
min-idle: 20
# 连接池中的最大空闲连接
max-idle: 100
# 连接池最大连接数(使用负值表示没有限制)
max-active: 300
max-wait: -1
mybatis:
mapper-locations: classpath:mapper/*.xml
pagehelper:
helper-dialect: mysql
reasonable: true
support-methods-arguments: true
params: count=countSql
编写配置文件
druid配置
@Configuration
public class DruidConfig {
private static final Logger logger = LoggerFactory.getLogger(DruidConfig.class);
private static final String DB_PREFIX = "spring.datasource.druid";
@Bean
public ServletRegistrationBean<StatViewServlet> druidServlet() {
logger.info("init Druid Servlet Configuration ");
ServletRegistrationBean<StatViewServlet> servletRegistrationBean = new ServletRegistrationBean<>(new StatViewServlet(), "/druid/*");
// IP白名单
servletRegistrationBean.addInitParameter("allow", "*");
// IP黑名单(共同存在时,deny优先于allow)
servletRegistrationBean.addInitParameter("deny", "192.168.1.100");
//控制台管理用户
servletRegistrationBean.addInitParameter("loginUsername", "admin");
servletRegistrationBean.addInitParameter("loginPassword", "admin");
//是否能够重置数据 禁用HTML页面上的“Reset All”功能
servletRegistrationBean.addInitParameter("resetEnable", "false");
return servletRegistrationBean;
}
@Bean
public FilterRegistrationBean<WebStatFilter> filterRegistrationBean() {
FilterRegistrationBean<WebStatFilter> filterRegistrationBean = new FilterRegistrationBean<>(new WebStatFilter());
filterRegistrationBean.addUrlPatterns("/*");
filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
return filterRegistrationBean;
}
//解决 spring.datasource.filters=stat,wall,log4j 无法正常注册进去
@ConfigurationProperties(prefix = DB_PREFIX)
class IDataSourceProperties {
private String url;
private String username;
private String password;
private String driverClassName;
private int initialSize;
private int minIdle;
private int maxActive;
private int maxWait;
private int timeBetweenEvictionRunsMillis;
private int minEvictableIdleTimeMillis;
private String validationQuery;
private boolean testWhileIdle;
private boolean testOnBorrow;
private boolean testOnReturn;
private boolean poolPreparedStatements;
private int maxPoolPreparedStatementPerConnectionSize;
private String filters;
private String connectionProperties;
@Bean //声明其为Bean实例
@Primary //在同样的DataSource中,首先使用被标注的DataSource
public DataSource dataSource() {
DruidDataSource datasource = new DruidDataSource();
datasource.setUrl(url);
datasource.setUsername(username);
datasource.setPassword(password);
datasource.setDriverClassName(driverClassName);
//configuration
datasource.setInitialSize(initialSize);
datasource.setMinIdle(minIdle);
datasource.setMaxActive(maxActive);
datasource.setMaxWait(maxWait);
datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
datasource.setValidationQuery(validationQuery);
datasource.setTestWhileIdle(testWhileIdle);
datasource.setTestOnBorrow(testOnBorrow);
datasource.setTestOnReturn(testOnReturn);
datasource.setPoolPreparedStatements(poolPreparedStatements);
datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
try {
datasource.setFilters(filters);
} catch (SQLException e) {
System.err.println("druid configuration initialization filter: " + e);
}
datasource.setConnectionProperties(connectionProperties);
return datasource;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
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;
}
public String getDriverClassName() {
return driverClassName;
}
public void setDriverClassName(String driverClassName) {
this.driverClassName = driverClassName;
}
public int getInitialSize() {
return initialSize;
}
public void setInitialSize(int initialSize) {
this.initialSize = initialSize;
}
public int getMinIdle() {
return minIdle;
}
public void setMinIdle(int minIdle) {
this.minIdle = minIdle;
}
public int getMaxActive() {
return maxActive;
}
public void setMaxActive(int maxActive) {
this.maxActive = maxActive;
}
public int getMaxWait() {
return maxWait;
}
public void setMaxWait(int maxWait) {
this.maxWait = maxWait;
}
public int getTimeBetweenEvictionRunsMillis() {
return timeBetweenEvictionRunsMillis;
}
public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) {
this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
}
public int getMinEvictableIdleTimeMillis() {
return minEvictableIdleTimeMillis;
}
public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) {
this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
}
public String getValidationQuery() {
return validationQuery;
}
public void setValidationQuery(String validationQuery) {
this.validationQuery = validationQuery;
}
public boolean isTestWhileIdle() {
return testWhileIdle;
}
public void setTestWhileIdle(boolean testWhileIdle) {
this.testWhileIdle = testWhileIdle;
}
public boolean isTestOnBorrow() {
return testOnBorrow;
}
public void setTestOnBorrow(boolean testOnBorrow) {
this.testOnBorrow = testOnBorrow;
}
public boolean isTestOnReturn() {
return testOnReturn;
}
public void setTestOnReturn(boolean testOnReturn) {
this.testOnReturn = testOnReturn;
}
public boolean isPoolPreparedStatements() {
return poolPreparedStatements;
}
public void setPoolPreparedStatements(boolean poolPreparedStatements) {
this.poolPreparedStatements = poolPreparedStatements;
}
public int getMaxPoolPreparedStatementPerConnectionSize() {
return maxPoolPreparedStatementPerConnectionSize;
}
public void setMaxPoolPreparedStatementPerConnectionSize(int maxPoolPreparedStatementPerConnectionSize) {
this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
}
public String getFilters() {
return filters;
}
public void setFilters(String filters) {
this.filters = filters;
}
public String getConnectionProperties() {
return connectionProperties;
}
public void setConnectionProperties(String connectionProperties) {
this.connectionProperties = connectionProperties;
}
}
}
redis配置
@Configuration
public class RedisConfig {
/**
* 注入 RedisConnectionFactory
*/
@Autowired
RedisConnectionFactory redisConnectionFactory;
/**
* 实例化 RedisTemplate 对象
* @return
*/
@Bean
public RedisTemplate<String, Object> functionDomainRedisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
return redisTemplate;
}
/**
* 设置数据存入 redis 的序列化方式
* @param redisTemplate
* @param factory
*/
private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setConnectionFactory(factory);
}
/**
* 实例化 HashOperations 对象,可以使用 Hash 类型操作
* @param redisTemplate
* @return
*/
@Bean
public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForHash();
}
/**
* 实例化 ValueOperations 对象,可以使用 String 操作
* @param redisTemplate
* @return
*/
@Bean
public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForValue();
}
/**
* 实例化 ListOperations 对象,可以使用 List 操作
* @param redisTemplate
* @return
*/
@Bean
public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForList();
}
/**
* 实例化 SetOperations 对象,可以使用 Set 操作
* @param redisTemplate
* @return
*/
@Bean
public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForSet();
}
/**
* 实例化 ZSetOperations 对象,可以使用 ZSet 操作
* @param redisTemplate
* @return
*/
@Bean
public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
return redisTemplate.opsForZSet();
}
}
实体类
public class RedisModel implements Serializable {
private String redisKey;//redis中的key
private String name;//姓名
private String tel;//电话
private String address;//住址
public String getRedisKey() {
return redisKey;
}
public void setRedisKey(String redisKey) {
this.redisKey = redisKey;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
service层
hash
public interface IHashRedisService<T> {
void put(String redisKey,String key, T doamin,long expire);
void putAll(String redisKey, Map<String,T> m,long expire);
void remove(String redisKey,String key);
T get(String redisKey,String key);
List<T> getAll(String redisKey);
Set<String> getKeys(String redisKey);
List<T> getValues(String redisKey);
boolean isKeyExists(String redisKey,String key);
long count(String redisKey);
void empty(String redisKey);
}
public abstract class AHashRedisService<T> implements IHashRedisService<T> {
@Autowired
protected RedisTemplate<String, Object> redisTemplate;
@Resource
protected HashOperations<String, String, T> hashOperations;
/**
* 添加
*
* @param key key
* @param doamin 对象
* @param expire 过期时间(单位:秒),传入 -1 时表示不设置过期时间
*/
@Override
public void put(String redisKey,String key,T doamin,long expire) {
hashOperations.put(redisKey, key, doamin);
if (expire != -1) {
redisTemplate.expire(redisKey, expire, TimeUnit.SECONDS);
}
}
/**
* @Description: 添加多个
* @method putAll
* @Param redisKey
* @Param map
* @Param expire
* @return: void
* @auther: LHL
* @Date: 2018/11/2 10:38
*/
@Override
public void putAll(String redisKey, Map<String, T> map,long expire){
hashOperations.putAll(redisKey, map);
if (expire != -1) {
redisTemplate.expire(redisKey, expire, TimeUnit.SECONDS);
}
}
/**
* 删除
*
* @param key 传入key的名称
*/
@Override
public void remove(String redisKey,String key) {
hashOperations.delete(redisKey, key);
}
/**
* 查询
* @param key 查询的key
* @return
*/
@Override
public T get(String redisKey,String key) {
return hashOperations.get(redisKey, key);
}
/**
* 获取当前redis库下所有对象
*
* @return
*/
@Override
public List<T> getAll(String redisKey) {
return hashOperations.values(redisKey);
}
/**
* 查询查询当前redis库下所有key
*
* @return
*/
@Override
public Set<String> getKeys(String redisKey) {
return hashOperations.keys(redisKey);
}
/**
* @Description: 查询查询当前redis库下所有values
* @method getValues
* @Param redisKey
* @return: java.util.List<T>
* @auther: LHL
* @Date: 2018/11/2 10:31
*/
@Override
public List<T> getValues(String redisKey){
return hashOperations.values(redisKey);
}
/**
* 判断key是否存在redis中
*
* @param key 传入key的名称
* @return
*/
@Override
public boolean isKeyExists(String redisKey,String key) {
return hashOperations.hasKey(redisKey, key);
}
/**
* 查询当前key下缓存数量
*
* @return
*/
@Override
public long count(String redisKey) {
return hashOperations.size(redisKey);
}
/**
* 清空redis
*/
@Override
public void empty(String redisKey) {
Set<String> set = hashOperations.keys(redisKey);
set.stream().forEach(key -> hashOperations.delete(redisKey, key));
}
}
zset
public interface IZSetRedisService<T> {
Boolean add(String redisKey, T value, double score);
Long multiAdd(String redisKey, Set<ZSetOperations.TypedTuple<T>> tuples);
Long remove(String redisKey, T ... values);
Long removeRange(String redisKey, long start, long end);
Long removeRangeByScore(String redisKey, double min, double max);
Long count(String redisKey, double min, double max);
Long size(String redisKey);
Double score(String redisKey, T obj);
Map<Double,T> scan(String redisKey);
Long rank(String redisKey, T obj);
Long reverseRank(String redisKey, T obj);
Set<T> range(String redisKey, long start, long end);
Set<T> rangeByScore(String redisKey, double min, double max);
Set<T> rangeByScore(String redisKey, double min, double max, long offset, long count);
Map<Double,T> rangeWithScores(String redisKey, long start, long end);
Map<Double,T> rangeByScoreWithScores(String redisKey, double min, double max);
Map<Double,T> rangeByScoreWithScores(String redisKey, double min, double max, long offset, long count);
Set<T> reverseRange(String redisKey, long start, long end);
Set<T> reverseRangeByScore(String redisKey, double min, double max);
Set<T> reverseRangeByScore(String redisKey, double min, double max, long offset, long count);
Map<Double,T> reverseRangeWithScores(String redisKey, long start, long end);
Map<Double,T> reverseRangeByScoreWithScores(String redisKey, double min, double max);
Map<Double,T> reverseRangeByScoreWithScores(String redisKey, double min, double max, long offset, long count);
}
public abstract class AZSetRedisService<T> implements IZSetRedisService<T> {
@Resource
protected ZSetOperations<String, T> zSetOperations;
@Override
public Boolean add(String redisKey, T value, double score){
return zSetOperations.add(redisKey,value,score);
}
@Override
public Long multiAdd(String redisKey, Set<TypedTuple<T>> tuples){
return zSetOperations.add(redisKey,tuples);
}
@Override
public Long remove(String redisKey, T... values){
return zSetOperations.remove(redisKey,values);
}
@Override
public Long removeRange(String redisKey, long start, long end){
return zSetOperations.removeRange(redisKey,start,end);
}
@Override
public Long removeRangeByScore(String redisKey, double min, double max){
return zSetOperations.removeRangeByScore(redisKey,min,max);
}
@Override
public Long count(String redisKey, double min, double max){
return zSetOperations.count(redisKey,min,max);
}
@Override
public Long size(String redisKey){
// zSetOperations.zCard(redisKey);
return zSetOperations.size(redisKey);
}
@Override
public Double score(String redisKey, T obj){
return zSetOperations.score(redisKey,obj);
}
@Override
public Map<Double,T> scan(String redisKey){
Map<Double,T> map = new HashMap<>();
Cursor<TypedTuple<T>> scan = zSetOperations.scan(redisKey, ScanOptions.NONE);
while (scan.hasNext()){
TypedTuple<T> item = scan.next();
map.put(item.getScore(),item.getValue());
}
return map;
}
@Override
public Long rank(String redisKey, T obj){
return zSetOperations.rank(redisKey,obj);
}
@Override
public Long reverseRank(String redisKey, T obj){
return zSetOperations.reverseRank(redisKey,obj);
}
@Override
public Set<T> range(String redisKey, long start, long end){
return zSetOperations.range(redisKey, start, end);
}
@Override
public Set<T> rangeByScore(String redisKey, double min, double max){
return zSetOperations.rangeByScore(redisKey,min,max);
}
@Override
public Set<T> rangeByScore(String redisKey, double min, double max, long offset, long count){
return zSetOperations.rangeByScore(redisKey,min,max,offset,count);
}
@Override
public Map<Double,T> rangeWithScores(String redisKey, long start, long end){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> rangeWithScores = zSetOperations.rangeWithScores(redisKey, start , end);
Iterator<TypedTuple<T>> iterator = rangeWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
@Override
public Map<Double,T> rangeByScoreWithScores(String redisKey, double min, double max){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> rangeByScoreWithScores = zSetOperations.rangeByScoreWithScores(redisKey, min, max);
Iterator<TypedTuple<T>> iterator = rangeByScoreWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
@Override
public Map<Double,T> rangeByScoreWithScores(String redisKey, double min, double max, long offset, long count){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> rangeByScoreWithScores = zSetOperations.rangeByScoreWithScores(redisKey, min, max ,offset,count);
Iterator<TypedTuple<T>> iterator= rangeByScoreWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
@Override
public Set<T> reverseRange(String redisKey, long start, long end){
return zSetOperations.reverseRange(redisKey,start,end);
}
@Override
public Set<T> reverseRangeByScore(String redisKey, double min, double max){
return zSetOperations.reverseRangeByScore(redisKey,min,max);
}
@Override
public Set<T> reverseRangeByScore(String redisKey, double min, double max, long offset, long count){
return zSetOperations.reverseRangeByScore(redisKey,min,max,offset,count);
}
@Override
public Map<Double,T> reverseRangeWithScores(String redisKey, long start, long end){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> reverseRangeWithScores = zSetOperations.reverseRangeWithScores(redisKey, start, end);
Iterator<TypedTuple<T>> iterator = reverseRangeWithScores.iterator();
while(iterator.hasNext()) {
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
@Override
public Map<Double,T> reverseRangeByScoreWithScores(String redisKey, double min, double max){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> reverseRangeByScoreWithScores = zSetOperations.reverseRangeByScoreWithScores(redisKey,min, max);
Iterator<TypedTuple<T>> iterator = reverseRangeByScoreWithScores.iterator();
while(iterator.hasNext()){
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
@Override
public Map<Double,T> reverseRangeByScoreWithScores(String redisKey, double min, double max, long offset, long count){
Map<Double,T> map = new HashMap<>();
Set<TypedTuple<T>> reverseRangeByScoreWithScores = zSetOperations.reverseRangeByScoreWithScores(redisKey,min, max,offset,count);
Iterator<TypedTuple<T>> iterator = reverseRangeByScoreWithScores.iterator();
while(iterator.hasNext()) {
TypedTuple<T> next = iterator.next();
map.put(next.getScore(),next.getValue());
}
return map;
}
}
测试
service
hash
@Service
public class HashRedisServiceImpl<RedisModel> extends AHashRedisService<RedisModel> {
}
zset
@Service
public class ZSetRedisServiceImpl<RedisModel> extends AZSetRedisService<RedisModel> {
}
controller
hash
@RestController
@RequestMapping("/hash")
public class TestHashRedisController {
@Autowired
private HashRedisServiceImpl service;
private final static String redisKey="TEST_REDIS_KEY";
//添加
@PostMapping("/add")
public void add() {
System.out.println("start.....");
RedisModel m = new RedisModel();
m.setName("张三");
m.setTel("1111");
m.setAddress("深圳1");
m.setRedisKey("zhangsanKey01");
service.put(redisKey,m.getRedisKey(), m, -1);
RedisModel m2 = new RedisModel();
m2.setName("张三2");
m2.setTel("2222");
m2.setAddress("深圳2");
m2.setRedisKey("zhangsanKey02");
service.put(redisKey,m2.getRedisKey(), m2, -1);
RedisModel m3 = new RedisModel();
m3.setName("张三3");
m3.setTel("3333");
m3.setAddress("深圳3");
m3.setRedisKey("zhangsanKey03");
service.put(redisKey,m3.getRedisKey(), m3, -1);
System.out.println("add success end...");
}
//添加多个
@PostMapping("/addAll")
public void addAll() {
System.out.println("start.....");
RedisModel m = new RedisModel();
m.setName("李四");
m.setTel("1111");
m.setAddress("上海1");
m.setRedisKey("Key01");
RedisModel m2 = new RedisModel();
m2.setName("李四2");
m2.setTel("2222");
m2.setAddress("上海2");
m2.setRedisKey("Key02");
RedisModel m3 = new RedisModel();
m3.setName("李四3");
m3.setTel("3333");
m3.setAddress("上海3");
m3.setRedisKey("Key03");
Map<String,RedisModel> map =new HashMap<>();
map.put(m.getRedisKey(),m);
map.put(m2.getRedisKey(),m2);
map.put(m3.getRedisKey(),m3);
service.putAll(redisKey,map,-1);
System.out.println("add success end...");
}
//查询所有对象
@GetMapping("/getAll")
public Object getAll() {
return service.getAll(redisKey);
}
//查询所有key
@GetMapping("/getKeys")
public Object getKeys() {
return service.getKeys(redisKey);
}
//查询所有value
@GetMapping("/getValues")
public Object getValues() {
return service.getValues(redisKey);
}
//根据key查询
@GetMapping("/get")
public Object get() {
RedisModel m = new RedisModel();
m.setRedisKey("zhangsanKey02");
return service.get(redisKey,m.getRedisKey());
}
//删除
@DeleteMapping("/remove")
public void remove() {
RedisModel m = new RedisModel();
m.setRedisKey("zhangsanKey01");
service.remove(redisKey,m.getRedisKey());
}
//判断key是否存在
@GetMapping("/isKeyExists")
public void isKeyExists() {
RedisModel m = new RedisModel();
m.setRedisKey("zhangsanKey01");
boolean flag = service.isKeyExists(redisKey,m.getRedisKey());
System.out.println("zhangsanKey01 是否存在: "+flag);
}
//查询当前缓存的数量
@GetMapping("/count")
public Object count() {
return service.count(redisKey);
}
//清空所有key
@DeleteMapping("/empty")
public void empty() {
service.empty(redisKey);
}
}
zset
@RestController
@RequestMapping("/zset")
public class TestZSetRedisController {
@Autowired
private ZSetRedisServiceImpl zSetRedisService;
private final static String redisKey="TEST_ZSet_REDIS_KEY";
/**
* @Description: 添加
* @method add
* @Param
* @return: java.lang.String
* @auther: LHL
* @Date: 2018/11/2 14:11
*/
@PostMapping("/add")
public String add(){
RedisModel m = new RedisModel();
m.setName("王五");
m.setTel("1111");
m.setAddress("武汉1");
m.setRedisKey("Key01");
Boolean aBoolean = zSetRedisService.add(redisKey, m, 1d);
if (aBoolean){
return "添加成功";
}
return "添加失败";
}
/**
* @Description: 添加多个 返回添加个数
* @method multiAdd
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 14:11
*/
@PostMapping("/addAll")
public Long multiAdd(){
RedisModel m = new RedisModel();
m.setName("张三");
m.setTel("1111");
m.setAddress("深圳1");
m.setRedisKey("zhangsanKey01");
RedisModel m2 = new RedisModel();
m2.setName("张三2");
m2.setTel("2222");
m2.setAddress("深圳2");
m2.setRedisKey("zhangsanKey02");
RedisModel m3 = new RedisModel();
m3.setName("张三3");
m3.setTel("3333");
m3.setAddress("深圳3");
m3.setRedisKey("zhangsanKey03");
Set<ZSetOperations.TypedTuple<RedisModel>> tuples = new HashSet<>();
tuples.add(new DefaultTypedTuple<RedisModel>(m, 2d));
tuples.add(new DefaultTypedTuple<RedisModel>(m2, 3d));
tuples.add(new DefaultTypedTuple<RedisModel>(m3, 4d));
return zSetRedisService.multiAdd(redisKey,tuples);
}
/**
* @Description: 移除有序集合中指定的多个成员. 如果成员不存在则忽略,返回删除数据的个数
* @method remove
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 14:34
*/
@DeleteMapping("/remove")
public Long remove(){
RedisModel m = new RedisModel();
m.setName("张三");
m.setTel("1111");
m.setAddress("深圳1");
m.setRedisKey("zhangsanKey01");
RedisModel m2 = new RedisModel();
m2.setName("张三2");
m2.setTel("2222");
m2.setAddress("深圳2");
m2.setRedisKey("zhangsanKey02");
RedisModel m3 = new RedisModel();
m3.setName("张三3");
m3.setTel("3333");
m3.setAddress("深圳3");
m3.setRedisKey("zhangsanKey03");
RedisModel[] models={m,m2,m3};
return zSetRedisService.remove(redisKey,models);
}
/**
* @Description: 删除索引在start<=index<=end的元素,返回删除个数
* @method removeRange
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 14:53
*/
@DeleteMapping("/removeRange")
public Long removeRange(){
return zSetRedisService.removeRange(redisKey,0,1);
}
/**
* @Description: 删除score在Smin<=score<=Smax的元素,返回删除个数
* @method removeRangeByScore
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 14:56
*/
@DeleteMapping("/removeRangeByScore")
public Long removeRangeByScore(){
return zSetRedisService.removeRangeByScore(redisKey,1d,3d);
}
/**
* @Description: 返回 score在 Smin<=score<=Smax的元素个数
* @method count
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 15:04
*/
@GetMapping("/getCount")
public Long count(){
return zSetRedisService.count(redisKey,1d,4d);
}
/**
* @Description: 获取redisKey的总个数
* @method size
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 15:10
*/
@GetMapping("/getSize")
public Long size(){
return zSetRedisService.size(redisKey);
}
/**
* @Description: 获取value的score
* @method score
* @Param
* @return: java.lang.Double
* @auther: LHL
* @Date: 2018/11/2 15:17
*/
@GetMapping("/getScore")
public Double score(){
RedisModel m = new RedisModel();
m.setName("王五");
m.setTel("1111");
m.setAddress("武汉1");
m.setRedisKey("Key01");
return zSetRedisService.score(redisKey,m);
}
/**
* @Description: 获取所有value和score
* @method scan
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 15:29
*/
@GetMapping("/getScan")
public Map<Double,RedisModel> scan(){
return zSetRedisService.scan(redisKey);
}
/**
* @Description: 在排序集中确定具有值的元素的索引,并返回其索引(从低到高)
* @method rank
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 15:54
*/
@GetMapping("/getPositiveSequenceIndex")
public Long rank(){
RedisModel m3 = new RedisModel();
m3.setName("张三3");
m3.setTel("3333");
m3.setAddress("深圳3");
m3.setRedisKey("zhangsanKey03");
return zSetRedisService.rank(redisKey,m3);
}
/**
* @Description: 当从高到低时,返回确定排序集中的值的元素的索引。
* @method reverseRank
* @Param
* @return: java.lang.Long
* @auther: LHL
* @Date: 2018/11/2 15:55
*/
@GetMapping("/getInvertedOrderIndex")
public Long reverseRank(){
RedisModel m3 = new RedisModel();
m3.setName("张三3");
m3.setTel("3333");
m3.setAddress("深圳3");
m3.setRedisKey("zhangsanKey03");
return zSetRedisService.reverseRank(redisKey,m3);
}
/**
* @Description: 获取指定范围内的成员集合。(不包括score)(0 -1)返回所有。 如果为正数,则按正常顺序取,如果为负数则反序取。索引start<=index<=end的元素子集 从小到大
* @method range
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 15:42
*/
@GetMapping("/getRange")
public Set<RedisModel> range(){
return zSetRedisService.range(redisKey, 0, -1);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素。(从小到大) 不包括score
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:15
*/
@GetMapping("/getRangeByScore1")
public Set<RedisModel> rangeByScore1(){
return zSetRedisService.rangeByScore(redisKey,1d,2d);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素(从小到大)并且从指定索引offset开始获取count个 不包括score
* @method rangeByScore2
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:16
*/
@GetMapping("/getRangeByScore2")
public Set<RedisModel> rangeByScore2(){
return zSetRedisService.rangeByScore(redisKey,1d,2d,0,1);
}
/**
* @Description: 从排序集(从小到大)中获取开始和结束之间索引的元素(包括score和value) 索引start<=index<=end
* @method rangeWithScores
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:27
*/
@GetMapping("/rangeWithScores")
public Map<Double,RedisModel> rangeWithScores(){
return zSetRedisService.rangeWithScores(redisKey,0,-1);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素。(从小到大) 包括score和value
* @method rangeByScoreWithScores1
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:42
*/
@GetMapping("/rangeByScoreWithScores1")
public Map<Double,RedisModel> rangeByScoreWithScores1(){
return zSetRedisService.rangeByScoreWithScores(redisKey,1d,2d);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素(从小到大)并且从指定索引offset开始获取count个 包括score和value
* @method rangeByScoreWithScores2
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:43
*/
@GetMapping("/rangeByScoreWithScores2")
public Map<Double,RedisModel> rangeByScoreWithScores2(){
return zSetRedisService.rangeByScoreWithScores(redisKey,1d,3d,1,1);
}
/**
* @Description: 获取指定范围内的成员集合。(不包括score)(0 -1)返回所有。 如果为正数,则按正常顺序取,如果为负数则反序取。索引start<=index<=end的元素子集 从大到小
* @method reverseRange
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 16:52
*/
@GetMapping("/reverseRange")
public Set<RedisModel> reverseRange(){
return zSetRedisService.reverseRange(redisKey,0,-1);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素。(从大到小) 不包括score
* @method reverseRangeByScore1
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 17:00
*/
@GetMapping("/reverseRangeByScore1")
public Set<RedisModel> reverseRangeByScore1(){
return zSetRedisService.reverseRangeByScore(redisKey,1d,2d);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素(从大到小)并且从指定索引offset开始获取count个 不包括score
* @method reverseRangeByScore2
* @Param
* @return: java.util.Set<com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 17:01
*/
@GetMapping("/reverseRangeByScore2")
public Set<RedisModel> reverseRangeByScore2(){
return zSetRedisService.reverseRangeByScore(redisKey,1d,4d,0,2);
}
/**
* @Description: 从排序集(从大到小)中获取开始和结束之间索引的元素(包括score和value) 索引start<=index<=end
* @method reverseRangeWithScores
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 17:13
*/
@GetMapping("/reverseRangeWithScores")
public Map<Double,RedisModel> reverseRangeWithScores(){
return zSetRedisService.reverseRangeWithScores(redisKey,0,-1);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素。(从大到小) 包括score和value
* @method reverseRangeByScoreWithScores1
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 17:13
*/
@GetMapping("/reverseRangeByScoreWithScores1")
public Map<Double,RedisModel> reverseRangeByScoreWithScores1(){
return zSetRedisService.reverseRangeByScoreWithScores(redisKey,1d,3d);
}
/**
* @Description: 得到分数score在最小和最大值之间Smin<=score<=Smax的元素(从大到小)并且从指定索引offset开始获取count个 包括score和value
* @method reverseRangeByScoreWithScores2
* @Param
* @return: java.util.Map<java.lang.Double,com.aqh.domain.RedisModel>
* @auther: LHL
* @Date: 2018/11/2 17:13
*/
@GetMapping("/reverseRangeByScoreWithScores2")
public Map<Double,RedisModel> reverseRangeByScoreWithScores2(){
return zSetRedisService.reverseRangeByScoreWithScores(redisKey,1d,3d,2,1);
}
}