精华内容
下载资源
问答
  • RedisTemplate和JedisPool的效率对比

    千次阅读 2020-07-02 11:02:48
    -- redisspring整合的依赖 --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> ${redis.spring.version}</version> </dependency> <!-- 管理redis数据库...

    1、准备环境

    1.1、安装本地Redis,并启动服务

    如果还没安装的,可以参考博客:Windows系统本地安装Redis并设置服务自启动(图文)

    1.2、创建Maven项目,并导入依赖

    在pom.xml文件中加入以下依赖

        <!-- 配置编译环境 -->
        <build>
            <plugins>
                <!-- 处理项目JDK编译版本的问题 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
                <!-- 设置maven内置服务器为tomcat7 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                </plugin>
            </plugins>
        </build>
    
        <!-- 属性 -->
        <properties>
            <!-- 指定spring的版本 -->
            <spring.version>5.1.9.RELEASE</spring.version>
            <!-- 指定redis数据库的版本 -->
            <redis.spring.version>1.8.23.RELEASE</redis.spring.version>
        </properties>
    
    
        <!-- 依赖 -->
        <dependencies>
            <!-- spring的IOC依赖 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
    
            <!-- spring单元测试的依赖 -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <!-- junit测试依赖 -->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <!-- junit版本超过4.11,需要手动加hamcrest的依赖 -->
            <dependency>
                <groupId>org.hamcrest</groupId>
                <artifactId>hamcrest-core</artifactId>
                <version>1.3</version>
                <scope>test</scope>
            </dependency>
            
            <!-- redis和spring整合的依赖 -->
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>${redis.spring.version}</version>
            </dependency>
            <!-- 管理redis数据库连接的jedis连接池依赖 -->
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.9.0</version>
            </dependency>
    
            <!-- pool连接池依赖 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>2.7.0</version>
            </dependency>
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
    
        </dependencies>
    

    1.3、准备Redis数据库参数的属性文件

    在resources目录下创建redisConfig.properties属性文件,配置内容如下:

    redis.host=127.0.0.1
    redis.port=6379
    redis.database=0
    redis.password=dearest
    redis.timeout=60000
    redis.maxTotal=50
    redis.maxIdle=20
    redis.minIdle=8
    redis.maxWaitMillis=60000
    redis.testOnBorrow=true
    redis.testOnReturn=true
    

    1.4、准备Redis数据库在Spring框架中的xml配置文件

    在resources目录下spring目录,在spring目录中创建applicationContext-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: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/context
           https://www.springframework.org/schema/context/spring-context.xsd">
    
        <context:property-placeholder location="classpath:redisConfig.properties" />
    
        <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
            <property name="maxTotal" value="${redis.maxTotal}" />
            <property name="maxIdle" value="${redis.maxIdle}" />
            <property name="minIdle" value="${redis.minIdle}" />
            <property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />
            <property name="testOnReturn" value="${redis.testOnReturn}" />
        </bean>
        
        <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
            <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
            <constructor-arg name="host" value="${redis.host}" />
            <constructor-arg name="port" value="${redis.port}" />
            <constructor-arg name="password" value="${redis.password}" />
            <constructor-arg name="database" value="${redis.database}" />
            <constructor-arg name="timeout" value="${redis.timeout}" />
        </bean>
        
        <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
            <property name="poolConfig" ref="jedisPoolConfig" />
            <property name="hostName" value="${redis.host}" />
            <property name="port" value="${redis.port}" />
            <property name="database" value="${redis.database}" />
            <property name="password" value="${redis.password}" />
        </bean>
    
        <!-- 序列化方式 -->
        <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        <!-- 序列化方式 -->
        <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    
        <!-- Redis模板 -->
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
            <property name="connectionFactory" ref="jedisConnectionFactory" />
            <property name="keySerializer" ref="stringRedisSerializer" />
            <property name="hashKeySerializer" ref="stringRedisSerializer" />
            <property name="valueSerializer" ref="jdkSerializationRedisSerializer" />
            <property name="hashValueSerializer" ref="jdkSerializationRedisSerializer" />
        </bean>
    
    </beans>
    

    2、开始测试

    2.1、创建测试类

    package com.zdrl.web.controller;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    @RunWith(value = SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:spring/applicationContext-redis.xml")
    public class Demo {
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
        @Autowired
        private JedisPool jedisPool;
    
        private final int num = 100000;
    
        @Test
        public void method1 () {
            long time = 0;
            System.out.println("RedisTemplate:");
            for (int i = 0; i <= num; i++) {
                long time1 = System.currentTimeMillis();
                redisTemplate.opsForValue().set(i + "", i + "");
                long time2 = System.currentTimeMillis();
                time += (time2 - time1);
                if (i == 10) {
                    System.out.println("10次:总时间" + time);
                } else if (i == 100) {
                    System.out.println("100次:总时间" + time);
                } else if (i == 500) {
                    System.out.println("500次:总时间" + time);
                } else if (i == 1000) {
                    System.out.println("1000次:总时间" + time);
                } else if (i == 5000) {
                    System.out.println("5000次:总时间" + time);
                } else if (i == 10000) {
                    System.out.println("10000次:总时间" + time);
                } else if (i == 100000) {
                    System.out.println("100000次:总时间" + time);
                }
            }
        }
    
        @Test
        public void method2 () {
            long time = 0;
            Jedis jedis = jedisPool.getResource();
            System.out.println("JedisPool:");
            for (int i = 0; i <= num; i++) {
                long time1 = System.currentTimeMillis();
                jedis.set(i + "", i + "");
                long time2 = System.currentTimeMillis();
                time += (time2 - time1);
                if (i == 10) {
                    System.out.println("10次:总时间" + time);
                } else if (i == 100) {
                    System.out.println("100次:总时间" + time);
                } else if (i == 500) {
                    System.out.println("500次:总时间" + time);
                } else if (i == 1000) {
                    System.out.println("1000次:总时间" + time);
                } else if (i == 5000) {
                    System.out.println("5000次:总时间" + time);
                } else if (i == 10000) {
                    System.out.println("10000次:总时间" + time);
                } else if (i == 100000) {
                    System.out.println("100000次:总时间" + time);
                }
            }
        }
    }
    
    
    

    2.2、测试结果

    RedisTemplate的执行效率如下:
    在这里插入图片描述

    JedisPool的执行效率如下:
    在这里插入图片描述

    3、结论

    JedisPool的效率比RedisTemplate简直快不要太多。
    当然,我这是在本地Redis测试,有时间的朋友,可以测试一下服务器上两者的执行效率。

    展开全文
  • @Autowired public Jedis jedis; @Autowired public RedisTemplate redisTemplate; 注入jedis每次都报错,但是redisTemplate可以正常使用...就是想问问RedisTemplate和jedis有什么区别吗;之前ssm的项目都是jedis
  • redisTemplate和JedisPool的效率对比

    千次阅读 2020-01-15 17:16:46
    注:JedisPool的连接参数均使用 `` private final int num = 100000; @Test public void testRedisTemplate() throws IOException { long time = 0; for (int i = 0; i < num; i++) { ...

    1:测试版本:腾讯云服务器
    配置:1核 2GB 1Mbps

    测试代码:
    注:JedisPool的连接参数均使用默认配置

    private final int num = 100000;
    @Test
    public void testRedisTemplate() throws IOException {
    
    long time = 0;
    for (int i = 0; i < num; i++) {
        // 1、推送
        long time1 = System.currentTimeMillis();
        redisTemplate.opsForValue().set(i+"",i+"");
        long time2 = System.currentTimeMillis();
        time += time2 - time1;
    }
    System.out.println("总时间:" + time);
    //------------------------------------------------
    @Test
    public void testJedis2() throws IOException {
    
    JedisPool jedisPool = new JedisPool(poolConfig,hostName,port,5000,password);
    
    long time = 0;
    for (int i = 0; i < num; i++) {
        try (Jedis jedis = jedisPool.getResource()) {
            // 1、推送
            long time1 = System.currentTimeMillis();
            jedis.set(i+"",i+"");
            long time2 = System.currentTimeMillis();
            time += time2 - time1;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    System.out.println("总时间:" + time);
    

    由于是在本机连着云服务器测得,所以主要时间基本会耗费在Tcp的连接上,看下结果:

    单位(毫秒)
    
    redisTemplate;
    //10:总时间:1966
    //100:总时间:4861
    //500:30712
    //5000:总时间:264042
    //------------------------
    JedisPool:
    //10:总时间:308
    //100:总时间:2412
    //500:总时间:14388
    //5000:总时间:134836
    

    耗时基本都是按访问的倍数增长的,但是JedisPool稍微好点,因为本机测试redisTemplate到5000次的访问已经已经突破4分钟了,所以没有继续测,看下图形趋势:
    在这里插入图片描述
    测完服务器,来试一下本地的,在windows上直接启动redis服务,host设置为"127.0.0.1",再测:

    单位(毫秒)
    
    redisTemplate;
    //本地-10:总时间:1506
    //本地-100:总时间:1670
    //本地-500:总时间:2178
    //本地-5000:总时间:5964
    //本地-50000:总时间:38045
    //本地-100000:总时间:72839
    //----------------------------------------
    JedisPool:
    //本地-10:总时间:6
    //本地-100:总时间:25
    //本地-500:总时间:92
    //本地-5000:总时间:771
    //本地-50000:总时间:7066
    //本地-100000:总时间:13962
    

    这结果简直是优秀啊,纵使redistTemplate再怎么坑比,但是5000次的耗时依然只有接近6秒,所以一直搞到了十万次,也才不过72秒而已,但是是按指数增长的,JedisPool这边就好多了,看下数据图:
    在这里插入图片描述
    这个主因是服务器的带宽太低了,另一个就是磁盘了,使用redis-benchmark测试一下:

    redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 10000 -q
    

    低速服务器:
    在这里插入图片描述
    本地:
    在这里插入图片描述
    写入性能差了三倍,我本机内存是DDR4频率2666Mhz的,看这结果服务器配的应该连三代都不如,唉,一分钱一分货了

    展开全文
  • redisTemplate和jedis两种操作缓存

    千次阅读 2019-06-05 10:00:55
    概念:Jedis是Redis官方推荐的面向Java的操作Redis的客户端,而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接...

    概念:Jedis是Redis官方推荐的面向Java的操作Redis的客户端,而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接池的特性,方便与其他Spring框架进行搭配使用如:SpringCache。总体redisTemplate 用的多。

    (一)操作引用自
    redis 菜鸟教程(opsfor类型):
    https://www.runoob.com/redis/redis-commands.html 这里事务,安装,操作,分区全有。
    别人写的不错(配置util都有): https://blog.csdn.net/weixin_44030218/article/details/87897032#2SerializeUtilclass_207
    opsforvalue: Redis 字符串数据类型的相关命令用于管理 redis 字符串

    opsforHash: Redis hash 是一个string类型的field和value的映射表,hash特别适合用于存储对象

    opsforList: Redis列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)

    其他人写的redis操作:
    https://blog.csdn.net/ruby_one/article/details/79141940

    自己买的redis 小册子:
    扫码阅读(仅限自己)在这里插入图片描述

    (二) jedis操作redis 缓存(jedis类型 自己做的增删改查):
    这个写的可以(配置util都有):
    https://blog.csdn.net/weixin_44030218/article/details/87553193
    CRUD:

      /** 
     * <pre>项目名称:Commodity-Web 
     * 文件名称:RedisController.java 
     * 包名:com.jk.commodity.controller 
     * 创建日期:2018年6月23日下午8:38:28 
     * Copyright (c) 2018, yuxy123@gmail.com All Rights Reserved.</pre> 
     */  
    package com.jk.commodity.controller;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.Random;
    
    import org.codehaus.jackson.annotate.JsonAnyGetter;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.jk.commodity.model.User;
    import com.jk.commodity.service.RedisService;
    
    import redis.clients.jedis.ShardedJedis;
    import redis.clients.jedis.ShardedJedisPool;
    
    /** 
     * <pre>项目名称:Commodity-Web    
     * 类名称:RedisController    
     * 类描述:    
     * 创建人:
     * 创建时间:2018年6月23日 下午8:38:28    
     * 修改人:
     * 修改时间:2018年6月23日 下午8:38:28    
     * 修改备注:       
     * @version </pre>    
     */
    @Controller
    @RequestMapping(value="/Redis")
    public class RedisController {
      @Autowired
      private RedisService redisService;
      @Autowired
      private ShardedJedisPool shardedJedisPool;
      @RequestMapping(value="/queryRedis")
      @ResponseBody
      public String queryRedis(Integer offset,Integer limit){
    	  List <User>list=null;
    	  //获取jedis
    	  ShardedJedis jedis= shardedJedisPool.getResource();
    	  Boolean exists = jedis.exists("list");
    	  if(!exists){
    		if(jedis.setnx("synouc","1")==1){ //加锁
    			jedis.expire("synouc",20*60);//防止死锁
    			//这里不需要加offset,limit!!!
    			list= redisService.queryRedis();
    			HashMap<String ,String>map=new HashMap<>();
    			for (User user : list) {
    			 jedis.lpush("list",user.getUserid().toString());
    			 map.put("userid",user.getUserid().toString());
    			 map.put("username",user.getUsername());
    			 map.put("userpas",user.getUserpas().toString());
    			 jedis.hmset("list_"+user.getUserid().toString(),map);
    			 Random random=new Random();//准备失效时间 随机
    			 int nextInt = random.nextInt(100);
    			}
    			jedis.del("synouc");
    			jedis.expire("list",300*600);
    		}else{
    			try {
    				Thread.sleep(50);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}   
    	  }
    //如果你把redis 中删了则全依靠下面的代码重新生成!!他这个分页是针对redis的与查询方法无关,但是你前台任然得写 server!!!!!!!!!!!!!!!
    	  List<String> list2 = jedis.lrange("list", offset, offset+limit-1);
    	  List<Map<String,String>>list1=new ArrayList();
    	  for (String id : list2) {
    		  Map<String, String> hgetAll = jedis.hgetAll("list_"+id);
    		  list1.add(hgetAll);
    	}
           JSONObject object=new JSONObject();
           object.put("total",jedis.llen("list"));
           object.put("rows",list1);
    	  return object.toJSONString();
      }
    }
    
    -----------------------------------------------------------------------------------------------
    redis 新增
        @Override
    public void insertRedis(User user) {
    	//新增没有传过来id 所以需要拿id 接收一下!!
    	//利用username 查 id
    	redisMapper.insertRedis(user);
    	int id=redisMapper.queryRedisid(user.getUsername());
    /*	List<User> list1=redisMapper.queryRediss(id);*/
    	List<User> list1=redisMapper.queryRedisss(id);
    	ShardedJedis jedis = shardedJedisPool.getResource();
    	//存map 和hashMap都一样 HashMap hashmap=new HashMap();  
    	Map<String,String> map=new HashMap();
    	//往list中添加id 不是删了在建!!!
    	jedis.lpush("list",list1.get(0).getUserid().toString());
    	map.put("userid", list1.get(0).getUserid().toString());
    	map.put("username",list1.get(0).getUsername());
    	map.put("userpas",list1.get(0).getUserpas());
    	jedis.hmset("list_"+list1.get(0).getUserid(),map);
    }
    
    sql:
      <insert id="insertRedis" parameterType="com.jk.commodity.model.User">
         insert into t_user(username,userpas) values(#{username},#{userpas})
       </insert>
        <select id="queryRedisid" resultType="int" parameterType="String">
        select t.userid from t_user t where t.username=#{username}
       </select>
       <select id="queryRedisss" resultType="com.jk.commodity.model.User" parameterType="int">
        select t.* from t_user t where t.userid=#{id} 
       </select>
    
    -------------------------------------------------------------------------------------------------------------------------------
    reids 删除:
    1:用del 删除redis来做!!
          @RequestMapping(value="/delredis")
      @ResponseBody
      public void delredis(Integer id){
    	  redisService.delredis(id); 
    	 
      }
    
       @Override
    public void delredis(Integer id) {
    	redisMapper.delredis(id);
    	 ShardedJedis jedis = shardedJedisPool.getResource();
    	  jedis.del("list");
    	  jedis.del("list_"+id);
    }
    
    
    
    就是在基本删除的基础上加上上面红字就行。
        jedis.del("list");  //先数据库删了之后再在redis中删了 list 然redis 查询方法 当list  不存在时会根据数据库中现在已有的数据新创建一个list 而 list_id id 为是数字这这个会直接删除了不会再redis中继续生成
    
    2:用expire 过期时间来做!!
    expire(String,seconds);   时间单位为秒
    expire(list,seconds);
    ShardedJedis jedis = shardedJedisPool.getResource();
    	jedis.expire("list",10);
    	jedis.expire("list_"+id,10);
    代替:
     ShardedJedis jedis = shardedJedisPool.getResource();
    	  jedis.del("list");
    	  jedis.del("list_"+id); 
    ------------------------------------------------------------------------------------------------------------------------------
    redis修改:
    id 不能 修改所以redis中的list不需要过期!!!! 
      一样意思,修改方法上后面加上过期在加上查询
    

    配置:

    配置文件:
      config.properties:
        #db driver
    jdbc.driver=com.mysql.jdbc.Driver
    #db url
    jdbc.url=jdbc:mysql://主机ip:3306/888?&useUnicode=true&characterEncoding=utf8&mysqlEncoding=utf8
    #db username
    jdbc.username=root
    #db password
    jdbc.password=root
    #db maxActive
    jdbc.maxActive=2
    #db minIdle
    jdbc.minIdle=5
    #db maxIdle
    jdbc.maxIdle=5
    #redis
    maxTotal=2000
    maxIdle=50
    redisHost=127.0.0.1
    redisPort=6379
    redisTimeout=3000
    
    spring-context:
          <?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: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.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx.xsd">
    	<!-- 开启注解扫描 识别框架搭建过程中的 @service 和 @repository base-package 扫描com.jk包下的所有类 
    		识别类中有关于spring的注解 注解 其实就是在java类当中编写一个标志,能够被java代码所识别,通过该注解的形式,做对应的代码操作 -->
    	<context:component-scan base-package="com.jk">
    	</context:component-scan>
    
    	<!-- 不需要扫描service等等 -->
    	<!-- 配置数据源属性文件 spring读取properties文件所用工具类 -->
    	<bean id="propertyConfigurer"
    		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    		<property name="locations">
    			<list>
    				<value>classpath:config.properties</value>
    			</list>
    		</property>
    	</bean>
    	<!-- 配置数据源 配置数据库连接池 获取数据源 -->
    	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    		<property name="driverClassName" value="${jdbc.driver}" />
    		<property name="url" value="${jdbc.url}" />
    		<property name="username" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.password}" />
    		<!--maxActive: 最大连接数量 -->
    		<property name="maxActive" value="${jdbc.maxActive}" />
    		<!--minIdle: 最小空闲连接 -->
    		<property name="minIdle" value="${jdbc.minIdle}" />
    		<!--maxIdle: 最大空闲连接 -->
    		<property name="maxIdle" value="${jdbc.maxIdle}" />
    
    	</bean>
    	
    	
         <!--jedis   配置  -->
         	<!-- spring注入jedis  -->
    		  <bean  id="jedisPoolConfig"  class="redis.clients.jedis.JedisPoolConfig">
    			  	     	<property name="maxTotal" value="30" />
    				        <property name="maxIdle" value="30" />
    				        <property name="numTestsPerEvictionRun" value="1024"/>
    				        <property name="timeBetweenEvictionRunsMillis" value="30000" />
    				        <property name="minEvictableIdleTimeMillis" value="-1" />
    				        <property name="softMinEvictableIdleTimeMillis" value="10000" />
    				        <property name="maxWaitMillis" value="1500"/>
    				        <property name="testOnBorrow" value="true" />
    				        <property name="testWhileIdle" value="true"/>
    				        <property name="testOnReturn" value="false"/>
    				        <property name="blockWhenExhausted" value="false"/>
    				        <property name="evictionPolicyClassName" value="org.apache.commons.pool2.impl.DefaultEvictionPolicy" />
    			  </bean>
    		  	
    		  	<!-- spring注入jedis  -->
    		  	  <bean id="jedisShardInfo" class="redis.clients.jedis.JedisShardInfo">
    		        <constructor-arg index="0" value="${redisHost}" />
    		        <constructor-arg index="1" value="${redisPort}" />
    		        <constructor-arg index="2" value="${redisTimeout}" />
       			 </bean>
    		  	
    		  	
    		  	<bean  id="shardedJedisPool"  class="redis.clients.jedis.ShardedJedisPool">
    		  		 <constructor-arg index="0" ref="jedisPoolConfig"/>
    		  		 <constructor-arg index="1">
    		  		 	<list>
    			  		 	<ref bean="jedisShardInfo"/>
    		  		 	</list>
    		  		 </constructor-arg>
    		  	</bean>
         
    	
    	
    
    	<!-- mybatis的SqlSession的工厂: SqlSessionFactoryBean dataSource:引用数据源 MyBatis定义数据源,同意加载配置 -->
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		<!-- 引入数据配置 方便mybatis获取数据库连接 -->
    		<property name="dataSource" ref="dataSource"></property>
    		<!-- 配置mybatis的日志记录 mybatis-config.xml mybatis的全局配置文件 主要用来配置共有常量等信息 配置日志信息 -->
    		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
    		<!--mapperLocations mybatis映射文件的扫描路径 扫描识别mybatis的映射文件 -->
    		<property name="mapperLocations" value="classpath:com/jk/*/mapper/*.xml"></property>
    	</bean>
    	
    	<!-- mybatis自动扫描加载Sql映射文件/接口 : MapperScannerConfigurer sqlSessionFactory 
    		basePackage:指定sql映射文件/接口所在的包(自动扫描) -->
    
    	<!-- 上传文件拦截,设置最大上传文件大小 10M=10*1024*1024(B)=10485760 bytes -->
    	<bean id="multipartResolver"
    		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    		<property name="maxUploadSize" value="10485760" />
    	</bean>
    	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    		<!-- mybatis没有dao层 mybatis的映射接口充当dao层 -->
    		<property name="basePackage" value="com.jk.*.mapper" />
    		<!-- 注入sqlSessionFactory 相当于把Hibernate的sessionFactory注入到HibernateDaoSupport一样 -->
    		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    	</bean>
    
    
    
    	<!-- 配置事务管理器 -->
    	<bean id="transactionManager"
    		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		<!-- 配置数据源 引入数据库连接池 获取到数数据连接 -->
    		<property name="dataSource" ref="dataSource" />
    	</bean>
    
    	<!-- 定义advice,配置传播特性、事务隔离级别、只读事务、回滚策略 -->
    	<tx:advice id="txAdvice" transaction-manager="transactionManager">
    		<tx:attributes>
    			<tx:method name="add*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
    			<tx:method name="save*" propagation="REQUIRED"
    				rollback-for="java.lang.Exception" />
    			<tx:method name="up*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
    			<tx:method name="del*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
    			<tx:method name="insert*" propagation="REQUIRED"
    				rollback-for="java.lang.Exception" />
    			<tx:method name="set*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
    			<tx:method name="*" propagation="REQUIRED" read-only="true" />
    		</tx:attributes>
    	</tx:advice>
     	<aop:config>
    		<aop:advisor pointcut="execution(* com.jk.*.service.*.*(..))"
    			advice-ref="txAdvice" />
    	</aop:config>
    	
    		<!--
    	<bean  id="aopMongoLog"  class="com.jk.aoplog.AopMongoLog"></bean>
    	<aop:config> 
    		<aop:advisor 
       			 pointcut="execution(* com.jk.service.impl.*.*(..))" 
        		 advice-ref="aopMongoLog"/> 
       </aop:config>
    	 -->	
    </beans> 
    

    Pom文件:

    <dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-redis</artifactId>
    			<version>1.5.0.RELEASE</version>
    		</dependency>
    		<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.9.0</version>
    		</dependency>
    redis.client 这个jar包提供jedis的一些方法!!
    
    **若是springboot 则可能是:**
    <!-- 缓存支持 -->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-cache</artifactId>
    		</dependency>
    		<!-- Redis缓存支持 -->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    		</dependency>
    
    展开全文
  • 1、redisTemplate是基于某个具体实现的再封装,比如说springBoot1.x时,具体实现是jedis;而到了springBoot2.x时,具体实现变成了lettuce。封装的好处就是隐藏了具体的实现,使调用更简单,但是有人测试过jedis效率...

    1、redisTemplate是基于某个具体实现的再封装,比如说springBoot1.x时,具体实现是jedis;而到了springBoot2.x时,具体实现变成了lettuce。封装的好处就是隐藏了具体的实现,使调用更简单,但是有人测试过jedis效率要10-30倍的高于redisTemplate的执行效率,所以单从执行效率上来讲,jedis完爆redisTemplate。redisTemplate的好处就是基于springBoot自动装配的原理,使得整合redis时比较简单。

    2、jedis作为老牌的redis客户端,采用同步阻塞式IO,采用线程池时是线程安全的。优点是简单、灵活、api全面,缺点是某些redis高级功能需要自己封装。

    3、lettuce作为新式的redis客户端,基于netty采用异步非阻塞式IO,是线程安全的,优点是提供了很多redis高级功能,例如集群、哨兵、管道等,缺点是api抽象,学习成本高。lettuce好是好,但是jedis比他生得早。

    4、redission作为redis的分布式客户端,同样基于netty采用异步非阻塞式IO,是线程安全的,优点是提供了很多redis的分布式操作和高级功能,缺点是api抽象,学习成本高。

    中文文档:https://github.com/redisson/redisson/wiki

    综上所述:单机并发量低时优先选择jedis,分布式高并发时优先选择redission。

     

    展开全文
  • 首先项目A,也就是SpringBOOT项目中使用redisTemplate 来做REDIS的缓存时,你会发现存到REDIS里边的KEYVALUE,redisTemplat使用jdkSerializeable存储二进制字节编码 项目B中使用jedis时,存储起来的是字符串,...
  • RedisTemplateJedisPool的区别

    千次阅读 2019-01-02 16:43:00
    1、RedisTemplate是SpringDataRedis中对JedisApi的高度封装。而Jedis是Redis官方推荐的面向Java的操作Redis的客户端,可以用JedisPool来获得连接进行get、set、del等操作相对简单...
  • RedisTemplate redisTemplate; //存入数据 redisTemplate.opsForValue().set(key, girl, 600, TimeUnit.SECONDS); redisTemplate.取出的数据不能直接反序列化为entity实体,List<JSONObject> 否则使用...
  • Jedis和RedisTemplate有何区别

    万次阅读 2019-07-09 15:49:55
    Jedis是Redis官方推荐的面向Java的操作Redis的客户端,而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接池的...
  • Jedis和RedisTemplate有何区别

    千次阅读 2020-10-16 11:33:34
    Jedis是Redis官方推荐的面向Java的操作Redis的客户端,而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接池的...
  • jedis和redisTemplate

    万次阅读 2019-01-30 11:38:14
    使用原生jedis和spring的redisTemplate调用连接池,发现差别巨大: redis配置: redis: database: 0 host: 127.0.0.1 port: 6379 password: 123456 timeout: 5000 lettuce: shutdown-timeout: 200 ...
  • 博主小白最近刚在项目里接触redis,结果发现各种各样对redis进行操作的方式,当时就懵逼了,比如RedisTemplateJedis等等,好像对redis操作起来都挺方便呀,这哥几个到底啥关系呀??? 一气之下各种查找资料…...
  • redisTemplate封装jedis方法

    千次阅读 2018-10-14 18:27:41
    http://www.mamicode.com/info-detail-1856843.html
  • 前言:在 JavaWeb 中实现对 Redis 的操作,主要有两种方式:Jedis和RedisTemplateJedis是Redis官方推荐的面向Java操作Redis的客户端开发Jar包;而RedisTemplate是Spring框架对Jedis API的进行了高度封装,支持连接...
  • 很多时候,我们也许需要使用一些更为高级的缓存服务器的 API,如 Redis 的流水线、事务 Lua 语言等,所以也许会使用到 RedisTemplate 本身。 首先,定义 RedisTemplateService 的接口,代码如下所示。 package ...
  • Springboot+redis(Jedis和RedisTemplate)+CRUD

    千次阅读 2019-05-29 14:33:57
    talk is cheap,show you my code 方法一:使用jedis(Jedis是Redis官方推荐的面向Java的操作Redis的客户端,详细文档可见jedis文档) 0.当然,首先你要先安装redis数据库,不会安装的...2.在pom文件中导入jedis和fastj...
  • 项目中用的是RedisTemplate操作redis,但是某些api只有原生jedis里才有,比如jedis.hset 我们可以通过RedisTemplate获取原生Jedis,来满足我们的需求。 代码如下 RedisConnection conn= null; try { conn = ...
  • Java如何使用redis:Jedis和RedisTemplate

    千次阅读 2020-05-07 17:55:21
    本文详细介绍了Java使用redis的两种方式:Jedis和RedisTemplate的详细配置使用。其中Jedis提供了各个数据类型的操作方法;RedisTemplate介绍了如何配置redis,以配置类的方式进行结合,提供了一个封装类RedisUtil...
  • RedisTemplate和Jedis

    2019-10-28 14:49:43
    RedisTemplate:是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接池的特性,方便与其他Spring框架进。 Jedis相关文档: ...
  • Jedis和RedisTemplate 全方位对比总结

    千次阅读 2020-09-22 21:08:52
    jedis – redis提供官方API 使用时自构建 jedisPool RedisTemplate – 基于Spring ,拓展性 极强 使用上 jedis – 十分不优美,看着low ,但十分简单 RedisTemplate – 比较优美 , 使用较为复杂 ...
  • RedisTemplate是SpringDataRedis中对JedisApi的高度封装。RedisTemplate是基于某个具体实现的再封装,比如说springBoot1.x时,具体实现是jedis;而到了springBoot2.x时,具体实现变成了lettuce。 SpringDataRedis相...
  • springboot整合jedisCluster和RedisTemplate

    千次阅读 2020-06-11 14:17:41
    springboot整合jedisCluster SpringBoot集成redis的JedisCluster和RedisTemplate SpringBoot整合redis——redisTemplate jedisjedisPool、jedisCluster区别和使用
  • 用于jedis-spring-data redisTemplate --> 7 < dependency > 8 < groupId > org.apache.commons groupId > 9 < artifactId > commons-pool2 artifactId > 10 < version > ${apache-commons-...
  • 在开发项目的时候,习惯使用Jedis操作redis,但如果我们用Spring boot框架,它已经帮我们整合好了redis缓存操作类,具体看RedisAutoConfiguration类,此时我们想获得Jedis操作redis怎么办???? 1.1. 实现 public ...
  • redisTemplate代替jedis实现分布式锁

    千次阅读 2019-09-22 13:45:41
    springBoot集成redis之后,在使用之前的jedis,会加上诸多配置注解,很烦恼,因此,自己研究了两天,使用redisTemplate实现
  • Jedis是Redis官方推荐的面向Java的操作Redis的客户端,而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。 SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端,比Jedis多了自动管理连接池的...
  • SpringBoot2之后,默认采用Lettuce作为redis的连接客户端,当然我们还是可以强制捡回来,使用我们熟悉的Jedis的,本篇简单介绍下使用Jedis的相关配置 原文链接: 181101-SpringBoot高级篇Redis之Jedis配置 I. 基本...
  • JedisRedisTemplate、StringRedisTemplate: Jedis是官方推荐使用的操作redis的客户端 StringRedisTemplate继承自RedisRemplate,但是两者是不共通的,StringRedisTemplate只管理StringRedisTemplate里面的数据,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,515
精华内容 5,806
关键字:

redistemplate和jedis的区别

redis 订阅