spring+redis+mysql做缓存操作

最新推荐文章于 2024-04-29 17:13:56 发布
最新推荐文章于 2024-04-29 17:13:56 发布
阅读量323 收藏 1
点赞数
分类专栏： redis 文章标签： spring redis mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50975965/article/details/122417474
版权

spring+redis+mysql做缓存操作

idea创建普通java项目

在这里插入图片描述

修改pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<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.sxt</groupId>
  <artifactId>03redis-spring-mysql</artifactId>
  <version>1.0</version>

  <name>03redis-spring-mysql</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
    <mybatis.version>3.5.2</mybatis.version>
    <mybatis-spring.version>2.0.2</mybatis-spring.version>
    <spring.version>4.3.24.RELEASE</spring.version>
    <druid.version>1.0.18</druid.version>
    <mysql.version>8.0.17</mysql.version>
    <fastjson.version>1.2.59</fastjson.version>
    <!-- 注意只能使用2.0以下的版本 -->
    <log4j.version>1.2.17</log4j.version>
    <jedis.version>3.1.0</jedis.version>
<lombok.verison>1.18.10</lombok.verison>

  </properties>

  <dependencies>
    <!-- mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>
    <!-- mybatis-spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis-spring.version}</version>
    </dependency>
    <!-- 导入spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</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-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- mysql数据库驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <!-- json -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>${fastjson.version}</version>
    </dependency>
    <!-- log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>${jedis.version}</version>
    </dependency>
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>${lombok.verison}</version>
  <scope>provided</scope>
</dependency>


  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-project-info-reports-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

我这里用的是Mybatisgenerator插件

生成User实体类

import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
    * 用户编号
    */
    private Integer id;

    /**
    * 用户姓名
    */
    private String name;

    /**
    * 用户地址
    */
    private String address;

    /**
    * 出生时间
    */
    private Date birth;

    /**
    * 是否删除1删除0未删除
    */
    private Integer flag;

    private static final long serialVersionUID = 1L;
}

生成UserMapper

import com.sxt.domain.User;

import java.util.List;

public interface UserMapper {
    int deleteByPrimaryKey(Integer id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);

    List<User> queryAllUser();
}

