Mysql与Redis整合 实现读写

已于 2023-04-12 09:56:01 修改
阅读量409 收藏
点赞数 6
文章标签： redis mysql 数据库 大数据 java
于 2023-04-12 09:51:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuhahaq/article/details/130099513
版权

 

目录

1 bean

2 config

3 dao

4 service

5 serviceimpl

6 controller

pom.xml

其他博主的：

配置文件  application.properties

创建        bean/        config/        dao/        service/        serviceimpl/        controller 包

1 bean


import java.io.Serializable;

//序列化
public class Course implements Serializable {
    private  String cid;
    private String cname;
    private String tid;


    public Course(String cid, String cname, String tid) {
        this.cid = cid;
        this.cname = cname;
        this.tid = tid;
    }


    public Course() {
    }


    public String getCid() {
        return cid;
    }

    public void setCid(String cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public String getTid() {
        return tid;
    }

    public void setTid(String tid) {
        this.tid = tid;
    }


    @Override
    public String toString() {
        return "course{" +
                "cid='" + cid + '\'' +
                ", cname='" + cname + '\'' +
                ", tid='" + tid + '\'' +
                '}';
    }
}


import lombok.Data;

@Data
public class User {
    private String name;
    private Integer age;
    private Integer high;

}

2 config

package com.wzx.gmall.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;


@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    //注入connectionFactory
    @Autowired
    private RedisConnectionFactory connectionFactory;


//    @Bean
//    public RedisTemplate redisTemplate() {
//        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
//        redisTemplate.setConnectionFactory(connectionFactory);
//        //设置序列化策略
//        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
//        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//
//        redisTemplate.afterPropertiesSet();
//        return redisTemplate;
//    }


    @Bean
    public StringRedisTemplate stringRedisTemplate() {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(connectionFactory);
        return stringRedisTemplate;
    }


    //缓存cache管理器
    @Override
    public CacheManager cacheManager() {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(120)).disableCachingNullValues();
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config)
                .transactionAware().build();
    }




    // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
    // 自己定义了一个RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我们为了自己开发方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}

