Redis可视化工具Web Redis Manager分分快三计划

作者:编程技术

三、开拓简单介绍

  上面根本是根据SAEA.Socket通讯框架中的SAEA.RedisSocket、SAEA.WebApi几个零部件来促成redis通讯、webserver以致仿asp.net mvc的敏捷风格的后端程序,web端使用的是layui ajax。项目源码结构:

  分分快三计划 1

 

Java Spring mvc 操作 Redis 及 Redis 集群,mvcredis

 本文原创,转发请申明:

至于 Redis 集群搭建能够参考小编的另一篇作品 Redis集群搭建与轻巧利用

Redis 是怎样,能做什么样

Redis 是二个开源(BSD许可),内部存款和储蓄器存款和储蓄的数据结构服务器,可用作数据库,高速缓存和信息队列代理。它帮助字符串、哈希表、列表、集结、有序聚焦,位图,hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以致不相同品级磁盘长久化功用,相同的时候经过Redis Sentinel 提供高可用,通过 Redis Cluster 提供自动分区。(摘自 Redis 官方网站)

用作内部存款和储蓄器数据库,在今世网络 web 系统中,依然注重将 Redis 作为缓存使用。大型互连网 Web 系统对质量需要非常高,而在前端和数据层之间增扩展少缓存已产生至关重要的手腕之一,当前比较流行的多少个技巧就是 Redis 和 Memcached,至于两岸有啥样差别,不是本文要说的开始和结果。本文首要讲 Java web 怎么样操作 Redis 及 Redis 集群。

日常 Java 程序操作Redis

Redis 提供了八种语言的顾客端,在 Java 中最流行的是 Jedis 。访谈可查阅源码及利用办法。方今 Jedis 最新版本是2.9.0。无论是单机还是集群,Jedis 都有很详细的求证和实例代码,这里只做轻易表明。假设用 Maven 做包管理,供给援用  jedis 包,本例使用最新的2.9.0本子,如下:

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

操作 Redis 单机

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

/**
 * Created by fengdezitai on 2016/10/9.
 */
public class JedisClient {

    private static final String host= "192.168.31.121";

    private static final JedisClient jedisClient = new JedisClient();

    private Jedis jedis = null;
    /**
     * 私有构造函数
     */
    private JedisClient(){}

    public static JedisClient getInstance(){
        return jedisClient;
    }

    private JedisPoolConfig getPoolConfig(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(10);
        jedisPoolConfig.setMaxTotal(100);
        jedisPoolConfig.setMaxWaitMillis(3000);
        return jedisPoolConfig;
    }

    /**
     * 添加
     * @param key
     * @param value
     * @return
     * @throws Exception
     */
    public Boolean add(String key,String value) throws Exception{
        JedisPool pool = new JedisPool(getPoolConfig(),host);
        Jedis jedis = null;
        try {
            jedis = pool.getResource();
            if(jedis.exists(key)){
                throw new Exception(String.format("key (%s) 已存在 ",key));
            }
            jedis.set(key,value);

        }catch (Exception e){
            throw e;
        }
        finally {
            if(jedis!=null){
                jedis.close();
            }
        }
        pool.destroy();
        return true;
    }

    /**
     * 获取值
     * @param key
     * @return
     * @throws Exception
     */
    public String get(String key) throws Exception{
        JedisPool pool = new JedisPool(getPoolConfig(),host);
        Jedis jedis = null;
        String result = "";
        try {
            jedis = pool.getResource();
            result = jedis.get(key);
        }catch (Exception e){
            throw e;
        }
        finally {
            if(jedis!=null){
                jedis.close();
            }
        }
        pool.destroy();
        return result;
    }

