java代码操作Redis数据库

最新推荐文章于 2024-04-28 17:09:48 发布

chen_jia_hao

最新推荐文章于 2024-04-28 17:09:48 发布

阅读量2.9k

点赞数 1

分类专栏： Redis

本文链接：https://blog.csdn.net/chen_jia_hao/article/details/76162555

版权

Redis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

Redis 是一个基于内存高性能的key-value数据库。

先学习用命令操作Redis数据，再来写java代码操作，先用命令的方式做下，然后使用该Redis 提供api方式操作一下会更能容易理解。

学习地址：

【1】http://www.yiibai.com/redis/redis_quick_guide.html

【2】http://www.redis.cn/

【3】 http://www.runoob.com/redis/redis-tutorial.html

【4】http://www.redis.net.cn/

一、使用jedis操作redis数据库

所需jar包：

commons-pool-2.4.2.jar（因为我这里使用了连接池）

jedis-2.9.0.jar（操作Redis数据库所需jar包。）

junit-4.12.jar（我这里使用了单元测试，所以添加了这个jar包）

我这里用了Maven

在POM.xml配置里面添加依赖jar包配置：

<dependencies>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>2.4.2</version>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.9.0</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
        </dependencies>

【1】工具类：

package com.cjh.redis.utils;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Created by 陈嘉豪 on 2017/7/26.
 */
public class RedisUtils {
    private static String HOST = "127.0.0.1";
    private static int PORT = 6379;
    private static int TIMEOUT = 10000;
    private static String PASSWORD = "123456";
    //连接耗尽时是否阻塞，false报异常，true阻塞直到超时（默认） 
    private static boolean isBlock = true;
    private static JedisPool jedisPool = null;

    static {
        // 使用连接池 
        // 【2】创建JedisPool所需的连接池配置 
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //最大连接数，默认8 
        poolConfig.setMaxTotal(1024);
        // 最大空闲数,默认8 
        poolConfig.setMaxIdle(200);
        // 最小空闲连接数，默认0
        poolConfig.setMinIdle(0);
        // 对象最小空闲时间，默认1800000毫秒(30分钟) 
        poolConfig.setMinEvictableIdleTimeMillis(1800000);
        // 获取连接的最大等待毫秒数。如果设为小于0，则永远等待
        poolConfig.setMaxWaitMillis(-1);
        // 在创建对象时检测对象是否有效，true是，默认值是false
        poolConfig.setTestOnCreate(true);
        //从对象池获取对象时检测对象是否有效，默认false
        poolConfig.setTestOnBorrow(true);
        //在向对象池中归还对象时是否检测对象有效，true是，默认值是false
        poolConfig.setTestOnReturn(false);
        //在检测空闲对象线程检测到对象不需要移除时，是否检测对象的有效性。true是，默认值是false
        poolConfig.setTestWhileIdle(false);
        //检测空闲对象线程每次检测的空闲对象的数量。默认值是3；如果这个值小于0,则每次检测的空闲对象数量等于当前空闲对象数量除以这个值的绝对值，并对结果向上取整 
        poolConfig.setNumTestsPerEvictionRun(3);
        //是否启用后进先出, 默认true 
        poolConfig.setLifo(true);
        //多长时候执行一次空闲对象检测。单位是毫秒数。如果小于等于0，则不执行检测线程。默认值是-1 
        poolConfig.setTimeBetweenEvictionRunsMillis(-1);
        //当对象池没有空闲对象时，新的获取对象的请求是否阻塞。true阻塞。默认值是true; 
        poolConfig.setBlockWhenExhausted(true);
        //是否启用pool的jmx管理功能, 默认true 
        poolConfig.setJmxEnabled(true);
        //【1】创建JedisPool连接池 
        jedisPool = new JedisPool(poolConfig, HOST, PORT, TIMEOUT, PASSWORD);
    }

    /**
     * 同步获取Jedis
     *
     * @return
     */
    public synchronized static Jedis getJedis() {
        if (jedisPool != null) {
            //获取Jedis对象 
            Jedis jedis = jedisPool.getResource();
            return jedis;
        }
        return null;
    }

