Redis基本操作之Java實現(xiàn)(所有類型)

Imfan 發(fā)布于2019-08-16 18:29 / 1266人閱讀

摘要：前不久分享過的基本數(shù)據(jù)結(jié)構(gòu)及基本命令詳解。在熟悉了的基本操作之后如果還有對的基本操作不熟悉的，可以點擊前面的連接先熟悉下，今天給大家分享下實際開發(fā)中對操作的實現(xiàn)版本。

前不久分享過Redis的基本數(shù)據(jù)結(jié)構(gòu)及基本命令詳解。在熟悉了redis的基本操作之后（如果還有對redis的基本操作不熟悉的，可以點擊前面的連接先熟悉下），今天給大家分享下實際開發(fā)中對redis操作的Java實現(xiàn)版本。

Maven依賴

使用maven來構(gòu)建項目在當下應(yīng)該已經(jīng)是主流了，所以我們也不例外使用了Maven。因為使用了spring對redis封裝的jar，所以也需要引入spring基本jar，Maven依賴如下：


    org.springframework
    spring-core
    5.1.5.RELEASE


    org.springframework
    spring-context
    5.1.5.RELEASE


    org.springframework.data
    spring-data-redis
    2.1.3.RELEASE


    redis.clients
    jedis
    2.9.2


    
    redis

實現(xiàn)代碼

實現(xiàn)代碼篇幅有點長，而且segmentfault代碼div的高度有限制，建議大家把代碼拷貝到開發(fā)工具中再閱讀。

package spring.redis;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;