    public static void main(String[] args) {
        JedisClient jedisClient = JedisClient.getInstance();
        try {
            /*Boolean result = jedisClient.add("hello", "redis1");
            if(result){
                System.out.println("success");
            }*/

            System.out.println(jedisClient.get("hello"));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

操作 redis 集群

import redis.clients.jedis.*;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by fengdezitai on 2016/10/13.
 */
public class JedisClusterClient {

    private static int count = 0;

    private static final JedisClusterClient redisClusterClient = new JedisClusterClient();

    /**
     * 私有构造函数
     */
    private JedisClusterClient() {}

    public static JedisClusterClient getInstance() {
        return redisClusterClient;
    }

    private JedisPoolConfig getPoolConfig(){
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(1000);
        config.setMaxIdle(100);
        config.setTestOnBorrow(true);
        return config;
    }

    public void SaveRedisCluster() {
        Set<HostAndPort> jedisClusterNodes = new HashSet<HostAndPort>();
        jedisClusterNodes.add(new HostAndPort("192.168.31.245", 7000));
        jedisClusterNodes.add(new HostAndPort("192.168.31.245", 7001));
        jedisClusterNodes.add(new HostAndPort("192.168.31.245", 7002));
        jedisClusterNodes.add(new HostAndPort("192.168.31.210", 7003));
        jedisClusterNodes.add(new HostAndPort("192.168.31.210", 7004));
        jedisClusterNodes.add(new HostAndPort("192.168.31.210", 7005));

        JedisCluster jc = new JedisCluster(jedisClusterNodes,getPoolConfig());
        jc.set("cluster", "this is a redis cluster");
        String result = jc.get("cluster");
        System.out.println(result);
    }

    public static void main(String[] args) {
        JedisClusterClient jedisClusterClient = JedisClusterClient.getInstance();
        jedisClusterClient.SaveRedisCluster();
    }
}  

Spring mvc 操作 Redis

在 Spring mvc 中操作 Redis ,首先当然要搭好 Spring mvc 框架了。以下是在如果 Spring mvc 情形已经架好的情形下。本例中 Spring 版本为 4.3.2 RELEASE。关于 Spring 的 maven 援引如下:

<!-- spring版本号 -->
<spring.version>4.3.2.RELEASE</spring.version>

<!-- spring核心包 -->
    <!-- springframe start -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
      <exclusions>
        <exclusion>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>


    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- springframe end -->

操作 Redis 单机

只用 Jedis 自身达成注入(差别于上边包车型客车征引spring-data-redis) 

把前边的 JedisClient 代码拿过来引用就可以,只需兑现贰个走访 Redis 的 Service ,就能够融为一炉到 Spring mvc 。Service 代码如下:

import org.springframework.stereotype.Service;
import util.JedisClient;

/**
 * Created by fengdezitai on 2016/10/9.
 */
@Service
public class RedisService {

    public String get(String key) throws Exception{
        JedisClient jedisClient = JedisClient.getInstance(); //上面实现的JedisClient
        String result = "";
        try {
            result = jedisClient.get("hello");
        }catch (Exception e){
            throw e;
        }
        return result;
    }
}

Controller 完成如下:

@Controller
@RequestMapping(value = "redisAllInOne")
public class RedisAllInOneController {

    @Autowired
    private RedisService redisService;

    @RequestMapping(value = "get",method = RequestMethod.GET)
    @ResponseBody
    public Object getByMyService(String key){
        try {
            String result = redisService.get(key);
            return result;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }
}  

用 spring-data-redis 包做集成

上边是团结完成的注入,这里用 spring-data-redis 进行合併,只需轻易布署就能够,需求援引 maven 包如下,版本为当下流行版 1.7.2.RELEASE:

<dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.7.2.RELEASE</version>
    </dependency>

行使 spring-data-redis ,即省去了投机达成注入的长河,通过它提供的一些布署,就能够兑现连接池配置、RedisTemplate 配置、JedisConnectionFactory 配置;通过 JedisConnectionFactory 可安插连接池参数、redis 服务器、端口、密码、超时时间、database索引等;RedisTemplate 即注入的bean ,可以利用 RedisTemplate 自动注入的实业实行 redis 的一密密麻麻操作,具体看陈设;

redis 服务属性配置文件:

redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow=true
redis.host=192.168.31.121
redis.port=6379
redis.password=password
redis.timeout=3000

spring-data-redis xml 配置文件 redis-context.xml:

<!-- jedis 连接池 配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>
    <!-- redis服务器中心 -->
    <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
        <property name="poolConfig" ref="poolConfig" />
        <property name="port" value="${redis.port}" />
        <property name="hostName" value="${redis.host}" />
        <!--<property name="password" value="${redis.password}" />-->
        <property name="timeout" value="${redis.timeout}" ></property>
        <property name="database" value="1"></property>
    </bean>

    <bean id="commonRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="hashKeySerializer" ref="stringRedisSerializer" />
        <property name="valueSerializer" ref="stringRedisSerializer" />
        <property name="hashValueSerializer" ref="stringRedisSerializer" />
    </bean>

    <bean id="connectionFactory1"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
        <property name="poolConfig" ref="poolConfig" />
        <property name="port" value="${redis.port}" />
        <property name="hostName" value="${redis.host}" />
        <!--<property name="password" value="${redis.password}" />-->
        <property name="timeout" value="${redis.timeout}" ></property>
        <property name="database" value="2"></property>
    </bean>

    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    <bean id="cacheRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
        <property name="connectionFactory" ref="connectionFactory1" />
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="hashKeySerializer" ref="stringRedisSerializer" />
        <property name="valueSerializer" ref="stringRedisSerializer" />
        <property name="hashValueSerializer" ref="stringRedisSerializer" />
    </bean>

日后在 spring 配置文件中援用以上文件:

<import resource="redis-context.xml" />  

解释一下上边的配备:

poolConfig 即配置 redis 连接池,之后安插了几个 JedisConnectionFactory 和 RedisTemplate ,三个 RedisTemplate 对应一个 JedisConnectionFactory ,那样能够配备依据气象布局区别的 Redis 连接,举个例子超时时间供给分歧样、database 0-15 能够积累不一致的数量等。这里就安排了database 1 和 2 ,调用 commonRedisTemplate 会存到 database1 ,调用 cacheRedisTemplate 会存到 database2。

从此现在在 Service 层就能够注入并援引这七个 RedisTemplate ,如下代码:

import org.apache.commons.lang3.StringUtils;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import javax.annotation.Resource;
import java.io.*;

@Repository
public class RedisCache {
  
    @Resource(name = "cacheRedisTemplate")
    private RedisTemplate<String, String> cacheRedisTemplate;

    public void put(Object key, Object value) {
        if(null == value) {
            return;
        }

        if(value instanceof String) {
            if(StringUtils.isEmpty(value.toString())) {
                return;
            }
        }

        // TODO Auto-generated method stub
        final String keyf = key   "";
        final Object valuef = value;
        final long liveTime = 86400;

        cacheRedisTemplate.execute(new RedisCallback<Long>() {
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] keyb = keyf.getBytes();
                byte[] valueb = toByteArray(valuef);
                connection.set(keyb, valueb);
                if (liveTime > 0) {
                    connection.expire(keyb, liveTime);
                }
                return 1L;
            }
        });
    }

    public Object get(Object key) {
        final String keyf = (String) key;
        Object object;
        object = cacheRedisTemplate.execute(new RedisCallback<Object>() {
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {

                byte[] key = keyf.getBytes();
                byte[] value = connection.get(key);
                if (value == null) {
                    return null;
                }
                return toObject(value);

            }
        });

        return object;
    }

    /**
     * 描述 : <byte[]转Object>. <br>
     * <p>
     * <使用方法说明>
     * </p>
     *
     * @param bytes
     * @return
     */
    private Object toObject(byte[] bytes) {
        Object obj = null;
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bis);
            obj = ois.readObject();
            ois.close();
            bis.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        return obj;
    }

    private byte[] toByteArray(Object obj) {
        byte[] bytes = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            oos.flush();
            bytes = bos.toByteArray();
            oos.close();
            bos.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return bytes;
    }
}

最终在 Controller 中调用就可以

