Redis客户端操作之Jedis-蒲公英云

Jedis

Jedis Client是Redis官网推荐的一个面向java客户端，库文件实现了对redis各类API进行封装调用,通过这些API我们会非常方便的操作我们的Redis数据库。

redis配置文件地修改

1.注释掉绑定地信息

在redis.conf的配置文件中bind配置的信息表示的是redis服务可以接收外部访问的地址，这个主要还是为了提高安全性，我们在学习阶段可以将这个信息直接注释掉，这样的话任意的外部ip地址都可以访问。bind是protected-mode配合使用的

bind 127.0.0.1

2.关闭保护模式

redis3.2版本后新增protected-mode配置，默认是yes，即开启。设置外部网络连接redis服务，设置方式如下：
1、关闭protected-mode模式，此时外部网络可以直接访问
2、开启protected-mode保护模式，需配置bind ip或者设置访问密码

创建项目

添加依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>3.8.1</version>
</dependency>

redis单机版

案例代码：

/**
     * 测试是否连接成功
     */
    public void ping(){
        Jedis jedis = new Jedis("192.168.119.12", 6379);
        System.out.println(jedis.ping());
    }
    /**
     * 设置key/value对
     */
    public void set(){
        Jedis jedis = new Jedis("192.168.119.12", 6379);
        jedis.set("name", "張三");
        jedis.set("age", "18");
        jedis.close();
    }
    /**
     * 通过key获取对应的value
     */
    public void get(){
        Jedis jedis = new Jedis("192.168.119.12", 6379);
        String name = jedis.get("name");
        String age = jedis.get("age");
        System.out.println(name+"--"+age);
        jedis.close();
    }
    /**
     * 通过Jedis的连接池Pool
     */
    public void testJedisPool() {
        // 创建Jedis连接池
        JedisPool pool = new JedisPool("192.168.119.12", 6379);
        // 从连接池中获取Jedis对象
        Jedis jedisItem = pool.getResource();
        String name = jedisItem.get("name");
        System.out.println(name);
        jedisItem.close();
        pool.close();
    }
    /**
     * 操作incr方法自增1
     */
    public void incr(){
        Jedis jedis = new Jedis("192.168.119.12", 6379);
        Long age = jedis.incr("age");
        System.out.println(age);
    }

redis数据
在这里插入图片描述
控制台输出

Jedis整合Spring

添加依赖

<dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.3.RELEASE</version>
        </dependency>
    </dependencies>

Redis单机环境【Spring地配置文件】

<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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    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-4.3.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
        <context:component-scan base-package="com.sxt.dao.impl"></context:component-scan>
        <!-- 连接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大连接数 -->
        <property name="maxTotal" value="30" />
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="10" />
        <!-- 每次释放连接的最大数目 -->
        <property name="numTestsPerEvictionRun" value="1024" />
        <!-- 释放连接的扫描间隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="30000" />
        <!-- 连接最小空闲时间 -->
        <property name="minEvictableIdleTimeMillis" value="1800000" />
        <!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
        <property name="softMinEvictableIdleTimeMillis" value="10000" />
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="1500" />
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="false" />
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="false" />
        <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted" value="false" />
    </bean>
    <!-- jedis客户端单机版 -->
    <bean id="redisClient" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="host" value="192.168.119.12"></constructor-arg>
        <constructor-arg name="port" value="6379"></constructor-arg>
        <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
    </bean>
</beans>

定义user对象

package com.sxt.bean;
public class User {
    private Integer id;
    private String username;
    private String password;
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

定义接口和实现类

dao层

package com.sxt.dao;
import java.util.List;
import com.sxt.bean.User;
public interface UserDao {
    //查询方法
    public List<User> query(User user);
    //添加方法
    public int add(User user);
    //删除方法·
    public int delete(Integer id);
    //更新数据
    public int update(Integer id);
}

dao层实现类

package com.sxt.dao.impl;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.sxt.bean.User;
import com.sxt.dao.UserDao;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
@Service
public class UserDaoImpl implements UserDao{
    @Resource
    private JedisPool jedis1;
    private Jedis jedis;
    @Override
    public List<User> query(User user) {
        jedis = jedis1.getResource();//从连接池获取jedis对象
         Set<String> set = jedis.keys("user:*");
        List<User> list= new ArrayList<>();
        for (String key : set) {
            User user2 = new User();
            String hget = jedis.hget(key, "id");
            String hget2 = jedis.hget(key,"username");
            String hget3 = jedis.hget(key,"password");
            user2.setId(Integer.parseInt(hget));
            user2.setUsername(hget2);
            user2.setPassword(hget3);
            list.add(user2);
        }
        return list;
    }
    @Override
    public int add(User user) {    
        jedis = jedis1.getResource();
        jedis.hset("user:"+user.getId(), "username", user.getUsername());
        jedis.hset("user:"+user.getId(), "id",user.getId()+"");
        jedis.hset("user:"+user.getId(), "password", user.getPassword());
        return 0;
    }
    @Override
    public int delete(Integer id) {
        jedis = jedis1.getResource();
        jedis.del("user:"+id);
        return 0;
    }
    @Override
    public int update(Integer id) {
        jedis = jedis1.getResource();
        Map<String,String> map = new HashMap<>();
        map.put("username", "zhangsan");
        map.put("id", 1+"");
        map.put("password", "321");
        jedis.hmset("user:"+id, map);
        return 0;
    }
}

测试

package com.sxt;
import java.util.List;
import org.junit.Before;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.sxt.bean.User;
import com.sxt.dao.UserDao;
public class Test {
    private UserDao dao;
    @org.junit.Test
    @Before
    public void test() {
                ApplicationContext ac = new ClassPathXmlApplicationContext("application.xml");
                 dao = ac.getBean(UserDao.class);
    }
    //查询
    @org.junit.Test
    public void test1(){
        User user = new User();
        List<User> list = dao.query(user);
        System.out.println(list);
    }
    //添加
    @org.junit.Test
    public void test2(){
        User user = new User();
        user.setId(2);
        user.setUsername("lisi");
        user.setPassword("321");
        dao.add(user);
    }
    //删除
    @org.junit.Test
    public void test3(){
        dao.delete(2);
    }
    //更新
    @org.junit.Test
    public void test4(){
        dao.update(1);
    }
}