import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class SpringRedisHandler implements InitializingBean {

    //redis編碼
    private static final String redisCode = "utf-8";
    private static final String EmptyString = "";

    @Autowired
    private RedisTemplate jtRedis;

    /**
     * 設(shè)置key-value【不含超時時間】
     *
     * @param key
     * @param value
     */
    public void set(String key, Object value) {
        this.set(key, String.valueOf(value), 0L);
    }

    /**
     * 設(shè)置key-value【含超時時間】
     *
     * @param key
     * @param value
     * @param liveTime
     */
    public void set(String key, Object value, long liveTime) {
        this.set(key.getBytes(), String.valueOf(value).getBytes(), liveTime);
    }


    @SuppressWarnings({"unchecked", "rawtypes"})
    private void set(final byte[] key, final byte[] value, final long liveTime) {
        jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                connection.set(key, value);
                if (liveTime > 0) {
                    connection.expire(key, liveTime);
                }
                return 1L;
            }
        });
    }

    /**
     * get key的值
     *
     * @param key
     * @return
     */
    public String get(final String key) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                try {
                    return new String(connection.get(key.getBytes()), redisCode);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    return "";
                }
            }
        });
    }

    /**
     * 是否存在key
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.exists(key.getBytes());
            }
        });
    }

    /**
     * 某數(shù)據(jù)中所有key的總數(shù)
     *
     * @return
     */
    public long dbSize() {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
    }

    /**
     * 檢測redis服務(wù)器是否能平通
     */
    public String ping() {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.ping();
            }
        });
    }

    /**
     * value增加某個值
     *
     * @param key
     * @param value
     * @return
     */
    public Long incr(String key, long value) {
        return incr(key.getBytes(), value);
    }

    private Long incr(byte[] key, long value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.incrBy(key, value);
            }
        });
    }

    /**
     * 自增
     *
     * @param key
     * @return
     */
    public Long incr(String key) {
        return incr(key.getBytes(), 1);
    }

    /**
     * 自減
     *
     * @param key
     * @return
     */
    public Long decr(String key) {
        return decr(key.getBytes(), 1);
    }

    /**
     * value減少某個值
     *
     * @param key
     * @param value
     * @return
     */
    public Long decr(String key, long value) {
        return decr(key.getBytes(), value);
    }

    private Long decr(byte[] key, long value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.decrBy(key, value);
            }
        });
    }

    /**
     * 刪除key
     *
     * @param key
     * @return
     */
    public Long del(String key) {
        return del(key.getBytes());
    }

    private Long del(byte[] key) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.del(key);
            }
        });
    }

    /**
     * flushdb：刪除db下的所有數(shù)據(jù)
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    public void flushDb() {
        jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return 1L;
            }
        });
    }

    /**
     * 設(shè)置hash
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Boolean hSet(String key, String field, String value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hSet(key.getBytes(), field.getBytes(), value.getBytes());
            }
        });
    }

    /**
     * 獲取hash的屬性值
     *
     * @param key
     * @param field
     * @return
     */
    public String hGet(String key, String field) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return new String(redisConnection.hGet(key.getBytes(), field.getBytes()));
            }
        });
    }

    /**
     * 批量設(shè)置hash
     *
     * @param key
     * @param values
     */
    public void hMSet(String key, Map values) {
        jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                redisConnection.hMSet(key.getBytes(), stringObjectMapToBytes(values));
                return null;
            }
        });
    }

    /**
     * 批量獲取hash的多個屬性
     *
     * @param key
     * @param fields
     * @return
     */
    public List hMGet(String key, String... fields) {
        return jtRedis.execute(new RedisCallback>() {
            @Override
            public List doInRedis(RedisConnection redisConnection) throws DataAccessException {
                List listFileds = new ArrayList<>();
                for (int i = 0; i < fields.length; i++) {
                    listFileds.add(fields[i]);
                }

                List byteFileds = stringListToByte(listFileds);
                return bytesListToString(redisConnection.hMGet(key.getBytes(), byteFileds.toArray(new byte[byteFileds.size()][byteFileds.size()])));
            }
        });
    }

    /**
     * 獲取hash的所有屬性
     *
     * @param key
     * @return
     */
    public Map hGetAll(String key) {
        return jtRedis.execute(new RedisCallback>() {
            @Override
            public Map doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return bytesMapToString(redisConnection.hGetAll(key.getBytes()));
            }
        });
    }

    /**
     * 針對hash中某個屬性增加指定的值
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Double hIncrBy(String key, String field, double value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hIncrBy(key.getBytes(), field.getBytes(), value);
            }
        });
    }

    /**
     * hash是存在某屬性
     *
     * @param key
     * @param field
     * @return
     */
    public Boolean hExists(String key, String field) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hExists(key.getBytes(), field.getBytes());
            }
        });
    }

    /**
     * 刪除hash的某屬性
     *
     * @param key
     * @param field
     * @return
     */
    public Long hDel(String key, String field) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.hDel(key.getBytes(), field.getBytes());
            }
        });
    }

    /**
     * 向zset中的某個key添加一個屬性幾分數(shù)（可以根據(jù)分數(shù)排序）
     *
     * @param key
     * @param score
     * @param field
     * @return
     */
    public Boolean zAdd(String key, double score, String field) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zAdd(key.getBytes(), score, field.getBytes());
            }
        });
    }

    /**
     * 給zset中的某個key中的某個屬性增加指定分數(shù)
     *
     * @param key
     * @param score
     * @param field
     * @return
     */
    public Double zIncrBy(String key, double score, String field) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Double doInRedis(RedisConnection redisConnection) throws DataAccessException {
                return redisConnection.zIncrBy(key.getBytes(), score, field.getBytes());
            }
        });
    }

    /**
     * 從list左側(cè)插入一個元素
     *
     * @param key
     * @param values
     * @return
     */
    public Long lPush(String key, String value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.lPush(key.getBytes(), value.getBytes());
            }
        });
    }

    /**
     * 從list左側(cè)插入多個元素
     *
     * @param key
     * @param values
     * @return
     */
    public Long lPush(String key, List values) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                List bytes = stringListToByte(values);
                return connection.lPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
            }
        });
    }

    /**
     * 從list的左側(cè)取出一個元素
     *
     * @param key
     * @return
     */
    public String lPop(String key) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                if (connection.lLen(key.getBytes()) > 0) {
                    return new String(connection.lPop(key.getBytes()));
                } else {
                    return EmptyString;
                }
            }
        });
    }

    /**
     * 向list的右側(cè)插入一個元素
     *
     * @param key
     * @param value
     * @return
     */
    public Long rPush(String key, String value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.rPush(key.getBytes(), value.getBytes());
            }
        });
    }

    /**
     * list的rpush，從右側(cè)插入多個元素
     *
     * @param key
     * @param values
     * @return
     */
    public Long rPush(String key, List values) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                List bytes = stringListToByte(values);
                return connection.rPush(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
            }
        });
    }

    /**
     * 從list的右側(cè)取出一個元素
     *
     * @param key
     * @return
     */
    public String rPop(String key) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                if (connection.lLen(key.getBytes()) > 0) {
                    return new String(connection.rPop(key.getBytes()));
                } else {
                    return EmptyString;
                }
            }
        });
    }

    /**
     * 給set中添加元素
     *
     * @param key
     * @param values
     * @return
     */
    public Long sadd(String key, List values) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                List bytes = stringListToByte(values);
                return connection.sAdd(key.getBytes(), bytes.toArray(new byte[bytes.size()][bytes.size()]));
            }
        });
    }

    /**
     * 獲取set中的所有元素
     *
     * @param key
     * @return
     */
    public List smembers(String key) {
        return jtRedis.execute(new RedisCallback>() {
            @Override
            public List doInRedis(RedisConnection connection) throws DataAccessException {
                return bytesListToString(connection.sMembers(key.getBytes()));
            }
        });
    }

    /**
     * set中是否包含某元素
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean sIsMember(String key, String value) {
        return jtRedis.execute(new RedisCallback() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.sIsMember(key.getBytes(), value.getBytes());
            }
        });
    }

    private byte[][] change(List values) {
        byte[][] result = {};
        return result;
    }

    private List stringListToByte(List values) {
        return values
                .stream()
                .map(p -> p.getBytes())
                .collect(
                        Collectors.toList()
                );
    }

    private List bytesListToString(Collection values) {
        return values
                .stream()
                .map(p -> new String(p))
                .collect(
                        Collectors.toList()
                );
    }

    private Map bytesMapToString(Map values) {
        Map result = new HashMap<>();
        values.forEach((k, v) -> result.put(new String(k), new String(v)));
        return result;
    }

    private Map stringObjectMapToBytes(Map values) {
        Map result = new HashMap<>();
        values.forEach((k, v) -> result.put(k.getBytes(), String.valueOf(v).getBytes()));
        return result;
    }

    /**
     * 正則表達式獲取值
     *
     * @param pattern
     * @return
     */
    public Set keys(String pattern) {
        return jtRedis.keys(pattern);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        RedisSerializer stringSerializer = new StringRedisSerializer();
        jtRedis.setKeySerializer(stringSerializer);
        jtRedis.setValueSerializer(stringSerializer);
        jtRedis.setHashKeySerializer(stringSerializer);
        jtRedis.setHashValueSerializer(stringSerializer);
    }
}