    @Autowired
    private RedisCache redisCache;


    @RequestMapping(value = "get", method = RequestMethod.GET)
    @ResponseBody
    public Object getByMyService(String key) {
        try {
            String result = redisService.get(key);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @RequestMapping(value = "save", method = RequestMethod.GET)
    @ResponseBody
    public Object save() {
        Token token = new Token();
        token.setAccess_token("token");
        token.setExpires_in(1000);
        try {
            redisCache.put("token", token);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "ok";
    }  

操作 Redis 集群

只用 Jedis 自身达成注入(差距于上面的援用spring-data-redis)

把后面包车型大巴 JedisClusterClient 代码拿过来引用就能够,只需兑现三个访谈 Redis 的 Service ,就能够合而为一到 Spring mvc 。瑟维斯 代码如下:

import org.springframework.stereotype.Service;
import util.JedisClusterClient;

/**
 * Created by fengdezitai on 2016/10/13.
 */
@Service
public class RedisClusterService {

    public void save() throws Exception{
        //调用 JedisClusterClient 中的方法
        JedisClusterClient jedisClusterClient = JedisClusterClient.getInstance();
        try {
            jedisClusterClient.SaveRedisCluster();
        }catch (Exception e){
            throw e;
        }
    }
}

最后在 Controller 中调用落成的 Service 就可以

@Controller
@RequestMapping(value = "redisCluster")
public class RedisClusterController {

    @Autowired
    private RedisClusterService redisClusterService;

    @RequestMapping(value = "save",method = RequestMethod.GET)
    @ResponseBody
    public Object save(){
        try{
            redisClusterService.save();
        }catch (Exception e){
            e.printStackTrace();
            return String.format("error: %s",e.getMessage());
        }
        return "ok";
    }
}  

用 spring-data-redis 包做集成 

Spring 和 spring-data-redis maven 包引述和眼下一致,之所以引用 spring-data-redis 1.7.2.RELEASE,是因为如今唯有这几个最新版本才支撑集群操作。

redis 集群服务个性配置

redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow=false
redis.timeout=3000

spring-data-redis xml 集群配置文件 redis-cluster-context.xml

<!-- 连接池 配置 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>


    <bean id="redisClusterConfig" class="org.springframework.data.redis.connection.RedisClusterConfiguration">
        <property name="maxRedirects" value="3"></property>
        <property name="clusterNodes">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.245"></constructor-arg>
                    <constructor-arg name="port" value="7000"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.245"></constructor-arg>
                    <constructor-arg name="port" value="7001"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.245"></constructor-arg>
                    <constructor-arg name="port" value="7002"></constructor-arg>
                </bean>
                 <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.210"></constructor-arg>
                    <constructor-arg name="port" value="7003"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.210"></constructor-arg>
                    <constructor-arg name="port" value="7004"></constructor-arg>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="192.168.31.210"></constructor-arg>
                    <constructor-arg name="port" value="7005"></constructor-arg>
                </bean>
            </set>
        </property>
    </bean>

    <bean id="redis4CacheConnectionFactory"
          class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <constructor-arg name="clusterConfig" ref="redisClusterConfig" />
        <property name="timeout" value="${redis.timeout}" />
        <property name="poolConfig" ref="poolConfig"/>
    </bean>


    <bean name="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    <bean id="clusterRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redis4CacheConnectionFactory" />
        <property name="keySerializer" ref="stringRedisSerializer" />
        <property name="hashKeySerializer" ref="stringRedisSerializer" />
        <property name="valueSerializer" ref="stringRedisSerializer" />
        <property name="hashValueSerializer" ref="stringRedisSerializer" />
    </bean>

随后在 Spring 配置文件中援用

<import resource="redis-cluster-context.xml" />

释疑以上配置

poolConfig是连接池配置,redisClusterConfig 配置了 Redis 集群的一一节点(节点 host 和 port 最佳写在性质配置文件中),集群搭建可以看见小编的 另一篇博客 。然后上边和单机配置同样了,一对 JedisConnectionFactory 和 RedisTemplate 。

从此以往在 Service 层就可以注入并引述那一个 RedisTemplate,代码如下:

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;

import java.io.*;

/**
 * Created by fengdezitai on 2016/9/29.
 */
@Repository
public class RedisClusterCache {

    @Autowired
    private RedisTemplate clusterRedisTemplate;


    public void put(Object key, Object value) {
        if(null == value) {
            return;
        }

        if(value instanceof String) {
            if(StringUtils.isEmpty(value.toString())) {
                return;
            }
        }

        // TODO Auto-generated method stub
        final String keyf = key   "";
        final Object valuef = value;
        final long liveTime = 86400;

        clusterRedisTemplate.execute(new RedisCallback<Long>() {
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                byte[] keyb = keyf.getBytes();
                byte[] valueb = toByteArray(valuef);
                connection.set(keyb, valueb);
                if (liveTime > 0) {
                    connection.expire(keyb, liveTime);
                }
                return 1L;
            }
        });
    }

    public Object get(Object key) {
        final String keyf = (String) key;
        Object object;
        object = clusterRedisTemplate.execute(new RedisCallback<Object>() {
            public Object doInRedis(RedisConnection connection)
                    throws DataAccessException {

                byte[] key = keyf.getBytes();
                byte[] value = connection.get(key);
                if (value == null) {
                    return null;
                }
                return toObject(value);

            }
        });

        return object;
    }

    /**
     * 描述 : <byte[]转Object>. <br>
     * <p>
     * <使用方法说明>
     * </p>
     *
     * @param bytes
     * @return
     */
    private Object toObject(byte[] bytes) {
        Object obj = null;
        try {
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bis);
            obj = ois.readObject();
            ois.close();
            bis.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        return obj;
    }

    private byte[] toByteArray(Object obj) {
        byte[] bytes = null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        try {
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            oos.flush();
            bytes = bos.toByteArray();
            oos.close();
            bos.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        return bytes;
    }
}

提起底在 Controller 中调用就可以

@Controller
@RequestMapping(value = "redisCluster")
public class RedisClusterController {

    @Autowired
    private RedisClusterCache redisClusterCache;

    @RequestMapping(value = "clusterSave",method = {RequestMethod.GET,RequestMethod.POST})
    @ResponseBody
    public Object clusterSave(){
        //redisClusterCache.put("cluster","save cluster");
        Token token = new Token();
        token.setExpires_in(1000);
        token.setAccess_token("hello world");
        redisClusterCache.put("token",token);
        return "ok";
    }

    @RequestMapping(value = "getKey",method = RequestMethod.GET)
    @ResponseBody
    public Object getCluster(String key){
        Object val = redisClusterCache.get(key);
        return val;
    }
} 

注意事项:

  • 本子难题,若是用 spring-data-redis 做集成操作 Reids 集群,唯有 spring-data-redis 近年来新星版本1.7才含有对集群的操作,而最新的 spring-data-redis 中的有个别职能对 Spring mvc 的版本也有个别限制,所以尽大概接纳高版本的 Spring mvc 对应。
  • 假设存款和储蓄的value值是三个实体对象,那么应当要达成 Serializable 接口

 

Spring mvc 操作 Redis 及 Redis 集群,mvcredis 本文原创,转发请注解: 关于 Redis 集群搭建能够参照他事他说加以考察我的另...

事先面试的时候被问到了那部分的内容,未有青睐,还好还有的时候间,就把Redis的源码看了三次。

二、基本选拔手续

  首先下载包,并解压张开,如下图:

  分分快三计划 2

  接下去双击文件WebRedisManager.exe运营,如若不可能运转以来,可能要求安装.net framework 4.5,成功开辟分界面如下:

  分分快三计划 3

  然后张开浏览器,地址栏按上面提示输入url,分界面如下:

  分分快三计划 4

  这年就足以增加redis服务器了:

  分分快三计划 5

  增多职业有成后会自动呈现在左边:

  分分快三计划 6

  分分快三计划 7

  分分快三计划 8

  一些正规的增加和删除改查的效果与利益都有,方今还大概有一点询问效用、集群管理等未有到位,未来询问项私下认可都以50个,后续再稳步加上吧。  

 

一、简介

  这段时间因为做事亟待,使用了部分单机版Redis的分界面化管理工科具,使用进程中那忧伤的体验真正独有用过的人能力体会;为此笔者和小友人图谋入手二个Redis可视化学工业具,可是因为小同伙近日做事比较忙,搞了半数以上没不时间持续(会有继续,分界面不敢说,使用体验方面确定要比现成的好);自个儿对wpf不是很熟,再想到十分久在此以前的web迅雷,就想开始实现二个web版的Redis的分界面化管理工科具;方今这几个工具已开端成型,所以放出去分享一下。

Redis源码的收获

Redis是一丝一毫开源的,其源代码能够在一贯在GitHub上获得:(方今的版本是4.4.0)。此时,走入解压后的redis目录下的src文件夹,redis的具有源代码都贮存在这里。

四、核心本事详细

  1.SAEA.RedisSocket:那个是依照SAEA.Socket达成的Redis编解码命令的客商端,近期打包了六头的redis数据操作命令和全部的redis cluster命令,越来越多详细可参谋。

  2.SAEA.WebApi:那些是依靠SAEA.Socket完毕的http编解码命令的服务端,近日已落到实处了get、post的拍卖,帮忙三种form的解码;况兼已购并了mvc风格的编码框架,更多详细可参谋。

  3.LayUI:这些是风传中面向后端开辟职员的Web框架,排版上是仿Bootstrap的品格,集成了大气的插件,能够一点也不慢完成相关的web页面功用,越来越多详细可参看:。

源代码结构深入分析

从redis源码剖析观望的redis源码阅读格局,笔者觉着那适用于广大源码的阅读:

  1. 自底向上:从耦合关系十分的小的模块最早读,然后稳步过度到事关密不可分的模块。就类似写程序的测量试验一样,先从单元测量试验开首,然后才到效果测量检验。
  2. 从效果动手:通过文件名(模块名)和函数名,快捷稳固到二个功力的实际贯彻,然后追踪整个达成的周转流程,进而精通该意义的完毕形式。
  3. 自顶向下:从程序的 main() 函数,或然某些一点都一点都不小的调用者函数为进口,以深度优先只怕广度优先的点子阅读它的源码。
  • Redis的数据结构部分
内存分配 zmalloc.c和zmalloc.h
动态字符串 sds.h和sds.c
双端链表 adlist.c和adlist.h
字典 dict.h和dict.c
跳跃表 server.h文件里面关于zskiplist结构和zskiplistNode结构,以及t_zset.c中所有zsl开头的函数

 

 

 

 

 

  • Redis的内部存款和储蓄器编码
整数集合 intset.h和intset.c
压缩列表 ziplist.h和ziplist.c
压缩表 zipmap.h和zipmap.c

 

 

 

  • Redis数据类型
对象 object.c
字符串对象 t_string.c
列表对象 t_list.c
散列对象 t_hash.c
集合对象 t_set.c
有序集合对象 t_zset.c中除 zsl 开头的函数之外的所有函数

 

 

 

 

 

  • Redis数据库的贯彻
数据库实现 db.c
RDB持久化 rdb.c
AOF持久化 aof.c
通知功能 notify.c

 

 

 

 

  • 顾客端和服务器端的代码完结
服务器端 redis.c
客户端 redis-cli.c
事件处理 ae.c/ae_epoll.c/ae_evport.c/ae_kqueue.c/ae_select.c
网络链接 anet.c和networking.c

 

 

 

 

  • Redis多机部分的代码完结
复制功能 replication.c
Redis Sentinel sentinel.c
集群 cluster.c

 

 

 

  • 独自成效模块的完毕
发布和订阅 pubsub.c文件
事务 multi.c
lua脚本 scripting.c
慢查询 slowlog.c
监视 monitor.c

 

 

 

 

 

一切Redis的源码分类轮廓上如上所述了。

 

后边参照他事他说加以考察了果壳网笔者Zeech的有关redis阅读的建议:

Redis简介

redis全称REmote DIctionary Server,是一个由Salvatore Sanfilippo写的高性能key-value存款和储蓄系统,其完全开源无需付费,坚守BSD左券。Redis与别的key-value缓存产品(如memcache)有以下几个特点。

  • Redis协理数据的长久化,能够将内存中的多寡保存在磁盘中,重启的时候能够另行加载进行应用。
  • Redis不止扶植简单的key-value类型的数额,同有的时候间还提供list,set,zset,hash等数据结构的仓库储存。
  • Redis援助数据的备份,即master-slave形式的数据备份。

Redis的属性相当高且具备丰硕的数据类型,同一时候,Redis全部操作都以原子性的,也支撑对多少个操作合併后原子性的进行。其他,Redis有丰盛的强盛特性,它协理publish/subscribe, 公告,key 过期等等特色。

那边贴出针对Zeech提供的读书提出,也足以督促谐和,希望能够对找到专业有着帮衬。

率先阶段

  • 翻阅Redis的数据结构部分,基本位于如下文件中:内部存款和储蓄器分配 zmalloc.c和zmalloc.h
  • 动态字符串 sds.h和sds.c
  • 双端链表 adlist.c和adlist.h
  • 字典 dict.h和dict.c
  • 跳跃表 server.h文件之中关于zskiplist结交涉zskiplistNode结构,以至t_zset.c中装有zsl先河的函数,比如zslCreate、zslInsert、zslDeleteNode等等。
  • 基数总计 hyperloglog.c 中的 hllhdr 结构, 以至有着以 hll 开端的函数

其次等级 熟知Redis的内存编码结构

  • 大背头集结数据结构 intset.h和intset.c
  • 减去列表数据结构 ziplist.h和ziplist.c

其三阶段 熟知Redis数据类型的兑现

  • 对象系统 object.c
  • 字符串键 t_string.c
  • 列表建 t_list.c
  • 散列键 t_hash.c
  • 集合键 t_set.c
  • 稳步集结键 t_zset.c中除 zsl 开首的函数之外的享有函数
  • HyperLogLog键 hyperloglog.c中具有以pf开端的函数

第四等第 熟谙Redis数据库的兑现

  • 数据库达成 redis.h文件中的redisDb结构,以致db.c文件
  • 公告成效 notify.c
  • RDB持久化 rdb.c
  • AOF持久化 aof.c

以致部分独门功用模块的完成

  • 发表和订阅 redis.h文件的pubsubPattern结构,以至pubsub.c文件
  • 事务 redis.h文件的multiState结构以致multiCmd结构,multi.c文件

第五阶段 熟练客商端和劳动器端的代码达成

  • 事件管理模块 ae.c/ae_epoll.c/ae_evport.c/ae_kqueue.c/ae_select.c
  • 网路链接库 anet.c和networking.c
  • 服务器端 redis.c
  • 客户端 redis-cli.c
  • 其一时候能够翻阅上边包车型地铁独自功用模块的代码完毕
  • lua脚本 scripting.c
  • 慢查询 slowlog.c
  • 监视 monitor.c

第六等第 这一阶段注重是成竹在胸Redis多机部分的代码达成

  • 复制作而成效 replication.c
  • Redis Sentinel sentinel.c
  • 集群 cluster.c

任何代码文件介绍

至于测量试验方面包车型大巴文本有:

  • memtest.c 内部存款和储蓄器检验
  • redis_benchmark.c 用于redis质量测量试验的贯彻。
  • redis_check_aof.c 用于革新日志检查的贯彻。
  • redis_check_dump.c 用于地点数据库检查的落到实处。
  • testhelp.c 三个C风格的Mini测量检验框架。

一对工具类的公文如下:

  • bitops.c GETBIT、SETBIT 等二进制位操作命令的完结
  • debug.c 用于调节和测验时选择
  • endianconv.c 高未有调换,分歧种类,高未有顺序不一致
  • help.h 援救于命令的提示新闻
  • lzf_c.c 压缩算法体系
  • lzf_d.c 压缩算法连串
  • rand.c 用于发生随机数
  • release.c 用于发表时使用
  • sha1.c sha加密算法的落到实处
  • util.c 通用工具方法
  • crc64.c 循环冗余校验
  • sort.c SORT命令的达成
  • 一部分封装类的代码完结:
  • bio.c background I/O的乐趣,开启后台线程用的
  • latency.c 延迟类
  • migrate.c 命令迁移类,包罗命令的过来迁移等
  • pqsort.c 排序算法类
  • rio.c redis定义的二个I/O类
  • syncio.c 用于共同Socket和文件I/O操作

五、完整封装及源代码共享

  那一个类型按SAEA简洁高效的章程打开编码的,相当多地点都使用的暗许值,无论是查看代码依然三回九转衔接都很自在方便,下边是本项目标开行源码:

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             ConsoleHelper.Title = "WebRedisManagerService";
 6 
 7             MvcApplication mvcApplication = new MvcApplication(10240, 3000);
 8 
 9             mvcApplication.Start();
10 
11             ConsoleHelper.WriteLine("WebRedisManager服务已启动");
12 
13             ConsoleHelper.WriteLine("http://localhost:39654/html/index.html,按回车结束......");
14 
15             Process.Start("http://localhost:39654/html/index.html");
16 
17             ConsoleHelper.ReadLine();
18         }
19     }

  更加多源码请访问 

 

转发请申明本文来源:
更多内容款待star笔者的github:
比如开掘本文有怎么着难点和别的建议,也随即招待调换~

看了黄建宏先生的《Redis设计与达成》,对redis的局地完毕有了三个人所共知的认知;

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划