springboot + mybatis + redis的本地测试demo

最新推荐文章于 2024-05-09 11:31:44 发布
最新推荐文章于 2024-05-09 11:31:44 发布
阅读量672 收藏
点赞数
文章标签： mybatis springboot redis demo java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40983417/article/details/82796661
版权

对于对数据库请求量较大的项目，设置缓存是必要且必须的。不但可以减轻数据库的压力，还可以提高数据查询的速度。尤其是对于查询远远大于更新的项目来说，缓存的设置对性能的提升是显而易见的。当然，缓存也不是尽善尽美的，缓存的最大问题就是可能出现脏数据。而这几乎是很难避免的，所以对于一些对数据要求极其精准的字段，是不能应用缓存的。关于redis相关推荐大家看下面的博客：
https://www.cnblogs.com/rjzheng/p/9096228.html

本demo是基于我的前两篇文章，参考了网上的redis配置代码进行结合，最终实现的demo。
关于redis的主要代码借鉴了：
https://blog.csdn.net/plei_yue/article/details/79362372

程序的结构如图：
在这里插入图片描述

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/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.redis-mybatis</groupId>
	<artifactId>redis-mybatis</artifactId>
	<version>1.0.0.BUILD-SNAPSHOT</version>
    <parent>
    	<groupId> org.springframework.boot </groupId>
        <artifactId> spring-boot-starter-parent </artifactId>
        <version> 1.5.6.RELEASE </version>
    </parent >
    <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.7</java.version>
	</properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
           
		<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
		
        <dependency>
    		<groupId>org.springframework.boot</groupId>
   			<artifactId>spring-boot-starter</artifactId>
    			<exclusions>
        			<exclusion>
            			<groupId>org.springframework.boot</groupId>
            			<artifactId>spring-boot-starter-logging</artifactId>
        			</exclusion>
    			</exclusions>
		</dependency>
		
		<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>
		
        <dependency>
        	<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-devtools</artifactId>
        	<optional>true</optional>
    	</dependency>
    	
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
        	<groupId>com.oracle</groupId>
			<artifactId>ojdbc14</artifactId>
			<version>10.2.0.4.0</version>
		</dependency>

    </dependencies>
    
     <build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
			<plugin>
           	 	<groupId>org.springframework.boot</groupId>
            	<artifactId>spring-boot-maven-plugin</artifactId>
            	<configuration>
                <fork>true</fork>
            	</configuration>
        	</plugin>
		</plugins>
	</build>
</project>

MybatisRedisCache.java

public class MybatisRedisCache implements Cache {

    private static JedisConnectionFactory jedisConnectionFactory;