    /**
     * 释放jedis资源
     */
    public static void releaseResource(Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
}

【2】测试类

package com.cjh.redis.test;

import com.cjh.redis.utils.RedisUtils;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class RedisTest {
    private Jedis jedis;

    public static void main(String[] args) {
    }

    /**
     * 连接redis服务
     */
    @Test
    public void connectionRedis() {
        //连接本地的Redis服务 
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        // 如果有密码，则需要下面权限认证
        jedis.auth("123456");
        System.out.println("连接成功！");
        // 查看服务是否运行 
        System.out.println("服务正在运行：" + jedis.ping());
    }

    @Before
    public void getJedis() {
        jedis = RedisUtils.getJedis();
    }

    /**
     * 测试Redis存储String
     */
    @Test
    public void testString() {
        jedis.set("name", "爱华");
        System.out.println(jedis.get("name"));
        jedis.append("name", "，嘉豪");
        System.out.print(jedis.get("name"));
        // 存储多个键值 
        jedis.mset("name", "爱华", "age", "20");
        jedis.incr("age");
        System.out.println(jedis.get("name") + "," + jedis.get("age"));
        jedis.del("name", "age");
        System.out.println(jedis.get("name") + "," + jedis.get("age"));
    }

    /**
     * 测试redis存储List
     */
    @Test
    public void testList() {
        jedis.del("lists");
        // 在头部添加 
        jedis.lpush("lists", "o1", "o2");
        // 第一个是key，第二个参数是起始位置，第三个是结束位置,-1表示全部输出
        System.out.println(jedis.lrange("lists", 0, -1));
        jedis.del("lists");
        // 在尾部后添加
        jedis.rpush("lists", "o1", "o2");
        System.out.println(jedis.lrange("lists", 0, -1));
    }

    /**
     * 测试Redis存储Set
     */
    @Test
    public void testSet_() {
        jedis.sadd("users", "爱华");
        jedis.sadd("users", "嘉豪");
        // 全部输出set集合中的元素 
        System.out.println(jedis.smembers("users"));
        // 判断是否是set集合中的元素 
        System.out.println(jedis.sismember("users", "嘉豪"));
        // 获取set集合中元素的总数目 
        System.out.println(jedis.scard("users"));
        // 随机获取set集合中的元素 
        System.out.println(jedis.srandmember("users"));
        jedis.del("users");
    }

    /**
     * 测试Redis存储Map（Hash）
     */
    @Test
    public void testMap() {
        Map<String, String> map = new HashMap<>();
        map.put("name", "嘉豪");
        map.put("name2", "爱华");
        jedis.hmset("person", map);
        Iterator<String> iterator = jedis.hkeys("person").iterator();
        while (iterator.hasNext()) {
            System.out.println(jedis.hmget("person", iterator.next()));
        }
        jedis.del("person");
    }

    /**
     * 测试List排序
     */
    @Test
    public void testListSort() {
        this.jedis.del("array");
        this.jedis.rpush("array", "88");
        this.jedis.rpush("array", "56");
        this.jedis.rpush("array", "1");
        this.jedis.rpush("array", "2");

        System.out.println(this.jedis.lrange("array", 0, -1));
        this.jedis.sort("array");
        System.out.println(this.jedis.lrange("array", 0, -1));
        this.jedis.del("array");
    }
}

最后测试的时候，首先开启Redis服务端，再进行测试。Redis的密码也要注意，简单的操作就到这里了。

二、spring-data-redis操作redis数据库

在导入spring基础包之上加入下面依赖：（注意spring-data-redis版本）

<!-- 整合spring-date-redis https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>

示例如下：

1、maven依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>
        <artifactId>cjh-root</artifactId>
        <groupId>xyz.chen-jia-hao</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-data-redis-demo</artifactId>
    <version>1.0</version>
    <packaging>war</packaging>

    <name>spring-data-redis-demo</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- spring版本号 -->
        <spring.version>4.2.4.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <!--<scope>test</scope>-->
        </dependency>

