Redis的简单使用

最新推荐文章于 2024-08-11 22:29:56 发布
最新推荐文章于 2024-08-11 22:29:56 发布
阅读量406 收藏
点赞数
文章标签： Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/insisting2018/article/details/79784127
版权

这里结合SSM框架使用,Mac系统

首先需要安装Redis

  • 安装包:Redis安装包
  • 解压安装包,放在usr/local下,改名redis
  • 进入终端:cd /usr/local/redis
  • make
  • sudo make install
  • 输入电脑设置的密码111111
  • 安装完成
  • 配置:
    • 打开redis.conf文件
    • 在500行左右,把# require pass foobared 改为 requirepass 自己设置密码
    • 保存退出
  • 启动:
    • cd src/
    • ./redis-server ../redis.conf
  • 终止:
    • ctrl+c
  • 使用:
    • 新建一个终端窗口
    • /usr/local/redis/src/redis-cli -a 自己前面设置的密码
    • 简单命令使用
    • 查看所有的key: keys *
    • 赋值: set name zhangsan
    • 取值: get name
    • 如果不存在key设置值:setnx name1 lisi
    • 拼接: append name zhaoliu
    • 删除: del name
    • 重命名: rename name1 新key值
    • 同时设置多个值: meet name1 123 age 22
    • 查看某key是否存在: exists key值
    • 加一: incr age (age=23)
    • 赋新值: getset name 123

SSM框架中的使用(先搭好框架!!!!!!!!!!)

工程结构
- 首先添加Redis的依赖

<!--Redis的依赖-->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.7.2.RELEASE</version>
    </dependency>
  • Student类:必须实现序列化

public class Student implements Serializable{

package com.lanou.bean;

import java.io.Serializable;

/**
 * Created by dllo
 */
public class Student implements Serializable{
    private int id;
    private String name;
    private String hobby;
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", hobby='" + hobby + '\'' +
                '}';
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getHobby() {
        return hobby;
    }
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}
  • RedisCache类
package com.lanou.cache;

import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.connection.jedis.JedisConnection;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import redis.clients.jedis.exceptions.JedisConnectionException;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by dllo
 */
public class RedisCache implements Cache {
    private final String id;
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private static JedisConnectionFactory jedisConnectionFactory;

    //jedis框架提供的Redis连接工厂
    //我们使用spring框架来赋值(注入)
    public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
        RedisCache.jedisConnectionFactory = jedisConnectionFactory;
    }

    //添加id的构造方法
    public RedisCache(String id) {
        if (id == null) {
            throw new IllegalArgumentException("id不能为空");
        }
        this.id = id;
    }

    //获取缓存对象的唯一标识
    @Override
    public String getId() {
        return this.id;
    }

