Java操作Redis数据库的学习

点击跳转>>>>>>>>Redis在Linux环境下的学习
根据上篇博客，我们可以使用Linux环境下对Redis进行操作了，但实际中我们肯定是需要使用java代码来进行操作的

概述：

Redis不仅是使用命令来操作，基本上主流编程语言都有自己的客户端（操作Redis的API）Java客户端：Jedis 、Redisson、 Jredis、 JDBC-Redis…官网上推荐使用Jedis和Redisson企业中使用的比较多的是Jedis学习使用的就是Jedis

准备工作：

• 设置Redis的远程连接ip 0.0.0.0
• 开放6379端口，重启防火墙这里的使用方式可以去看linux的相关教程
• 设置Redis的密码

第一步：创建Mvae项目，导入相关依赖

• 依赖包：

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
 <dependency>       
 <groupId>redis.clients</groupId>        
 <artifactId>jedis</artifactId>        
 <version>2.9.0</version>   
 </dependency>

第二步：创建测试类，进行单实例测试连接：

• 代码如下：

//传入端口号和ip地址
 Jedis jedis = new Jedis("192.168.184.129",6379);
 // 认证：指定密码        
 jedis.auth("123456");        
 // 使用jedis对象操作Redis        
 jedis.set("jedisDemo","Hello jedis!!!!");
 System.out.println(jedis.get("a"));        
 // 关闭连接，释放资源        
 jedis.close();

• 缺点：每次需要创建一个连接对象jedis

第二步：使用连接池对象获取jedis对象，使用Spring容器管理

• 使用spring来配置连接池：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大连接数 -->
        <property name="maxTotal" value="10"/>
        <!-- 空闲连接数 -->
        <property name="maxIdle" value="2"/>
        <!-- 设置链接池的连接耗尽时，是否等待 -->
        <property name="blockWhenExhausted" value="true"/>
        <!-- 最大等待时间 -->
        <property name="maxWaitMillis" value="30000"/>
        <!-- 获取到连接时，是否检查链接的有效性 -->
        <property name="testOnBorrow" value="true"/>
    </bean>

    <!--注入连接池对象:构造函数方式注入 -->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <!-- 池的属性 -->
        <constructor-arg name="poolConfig" ref="poolConfig"/>
        <!-- Redis主机地址 -->
        <constructor-arg name="host" value="192.168.179.129"/>
        <!-- Redis主机端口 -->
        <constructor-arg name="port" value="6379"/>
        <!-- Redis密码 -->
        <constructor-arg name="password" value="123456"/>
        <!-- 可以选择Redis数据库（要选择数据库，必须开启了密码） -->
        <constructor-arg name="database" value="2"/>
        <!-- 链接超时时间 -->
        <constructor-arg name="timeout" value="30000"/>
    </bean>
</beans>

• 使用注解：

• 获取Jedis对象，进行测试：

@Test
public void addRedis(){
    Jedis resource = jedisPool.getResource();
    Person person=new Person(111,"yi","男",24,new Date());
    resource.select(2);
    resource.auth("123456");
    resource.set("s1","chengxuyi");
    resource.hset("s2","name","lisi");
    resource.hset("s2","sex","男");
    resource.hset("s3",person.getName(),JsonUtils.objectToJson(person));
    resource.close();
    System.out.println("插入成功");
}



 

上面使用Java来操作Redis,那么接下来我们学习使用Redis存储Java对象(序列话操作)

• 定义序列化工具类

public class SerializeUtil {    
// 序列化    
// 将Java对象转换成字节数组    
// 将Java对象信息写入字节数组  
OutputStream    public static byte[] serialeze(Object object){        
// 对象输出流  将对象信息写入ByteArrayOutputStream        
ObjectOutputStream oos = null;        
// 存储对象信息        
ByteArrayOutputStream baos = null;        
byte[] bytes = null;        
try {            
baos = new ByteArrayOutputStream();            
oos = new ObjectOutputStream(baos);             
// 对象信息写入过程            
oos.writeObject(object);            
// 完成对象信息到字节数组的转换            
bytes = baos.toByteArray();        

} catch (IOException e) {            
e.printStackTrace();        
}        
return bytes;    
}

• 反序列化：

public static Object deserialeze(byte[] bytes) throws IOException,
 ClassNotFoundException {        
 ByteArrayInputStream bais = null;        
 ObjectInputStream ois = null;        
 try {            
 bais = new ByteArrayInputStream(bytes);            
 ois = new ObjectInputStream(bais);        
 } catch (IOException e) {            
 e.printStackTrace();        
 }        
 return ois.readObject();    
 }

• 使用方式：

存：jedis.set("p3".getBytes(),SerializeUtil.serialeze(person));
取：Person person = (Person) SerializeUtil.deserialeze(jedis.get("p3".getBytes()));

我们从Redis中获取数据如何转换为Json格式传递到前台呢？

第一种：使用第三方库

• Google：Gson阿里巴巴：FastJson存：将Java对象转换成Json数据，存储到Redis中取：将Json数据取出，转换成Java对象
• 导入依赖：

<!-- gson -->
<dependency>    
<groupId>com.google.code.gson</groupId>    
<artifactId>gson</artifactId>    
<version>2.8.5</version>
</dependency> 
<!-- fastjson -->
<dependency>    
<groupId>com.alibaba</groupId>    
<artifactId>fastjson</artifactId>    
<version>1.2.68</version>
</dependency>

• 存取数据：

使用Gson
//使用Gson将对象转换成Json串    
Gson gson = new Gson();    
String perJson = gson.toJson(person); 	
//使用Gson对象将json串转成Java对象
Person person1 = gson.fromJson(json,Person.class);

使用FastJson	
//使用FastJson将Java对象转换成Json串
String Json = JSON.toJSONString(person); 
//使用FastJson将Json串转成Java对象
Person person = JSON.parseObject(Json,Person.class);

使用工具类：

• 代码如下：

package com.offcn.utils;

import java.util.List;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;


public class JsonUtils {

    // 定义jackson对象
    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     * <p>Title: entityToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
       try {
         String string = MAPPER.writeValueAsString(data);
         return string;
      } catch (JsonProcessingException e) {
         e.printStackTrace();
      }
       return null;
    }
    
    /**
     * 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param clazz 对象中的object类型
     * @return
     */
    public static <T> T jsonToEntity(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
           e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成entity对象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
       JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
       try {
          List<T> list = MAPPER.readValue(jsonData, javaType);
          return list;
      } catch (Exception e) {
         e.printStackTrace();
      }
       
       return null;
    }
    
}