Redis 存值，序列化与反序列化

Redis 使用

准备环境：打开虚拟机，ip addr 查看IP地址，关闭防火墙

finashell远程连接，打开redis的src目录下，./redis-server …/redis-conf打开服务

再打开另外的窗口，./redis-cli远程连接，

#查看Linux进程
ps -ef | grep redis
#结束进程
kill -9 对应的进程编号

利用反射Redis存值

标记那些对象可以存储在redis中，新建一个接口，让想要存进redis的对象实现这个接口，这样就可以区分那些对象是想要存进redis的了

 public static void hashSetAdd(RedisObject object) throws InvocationTargetException, IllegalAccessException {
        Jedis jedis = new Jedis("192.168.128.129");
        //验证密码
        jedis.auth("123456");
        //获取反射类的类型
        Class<? extends RedisObject> objectClass = object.getClass();
        //获取本类中的所有的get方法
        Method[] methods = objectClass.getDeclaredMethods();
        for (Method method : methods) {
            String methodName = method.getName();
            //只需要get开头的
            if (methodName.startsWith("get")){
                //从第三个开始取值
                String field = methodName.substring(3);
                //get方法的值
                Object value = method.invoke(object);
                //把值存进Redis中
                jedis.hset(objectClass.getName(),field,value.toString());
            }
        }
        //验证连接
//        jedis.ping();
        jedis.close();
 }

    public static void main( String[] args ) throws InvocationTargetException, IllegalAccessException {
        //设置想要存储的对象的值
        User user = new User(1,"xiongjing",18);
        hashSetAdd(user);

    }

finaShell运行结果：

127.0.0.1:6379> keys *
1) "name"
2) "menuList"
3) "userList"
4) "com.layjava.bean.User"
5) "userSet"
127.0.0.1:6379> HGETAll com.layjava.bean.User
1) "Name"
2) "xiongjing"
3) "Age"
4) "18"
5) "UserId"
6) "1"

首字母变为小写的方法

/**
     * 首字母小写
     * @param string
     * @return
     */
    public static String firstLowerCase(String string){
        Character c = string.charAt(0);
        return string.replaceFirst(c.toString(), c.toString().toLowerCase());
    }

序列化与反序列化

序列化：将对象转换成二进制（字节数组）的过程，（把对象转化成二进制后，可以存储在任何地方）

反序列化：将二进制转换（字节数组）转化成对象的过程（存储起来肯定要去用，这就是反序列化）

package org.example;

import com.layjava.bean.User;
import redis.clients.jedis.Jedis;

import java.io.*;

/**
 * @description: 序列化和反序列化
 * @program: 2020.4.21RedisDemo
 * @author: Ldr
 * @date: 2020-06-03 07:08
 **/
public class RedisDemo {

    private byte[] serialize;

    /**
     * 序列化
     * @param object 将一个对象转化成一个二进制（字节数组）
     * @return 数组
     */
    public static byte[] serialize(Object object){
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
            //将对象写入到对象输出流中
            objectOutputStream.writeObject(object);
            //将对象转换成字节数组
            return outputStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 反序列化
     * @param bytes 将字节数组转换成对象
     * @return 对象
     */
    public static Object unSerialize(byte[] bytes){
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
        try {
            ObjectInputStream objectInputStream = new ObjectInputStream(inputStream);
            //将字节数组读取入输入流中
            return objectInputStream.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }


    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.128.129");
        jedis.auth("123456");

        //序列化：将对象转换成二进制（字节数组）的过程
//        User user = new User(1,"liangxiong",45);
//        byte[] serialize = serialize(user);
//        //可以在这里存储文件，存储到内存
//        jedis.set((user.getUserId()+"").getBytes(),serialize);
        //反序列化：将二进制（字节数组）转化成对象的过程
//        User unSerialize = (User) unSerialize(serialize);

        byte[] bytes = jedis.get("1".getBytes());
        //反序列化
        User value = (User) unSerialize(bytes);
        System.out.println(value.getName());
    }
}