配置文件

配置文件主要有兩個，一個是spirng相關(guān)配置的配置文件applicationContext-redis.xml，還有一個是redis相關(guān)配置文件redis-config.properties
applicationContext-redis.xml配置文件內(nèi)容如下：

redis-config.properties配置文件內(nèi)容如下：

#裝有redis數(shù)據(jù)庫的虛擬機中的一臺機器的ip
redis.host=127.0.0.1
redis.port=6379
redis.pass=
#默認存儲在databse[0]數(shù)據(jù)庫, redis的database相當于一個數(shù)據(jù),默認也是0
redis.database=0
#maxIdle:最大空閑數(shù)
redis.maxIdle=300
#maxWait:最大等待時長,3秒
redis.maxWait=3000
#testOnBorrow：在提取一個jedis實例時，是否提前進行驗證操作；如果為true，則得到的jedis實例均是可用的；
redis.testOnBorrow=true

結(jié)語

雖然代碼篇幅有點長，但是都是基于spring封裝之后的再次封裝，大家應(yīng)該都能理解。并且以上方法我都有測試過，親測可用，因為測試代碼也比較的簡單，因此就不貼出來了。最后，歡迎大家補充、批評、指正。

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/75182.html

發(fā)表評論

登陸后可評論

0條評論

Imfan

男|高級講師

我要關(guān)注我要私信

TA的文章

【親測非常好用】勤哲 Excel 服務(wù)器2007 V13.0.144 最好用穩(wěn)定版本，帶注冊，無限用

閱讀 2385·2021-11-15 11:37
一文學會 - Fiddler抓包快速實戰(zhàn)

閱讀 2637·2021-09-23 11:21
阿里云老用戶爆款特惠活動：阿里云服務(wù)器購買優(yōu)惠老用戶首臺3.5折

閱讀 2967·2021-09-07 10:11
前端每日實戰(zhàn)：61# 視頻演示如何用純 CSS 創(chuàng)作一只咖啡壺

閱讀 3174·2019-08-30 15:53
原生css變量聲明

閱讀 2834·2019-08-29 15:13
前端小知識10點（2019.5.28）

閱讀 1618·2019-08-26 13:57
js的那些騷操作

閱讀 1111·2019-08-26 12:23
我們不一樣：for...of與for...in

閱讀 2450·2019-08-26 11:51

成人国产在线小视频_日韩寡妇人妻调教在线播放_色成人www永久在线观看_2018国产精品久久_亚洲欧美高清在线30p_亚洲少妇综合一区_黄色在线播放国产_亚洲另类技巧小说校园_国产主播xx日韩_a级毛片在线免费

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Redis基本操作之Java實現(xiàn)(所有類型)

相關(guān)文章

Java基礎(chǔ)知識整理之操作Redis（三）

**面試中關(guān)于Redis的問題看這篇就夠了**

發(fā)表評論

0條評論

Imfan

男|高級講師

TA的文章

【親測非常好用】勤哲 Excel 服務(wù)器2007 V13.0.144 最好用穩(wěn)定版本，帶注冊，無限用

一文學會 - Fiddler抓包快速實戰(zhàn)

阿里云老用戶爆款特惠活動：阿里云服務(wù)器購買優(yōu)惠老用戶首臺3.5折

前端每日實戰(zhàn)：61# 視頻演示如何用純 CSS 創(chuàng)作一只咖啡壺

原生css變量聲明

前端小知識10點（2019.5.28）

js的那些騷操作

我們不一樣：for...of與for...in

最新活動

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

Redis基本操作之Java實現(xiàn)(所有類型)

相關(guān)文章

發(fā)表評論

0條評論

男|高級講師

TA的文章

最新活動

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！