    private final String id;

    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public MybatisRedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        this.id = id;
    }

    @Override
    public void clear() {
        RedisConnection connection = null;
        try {
            connection = jedisConnectionFactory.getConnection();
            connection.flushDb();
            connection.flushAll();
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }

    @Override
    public String getId() {
        return this.id;
    }

    @Override
    public Object getObject(Object key) {
        Object result = null;
        RedisConnection connection = null;
        try {
            connection = jedisConnectionFactory.getConnection();
            RedisSerializer<Object> serializer = new GenericJackson2JsonRedisSerializer();
            result = serializer.deserialize(connection.get(serializer.serialize(key)));
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    @Override
    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }

    @Override
    public int getSize() {
        int result = 0;
        RedisConnection connection = null;
        try {
            connection = jedisConnectionFactory.getConnection();
            result = Integer.valueOf(connection.dbSize().toString());
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    @Override
    public void putObject(Object key, Object value) {
        RedisConnection connection = null;
        try {
            connection = jedisConnectionFactory.getConnection();
            RedisSerializer<Object> serializer = new GenericJackson2JsonRedisSerializer();
            connection.set(serializer.serialize(key), serializer.serialize(value));
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }

    @Override
    public Object removeObject(Object key) {
        RedisConnection connection = null;
        Object result = null;
        try {
            connection = jedisConnectionFactory.getConnection();
            RedisSerializer<Object> serializer = new GenericJackson2JsonRedisSerializer();
            result = connection.expire(serializer.serialize(key), 0);
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return result;
    }

    public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
        MybatisRedisCache.jedisConnectionFactory = jedisConnectionFactory;
    }

}

RedisConfig.java

@Configuration
@PropertySource("classpath:application.properties")
public class RedisConfig {

    @Value("${redis.maxIdle}")
    private Integer maxIdle;

    @Value("${redis.maxTotal}")
    private Integer maxTotal;

    @Value("${redis.maxWaitMillis}")
    private Integer maxWaitMillis;

    @Value("${redis.minEvictableIdleTimeMillis}")
    private Integer minEvictableIdleTimeMillis;

    @Value("${redis.numTestsPerEvictionRun}")
    private Integer numTestsPerEvictionRun;

    @Value("${redis.timeBetweenEvictionRunsMillis}")
    private long timeBetweenEvictionRunsMillis;

    @Value("${redis.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${redis.testWhileIdle}")
    private boolean testWhileIdle;
    
    @Value("${redis.host}")
    private String url;

    @Value("${redis.port}")
    private int port;
    
    @Value("${redis.password}")
    private String password;
    
    @Value("${redis.timeout}")
    private int timeout;
    
    /**
     * JedisPoolConfig 连接池
     * @return
     */
    @Bean
	public JedisPoolConfig jedisPoolConfig() {
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		// 最大空闲数
		jedisPoolConfig.setMaxIdle(maxIdle);
		// 连接池的最大数据库连接数
		jedisPoolConfig.setMaxTotal(maxTotal);
		// 最大建立连接等待时间
		jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
		// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
		jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
		// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
		jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
		// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
		jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
		// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
		jedisPoolConfig.setTestOnBorrow(testOnBorrow);
		// 在空闲时检查有效性, 默认false
		jedisPoolConfig.setTestWhileIdle(testWhileIdle);
		return jedisPoolConfig;
	}
    /**
     * 单机版配置
    * @Title: JedisConnectionFactory 
    * @param @param jedisPoolConfig
    * @param @return
    * @return JedisConnectionFactory
    * @throws
     */
    
    
    @Bean
    public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);
        //连接池  
        
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig);  
        //IP地址  
        jedisConnectionFactory.setHostName(url);  
        //端口号  
        jedisConnectionFactory.setPort(port);  
        //如果Redis设置有密码  
        jedisConnectionFactory.setPassword(password);
        //客户端超时时间单位是毫秒  
        jedisConnectionFactory.setTimeout(timeout);  
        
        return jedisConnectionFactory; 
    }

    /**
     * 实例化 RedisTemplate 对象
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
    /**
     * 设置数据存入 redis 的序列化方式,并开启事务
     * 
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        //如果不配置Serializer，那么存储的时候缺省使用String，如果用Order类型存储，那么会提示错误Order can't cast to String！  
        redisTemplate.setKeySerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // 开启事务
        redisTemplate.setEnableTransactionSupport(true);
        redisTemplate.setConnectionFactory(factory);
    }
    /**
     * 注入封装RedisTemplate
    * @Title: redisUtil 
    * @return RedisUtil
    * @throws
     */
    @Bean(name = "redisUtil")
    public RedisUtil redisUtil(RedisTemplate<String, Object> redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }
    
}

DomesticSalesMapper.java

@Mapper
@Repository
public interface DomesticSalesMapper {
	
	List<Order> getOrder(String date1,String date2);

}

DomesticSalesMapper.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.redis.dao.DomesticSalesMapper"> 
	<cache type="com.redis.cache.MybatisRedisCache"/>
	<resultMap id="getOrder" type="com.redis.model.Order">
	</resultMap>
    <select id="getOrder"  resultType="com.redis.model.Order" parameterType="String" >
      查询语句
    </select>
</mapper>

TestMapper.java

@Mapper
@Repository
public interface TestMapper{
	
	List<Order> getOrder(String date);
	
}

TestMapper.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.redis.dao.TestMapper" > 
	<cache type="com.redis.cache.MybatisRedisCache"/>
	<resultMap id="getOrder" type="com.redis.model.Order">
	</resultMap>
    <select id="getOrder"  resultType="com.redis.model.Order"  parameterType="String">
    	查询语句
    </select>
</mapper>

Order.java

public class Order implements Serializable{

	/**
	 * 
	 */
	private String orderId;
	private String orderTotalPrice;
	private String orderTotalTax;
	private String contactName;

	public String getOrderId() {
		return orderId;
	}
	public void setOrderId(String orderId) {
		this.orderId = orderId;
	}
	public String getOrderTotalPrice() {
		return orderTotalPrice;
	}
	public void setOrderTotalPrice(String orderTotalPrice) {
		this.orderTotalPrice = orderTotalPrice;
	}

	public String getOrderTotalTax() {
		return orderTotalTax;
	}
	public void setOrderTotalTax(String orderTotalTax) {
		this.orderTotalTax = orderTotalTax;
	}
	public String getContactName() {
		return contactName;
	}
	public void setContactName(String contactName) {
		this.contactName = contactName;
	}
	
}

RedisCacheTransfer.java

@Component
public class RedisCacheTransfer {

    @Autowired
    public void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
        MybatisRedisCache.setJedisConnectionFactory(jedisConnectionFactory);
    }

}

