Spring+Mybatis+redis整合(用依赖注入的方式手动修改缓存)

最新推荐文章于 2024-03-29 18:48:58 发布

胖墩的IT

最新推荐文章于 2024-03-29 18:48:58 发布

阅读量2.3k

点赞数 1

分类专栏： # SSM # Redis

本文链接：https://blog.csdn.net/weixin_43113679/article/details/90413124

版权

Redis 同时被 2 个专栏收录

49 篇文章 4 订阅

订阅专栏

SSM

23 篇文章 1 订阅

订阅专栏

现在开始Spring+mybatis+redis的整合，一开始我想的是Spring+SpringMVC+Mybatis+redis进行整合，但是慢慢整合着就就感觉前面的会了，后面的肯定也就会了，也就不整合后面的了，如果感觉还是很模糊的话，你可以根据下面的慢慢的来整合你肯定会这么觉的

这篇redis不是用注解的方式操作缓存的，用依赖注入的方式，让redis相当于一个数据库(它原本就是一个key-value库)，不像用注解的方式完全不用自己管理，只需有几个工具类，这里需要自己手动写redis的set，get…，添加生命周期和对象转成json字符串也是自己手动解决，当然如果redisDao完善了(命令全了，以后也可以相当于个工具包了)
注解方式请看这：https://blog.csdn.net/weixin_43113679/article/details/90680254

先看看我的目录结构

在这里插入图片描述

首先spring-server.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:tx="http://www.springframework.org/schema/tx"
	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/tx 
						http://www.springframework.org/schema/tx/spring-tx.xsd
						http://www.springframework.org/schema/context 
						http://www.springframework.org/schema/context/spring-context-4.0.xsd
	">
	<!-- 包扫描 -->
	<context:component-scan base-package="cn.qlq.service"/>
	<!-- 下面这俩import,因为是测试，没办法从web.xml里读取，所以只能写这个，等再加上springmvc时就可以直接让web.xml读取全部的xml了，就不用下面这两个import了 -->
	<import resource="spring-dao.xml"/>
	<import resource="spring-redis.xml"/>
	<!--配置事务管理器 -->
	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
		
	</bean>
	<!-- 配置注解的事务驱动 -->
	<tx:annotation-driven transaction-manager="txManager"/>	
	
</beans>

spring-dao.xml和它的配置文件conn.properties

<?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:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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-4.0.xsd
						http://www.springframework.org/schema/tx
						http://www.springframework.org/schema/tx/spring-tx.xsd
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop.xsd
	">
	
	<!-- property-placeholder用于加载一个属性文件 -->
	<!-- ignore-unresolvable="true"  必须加上，要不肯定出错，错误应该是没有找到配置文件，如果不加上，它就会只读一个，剩下的不会读按顺序 -->
	<context:property-placeholder location="classpath:conn.properties" ignore-unresolvable="true"/>
	
	<!-- c3p0数据库连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
		p:driverClass="${jdbc.driver}" p:jdbcUrl="${jdbc.url}"
		p:user="${jdbc.username}" p:password="${jdbc.password}"
		p:maxPoolSize="100" p:minPoolSize="20"
		p:initialPoolSize="20" p:maxIdleTime="200" >
		</bean>

	
	<!-- sqlSessionFactory工厂bean -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	     <!-- 数据库连接池,ref和上面的数据库连接池的id对应 -->
	     <property name="dataSource" ref="dataSource" />
	     <!-- 加载mybatis的全局配置文件 -->
	     <property name="configLocation" value="classpath:sqlMapConfig.xml" />
	</bean>											
	
	<!-- 配置MyBatis的高级mapper代理方式 -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- 扫描包路径，如果需要扫描多个包，中间使用半角逗号隔开 -->
		<property name="basePackage" value="cn.qlq.mapper"></property>
		
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
	
	</bean>
 

</beans>

conn.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/qbb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=

sqlMapConfig

<?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>
	<!-- MyBatis的全局参数设置，基本用来进行MyBatis的优化处理 -->
	<settings>
	  <!-- 开启二级缓存 -->
 
      <setting name="cacheEnabled" value="true"/>
   
    
		<!-- 下面的是延迟加载 -->
		<setting name="lazyLoadingEnabled" value="true"/>
		<!-- 是否开启延迟加载 -->
		<setting name="aggressiveLazyLoading" value="false"/>
		<!-- 缓冲加载 -->
		<setting name="cacheEnabled" value="true"/>
	</settings>
	
	<typeAliases>
		<!--肯定要有这个的啦，要不怎么从mybatis中返回自己想要的对象呢-->
		<package name="cn.qlq.bean"/>
	</typeAliases>
	
</configuration>