        <!-- 整合Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.10</version>
        </dependency>

        <!-- 整合spring-date-redis https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.7.2.RELEASE</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>spring-data-redis-demo</finalName>
        <sourceDirectory>src/main/java</sourceDirectory>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <outputDirectory>src/main/webapp/WEB-INF/classes</outputDirectory>
    </build>

</project>

2、spring配置文件中配置spring-data-redis相关配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/cache
            http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!--
    注意：SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
    redis 序列化策略 ，通常情况下key值采用String序列化策略，
    如果不指定序列化策略，StringRedisTemplate的key和value都将采用String序列化策略。
    但是RedisTemplate的key和value都将采用JDK序列化，这样就会出现采用不同template保存的数据序列化方式不一致出现问题 -->

    <!--redisTemplate 模板，访问redis数据库-->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="hashKeySerializer" ref="stringRedisSerializer" />
        <property name="valueSerializer" ref="stringRedisSerializer"/>
    </bean>

    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="localhost"></property>
        <property name="port" value="6379"></property>
        <property name="password" value="123456"></property>
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>

    <!-- redis连接池配置相关配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="10"/>
    </bean>

    <bean id="stringRedisSerializer"  class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</beans>

注意：

spring-data-redis默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
redis 序列化策略，通常情况下key值采用String序列化策略，
如果不指定序列化策略，StringRedisTemplate的key和value都将采用String序列化策略。
但是RedisTemplate的key和value都将采用JDK序列化，这样就会出现采用不同template保存的数据序列化方式不一致。

3、测试代码，验证效果

package com.cjh.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * spring-data-redis 操作redis
 * @author chen jia hao
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:config/spring-redis.xml"})
public class RedisTest {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    /**
     * 保存字符串
     */
    @Test
    public void setVlaue(){

        redisTemplate.boundValueOps("name").set("cjh");
        System.out.println( redisTemplate.boundValueOps("name").get() );

        redisTemplate.delete("name");
        System.out.println( redisTemplate.boundValueOps("name").get() );
    }

    /**
     * 保存列表
     */
    @Test
    public void setList(){

        redisTemplate.boundListOps("list").leftPush("cjh1");
        redisTemplate.boundListOps("list").leftPush("cjh2");
        redisTemplate.boundListOps("list").rightPush("cjh3");

        List<String> list = redisTemplate.boundListOps("list").range(0, -1);
        list.stream().forEach(item->{
            System.out.println(item);
        });

        redisTemplate.delete("list");
    }

    /**
     * 保存哈希
     */
    @Test
    public void setHash(){

        Map<String, Object> data = new HashMap<>();
        data.put("key1","ccc");
        data.put("key2","bbb");
        redisTemplate.boundHashOps("hash").putAll(data);

        Map<Object, Object> hash = redisTemplate.boundHashOps("hash").entries();
        for(Map.Entry item:hash.entrySet()){
            System.out.println(item.getKey()+":"+item.getValue());
        }

        redisTemplate.delete("hash");
    }

    /**
     * 保存有序集合
     */
    @Test
    public void setSortedSet(){

        redisTemplate.boundZSetOps("rank").add("name1",90.0);
        redisTemplate.boundZSetOps("rank").add("name2",100.0);
        redisTemplate.boundZSetOps("rank").add("name3",70.0);

        Set<String> rank = redisTemplate.boundZSetOps("rank").reverseRange(0, -1);
        rank.stream().forEach(item->{
            System.out.println(item);
        });

        redisTemplate.delete("rank");
    }
}

spring缓存：spring-cache学习地址

chen_jia_hao

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
java代码操作Redis数据库

Redis 是一个基于内存高性能的key-value数据库。先学习用命令操作Redis数据，再来写java代码操作，先用命令的方式做下，然后使用该Redis 提供api方式操作一下会更能容易理解。学习地址：【1】http://www.yiibai.com/redis/redis_quick_guide.html【2】http://www.redis.cn/【3】 http://...
复制链接

扫一扫