    //将key-value保存到缓存中
    //key可以是任何对象,但是一般第一使用CacheKey对象
    //value是查询结果,List类型
    @Override
    public void putObject(Object key, Object value) {
        JedisConnection connection = null;
        try {
            //获取一个Connection
            connection = (JedisConnection) jedisConnectionFactory.getConnection();
            //jedis提供了一个序列化类,帮助转换
            RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
            connection.set(serializer.serialize(key), serializer.serialize(value));
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }

    //从缓存中获取key对应的Value值
    @Override
    public Object getObject(Object key) {
        JedisConnection connection = null;
        Object result = null;
        try {
            //获取一个Connection
            connection = (JedisConnection) jedisConnectionFactory.getConnection();
            //jedis提供了一个序列化类,帮助转换
            RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
            byte[] value = connection.get(serializer.serialize(key));
            result = serializer.deserialize(value);
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    //移除key对应的缓存
    //可选实现,没有被核心框架调用
    @Override
    public Object removeObject(Object key) {
        JedisConnection connection = null;
        Object result = null;
        try {//获取一个Connection
            connection = (JedisConnection) jedisConnectionFactory.getConnection();
            //jedis提供了一个序列化类,帮助转换
            RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
            byte[] value = connection.get(serializer.serialize(key));
            result = serializer.deserialize(value);
            connection.expire(serializer.serialize(key), 0);
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    //清空缓存
    @Override
    public void clear() {
        JedisConnection connection = null;
        try {
            //获取一个Connection
            connection = (JedisConnection) jedisConnectionFactory.getConnection();
            connection.flushDb();
            connection.flushAll();
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }

    //获取缓存中存储的键/值对的 数量
    @Override
    public int getSize() {
        JedisConnection connection = null;
        int result = 0;
        try {
            //获取一个Connection
            connection = (JedisConnection) jedisConnectionFactory.getConnection();
            result = connection.dbSize().intValue();
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    //获取读写锁
    //不是必须要实现的方法
    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.getReadWriteLock();
    }
}
  • RedisCacheTransfer类
package com.lanou.cache;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

/**
 * Created by dllo
 */
public class RedisCacheTransfer {
    @Autowired
    public void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
        RedisCache.setJedisConnectionFactory(jedisConnectionFactory);
    }
}

-MainController类

package com.lanou.controller;

import com.lanou.bean.Student;
import com.lanou.service.StudentService;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
import java.util.List;

/**
 * Created by dllo
 */
@Controller
public class MainController {
    @Resource
    private StudentService studentService;
    @RequestMapping(value = "/home")
    public String page(){
        return "home";
    }
    @ResponseBody
    @RequestMapping(value ="/getall")
    public List<Student> getAll(){
        return studentService.selectAll();
    }
}
  • StudentMapper接口
package com.lanou.mapper;

import com.lanou.bean.Student;

import java.util.List;

/**
 * Created by dllo
 */
public interface StudentMapper {

    List<Student> selectAll();
}
  • StudentMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lanou.mapper.StudentMapper">
    <cache type="com.lanou.cache.RedisCache"/>
    <resultMap id="StudentMap" type="com.lanou.bean.Student">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="hobby" property="hobby"/>
    </resultMap>
    <select id="selectAll" resultMap="StudentMap">
        SELECT * FROM  student
    </select>

</mapper>
  • StudentService接口
package com.lanou.service;

import com.lanou.bean.Student;

import java.util.List;

/**
 * Created by dllo
 */
public interface StudentService {
    List<Student> selectAll();

}
  • StudentServiceImpl类
package com.lanou.service.impl;

import com.lanou.bean.Student;
import com.lanou.mapper.StudentMapper;
import com.lanou.service.StudentService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * Created by dllo
 */
@Service
public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentMapper studentMapper;
    @Override
    public List<Student> selectAll() {
        return studentMapper.selectAll();
    }
}
  • mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- Globally enables or disables any caches configured in any mapper under this configuration -->
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
        <!-- Sets the number of seconds the driver will wait for a response from the database -->
        <setting name="defaultStatementTimeout" value="3000"/>
        <!-- Enables automatic mapping from classic database column names A_COLUMN to camel case classic Java property names aColumn -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- Allows JDBC support for generated keys. A compatible driver is required.
        This setting forces generated keys to be used if set to true,
         as some drivers deny compatibility but still work -->
        <setting name="useGeneratedKeys" value="true"/>
    </settings>

    <!-- Continue going here -->

</configuration>
  • sum-mybatis.xml
<?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 class="org.apache.commons.dbcp2.BasicDataSource" id="dataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/db1106"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:com/lanou/mapper/*.xml"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.lanou.mapper"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

ssm-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="redis.clients.jedis.JedisPoolConfig" id="poolConfig">
        <property name="maxIdle" value="300"/>
        <property name="maxTotal" value="600"/>
        <property name="maxWaitMillis" value="1000"/>
        <property name="testOnBorrow" value="true"/>
    </bean>
    <bean class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          id="jedisConnectionFactory"
          p:host-name="127.0.0.1"
          p:password="123456"
          p:port="6379"
          p:poolConfig-ref="poolConfig">

    </bean>
    <bean class="com.lanou.cache.RedisCacheTransfer" id="cacheTransfer">
        <property name="jedisConnectionFactory" ref="jedisConnectionFactory"/>
    </bean>

</beans>

sam-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <mvc:annotation-driven/>
    <context:component-scan base-package="com.lanou"/>
    <mvc:default-servlet-handler/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="viewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>
  • web.xml
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:ssm-mybatis.xml,classpath:ssm-redis.xml</param-value>
  </context-param>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <servlet>
    <servlet-name>SSMServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:ssm-servlet.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>SSMServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>
  • pom.xml
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lanou</groupId>
  <artifactId>1106-SSM-Lucene</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>1106-SSM-Lucene Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.8.6</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.8.6</version>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.8.0</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.40</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.2</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>2.1.1</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.6.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.5</version>
    </dependency>
<!--分页插件-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>3.6.3</version>
    </dependency>
<!--shiro-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.7.4</version>
    </dependency>
    <dependency>
      <groupId>org.apache.shiro</groupId>
      <artifactId>shiro-all</artifactId>
      <version>1.2.3</version>
    </dependency>

    <!--Lucene需要的依赖-->
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-core -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-core</artifactId>
      <version>6.1.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-queryparser -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-queryparser</artifactId>
      <version>6.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-analyzers-common -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-analyzers-common</artifactId>
      <version>6.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-queries -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-queries</artifactId>
      <version>6.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.lucene/lucene-highlighter -->
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-highlighter</artifactId>
      <version>6.0.0</version>
    </dependency>
    <!--FileUtils,文件读取依赖-->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.5</version>
    </dependency>
    <!--分词器的插件-->
    <dependency>
      <groupId>com.hankcs.nlp</groupId>
      <artifactId>hanlp-lucene-plugin</artifactId>
      <version>1.1.2</version>
    </dependency>

    <!--Redis的依赖-->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>1.7.2.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>1106-SSM-Lucene</finalName>

    <resources>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
          <include>**/*.tld</include>
        </includes>
        <filtering>false</filtering>
      </resource>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.properties</include>
          <include>**/*.xml</include>
          <include>**/*.tld</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.6.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>

  </build>
</project>
INSISTING2018
关注
redis的简单使用
逝水流年
04-09 1561
一. Redis简介 Redis是分布式内存数据库，即它的数据是存储在内存上的，运行速度很快。同时它也有自己的持久化机制。Redis常用作热点数据存储、计数器等，其它的应用场景可以自行百度。Redis默认支持16个数据库（可以通过配置文件支持更多，无上限），每个数据库对外都是一个从0开始的递增数字命名，可以通过配置databases来修改这一数字。客户端与Redis建立连接后会自动选择0号数据库。 二. Redis数据类型 Redis有5种基本数据类型，分别是String、Hash、List、Set、zs
Scrapy-Redis简单使用
dandanfengyun的博客
02-07 1925
首先，官方GitHub地址 https://github.com/rmax/scrapy-redis 特征 1。分布式抓取/抓取 您可以启动共享单个redis队列的多个spider实例。Y适合广泛的多域抓取。 2。分布式后处理 Scraped项目被推送到redis排队，这意味着您可以在共享项目队列的所需后处理过程中启动。 3。Scrapy即插即用组件 调度程序+复制过滤器，项目管道，基础蜘蛛。 使...
redis 简单使用总结
dengzai7446的博客
07-29 127
作者：王清培(Plen wang) 沪江Java资深架构师 最近一段时间与redis接触比较频繁。发现有些东西还是工作中经常会用到的，自己也花了点时间巩固下。本篇文章主要是以总结性的方式梳理，因为redis的主题很大，任何一个技术点展开都是几篇文章的量。也可以说这篇文章是个概览。 1.redis基本数据结构与短结构压缩 了解redis的数据结构有助于了解每种数据结构的优劣势，方便...
Redis基础用法
最新发布
2301_79201170的博客
08-11 955
SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis。2. 进入计算机服务中(右键计算机-->管理-->服务和应用程序-->服务)，再在右侧找到Redis名称的服务，查看启动情况。在Redis官网中提供了各种语言的客户端，地址：https://redis.io/docs/clients/然后即可如方法一操作。
Redis简单使用
陈家二少的博客
06-21 1463
1. 安装 安装包下载 安装包下载好以后，直接解压就可以使用，无需安装。 这是解压后的目录结构，其中redis-cli是客户端，redis-server是服务端。 双击启动redis服务端 双击启动redis客户端 如果每次访问redis都要手动点击redis-server肯定是很不方便的，而且命令框一直在那，让我想到了tomcat。 在客户端运行命令redis-serv...
Redis 简单使用
MaiYo_
10-11 266
官网： https://redis.io 安装使用： 解压 redis-4.0.2.tar.gz 进入解压目录执行 make 命令进行编译 编译完成后运行 src 目录下的 redis-server 启动服务 ./redis-server 通过客户端工具 redis-cli 执行 redis 命令，启动方式同 redis-server，默认会连接本机的 redis 服务器 配置：
Redis：Redis的简单使用
dengfengling999的博客
07-02 1872
目录：（1）Redis的细节使用 启动、关闭、启动客户端（2）Redis的基本知识1 测试性能、查看转态、服务器的统计信息 （3）Redis基本知识2 数据库实例 （4）Redis基本知识3 查看key、清空库 （1）Redis的细节使用 启动：redis-server & 进行查看：ps -ef|grep redis：发现有6379这个redis 关闭Redis：redis-cli shutdown 进行查看：ps -ef|grep redi
redis简单使用实例
12-10
Redis提供了发布/订阅（pub/sub）和阻塞列表（BLPOP/BRPOP）功能，可以实现简单的消息队列。发布/订阅模式用于一对多的消息传递，而阻塞列表则可以实现先进先出（FIFO）的队列服务，常见于工作流调度或者任务分发...
C++ Redis 客户端简单使用
06-17
本篇文章将深入探讨如何在C++中简单使用Redis客户端。 首先，为了在C++中与Redis进行交互，我们需要一个支持C++的Redis客户端库。常见的选择有`hiredis`，这是一个轻量级的C库，同时也提供了C++绑定。另一个是`cpp-...
使用redis构建简单的社交网站项目源码.zip
06-08
使用redis构建简单的社交网站使用redis构建简单的社交网站项目源码.zip使用redis构建简单的社交网站项目源码.zip使用redis构建简单的社交网站项目源码.zip使用redis构建简单的社交网站项目源码.zip使用redis构建简单...
Redis基础之【2.NetCore对接Redis简单使用】
qq_33101689的博客
09-10 727
Redis基础之【2. 对接.NetCore简单使用】 一. 前期准备 二. 几种数据类型的使用（只展示5种） 1.String 2.Hash 3.List 4.Set 5.Sorted set 三. 总结
Redis的简单应用
热门推荐
至尊宝
11-12 2万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 一、启动Redis(安装参考上篇博客) 1.单机版的启动命令可使用./redis-server或./redis-server redis.conf(在/usr/local/redis/下执行) 2.集群版的启动命令使用./start-all.sh(在usr/loca...
redis简单使用
weixin_34217711的博客
07-02 78
介绍 Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供...
redis 的简单使用
Woo_home的博客
01-13 1625
文章目录Redis 与 各个数据库之间的区别Redis 数据结构简介string（字符串）尝试一下list（列表）尝试一下set（集合）尝试一下 Redis 与 各个数据库之间的区别 名称 类型 数据存储选项 查询类型 附加功能 redis 使用内存存储（in-memory）的非关系型数据库 字符串、列表、集合、散列表、有序集合 每种数据类型都有自己的专属命令，另外还有批量操作（b...
springboot+redis简单使用
05-07
以下是一个简单的示例，演示了如何在Spring Boot中使用Redis： 1. 添加依赖： 在pom.xml文件中添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` 2. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值