package com.wzx.gmall.config;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public final class RedisUtils {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;


    public Set<String> keys(String keys){
        try {
            return redisTemplate.keys(keys);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 指定缓存失效时间
     * @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((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }
    /**
     * 普通缓存获取
     * @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 值
     * @return true成功 false失败
     */
    public boolean setnx(String key, Object value) {
        try {
            redisTemplate.opsForValue().setIfAbsent(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 value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean setnx(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().setIfAbsent(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加几(大于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 delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
    /**
     * 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);
    }
    /**
     * 根据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 值
     * @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 值
     * @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;
        }
    }
}

3 dao

package com.wzx.gmall.dao;


import com.wzx.gmall.bean.Course;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface CourseDao {


//    查询所有
    @Select("select * from course")
    List<Course>  findAll();

//添加
    @Insert("insert into course values('006','王梓旭',50)")
    int addCourse(Course course);
    //修改
    @Update("update  course set cname='刘浩' , tid=50 where cid='006' ")
    int updateCourse(Course course);

    //删除
    @Delete("delete from course where cid='006'")
    int deleteCourse(String id);

}

4 service

package com.wzx.gmall.service;

import com.wzx.gmall.bean.Course;
import com.wzx.gmall.bean.User;

import java.util.List;

public interface CourseService {
    /**
     * 查询所有
     */
    List<Course> findAll();

    /**
     *
     * 新增数据
     */
    int addCourse(Course course);

    /**
     *
     *  修改数据
     */
    int  updateCourse(Course course);


    /**
     *
     * 删除数据
     */
    int  deleteCourse(String cid);


    /**
     *
     * 添加和查询
     */
    void setUser();

    String getUser();


}

5 serviceimpl

package com.wzx.gmall.service.serviceImpl;

import com.wzx.gmall.bean.Course;
import com.wzx.gmall.bean.User;
import com.wzx.gmall.config.RedisConfig;
import com.wzx.gmall.dao.CourseDao;
import com.wzx.gmall.service.CourseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

@Service
public class CourseServiceImpl implements CourseService {

    @Autowired
    CourseDao courseDao;

    //从spring容器中获取RedisTemplate实例
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public List<Course> findAll() {
        List<Course> all = courseDao.findAll();

        ValueOperations valueOperations = redisTemplate.opsForValue();

        valueOperations.set("1" ,all.toString());
                //设置过期时间
                redisTemplate.expire("1" ,60, TimeUnit.SECONDS);
        return all;
    }

    @Override
    public int addCourse(Course course) {
        int i = courseDao.addCourse(course);
        if(i==1){
            ValueOperations valueOperations = redisTemplate.opsForValue();

            List<Course> all = courseDao.findAll();

            valueOperations.set("1", all.toString());
        }
        return i;
    }

    @Override
    public int updateCourse(Course course) {
        int i = courseDao.updateCourse(course);
        if(i==1){
            ValueOperations valueOperations = redisTemplate.opsForValue();

            List<Course> all = courseDao.findAll();

            valueOperations.set("1", all.toString());
        }
        return i;
    }

    @Override
    public int deleteCourse(String cid) {
        int i = courseDao.deleteCourse(cid);


        if(i==1){
            ValueOperations valueOperations = redisTemplate.opsForValue();

            List<Course> all = courseDao.findAll();

            valueOperations.set("1", all.toString());
        }


        return i;
    }

    @Override
    public void setUser() {
        User user =new User();
        user.setName("wzx");
        user.setAge(18);
        user.setHigh(175);
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("wzx", user);
//设置过期时间
        redisTemplate.expire("1" ,60, TimeUnit.SECONDS);
    }

    @Override
    public String getUser() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object wzx = valueOperations.get("wzx");
        return wzx.toString();
    }
}

6 controller

package com.wzx.gmall.controller;

import com.wzx.gmall.bean.Course;
import com.wzx.gmall.service.CourseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@Slf4j
@CacheConfig
@RestController
public class CourseController {


    @Autowired
    CourseService courseService;


    @RequestMapping("add")
    public int addCourse(){
        System.out.println("新政数据");
        Course course = new Course();
        return courseService.addCourse(course);
    }

    @Cacheable(cacheNames = "find")
    @RequestMapping("find")
    public List<Course> findAll(){
        System.out.println("查询所有数据");
        return courseService.findAll();
    }



    @RequestMapping("delete")
    public int delete(){
        System.out.println("删除数据");
        return  courseService.deleteCourse("006");
    }

    @RequestMapping("update")
    public int update(){
        System.out.println("更新数据");
        Course course = new Course();
        return  courseService.updateCourse(course);
    }



    @RequestMapping("wzx")
    public void user() throws InterruptedException {
        System.out.println("哈哈我来了：");
        courseService.setUser();
        Thread.sleep(5);


        String user = courseService.getUser();

        System.out.println(user);

    }



}

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wzx.gmall</groupId>
    <artifactId>gmall2023-logger</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gmall2023-logger</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.4.1</spring-boot.version>
        <mybatis.version>3.4.2</mybatis.version>
        <mybatis.spring.version>1.3.0</mybatis.spring.version>
    </properties>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.xmlunit</groupId>
            <artifactId>xmlunit-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-reflect</artifactId>
            <version>2.10.3</version>
            <scope>compile</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/tk.mybatis/mapper-spring-boot-starter -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
        <!-- mybatis-spring 整合jar -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis.spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

        <!-- spring boot 缓存 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <!-- Spring boot Redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>


    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <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>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.1</version>
                <configuration>
                    <mainClass>com.wzx.gmall.Gmall2023LoggerApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>


</project>

其他博主的：

        Redis学习汇总（已完结）_大鱼等于负论坛_大鱼等于负的博客-CSDN博客

冷艳无情的小妈
关注
redis监听写入mysql_数据库应用之--Redis+mysql实现大量数据的读写，以及高并发
weixin_39644614的博客
01-18 315
一、开发背景在项目开发过程中中遇到了以下三个需求：1. 多个用户同时上传数据；2. 数据库需要支持同时读写；3. 1分钟内存储上万条数据；根据对Mysql的测试情况，遇到以下问题：1. 最先遇到压力的是服务器，在写入2500-3000条数据时，服务器崩溃了；2. 当数据库写入时，耗时太长，10000条数据，大概需要505.887s，相当于8分钟，如下：a. 表结构：b. 数据库Procedure:...
lamp架构之redis（3）：redis和mysql的整合
weixin_44717560的博客
02-27 3235
redis和mysql的整合一、redis结合mysql1.redis和mysql的基础概念2.redis和mysql的区别总结3.为什么要作缓存4.redis作为缓存二、环境部署三、mysql+redis部署 一、redis结合mysql 1.redis和mysql的基础概念 mysql：数据放在磁盘 是关系型数据库，主要用于存放持久化数据， redis：数据放在内存 AOF：增量更新 RDB：覆盖 是NOSQL，非关系型数据库。 2.redis和mysql的区别总结 （1）类型上 从类型上来说，mysq
Redis和MySQL的结合方案
yuyeqianhen的博客
04-29 228
本文转载自博客：https://blog.csdn.net/Stubborn_Cow/article/details/50586990 方案由从易到难的顺序，但无论哪种方法，都需要保证的是Reids和MySQL的数据一致性。 方案一： 程序同时写Redis和MySQL 读Redis 方案二： 程序写MySQL， 使用Gearman调用MySQL的UDF，完成对Redis的写 读Re...
mysql+redis
weixin_34034670的博客
02-03 83
微博的系统架构，想用mysql+redis配合使用，具体操作步骤：　　写入数据到Redis,，然后在写个运行cron的脚本，美妙读内存，并写入数据库即可。　　使用注意：　　1、MySQL使用需要注意的地方：1) 、存储引擎选择InnoDB，在高并发下读写有很好的表现；2)、 数据合理分表分区，均衡各数据库服务器的负载；3) 、适当作数据的冗余，便于在cache失效时的快速恢复；　　2、Redis使...
redis+mysql
weixin_34055787的博客
04-21 117
redis和mysql要根据具体业务场景去选型 mysql：数据放在磁盘   redis：数据放在内存 redis适合放一些频繁使用，比较热的数据，因为是放在内存中，读写速度都非常快，一般会应用在下面一些场景 排行榜、计数器、消息队列推送、好友关注、粉丝 首先要知道mysql存储在磁盘里，redis存储在内存里，redis既可以用来做持久存储，也可以做缓存，而目前大多数公司的存储都是m...
Redis和MySQL的结合方式
最新发布
IT深耕十余载，大道之简
05-27 1515
Redis和MySQL的结合方式可以多样化，以满足不同的应用需求。
SpringBoot2.7整合SpringSecurity+Jwt+Redis+MySQL+MyBatis完整项目代码
10-30
之后，每次API请求都会携带JWT，Redis和Spring Security共同完成身份验证，MyBatis则负责与MySQL数据库的交互，实现数据的读写操作。这样的设计提高了系统的安全性、性能和可扩展性，是现代Web应用开发中的典型架构...
springBoot+mysql+redis基础项目
10-29
Spring Boot通过JDBC或MyBatis等数据访问技术与MySQL进行交互，实现对数据库的查询和操作。 【Redis】则是一个高性能的键值存储系统，常被用作缓存服务。它以内存中的数据结构存储数据，读写速度快，特别适合频繁...
基于SpringBoot+MySQL+Redis+RabbitMQ+Guava开发的高并发商品限时秒杀系统【100013054】
07-25
本系统，即"基于SpringBoot+MySQL+Redis+RabbitMQ+Guava开发的高并发商品限时秒杀系统"，旨在解决此类活动中面临的高并发挑战，通过巧妙地整合多种技术，实现了高效稳定的服务。 首先，SpringBoot作为核心框架，...
springboot结合mysql和redis数据库进行数据读取和缓存的demo
confusingggg的博客
05-05 1657
springboot结合mysql和redis数据库进行数据读取和缓存的demo 结尾有项目代码的gitee下载路径。
redis mysql lvs_redis和mysql结合数据一致性方案
weixin_42696271的博客
02-21 150
缓存读：缓存由于高并发高性能，已经被广泛的应用。在读取缓存方面做法一致。流程如下：牛新星 > redis和mysql结合数据一致性方案 > image2021-2-19_16-57-35.png写缓存：1.先更新数据库，再更新缓存2.先更新数据库，再删除缓存。(1).先更新数据库，再更新缓存这套方案，基本不推荐使用。原因一：(线程安全角度)同时请求A和请求B进行更新操作，会出现。(1)...
Mysql&Redis
qq_41969287的博客
02-17 2901
数据库读写分离如何保证一致性？ innodb底层（不是索引结构哈） LRU和LFU 类加锁和实例对象加锁区别 数据库的隔离级别有哪些
Redis与MySQL的结合
weixin_34161083的博客
11-22 347
Redis与MySQL的结合 目前大部分互联网公司使用MySQL作为数据的主要持久化存储，那么如何让Redis与MySQL很好的结合在一起呢？我们主要使用了一种基于MySQL作为主库，Redis作为高速数据查询从库的异构读写分离的方案。 为此我们专门开发了自己的MySQL复制工具，可以方便的实时同步MySQL中的数据到Redis上。 （MySQL-Redis 异构读写分离） 总结： ...
redis+mysql组合
qq_36959774的博客
03-14 1945
1、原理？ 一般都是用redis作缓存，只用来读数据（将数据库中的数据读出来放到redis，下一次读取时取redis中的数据），而mysql则用来做数据的持久话； 执行过程：当需要查询数据时，先在redis缓存中找对应的键值对，若不存在，则执行对应的sql，然后再把查询的sql结果放到redis的缓存中； 2、redis的作用？ redis可以做缓存，也...
redis+mysql结合使用
热门推荐
小黑的博客
04-09 1万+
redis-mysql mysql：数据放在磁盘 是关系型数据库，主要用于存放持久化数据， redis：数据放在内存 AOF：增量更新 RDB：覆盖 是NOSQL，非关系型数据库， redis和mysql的区别总结 （1）类型上 从类型上来说，mysql是关系型数据库，redis是缓存数据库 （2）作用上 mysql用于持久化的存储数据到硬盘，功能强大，但是速度较慢 redis用于存储使用较为频...
mysql+redis_mysql+redis
weixin_39875832的博客
01-21 173
mysql_with_redis_with_php_with_nginx大结合：本版本mysql使用系统自带的版本redis，php，nginx等软件及依赖性见官网及pkgs.orgserver1.example.com:172.25.33.1mysqlserver2.example.com:172.25.33.2nginx+phpserver3.example.com:172.2...
数据库（MySQL + Redis）
weixin_46608852的博客
11-25 1519
数据库基础笔记
MySQL与Redis整合：构建高效KV存储解决方案
总结来说，MySQL和Redis结合的KV存储服务设计旨在优化数据读写性能和一致性，但同时也需注意其潜在的问题，并结合业务需求和运维挑战进行权衡和优化。对于大规模和高并发场景，MySQL的主键或索引键用于充当键，非...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值