Redis简单入门认识

写在前面：

　　最近一直都在按照老大的学习路线来进行学习，这几天看了下redis，从刚开始的摸不着头脑，到后面慢慢的查资料，对其逐渐有了简单的了解，也通过一个与ssm框架整合的小demo去动手实践 了，知道了怎么去用。这里也是单纯的记录下，因为对于现阶段的我来说，还不可能去做优化这一块，所以这里先记录着，后面等需要用时再去做深入的学习也不迟。

　　1.什么是redis?

　　redis，Remote Dictionary Server,用我自己的话说，就是一个数据库或者说是一个缓存服务器，但是它不同于mysql,oracle这些关系型的数据库，它是NoSQL(Not Only SQL)数据库，即非关系型数据库，因为它存数据是以key-value键值对的方式来存储的。它运行在内存中。

　　2.为什么要使用redis?

　　从性能和并发的角度来说明。

　　1.性能：

　　场景：当用户打开一个页面，向后台发送请求，系统后台会从数据库中查询数据，查询的数据需要关联到许多的表，如果每次请求都执行多表查询，会很复杂，执行的速度很慢。

　　当加入redis后，用户打开一个页面，系统后台会从数据库中查询数据并把数据以key-value的形式存储到redis中，即在redis中一个页面对应着一条数据，当用户再次打开同一个页面时，系统首先会从redis中来获取这一条数据。而不是再去数据库中进行复杂的查询。这样速度就会比较快。

　　2.并发：

　　场景：多个用户同时发送请求，系统也会对数据库发送多个请求，这时对数据库的负载会很大，容易造成数据库宕机。

　　当加入redis后，由于redis采用单线程工作模型，不管有多少个请求，都只有一个线程处理。因为如果不使用redis,向数据库发送多个请求，每个请求都会建立一个连接，只有当一个请求完成后，才会开始另外一个请求，会造成多线程阻塞。

　　单线程redis的优点：

　　1.纯内纯操作

　　2.单线程操作，避免了频繁的上下文切换

　　3.采用了非阻塞I/O多路复用机制

　　redis下载

　　官网下载https://redis.io/dowoload,太卡了，使用github的资源：https://github.com/MicrosoftArchive/redis/releases,只有64位的，32位的自行百度。

　　下载解压后，直接打开redis-server.exe,这是redis的服务端，其中6379是它的端口号。

　　接着打开redis客户端，直接打开安装目录中redis-cli.exe即可

　　基本命令：

　　set name wenzi：设置键name的值为wenzi

　　get name：获取键name的值

　　del name：删除键name

　　更多命令：

　　　http://www.runoob.com/redis/redis-commands.html

　　下面就来将redis与ssm整合：

　　　网上的资料很多的，这里没有做过多的深究，只是让项目跑起来，对redis的用法有个大概的了解与认识。

　　　这里主要贴出有关redis的配置，关于ssm的整合相关的代码，就不再贴出来了，可以去看之前的博客https://www.cnblogs.com/eleven258/p/9844355.html

　　　1.在pom.xml中引入redis相关jar包依赖

   <!--jedis客户端，即java redis客户端，封装了一些操作redis的功能-->
      <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.6.2</version>
      </dependency>
        <!--spring和redis的整合-->
      <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.4.2.RELEASE</version>
      </dependency>

　　这里一定要注意下这两个jar包版本的匹配，这里测试了这两个版本是可行的。如果出现了以下的异常，则需要对这两个jar包的版本进行修改。

nvocation of init method failed; nested exception is java.lang.NoSuchMethodError: 
org.springframework.core.serializer.support.DeserializingConverter.<init>(Ljava/lang/ClassLoader;)V

　　2.redis连接配置文件redis.properties

#*****************jedis连接参数设置*********************
#redis服务器ip
redis.ip=127.0.0.1
# redis服务器端口号
redis.port=6379
# redis访问密码
redis.passWord=“”
# 与服务器建立连接的超时时间
redis.timeout=20000
#************************jedis池参数设置*******************
# jedis的最大活跃连接数
redis.maxActive=50
#jedis的最大连接数
redis.maxTotal=100
# jedis最大空闲连接数
redis.maxIdle=10
# jedis池没有连接对象返回时，等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。
# 如果超过等待时间，则直接抛出JedisConnectionException
# 从池中获取连接的时候，是否进行有效检查
redis.testOnBorrow=true
redis.testOnReturn=true
# 归还连接的时候，是否进行有效检查
redis.maxWaitMillis = 360000

　　3.spring配置文件中添加有关redis的配置,由于是整合的ssm，所以直接在之前项目中的spring-mybatis.xml中进行配置即可。

