转载请表明出处 https://blog.csdn.net/Amor_Leo/article/details/85039461 谢谢

添加依赖

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);
    }

}