生成UserMapper.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.hgzy.mapper.UserMapper">
  <resultMap id="BaseResultMap" type="com.hgzy.domain.User">
    <!--@mbg.generated-->
    <!--@Table sys_user-->
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="address" jdbcType="VARCHAR" property="address" />
    <result column="birth" jdbcType="DATE" property="birth" />
    <result column="flag" jdbcType="INTEGER" property="flag" />
  </resultMap>
  <sql id="Base_Column_List">
    <!--@mbg.generated-->
    id, `name`, address, birth, flag
  </sql>
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    <!--@mbg.generated-->
    select 
    <include refid="Base_Column_List" />
    from sys_user
    where id = #{id,jdbcType=INTEGER}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    <!--@mbg.generated-->
    delete from sys_user
    where id = #{id,jdbcType=INTEGER}
  </delete>
  <insert id="insert" keyColumn="id" keyProperty="id" parameterType="com.hgzy.domain.User" useGeneratedKeys="true">
    <!--@mbg.generated-->
    insert into sys_user (`name`, address, birth, 
      flag)
    values (#{name,jdbcType=VARCHAR}, #{address,jdbcType=VARCHAR}, #{birth,jdbcType=DATE}, 
      #{flag,jdbcType=INTEGER})
  </insert>
  <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.hgzy.domain.User" useGeneratedKeys="true">
    <!--@mbg.generated-->
    insert into sys_user
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="name != null">
        `name`,
      </if>
      <if test="address != null">
        address,
      </if>
      <if test="birth != null">
        birth,
      </if>
      <if test="flag != null">
        flag,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="name != null">
        #{name,jdbcType=VARCHAR},
      </if>
      <if test="address != null">
        #{address,jdbcType=VARCHAR},
      </if>
      <if test="birth != null">
        #{birth,jdbcType=DATE},
      </if>
      <if test="flag != null">
        #{flag,jdbcType=INTEGER},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.hgzy.domain.User">
    <!--@mbg.generated-->
    update sys_user
    <set>
      <if test="name != null">
        `name` = #{name,jdbcType=VARCHAR},
      </if>
      <if test="address != null">
        address = #{address,jdbcType=VARCHAR},
      </if>
      <if test="birth != null">
        birth = #{birth,jdbcType=DATE},
      </if>
      <if test="flag != null">
        flag = #{flag,jdbcType=INTEGER},
      </if>
    </set>
    where id = #{id,jdbcType=INTEGER}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.hgzy.domain.User">
    <!--@mbg.generated-->
    update sys_user
    set `name` = #{name,jdbcType=VARCHAR},
      address = #{address,jdbcType=VARCHAR},
      birth = #{birth,jdbcType=DATE},
      flag = #{flag,jdbcType=INTEGER}
    where id = #{id,jdbcType=INTEGER}
  </update>

  <select id="queryAllUser" resultMap="BaseResultMap">
    <!--@mbg.generated-->
    select
    <include refid="Base_Column_List" />
    from sys_user

    </select>
</mapper>

生成UserService


import com.sxt.domain.User;

import java.util.List;

public interface UserService{


    int deleteByPrimaryKey(Integer id);

    User insert(User user);


    User selectByPrimaryKey(Integer id);


    User updateByPrimaryKey(User user);

    List<User> queryAllUser();

}

生成UserServiceImpl


import com.sxt.domain.User;
import com.sxt.mapper.UserMapper;
import com.sxt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;


    @Override
    public int deleteByPrimaryKey(Integer id) {
        return this.userMapper.deleteByPrimaryKey(id);
    }

    @Override
    public User insert(User user) {
        this.userMapper.insert(user);
        return user;
    }

    @Override
    public User selectByPrimaryKey(Integer id) {
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Override
    public User updateByPrimaryKey(User user) {
        int index = this.userMapper.updateByPrimaryKey(user);
        return user;
    }

    @Override
    public List<User> queryAllUser() {
        return this.userMapper.queryAllUser();
    }
}

创建application-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--声明配置-->
    <bean id="poolConfig" class="org.apache.commons.pool2.impl.GenericObjectPoolConfig">
        <property name="maxTotal" value="100"></property>
        <property name="maxIdle" value="80"></property>
        <property name="minIdle" value="20"></property>
        <property name="maxWaitMillis" value="2000"></property>
        <property name="testOnBorrow" value="true"></property>
    </bean>
    <!--jedispool-->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <!--因为JedisPool没有属性  所以只能使用构造器的注入方式-->
        <constructor-arg name="poolConfig" ref="poolConfig"/>
        <constructor-arg name="host" value="ip地址"/>
        <constructor-arg name="port" value="7001"/>
        <constructor-arg name="timeout" value="2000"/>
        <constructor-arg name="password" value="317311"/>
    </bean>
</beans>

创建db.properties

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/redis-test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=317311

创建log4j的配置文件

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

创建application-dao.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"
       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.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 引入db.properties -->
    <context:property-placeholder
            location="classpath*:db.properties" system-properties-mode="FALLBACK" />

    <!-- 声明dataSource -->
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <!-- 注入连接属性 -->
        <property name="driverClassName" value="${driverClassName}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${username}"></property>
        <property name="password" value="${password}"></property>
    </bean>
    <!-- 声明sessionFactory 并注入mybatis.cfg.xml -->
    <bean id="sqlSessionFactory"
          class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 注入mapper.xml -->
        <property name="mapperLocations">
            <array>
                <value>classpath:mapper/*Mapper.xml</value>
            </array>
        </property>
    </bean>

    <!-- 扫描mapper接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入mapper接口所在的包 注意多个包的情况的配置 -->
        <property name="basePackage">
            <value>
                com.sxt.mapper
            </value>
        </property>
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName"
                  value="sqlSessionFactory"></property>
    </bean>
</beans>

创建application-service.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"
       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">

    <context:component-scan base-package="com.sxt.service.impl"></context:component-scan>

    <!-- 1,声明事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 启动注解事务 -->
    <!-- <tx:annotation-driven/> -->
    <!-- 2,声明事务的传播特性 也就是通知 -->
    <tx:advice id="advise" transaction-manager="transactionManager">
        <tx:attributes>
            <!-- 以add开头的方法名需要事务 -->
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="change*" propagation="REQUIRED"/>
            <tx:method name="reset*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="load*" read-only="true"/>
            <tx:method name="*" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!-- 3进行AOP织入 -->
    <aop:config>
        <!-- 声明切面 -->
        <aop:pointcut expression="execution(* com.sxt.service.impl.*.*(..))" id="pc"/>
        <!-- 织入 -->
        <aop:advisor advice-ref="advise" pointcut-ref="pc"/>
    </aop:config>
</beans>

创建CacheUserAspect（切面）

package com.sxt.cache;

import com.alibaba.fastjson.JSON;
import com.sxt.domain.User;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.io.Serializable;

/**
 * @program: redis-code
 * @author: 雷哥
 * @create: 2019-12-31 16:39
 **/
@Component
@Aspect
@EnableAspectJAutoProxy
public class CacheUserAspect {


    private Log log= LogFactory.getLog(CacheUserAspect.class);

    public static final String POINTCUT_ADD="execution(* com.sxt.service.impl.UserServiceImpl.insert(..))";
    public static final String POINTCUT_UPDATE="execution(* com.sxt.service.impl.UserServiceImpl.updateByPrimaryKey(..))";
    public static final String POINTCUT_DELETE="execution(* com.sxt.service.impl.UserServiceImpl.deleteByPrimaryKey(..))";
    public static final String POINTCUT_GETONE="execution(* com.sxt.service.impl.UserServiceImpl.selectByPrimaryKey(..))";

    //redis里面的前缀
    public static final String PROFIX="user:";

    //注入JedisPool
    @Autowired
    private JedisPool jedisPool;



    @Around(value = CacheUserAspect.POINTCUT_ADD)
    public Object cacheAddUser(ProceedingJoinPoint pjp) throws Throwable {
        //插入数据库
        User user = (User) pjp.proceed();
        Jedis jedis = jedisPool.getResource();

        //把user转成json串
        String json= JSON.toJSONString(user);
        jedis.set(PROFIX+user.getId(),json);
        log.info(PROFIX+user.getId()+"数据已存入到Redis");
        jedis.close();
        return user;
    }

    @Around(value = CacheUserAspect.POINTCUT_UPDATE)
    public Object cacheUpdateUser(ProceedingJoinPoint pjp) throws Throwable {
        //修改数据库
        User user = (User) pjp.proceed();
        Jedis jedis = jedisPool.getResource();
        //把user转成json串
        String json= JSON.toJSONString(user);
        jedis.set(PROFIX+user.getId(),json);
        log.info(PROFIX+user.getId()+"数据已更新到Redis");
        jedis.close();
        return user;
    }

    @Around(value = CacheUserAspect.POINTCUT_DELETE)
    public Object cacheDeleteUser(ProceedingJoinPoint pjp) throws Throwable {
        //删除数据库
        Serializable id = (Serializable) pjp.getArgs()[0];
        log.info(PROFIX+id+"数据库数据已删除");
        Jedis jedis = jedisPool.getResource();
        if(jedis.exists(PROFIX+id)){
            jedis.del(PROFIX+id);
            log.info(PROFIX+id+"数据已从Redis删除");
        }
        jedis.close();
        return id;
    }

    @Around(value = CacheUserAspect.POINTCUT_GETONE)
    public Object cacheGetOneUser(ProceedingJoinPoint pjp) throws Throwable {
        Serializable id = (Serializable) pjp.getArgs()[0];
        if(null==id){
            return null;
        }
        Jedis jedis = jedisPool.getResource();
        String json = jedis.get(PROFIX + id);
        if(null!=json){
            User user=JSON.parseObject(json,User.class);
            log.info(PROFIX+id+"已从redis里机查询到数据");
            jedis.close();
            return user;
        }else{
            log.info(PROFIX+id+"缓存里面没有数据，要从数据库里面查询");
            User user= (User) pjp.proceed();
            if(null!=user){
                jedis.set(PROFIX+user.getId(),JSON.toJSONString(user));
                log.info(PROFIX+id+"数据已存入redis");
            }
            jedis.close();
            return  user;
        }
    }
}

创建application-cache.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 http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.sxt.cache"></context:component-scan>

</beans>

创建applicationContext.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">


    <import resource="classpath*:application-dao.xml"></import>
    <import resource="classpath*:application-service.xml"></import>
    <import resource="classpath*:application-redis.xml"></import>
    <import resource="classpath*:application-cache.xml"></import>
</beans>

测试

public class TestApp {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

        UserService userService = context.getBean(UserService.class);

        User user=new User();
        user.setName("张三");
        user.setAddress("株洲");
        user.setBirth(new Date());
        user.setFlag(1);
        userService.insert(user);
        System.out.println("成功");
    }
}
look-word
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
社区系统源码：基于 SpringBoot + MyBatis + MySQL + Redis + Kafka
05-08
分布式缓存：Redis 本地缓存：Caffeine 消息队列：Kafka 2.13-2.7.0 搜索引擎：Elasticsearch 6.4.3 安全：Spring Security 邮件任务：Spring Mail 分布式定时任务：Spring Quartz 日志：SLF4J（日志接口） + ...
SpringBoot整合Redis使用注解进行缓存
StoNENee的博客
07-18 1325
Hello，各位小伙伴，最近项目中需要将一些常用的数据缓存起来，毫无疑问，我们采用了Redis来缓存数据。那么使用Redis缓存数据有哪些方式呢？接下来我会一一道来。 1.环境搭建 引入Redis依赖以及Spring相关的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</ar.
基于Spring-Boot和Redis缓存Mysql数据库数据
Starbucks_star的专栏
11-02 5196
1.开发技术和工具 Spring-Boot、Mybatis、Redis  |  IDEA、Mysql、Navicat、Redis Desktop Manager、Postman 2.Redis 在目前企业开发过程中，对于热数据都是用NoSql的模式进行相应的缓存，而其中用的最多的就是Redis(ps:鹿晗事件你们可能见识到sina redis崩掉导致热门话题5个小时都没无法访问)。 Redi
SpringBoot+Mybatis整合Redis做MySQL的二级缓存
xiaoy990的博客
05-02 3271
SpringBoot+Mybatis整合Redis做MySQL的二级缓存 第一次接触Redis有说的不对的地方欢迎大家指正，代码亲测可以食用。文章是在vscode中用markdown插件写完的，后来想想还是发在csdn上吧，就直接站题过来了，排版或者什么可能会有些问题，就先说这么多叭。 1. 什么是Redis Redis是一个NoSQL key-value型数据库，在项目中使用Redis主要考虑...
springboot+redis+mybatis+mysql实现缓存技术，并保证redis与mysql中数据保持一致性
weixin_41756573的博客
03-21 8747
该篇博客会持续完善与更新，欢迎大神留言指教 原创文章转载请注明来源：https://blog.csdn.net/weixin_41756573/article/details/88719311 一：搭建项目基础架构 1.pom.xml(基于springboot2.0.1) pom文件中标为蓝色的表示是实现基于redis缓存的相关依赖 <project xmlns="http://m...
redis spring 切面缓存_SpringAOP实现redis缓存和mysql数据库同步
weixin_39960710的博客
12-19 149
1、定义一个切面，使用AfterReturning通知，修改、删除、新增等成功后更新缓存a、修改时先改数据库数据，修改成功后再同步到缓存中、b、删除时先删除数据库数据，删除成功再清理缓存中的对应数据c、新增时先插入数据库，插入成功，再同步进入缓存com.aspect.demo;com.model.Company;com.model.ExceptionCompany;com.Cache.RedisC...
使用springboot实现redis作为mysql缓存
weixin_43114582的博客
01-02 2785
使用springboot实现redis作为mysql缓存前言项目代码配置文件 前言 例子在github上使用springboot实现redis作为mysql缓存. 因为博主的linux通过购买阿里服务器并使用宝塔linux系统，博主通过宝塔系统提供的软件商店下载的Mysql和Redis。通过命令行安装网络上已经有很多，这里就不在赘述。 不过，大同小异之处在一下两点。 1. 开放3306和6379...
head请求_Redis【二】SpringBoot + Redis + Mysql 配置head请求头的验证
weixin_39988888的博客
11-26 1491
一、效果二、配置1.配置pom.xml <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-data-redisartifactId> depe...
SpringBoot整合redis+mysql
qq_44715376的博客
11-25 3631
SpringBoot+Redis+mysql
互联网大厂必问之 MySQL、Redis、Spring 三大块，面试必备技术栈
老男孩的架构路
12-08 237
前言怎么样是不是感觉面试很难，而且快到了“年底”跳槽涨薪高峰季了，不管是实习生还是有想要跳槽的大佬们即将进入找工作的高峰期，在任何 Java 面试当中 MySQL、Redis、Spring 方面的问题都是必不可少的一部分。所以这篇文章是我最新整理的面试题答案以及总结，希望对想进 BAT 的同学有帮助,由于篇幅较长，建议收藏后细看~答案是不区分如何解决需要区分英文大小写的场景例如登录用户为 admin，此时填写 ADMIN 也能登录，如果用户名需要区分大小写，你的做法是什么？解决方案一MySQL 默认的字符检
springmvc+redis+mysql（数据库连接简单实现）数据缓存
08-09
实现redis与springmvc配置，数据库连接简单实现，待完善实现连接池
一个简单的论坛-Spring+SpringMVC+MyBatis+MySQL+Redis
10-25
一个初学者练手项目，开发IDE为IntelliJ IDEA，通过Maven构建，后台采用Spring、SpringMVC、MyBatis，数据库采用MySQL、Redis，前台用到jQuery，图片被上传到七牛云。
Redis+mysql整合spring的Demo
04-07
redis使用例子，包含增删改査
Java+MySQL+redis缓存
12-18
案例中数据来自MySQL数据库，对查询出来的数据缓存到redis,redis缓存工具可以将缓存string，bean,list，map等类型，代码中有详细的注释，而且还将要缓存的数据进行了序列化，大家可以借鉴，进而更改成自己想要的格式。数据库配置使用了xml和propertis两种配置方式，redis缓存采用非切片和切片两种配置，大家可以自选择
spring boot + mysql +mybatis +redis（二级缓存）实例
12-14
spring boot + mysql +mybatis +redis（二级缓存）实例------------------------------------------------------------
基于SpringBoot2+Jpa+SpringSecurity+redis+Vue的前后端分离系统
03-10
系统缓存管理 将redis的操作可视化，提供对redis的基本操作 Sql监控 采用 druid 监控数据库访问性能 技术栈 基础框架：Spring Boot 2.1.0.RELEASE 持久层框架：Spring boot Jpa 安全框架：Spring Security 缓存框架...
maven 创建 spring + springmvc + mybatis + redis + mysql 学生查询例子
05-24
用maven创建基于springmvc和mybatis框架的小例子，数据库mysql，用的是redis缓存； jre 1.7，tomcat 7
通过Spring Boot + Mybatis + Redis快速搭建现代化Web项目
08-28
本篇文章介绍了如何通过Spring Boot、Mybatis以及Redis快速搭建一个现代化的Web项目，并且同时介绍了如何在Spring Boot下优雅地书写单元测试来保证我们的代码质量。具体内容详情大家通过本文学习下吧
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
最新发布
阿里巴巴云原生的博客
04-29 843
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
spring boot+redis+mysql实现秒杀操作
05-12
实现秒杀操作需要考虑以下几个方面： 1. 并发控制：秒杀操作本身是高并发场景，需要采取一些措施保证并发安全，例如使用分布式锁等。 2. 数据库设计：需要设计合理的数据库结构，例如订单表、商品表、库存表等，并且需要考虑事务的隔离级别和回滚机制。 3. 缓存设计：秒杀场景下对于商品库存需要频繁读写操作，可以使用 Redis 等内存缓存技术来提高读写性能。 下面是一个简单的 spring boot+redis+mysql 实现秒杀操作的示例： 1. 首先在数据库中创建商品表、订单表和库存表，并初始化数据。 2. 使用 Redis 存储商品库存信息，例如使用 hash 类型存储，key 为商品 id，value 为库存数量。 3. 在后端实现一个秒杀接口，首先从 Redis 中读取商品库存信息，并进行检查，如果库存不足则返回秒杀失败。如果库存充足，则使用分布式锁来保证并发安全，将库存数量减一，并将订单信息写入订单表中。最后返回秒杀成功的信息。 4. 在前端实现一个秒杀页面，用户点击秒杀按钮后会请求后端秒杀接口，根据返回的秒杀结果来显示秒杀成功或失败的信息。 需要注意的是，在实际应用中需要考虑更多的细节和安全问题，例如防止重复秒杀、防止恶意攻击等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值