spring-redis.xml和它的配置文件redis.properties

<?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 
						http://www.springframework.org/schema/context/spring-context-4.0.xsd">
 
	<!-- 连接池配置 -->
	<context:component-scan base-package="cn.qlq.Redis"/>
	<!--ignore-unresolvable必须写上true，要不配置文件就读不上了，当然，也可以全读，我这为了区分，分开读的-->
	<context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/>
	<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
	<!--下面这些可以用配置文件里也可以自己定义，在你，value格式和下一个bean一样-->
		<!-- 最大连接数 -->
		<property name="maxTotal" value="30" />
		<!-- 最大空闲连接数 -->
		<property name="maxIdle" value="10" />
		<!-- 每次释放连接的最大数目 -->
		<property name="numTestsPerEvictionRun" value="1024" />
		<!-- 释放连接的扫描间隔（毫秒） -->
		<property name="timeBetweenEvictionRunsMillis" value="30000" />
		<!-- 连接最小空闲时间 -->
		<property name="minEvictableIdleTimeMillis" value="1800000" />
		<!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
		<property name="softMinEvictableIdleTimeMillis" value="10000" />
		<!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
		<property name="maxWaitMillis" value="1500" />
		<!-- 在获取连接的时候检查有效性, 默认false -->
		<property name="testOnBorrow" value="true" />
		<!-- 在空闲时检查有效性, 默认false -->
		<property name="testWhileIdle" value="true" />
		<!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
		<property name="blockWhenExhausted" value="false" />
	</bean>	
	
	<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="host" value="${redis.url}"></constructor-arg>
		<constructor-arg name="port" value="${redis.port}"></constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
</beans>

redis.properties

redis.url="ip地址" //自己查自己的
redis.port=6379
redis.pass=
redis.maxIdle=300
redis.maxTotal=30
redis.maxActive=1024
redis.maxWait=10000
redis.testOnBorrow=true

pom.xml

除了SSM中必须有的jar包外下面的也要有

<!--redis必须有的jar包-->
<dependency>
	    <groupId>org.springframework.data</groupId>
	    <artifactId>spring-data-redis</artifactId>
	    <version>1.8.10.RELEASE</version>
	</dependency>
  	<dependency>
	    <groupId>redis.clients</groupId>
	    <artifactId>jedis</artifactId>
	    <version>2.9.0</version>
	</dependency>
	<!--负责json字符串和javabean对象之间的互转换-->
	 <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.56</version>
	</dependency>

User类

package cn.qlq.bean;


public class User {

	private int id;
	private String name;
	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;
	}
	
	
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + "]";
	}
	
	
}

Mapper类(数据库类)

接口

package cn.qlq.mapper;

import java.util.List;
import org.apache.ibatis.annotations.Param;
import cn.qlq.bean.User;

public interface UserMapper {

	/**
	 * 获得所有的用户
	 * */
	List<User> getUser()throws Exception;
	/**
	 * 插入一个用户
	 * */
	void insertUser(@Param("user")User user)throws Exception;
	/**
	 * 通过id查询用户
	 * 
	 * @param id
	 * @return
	 */
	User findUserById(@Param("id")int id);

}

mapper.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">