RedisUtil.java

public class RedisUtil {

private RedisTemplate<String, Object> redisTemplate;  

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
        this.redisTemplate = redisTemplate;  
    }  
    //=============================common============================  
    /** 
     * 指定缓存失效时间 
     * @param key 键 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean expire(String key,long time){  
        try {  
            if(time>0){  
                redisTemplate.expire(key, time, TimeUnit.SECONDS);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 根据key 获取过期时间 
     * @param key 键 不能为null 
     * @return 时间(秒) 返回0代表为永久有效 
     */  
    public long getExpire(String key){  
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);  
    }  

    /** 
     * 判断key是否存在 
     * @param key 键 
     * @return true 存在 false不存在 
     */  
    public boolean hasKey(String key){  
        try {  
            return redisTemplate.hasKey(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 删除缓存 
     * @param key 可以传一个值 或多个 
     */  
    @SuppressWarnings("unchecked")  
    public void del(String ... key){  
        if(key!=null&&key.length>0){  
            if(key.length==1){  
                redisTemplate.delete(key[0]);  
            }else{  
                redisTemplate.delete(CollectionUtils.arrayToList(key));  
            }  
        }  
    }  

    //============================String=============================  
    /** 
     * 普通缓存获取 
     * @param key 键 
     * @return 值 
     */  
    public Object get(String key){  
        return key==null?null:redisTemplate.opsForValue().get(key);  
    }  

    /** 
     * 普通缓存放入 
     * @param key 键 
     * @param value 值 
     * @return true成功 false失败 
     */  
    public boolean set(String key,Object value) {  
         try {  
            redisTemplate.opsForValue().set(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  

    }  

    /** 
     * 普通缓存放入并设置时间 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 
     * @return true成功 false 失败 
     */  
    public boolean set(String key,Object value,long time){  
        try {  
            if(time>0){  
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);  
            }else{  
                set(key, value);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 递增 
     * @param key 键 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public long incr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递增因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, delta);  
    }  

    /** 
     * 递减 
     * @param key 键 
     * @param by 要减少几(小于0) 
     * @return 
     */  
    public long decr(String key, long delta){    
        if(delta<0){  
            throw new RuntimeException("递减因子必须大于0");  
        }  
        return redisTemplate.opsForValue().increment(key, -delta);    
    }    

    //================================Map=================================  
    /** 
     * HashGet 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return 值 
     */  
    public Object hget(String key,String item){  
        return redisTemplate.opsForHash().get(key, item);  
    }  

    /** 
     * 获取hashKey对应的所有键值 
     * @param key 键 
     * @return 对应的多个键值 
     */  
    public Map<Object,Object> hmget(String key){  
        return redisTemplate.opsForHash().entries(key);  
    }  

    /** 
     * HashSet 
     * @param key 键 
     * @param map 对应多个键值 
     * @return true 成功 false 失败 
     */  
    public boolean hmset(String key, Map<String,Object> map){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * HashSet 并设置时间 
     * @param key 键 
     * @param map 对应多个键值 
     * @param time 时间(秒) 
     * @return true成功 false失败 
     */  
    public boolean hmset(String key, Map<String,Object> map, long time){    
        try {  
            redisTemplate.opsForHash().putAll(key, map);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 向一张hash表中放入数据,如果不存在将创建 
     * @param key 键 
     * @param item 项 
     * @param value 值 
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间 
     * @return true 成功 false失败 
     */  
    public boolean hset(String key,String item,Object value,long time) {  
         try {  
            redisTemplate.opsForHash().put(key, item, value);  
            if(time>0){  
                expire(key, time);  
            }  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 删除hash表中的值 
     * @param key 键 不能为null 
     * @param item 项 可以使多个 不能为null 
     */  
    public void hdel(String key, Object... item){    
        redisTemplate.opsForHash().delete(key,item);  
    }   

    /** 
     * 判断hash表中是否有该项的值 
     * @param key 键 不能为null 
     * @param item 项 不能为null 
     * @return true 存在 false不存在 
     */  
    public boolean hHasKey(String key, String item){  
        return redisTemplate.opsForHash().hasKey(key, item);  
    }   

    /** 
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回 
     * @param key 键 
     * @param item 项 
     * @param by 要增加几(大于0) 
     * @return 
     */  
    public double hincr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item, by);  
    }  

    /** 
     * hash递减 
     * @param key 键 
     * @param item 项 
     * @param by 要减少记(小于0) 
     * @return 
     */  
    public double hdecr(String key, String item,double by){    
        return redisTemplate.opsForHash().increment(key, item,-by);    
    }    

    //============================set=============================  
    /** 
     * 根据key获取Set中的所有值 
     * @param key 键 
     * @return 
     */  
    public Set<Object> sGet(String key){  
        try {  
            return redisTemplate.opsForSet().members(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 根据value从一个set中查询,是否存在 
     * @param key 键 
     * @param value 值 
     * @return true 存在 false不存在 
     */  
    public boolean sHasKey(String key,Object value){  
        try {  
            return redisTemplate.opsForSet().isMember(key, value);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将数据放入set缓存 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSet(String key, Object...values) {  
        try {  
            return redisTemplate.opsForSet().add(key, values);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 将set数据放入缓存 
     * @param key 键 
     * @param time 时间(秒) 
     * @param values 值 可以是多个 
     * @return 成功个数 
     */  
    public long sSetAndTime(String key,long time,Object...values) {  
        try {  
            Long count = redisTemplate.opsForSet().add(key, values);  
            if(time>0) expire(key, time);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 获取set缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long sGetSetSize(String key){  
        try {  
            return redisTemplate.opsForSet().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 移除值为value的 
     * @param key 键 
     * @param values 值 可以是多个 
     * @return 移除的个数 
     */  
    public long setRemove(String key, Object ...values) {  
        try {  
            Long count = redisTemplate.opsForSet().remove(key, values);  
            return count;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
    //===============================list=================================  

    /** 
     * 获取list缓存的内容 
     * @param key 键 
     * @param start 开始 
     * @param end 结束  0 到 -1代表所有值 
     * @return 
     */  
    public List<Object> lGet(String key,long start, long end){  
        try {  
            return redisTemplate.opsForList().range(key, start, end);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 获取list缓存的长度 
     * @param key 键 
     * @return 
     */  
    public long lGetListSize(String key){  
        try {  
            return redisTemplate.opsForList().size(key);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  

    /** 
     * 通过索引 获取list中的值 
     * @param key 键 
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 
     * @return 
     */  
    public Object lGetIndex(String key,long index){  
        try {  
            return redisTemplate.opsForList().index(key, index);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, Object value, long time) {  
        try {  
            redisTemplate.opsForList().rightPush(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 将list放入缓存 
     * @param key 键 
     * @param value 值 
     * @param time 时间(秒) 
     * @return 
     */  
    public boolean lSet(String key, List<Object> value, long time) {  
        try {  
            redisTemplate.opsForList().rightPushAll(key, value);  
            if (time > 0) expire(key, time);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }  

    /** 
     * 根据索引修改list中的某条数据 
     * @param key 键 
     * @param index 索引 
     * @param value 值 
     * @return 
     */  
    public boolean lUpdateIndex(String key, long index,Object value) {  
        try {  
            redisTemplate.opsForList().set(key, index, value);  
            return true;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return false;  
        }  
    }   

    /** 
     * 移除N个值为value  
     * @param key 键 
     * @param count 移除多少个 
     * @param value 值 
     * @return 移除的个数 
     */  
    public long lRemove(String key,long count,Object value) {  
        try {  
            Long remove = redisTemplate.opsForList().remove(key, count, value);  
            return remove;  
        } catch (Exception e) {  
            e.printStackTrace();  
            return 0;  
        }  
    }  
}

TestController.java

@RestController
public class TestController {
	
	Logger logger = LoggerFactory.getLogger(TestController.class);
    
	@Autowired
	private TestMapper testMapper;
	
	@Autowired
	private DomesticSalesMapper domesticSalesMapper;
	
	String date="2018-09-21";
	public String date1 = "'2018-09-21 00:00:00'";
	public String date2 = "'2018-09-21 02:00:00'";
	
	@Scheduled(cron = "0 0/1 * * * *")
	public void order() throws IOException{
		List<Order> tlist = testMapper.getOrder(date);
		List<Order> dslist = domesticSalesMapper.getOrder(date1,date2);
		
		logger.info("print start");
		
		String s = tlist.size()+"";
		logger.info(s);	
		
		File f = new File("D:/testrm."+".txt");
		FileWriter out = new FileWriter(f);
		
		for(int i=0;i<dslist.size();i++){
			out.write(dslist.get(i).getContactName() + "\r\n");
		}
		
		out.close();
		
		logger.info("print finished");
	}

	
}

和我参考的博客对比一下，细心的读者应该能看到一处不同。在redis的序列化时，我把所有的序列化方式都更改为了GenericJackson2JsonRedisSerializer() 。因为按照我参考博客的序列化方式，在使用Order的getter方法时会报错，并且使用redis可视化工具查看缓存时，缓存是我们无法直接读取的。使用了GenericJackson2JsonRedisSerializer()这个序列化方式，把Order类以Json的形式储存在redis中，节省了存储空间，使用可视化工具也可以清晰的查看缓存中的数据。

application.properties

#redis单服务器配置  
#spring.redis.database=0  
redis.host=主机ip
redis.port=6379  
redis.password=密码
redis.timeout=1000
#最大空闲数  
redis.maxIdle=300  
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal  
#redis.maxActive=600  
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性  
redis.maxTotal=1000  
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。  
redis.maxWaitMillis=1000  
#连接的最小空闲时间 默认1800000毫秒(30分钟)  
redis.minEvictableIdleTimeMillis=300000  
#每次释放连接的最大数目,默认3  
redis.numTestsPerEvictionRun=1024  
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1  
redis.timeBetweenEvictionRunsMillis=30000  
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个  
redis.testOnBorrow=true  
#在空闲时检查有效性, 默认false  
redis.testWhileIdle=true

spring.datasource.url=jdbc:oracle:thin:@ip:sid
spring.datasource.username=用户名
spring.datasource.password=密码
spring.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.jpa.database=oracle
mybatis.type-aliases-package=com.redis.dao
mybatis.mapper-locations=classpath*:mapper/*Mapper.xml
#使用debug级别的日志可以查看缓存命中率
logging.level.root=info
#logging.level.root=debug
logging.level.org.springframework.web=info
#logging.level.org.springframework.web=debug
logging.file=D:/REDIS-MYBATIS.log
logging.pattern.console=%d{yyyy/MM/dd-HH:mm:ss} [%thread] %-5level %logger- %msg%n
logging.pattern.file=%d{yyyy/MM/dd-HH:mm} [%thread] %-5level %logger- %msg%n

可以看到这时命中率为1，也就是说我们是完全从redis缓存中查询的数据，而且很明显从缓存读取数据速度很快。
在这里插入图片描述

用可视化工具清空redis中的缓存，再运行程序。

在这里插入图片描述
在这里插入图片描述
可以清楚的看到在数据库使用第一个Mapper中的查询语句，花了8秒钟
在这里插入图片描述
使用第二个Mapper中的查询语句，也花了8秒钟

也就是实际上我们花费了16秒从Oracle数据库读取数据。而前面的从缓存里读取数据时间是小于一秒的。性能提升由此可见一斑。

当然，第一次运行查询之后，第二次查询的缓存命中率是不可能到1.0的，现实生产中对于数据的查询也往往会出现这种情况。只有我们反复请求同样的数据时，缓存命中率才会逐渐逼近1.0直到某一次达到1.0。

鵷鶵籲天兮滴血千里
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis入门（含报错调试）
前端小白的成长之路
08-05 780
数据持久层框架快速入门
spring boot+mybatis+redis项目
10-31
spring boot/mybatis库存管理系统，内含代码自动生成系统
【手动读Mybatis源码】图片+源码+调试(全程可以自己动手)
m0_51215376的博客
02-22 487
看看源码
mybatis使用redis缓存两种方式
最新发布
yuguang的博客
05-09 273
【代码】mybatis使用redis缓存两种方式。
SpringBoot+MyBatis+redis
小儍鈲的专栏
11-22 1038
基于xml文件配置的、将redis作为MyBatis的二级缓存   环境：maven3.6.0 + SpringBoot2.1.0.RELEASE + MyBatis pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" ...
Spring boot 集成redis(包括安装本地redis服务)
y976416015的博客
05-23 8235
一、首先安装本地redis服务    1. redis下载地址：https://github.com/MicrosoftArchive/redis/releases    2.选择.msi文件下载下来并双击运行。点击下一步。3.同意安装协议，并进行下一步。4.将redis添加到环境变量当中去。5.添加windows防火墙，确保外界也能正常访问。6.设置redis空间，用于本地测试学习的话100MB...
基于SpringBoot+Spring+SpringMvc+Mybatis+Shiro+Redis 开发单点登录管理系统源码
06-19
基于 SpringBoot + Spring + SpringMvc + Mybatis + Shiro+ Redis 开发单点登录管理系统 基于 SpringBoot + Spring + SpringMvc + Mybatis + Shiro+ Redis 开发单点登录管理系统 基于 SpringBoot + Spring + ...
Seckill:基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统
03-11
基于SpringBoot + Mybatis + Redis + RabbitMQ秒杀系统 开发工具 想法2017.2 开发环境 JDK 玛文 MySQL的 弹簧靴 Redis 兔子MQ 1.8 3.2.2 5.7 1.5.10发布 3.2 4倍 项目启动说明 1，启动前，请配置application....
SpringBoot + Mybatis + Redis 整合
06-27
在IT行业中，SpringBoot、Mybatis和Redis是三个非常重要的技术组件，它们分别代表了Java应用框架、持久层框架和高性能的键值存储系统。本文将深入探讨如何将这三个技术进行整合，以便在实际开发中构建高效、可扩展的...
springboot+mybatis+redis+thymeleaf学习整合web项目demo源码
10-30
这是一个基于Spring Boot、MyBatis、Redis和Thymeleaf技术栈构建的Web项目示例。这个源码库提供了一个全面的学习平台，帮助开发者理解如何将这些流行的技术整合到一个实际的应用中。以下是对这些技术及其整合方式的...
springboot+mybatis+redis+mongodb
06-24
这个实践例子，为springboot项目，里面整合了mysql数据库Mybatis ，增删改查的注解和非主解方式； 整合了全局异常捕捉，统一的接口错误码返回；整合了Druid数据库连接池；整合了Redsi的使用；整合了mongodb的使用； ...
springboot + mybatis-plus + oracle + 多数据源 + redis + hutool
04-06
springboot + mybatis-plus + database+ 多数据源 + redis + hutool 框架干净，没有其他冗余的成分； 配置了MP的代码生成器，意见生成代码，节省开发时间！ 可用于各种定时任务处理，各种夸库操作， 多数据源支持Oracle、Mysql、Sql Server 等数据库夸库操作，使用 @DS 切换数据源。， 可设置多主多从 、纯粹多库（记得设置primary） 、混合配置等； Hutool工具类库，降低相关API的学习成本，提高工作效率；
springboot整合redis的测试案例
11-06
springboot整合redis的测试案例，完整的代码。其中的maven依赖版本是2019.11.6。
redis学习笔记+练习springboot-redisdemo
11-10
里面有关于redis的一些笔记介绍，PPT文档， 还有自己整合的springboot-redis的一个微博demo。有需要的可以下下来看下
SpringBoot+Mybatis+Redis框架Demo
10-12
SpringBoot+Mybatis+Redis框架Demo，内容见博客http://blog.csdn.net/u013965342/article/details/78212379
springboot+maven+mysql+redis框架
05-11
springboot+maven+mysql+redis框架 1. 创建独立的Spring应用程序 2. 嵌入的Tomcat，无需部署WAR文件 3. 简化Maven配置 4. 自动配置Spring 5. 提供生产就绪型功能，如指标，健康检查和外部配置 6. 绝对没有代码生成和对XML没有要求配置
spring boot学习4之mybatis+redis缓存整合
热门推荐
夢の殇
05-21 1万+
上篇博文学习了spring boot+mybatis+PageHelper分页插件的整合，在此基础上继续扩展，使用redis做数据库的二级缓存。对于用redis做数据库的缓存的必要性，就不多说了，特别是在少写多读的场景下（比如类似全国地区码配置表等常量配置表，或用户信息、角色、权限查询）。直接从缓存拿数据比从数据库（数据库要I/O操作）拿要快得多。       例子源码是在上篇博文的例子
SpringBoot重点详解--使用RedisTemplate操作Redis数据库
pengjunlee的博客
09-11 1万+
一、Maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.8.RELE...
SpringBoot整合Mybatis和Redis
04-28
好的，以下是SpringBoot整合Mybatis和Redis的步骤： 1. 在pom.xml中引入Mybatis和Redis的依赖： ```xml <groupId>org.mybatis.spring.boot <artifactId>mybatis-spring-boot-starter ${mybatis-spring-boot-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值