<!--    ************redis的相关配置****************************  -->

    <!--加载redis配置文件 由于前面也引入了jdbc的配置文件，所以两个都加上ignore-unresolvable="true" 不然会报错，找不到-->
    <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/>
    <!--jedis池配置，类似于c3p0连接池一样的作用-->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
     <!--最大连接数-->
        <property name="maxTotal" value="${redis.maxTotal}"/>
     <!--最大空闲数-->
        <property name="maxIdle" value="${redis.maxIdle}"/>
     <!--最大等待时长-->
        <property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <property name="testOnReturn" value="${redis.testOnReturn}"/>
    </bean>
    <!--jedis连接工厂，类似sqlSessionFactory连接工厂-->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
        <property name="hostName" value="${redis.ip}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value=""/>
        <property name="poolConfig" ref="jedisPoolConfig"/>
        <!--超时时间-->
        <property name="timeout" value="${redis.timeout}"/>
        <property name="usePool" value="true"/>
    </bean>

    <!-- Spring提供的访问Redis的类，类似Hibernate的HibernateTemplate -->
    <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
        <!-- 开启事务 -->
        <property name="enableTransactionSupport" value="true"/>
        <!--指明序列化类，因为redis存储的数据是二进制数据，因此需要对原始数据进行序列化和反序列化等操作。-->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>
        <!--开启注解，需要配置cacheManager，此处指定缓存管理器，如果不指定，默认为cacheManager-->
   <!-- <cache:annotation-driven/>-->
        <!--redisCache管理器，用于管理redisCache的-->
    <!--<bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        &lt;!&ndash;构造方法的第一个参数&ndash;&gt;
        <constructor-arg index="0" ref="jedisTemplate"/>
        &lt;!&ndash; 过期时间 &ndash;&gt;
        <property name="defaultExpiration" value="300000"/>
        &lt;!&ndash;支持事务 &ndash;&gt;
        <property name="transactionAware" value="true"/>
    </bean>-->

　　配置完成，下面看代码，这里就只是简单的测试下。弄明白当用户发送请求时，首先会去缓存中取，如果redis中有对应的数据，就拿，没有就从数据库中拿。所以这里也只是简单的贴下业务层的方法。大概能明白就行。

　　UserServiceImpl.java

//引入mapper接口
    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate<String,Object> redisTemplate;

    @Override
    public User getUserById(int id) {
        //在缓存中存
        //首先从缓存中查询
        String tempValue = (String) redisTemplate.opsForValue().get("user");
        User user = null;
        if(tempValue == null){
            System.out.println("从数据库中取数据-----");
            user = userMapper.selectByPrimaryKey(id);
            //将user对应的值存进redis中
            redisTemplate.opsForValue().set("user",user.getUserName());
            //return userMapper.selectByPrimaryKey(id);
        }else{
            System.out.println("从缓存中取数据------"+redisTemplate.opsForValue().get("user"));
            //这里可以从缓存中数据,具体redis怎么存取对象，这里没有去学习，目前只是简单了解下用法
            //......
        }
        return user;
    }

　

　　下面进行测试，我们将redis的服务端打开，同时也将redis的客户端打开，获取key为user的值：

　　此时user是没有对应的值的。然后在浏览器地址栏中输入对应的url，去请求对应的资源，首次请求，可以看到控制台打印,

　　这个时候，在redis客户端，再次获取user对应的值，可以看到是有值了的。

　　接着，在浏览器地址再次发送请求，可以看到控制台打印的。

　　这也就说明了，当第一次请求的时候，可以去数据库查询，然后将结果存在redis缓存中，当再次发送请求时就首先从redis缓存中去获取，这样就避免了，频繁去操作数据库，导致性能低下，速度慢。

　　参考链接：(有些链接是斌哥ppt里附上的，之后有时间再去学习)

　　http://www.runoob.com/redis/redis-intro.html------Redis 简介

　　https://www.cnblogs.com/rjzheng/p/9096228.html------【原创】分布式之redis复习精讲

　　https://www.cnblogs.com/hjwublog/p/5749929.html-------分布式缓存技术redis学习系列（五）——redis实战（redis与spring整合，分布式锁实现）

　　https://blog.csdn.net/xsyl08/article/details/78773760------ssm+redis整合的一个Demo

　　http://www.runoob.com/redis/redis-commands.html------Redis 命令

　　http://www.runoob.com/mongodb/nosql.html------NoSQL 简介

　　http://www.redis.net.cn/order/3674.html------Redis命令

　　https://www.cnblogs.com/fashflying/p/6908028.html------Spring缓存注解@Cacheable、@CacheEvict、@CachePut使用

       https://www.cnblogs.com/zjrodger/p/5800645.html------【原】Spring整合Redis(第三篇)—盘点SDR搭建中易出现的错误