<!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离 注意：使用mapper代理方法开发，namespace有特殊重要的作用 -->
<mapper namespace="cn.qlq.mapper.UserMapper">
     <select id="getUser"  resultType="cn.qlq.bean.User">
        select * from book
    </select>
	<update id="insertUser" parameterType="cn.qlq.bean.User">
		INSERT INTO book (id,name) VALUES (#{user.id},#{user.name})
	
	</update>
    <select id="findUserById" parameterType="int" resultType="cn.qlq.bean.User">
        select * from book where id = #{id}
    </select>
</mapper>

缓存类

接口

/**
 * 
 */
package cn.qlq.Redis;

/**
 * @author 作者
 * @date 2019年5月21日 
 */
public interface RedisDao {
	/**
	 * show 获得缓存中的value
	 * */
	String get(String key) throws Exception;
	/**
	 * show 往缓存中添加value
	 * */
	void set(String key,String value) throws Exception;
	/**
	 * show 获取hash
	 * */
	String hget(String hkey,String key) throws Exception;
	/**
	 * show 插入一个hash
	 * */
	void hset(String hkey,String key,String value)throws Exception;

	
}

实现类

package cn.qlq.Redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.JedisPool;

/**
 * @author 作者
 * @date 2019年5月21日 
 */
@Repository("redisDao")
public class RedisDaoImpl implements RedisDao{
	@Autowired
	private JedisPool jedisPool ;

	@Override
	public String get(String key) throws Exception {
		
		return jedisPool.getResource().get(key);
	}

	@Override
	public void set(String key,String value) throws Exception {
		//获得6小时到9小时的随机时间
		int time=(int)(6+Math.random()*(4))*60*60;
		//添加键
		 jedisPool.getResource().set(key, value);
		 //给键添加生命周期
		 jedisPool.getResource().expire(key, time);
	}

	@Override
	public String hget(String hkey, String key) throws Exception {
		
		return jedisPool.getResource().hget(hkey, key);
	}

	@Override
	public void hset(String hkey, String key,String value) throws Exception {
		int time=(int)(6+Math.random()*(4))*60*60;
		 jedisPool.getResource().hset(hkey, key,value);
		 jedisPool.getResource().expire(key, time);
	}


}

Server类

接口

package cn.qlq.service;
import java.util.List;
import cn.qlq.bean.User;

public interface UserService {
	/**
	 * show 获取所有的User
	 * */
	List<User> getUser()throws Exception;
	/**
	 * show 插入新的User
	 * */
	void insertUser(User user)throws Exception;
	
	
	/**
	 * 通过id查询用户
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	 User findUserById(int id) throws Exception;
	
	
}

实现类

package cn.qlq.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import com.alibaba.fastjson.JSON;
import cn.qlq.Redis.RedisDao;
import cn.qlq.bean.User;
import cn.qlq.mapper.UserMapper;
import cn.qlq.service.UserService;
@Transactional(rollbackFor=Exception.class)
@Service("userService")
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper=null;
	@Autowired
	private RedisDao redisDao =null;
	@Override
	public List<User> getUser() throws Exception {
		
		return userMapper.getUser();
	}

	@Override
	public void insertUser(User user) throws Exception {
		userMapper.insertUser(user);
		String userJson = redisDao.get("user_"+user.getId());
		if(StringUtils.isEmpty(userJson)) {
			System.out.println("插入缓存");
			//因为是缓存中存的是字符串，所以需要转成json字符串
			redisDao.set("user_"+user.getId(), JSON.toJSONString(user));	
		}
		//还需要插入数据库中，没写，自己写
	}
	
	@Override
	public User findUserById(int id) throws Exception {
		String userjson = redisDao.get("user_"+id);
		User user =null;
		//判断缓存中存在对应的id的
		if(StringUtils.isEmpty(userjson)) {
			//不存在去数据库中取出，再放进缓存
			user = userMapper.findUserById(id);
			if(user != null) {
				redisDao.set("user_"+id, JSON.toJSONString(user));	
			}else {
				//数据库中也不存在就把这个id也存进缓存中标识，防止雪崩或者穿透
			}
		}else {
			//存在就直接把缓存里的json拿出来转换成对象
			System.out.println("从缓存拿是数据，不去数据库");
			user = JSON.parseObject(userjson,User.class);
		}
		return user;
	}
}

是面关于fastjson的转换字符串和对象不明白的可以参考https://segmentfault.com/a/1190000011212806

测试类


package text;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.qlq.bean.User;
import cn.qlq.service.UserService;


public class ssmTest {
	@Autowired
	 private ApplicationContext ctx = null;
	 @Autowired
     private UserService userService = null;
	 
   
     @Test	
 	public void testGetUsers() throws Exception{
    	 ctx = new ClassPathXmlApplicationContext("spring-service.xml");
         userService = ctx.getBean(UserService.class);
 		List<User> users = userService.getUser();
 		System.out.println(users);
 	}
 	
 	@Test
 	public void testInsertUser() throws Exception{
 		ctx = new ClassPathXmlApplicationContext("spring-service.xml");
        userService = ctx.getBean(UserService.class);
 		User user = new User();
 		user.setId(9);
 		user.setName("第一个");
 		
 		userService.insertUser(user);
 	}
 	
 	@Test
 	public void testGetUserById() throws Exception{
 		ctx = new ClassPathXmlApplicationContext("spring-service.xml");
        userService = ctx.getBean(UserService.class);
 		System.out.println(userService.findUserById(9));
 		
 	}




}

结果：
第二个Test
在这里插入图片描述

第三个Test

没有经过数据库，直接进的缓存拿的数据，完成。

胖墩的IT

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Spring+Mybatis+redis整合(用依赖注入的方式手动修改缓存)

现在开始Spring+mybatis+redis的整合，一开始我想的是Spring+SpringMVC+Mybatis+redis进行整合，但是慢慢整合着就就感觉前面的会了，后面的肯定也就会了，也就不整合后面的了，如果感觉还是很模糊的话，你可以根据下面的慢慢的来整合你肯定会这么觉的先看看我的目录结构首先spring-server.xml<?xml version="1.0" en...
复制链接

扫一扫