java对redis的常规存储操作示例

1.首先建立redis的连接池操作工具类，代码如下：

package com.zgj.redis.util;

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

/**
 * 该类是用于连接redis的工具类
 */
public class RedisUtil {

    private static  String ADDR = "localhost";

    private static int PORT = 6379;

    //连接实例的最大连接数
    private static int MAX_ACTIVE = 1024;

    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;

    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException
    private static int MAX_WAIT = 10000;

    //连接超时的时间　　
    private static int TIMEOUT = 10000;

    // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;

    private static JedisPool jedisPool = null;

    /**
     * 初始化连接池
     */
    static{
        try {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(MAX_ACTIVE);
            jedisPoolConfig.setMaxIdle(MAX_IDLE);
            jedisPoolConfig.setMaxWaitMillis(MAX_WAIT);
            jedisPoolConfig.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(jedisPoolConfig,ADDR,PORT,TIMEOUT);
            System.out.println("连接池初始化成功.....");
        }catch (Exception e){
            System.out.println("连接池初始化错误.....");
            e.printStackTrace();
        }
    }

    /**
     * 从连接池获取连接
     * @return
     */
    public synchronized static Jedis getJedis(){
        try{
            if(jedisPool != null){
                Jedis jedis = jedisPool.getResource();
                return jedis;
            }else{
                return null;
            }
        }catch (Exception e){
            System.out.println("获取redis连接实例失败.....");
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 释放连接
     */
    public static void releaseResource(final Jedis jedis){
        if(jedis != null){
            jedisPool.returnResource(jedis);
            System.out.println("连接已释放....");
        }
    }
}

2.创建序列化对象操作类，代码如下：

package com.zgj.redis.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 序列化和反序列化对象操作类
 */
public class SerializeUtil {
    /**
     * 将对象序列化成字节数组
     * @param object 待序列化对象
     * @return byte[]
     */
    public static byte[] serializeObject(Object object){
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try{
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] res = baos.toByteArray();
            return res;
        }catch (Exception e){
            System.out.println("序列化对象异常.....");
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 反序列化对象
     * @param array 序列化后的字节数组
     * @return Object
     */
    public static Object unserializeObject(byte[] array){
        ByteArrayInputStream bais = null;
        try{
            bais = new ByteArrayInputStream(array);
            ObjectInputStream ois = new ObjectInputStream(bais);
            Object object = ois.readObject();
            return object;
        }catch (Exception e){
            System.out.println("反序列化对象异常......");
            e.printStackTrace();
            return null;
        }
    }
}

3.创建user实体类，代码如下：

package com.zgj.redis.bean;

import lombok.AllArgsConstructor;
import lombok.Data;

import java.io.Serializable;

@Data
@AllArgsConstructor
public class User implements Serializable {
    private String name;
    private String password;
    private int age;
}

3.创建redis操作数据类，代码如下：

package com.zgj.redis.dao;

import com.zgj.redis.bean.User;
import com.zgj.redis.util.RedisUtil;
import com.zgj.redis.util.SerializeUtil;
import redis.clients.jedis.Jedis;

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

public class RedisMapper {

    private Jedis jedis;

    private Scanner scanner = new Scanner(System.in);

    /**
     * 连接redis服务器
     */
    public void connectRedis(){
        jedis = RedisUtil.getJedis();
        System.out.println("连接建立成功....");
    }

    /**
     * 操作字符串
     * @param action
     */
    public void doString(String action){
        String key;
        String value;
        switch (action){
            case "add":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                System.out.println("请输入值：");
                value = scanner.nextLine();
                jedis.set(key,value);
                System.out.println("添加成功.....");
                break;

            case "append":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                System.out.println("请输入值：");
                value = scanner.nextLine();
                jedis.append(key,value);
                System.out.println("拼接成功.....");
                break;
            case "delete":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                jedis.del(key);
                System.out.println("删除成功.....");
                break;
            case "update":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                System.out.println("请输入新的值：");
                value = scanner.nextLine();
                jedis.set(key,value);
                System.out.println("修改成功.....");
                break;
            case "select":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                System.out.println("查询成功，值是："+jedis.get(key));
                break;
            default:
                System.out.println("选择无效.....");
                break;
        }
    }

    /**
     * 操作map
     * @param action
     */
    public void doMap(String action){
        String key;
        String value;
        Map<String,String> map = new HashMap<>();
        map.put("name","zgj");
        map.put("password","zgjzzm");
        switch (action){
            case "add":
                jedis.hmset("user",map);
                System.out.println("添加成功.....");
                break;
            case "delete":
                jedis.hdel("user","name","password");
                System.out.println("删除成功.....");
                break;
            case "update":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                System.out.println("请输入新的值：");
                value = scanner.nextLine();
                map.put(key,value);
                jedis.hmset("user",map);
                System.out.println("修改成功.....");
                break;
            case "select":
                List<String> rsmap = jedis.hmget("user", "name","password");
                System.out.println("查询成功，值是：");
                System.out.println(rsmap);
                break;
            default:
                System.out.println("选择无效.....");
                break;
        }
    }

    public void doList(String action){
        String key = "list";
        String value;
        switch (action){
            case "add":
                System.out.println("请输入值：");
                value = scanner.nextLine();
                jedis.lpush(key,value);
                System.out.println("添加成功.....");
                break;
            case "delete":
                System.out.println("请输入需要删除的值：");
                value = scanner.next();
                jedis.lrem(key,0,value);
                System.out.println("删除成功.....");
                break;
            case "update":
                System.out.println("请输入索引值：");
                int index = scanner.nextInt();
                System.out.println("请输入新的值：");
                value = scanner.next();
                jedis.lset(key,index,value);
                System.out.println("修改成功.....");
                break;
            case "select":
                System.out.println("查询成功，值是：");
                System.out.println(jedis.lrange(key,0,-1));
                break;
            default:
                System.out.println("选择无效.....");
                break;
        }
    }

    /**
     * redis操作对象
     */
    public void doObject(String action){
        String key;
        User value = new User("zgj","123456",23);
        switch (action){
            case "add":
                System.out.println("请输入键：");
                key = scanner.nextLine();
                jedis.set(key.getBytes(), SerializeUtil.serializeObject(value));
                System.out.println("添加成功.....");
                break;
            case "delete":
                System.out.println("请输入需要删除的键：");
                key = scanner.next();
                jedis.del(key.getBytes());
                System.out.println("删除成功.....");
                break;
            case "select":
                System.out.println("请输入需要查询的键：");
                key = scanner.nextLine();
                byte[] res = jedis.get(key.getBytes());
                User user = (User)SerializeUtil.unserializeObject(res);
                System.out.println("查询成功，数据如下:\n"+user.toString());
                break;
            default:
                System.out.println("选择无效.....");
                break;
        }
    }
    /**
     * 释放连接
     */
    public void realseResource(){
        if(jedis != null){
            RedisUtil.releaseResource(jedis);
        }
    }
}

4.创建测试类，代码如下：

package com.zgj.redis.controller;

import com.zgj.redis.dao.RedisMapper;

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        RedisMapper redis = new RedisMapper();
        redis.connectRedis();
        String action ;
        while(true){
            action = scan.nextLine();
            redis.doObject(action);
        }
    }
}

5.部分运行结果插图：

6.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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zgj.redis.learn</groupId>
    <artifactId>redis_java</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.5.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>