SpringBoot 整合MybatisPlus&MongoDB&Redis基础

最新推荐文章于 2024-06-15 16:29:34 发布
最新推荐文章于 2024-06-15 16:29:34 发布
阅读量8.7k 收藏 16
点赞数 5
分类专栏： 后端 文章标签： redis mongodb spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43914658/article/details/121082698
版权

SpringBoot 整合MybatisPlus&MongoDB&Redis基础

持续更新…

初始化数据库

连接Redis，初始时无数据：

在这里插入图片描述
连接Mysql，初始数据状态：

数据库名Test，表名students
在这里插入图片描述

连接MongoDB，初始数据状态：

数据库名story，集合名story，均为空
在这里插入图片描述

项目搭建

整体项目结构：

在这里插入图片描述

依赖配置：

<?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>org.wu</groupId>
    <artifactId>project</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>project</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.3.7.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <!-- Redis依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- MongoDB依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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.3.7.RELEASE</version>
                <configuration>
                    <mainClass>org.wu.project.ProjectApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

MybatisPlus映射配置：

<?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 = "org.wu.project.mapper.StudentMapper">
    <resultMap id="studentMap" type="org.wu.project.entity.Student">
        <id property="studentId" column="student_id"></id>
        <result property="studentName" column="student_name"></result>
        <result property="studentAge" column="student_age"></result>
        <result property="studentGrade" column="student_grade"></result>
    </resultMap>
    <insert id="addStudent">
        insert into students(student_id,student_name,student_age,student_grade)
         values(#{studentId},#{studentName},#{studentAge},#{studentGrade})
    </insert>
    <select id="findStudentById" parameterType="integer" resultMap="studentMap">
        select * from students
        where student_id = #{id}
    </select>
</mapper>

application.yml：

# 端口配置
server:
  port: 8888
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://192.168.123.188:3333/Test?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    name: defaultDataSource
  redis:
    host: 192.168.123.188
    port: 6666
    timeout: 1000
    database: 0 # 选择存储数据库
  application:
    name: project
  data:
    mongodb:
      host: 192.168.123.188
      database: story
      port: 22222
mybatis-plus:
  mapper-locations: classpath:/mybatis/mappers/*.xml
  type-aliases-package: org.wu.project.entity

# sql日志信息控制台输出
logging:
  level:
    org.wu.project.mapper: debug
    org.wu.project.service: debug

StudentServce.java：

package org.wu.project.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Service;
import org.wu.project.entity.Student;
import org.wu.project.mapper.StudentMapper;

@Slf4j
@Service("studentServiceBean")
public class StudentService {
    private StudentMapper studentMapper;
    @Autowired
    @Qualifier("studentMapperBean")
    public void setStudentMapper(StudentMapper studentMapper) {
        this.studentMapper = studentMapper;
    }
    private RedisTemplate redisTemplate;
    @Autowired
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
        this.redisTemplate.setKeySerializer(new StringRedisSerializer());
        this.redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    }
    /**
     * 增加学生
     * @param student
     */
    public void addStudent(Student student){
        studentMapper.addStudent(student);
    }
    /**
     * 通过学生id查找学生
     * 需要采用高并发思维来看待
     * 这里采用了双重校验锁方式
     * @param id
     * @return
     */
    public Student findStudentById(Integer id){
        // 先从Redis缓存获取数据，如果有则直接返回该数据，如果未找到则查询数据库，并将该数据放入Redis中
        // 一般的redis键的命名规范为：表名:主键名:主键值:字段名
        // Json数据规范为：表名:主键名:主键值 json字符串
        Object student = redisTemplate.opsForValue().get("students:student_id:"+id);
        if(student == null){
            synchronized(this.getClass()){
                student = redisTemplate.opsForValue().get("students:student_id:"+id);
                if(student == null){
                    log.debug(">>>>> Mysql返回数据… ");
                    Student temp = studentMapper.findStudentById(id);
                    redisTemplate.opsForValue().set("students:student_id:"+id,temp);
                    return temp;
                }
            }
        }
        log.debug(">>>>> Redis返回数据… ");
        return (Student)student;
    }
}

StoryService：

package org.wu.project.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.stereotype.Service;
import org.wu.project.entity.Story;

import org.springframework.data.mongodb.core.query.Query;
import java.util.List;
import java.util.regex.Pattern;

@Service("storyServiceBean")
public class StoryService {
    private MongoTemplate mongoTemplate;
    @Autowired
    public void setMongoTemplate(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }
    /**
     * 将数据存入MongoDB
     * @param story
     */
    public void addStory(Story story){
        // insert(): 若新增数据的主键已经存在，则会抛异常提示主键重复，不保存当前数据。可批处理
        // save(): 若新增数据的主键已经存在，则会对当前已经存在的数据进行修改操作。
        mongoTemplate.insert(story);
    }
    /**
     * 查找Story集合的所有文档
     * @return
     */
    public List<Story> findAllStory(){
        return mongoTemplate.findAll(Story.class);
    }

    /**
     * 通过故事ID查找故事对象
     * @param id
     * @return
     */
    public List<Story> findStoryById(String id){
        Query query = new Query();
        // 多个条件则重复类似以下语句
        query.addCriteria(Criteria.where("_id").is(id));
        return mongoTemplate.find(query,Story.class,"story");
    }

    /**
     * 模糊查询story集合content内容
     * @param content
     * @return
     */
    public List<Story> findContent(String content){
        Pattern pattern = Pattern.compile(".*"+content+".*");
        Query query = new Query(Criteria.where("content").regex(pattern));
        return mongoTemplate.find(query,Story.class,"story");
    }
}

Student实体类：

package org.wu.project.entity;

import lombok.Data;

import java.io.Serializable;

@Data
public class Student implements Serializable {
    String studentId;
    String studentName;
    Integer studentAge;
    String studentGrade;
}

Story实体类：

package org.wu.project.entity;


import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import org.springframework.data.mongodb.core.mapping.MongoId;
@Data
@Document(collection = "story") // MongoDB集合名
public class Story {
    @MongoId // 这个是将作为MongoDB的_id
    private String storyId; // 故事判别码
    @Field("name") // 别名，即MongoDB的属性名
    private String storyName; // 故事名称
    @Field("content") // 别名，即MongoDB的属性名
    private String storyContent; // 故事内容
    private String author; // 故事作者
    private Integer chapter; // 故事章节
}

StudentController.java：

package org.wu.project.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.wu.project.entity.Student;
import org.wu.project.service.StudentService;

@RestController
public class StudentController {

    private StudentService studentService;

    @Autowired
    @Qualifier("studentServiceBean")
    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    @PostMapping("/add/student")
    public boolean addStudent(Student student){
        try {
            studentService.addStudent(student);
            return true;
        }catch(Exception e){
            e.printStackTrace();
            return false;
        }
    }
    @GetMapping("/get/student")
    public String getStudentById(Integer id){
        return studentService.findStudentById(id).toString();
    }
}

StoryControlle.java：

package org.wu.project.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.wu.project.entity.Story;
import org.wu.project.service.StoryService;

@RestController
public class StoryController {
    private StoryService storyService;

    @Autowired
    public void setStoryService(StoryService storyService) {
        this.storyService = storyService;
    }
    @PostMapping("/add/story")
    public boolean addStory(Story story){
        try{
            this.storyService.addStory(story);
            return true;
        }catch(Exception e){
            e.printStackTrace();
            return false;
        }
    }
    @GetMapping("/get/stories")
    public String getStories(){
        return this.storyService.findAllStory().toString();
    }
    @GetMapping("/get/story/id")
    public String getStoryById(String id){
        return this.storyService.findStoryById(id).toString();
    }
    @GetMapping("/get/story/content")
    public String getContent(String content){
        return this.storyService.findContent(content).toString();
    }
}
  • 测试MySQL以及Redis

在这里插入图片描述
日志输出信息：

在这里插入图片描述

MySQL数据库信息，添加成功：

在这里插入图片描述

在这里插入图片描述
请求成功：

在这里插入图片描述
多次重复请求使用Redis缓存，有利于高并发：

在这里插入图片描述

  • 测试MongoDB

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
查看MongoDB数据信息，添加成功：

在这里插入图片描述

在这里插入图片描述
查询故事内容中带有水滴两字的所有文档：

在这里插入图片描述


一夜星尘
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot+MongoDB+Echarts图表数据可视化
07-21
SpringBoot+MongoDB+Echarts图表数据可视化 SpringBoot+MongoDB+Echarts图表数据可视化
springboot整合mongodb+redis+mybatis+mysql
08-15
本示例项目整合了多种数据库技术，包括 MongoDB、Redis 和 MyBatis，同时使用 MySQL 作为传统的关系型数据库。 MongoDB 是一个基于分布式文件存储的非关系型数据库，适用于处理大量数据的场景，尤其适合文档型数据...
Java学习——springboot整合mysql、redis、mongodb
RX1125的博客
07-16 1183
springboot快速整合mysql,redis,mongodb
【Mongodb-02】springboot整合mongodb(详解)
最新发布
zhenghuishengq的博客
06-15 1278
springboot整合mongodb详解
基于java语言，使用Springboot + Mongodb + Groovy + Es等框架搭建的轻量级实时风控引擎
04-25
实时风控引擎(Risk Engine)，自定义规则引擎(Rule Script)，完美支持中文，适用于反欺诈(Anti-fraud)应用场景,移动互联网时代的风险管理利器，
SpringBoot整合MongoDB
鸟人的博客
07-07 565
大数据领域的MongoDB在实际开发中有很多应用，基于文档的存储结构和关系型数据库有很大的区别，下面来通过SpringBoot整合MongoDB来理解一下这个数据库注MongoDB中数据表叫集合Collection，一条记录叫文档Document以下为SpringBoot项目配置。......
SpringBoot + Mybatis-Plus mysql多数据源 + mongodb 多数据源 [备忘]
weixin_43867432的博客
03-03 2203
yml mybatis-plus: configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl mapper-locations: classpath:mapping/*.xml global-config: refresh-mapper: true spring: profiles: active: dev datasource: dynamic: prima.
springboot整合其他技术栈（redis缓存，mongodb，exsyexcel，Mybatis-plus）
09-17
在这个项目中简单实现了springboot对redis缓存，Mybatis-Plus，mongodb等数据库相关的技术点，实现数据获取，可以直接在以后的项目中仿照使用。并且整合了exsyexcel等数据文件导入导出功能，后续会继续汇总整合一些...
一个基于SpringBoot+MybatisPlus+SpringSecurity+Redis+ES搜索引擎的个人博客系统
05-14
该项目利用了基于springboot + vue + mysql的开发...Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
springboot-mongodb-mybatisplus-redis-nacos工程例子
07-25
这是一个基于Spring Boot的综合工程示例，包含了MongoDB数据库、MyBatisPlus持久层框架、Redis缓存管理和Nacos服务发现及配置中心的集成。这个项目可以帮助开发者了解如何在Spring Boot环境中有效地整合这些技术，...
基于SpringBoot + Redis + MongoDB + MySQL开发的商品管理系统
05-01
基于SpringBoot+Mybatis+Thymeleaf商品信息管理系统 主要用到的技术： 使用maven进行项目构建 使用Springboot+Mybatis搭建整个系统 使用Thymeleaf模板技术实现页面静态化 使用框架Bootstrap、JQuery开发前端界面 ...
Spring + Spring Boot + MyBatis + MongoDB的整合教程
08-28
主要给大家介绍了关于Spring + Spring Boot + MyBatis + MongoDB的整合教程，文中通过图文以及示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
Java+Springboot+mybatis+RestAPI，整合swagger
10-28
Java+Springboot+mybatis+RestAPI架构，整合swagger，对外公开服务
maven-springboot整合mybatis-redis-mongo-druid
02-03
整合的springboot的项目 分享给大家 有mybatis redis mongo druid 推荐给有java基础的各位 配置请自行设置 基本上设置下就可以跑起来了 请自行删减不使用mongo或者mysql
springMVC+mybitis+mongodb+maven整合
03-06
文档中包含整合的所有pom文件和资源文件（applictionContext.xml、form-jdbc.properties、form-mongodb.properties、form-mongodb.xml、form-mybatis.xml、mybatis-config.xml、spring-mvc.xml、web.xml），由于上传资源大小限制，无法上次相应的依赖jar文件，请见谅
Mina+Mongodb+Mybatis+数据库连接池实例
04-09
这是一个简单的基于mina框架的实现增删改查的工程，融合了mongodb mybatis proxool等多个技术。
springboot整合mqtt实现消息发送和消费，以及客户端断线重连之后的消息恢复
weixin_45614461的博客
08-02 5427
参考资料： http://mqtt.p2hp.com/mqtt311 https://mcxiaoke.gitbooks.io/mqtt-cn/content/mqtt/02-ControlPacketFormat.html https://blog.csdn.net/anxianfeng55555/article/details/80908795 MQTT简介 ​ MQTT是一种基于发布/订阅模式的轻量级通讯协议，该协议构建在TCP/IP协议上。 MQTT最大的有点在于可以以极少的代码和有限的带宽，为远程
springboot+MongoDB+多线程 阅读量统计
吃不胖的Harry公子的博客
04-08 538
Leader告诉我一个需求：需要统计前台客户页面的文章阅读数、以及其他访问信息。之前也没有接触过这块，因此开始针对访问信息收集的研究。也借此机会，在模块开发完成之际，对模块进行一个回顾。
spring boot学习笔记（从0开始）之项目搭建、MongoDB集成、druid集成
ljj125896的博客
09-10 4253
1.搭建spring boot项目 这个过程很简单，只需要去spring官网选择相应版本直接下载即可。 2.向ide工具中导入项目 针对idea，只需要把本地项目当做maven项目导入即可 然后一路next即可。 3.spring boot集成MongoDB 第一步： &lt;dependency&gt; &lt;groupId&gt;org.springframew...
springboot整合mybatis,mongodb,redis
05-26
Spring Boot整合MyBatis、MongoDB和Redis可以分别按照以下步骤进行： 整合MyBatis： 1. 引入MyBatis和MyBatis-SpringBoot-Starter依赖： ```xml <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.2.0</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.1.22</version> </dependency> ``` 2. 配置数据源： ```properties spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=123456 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver ``` 3. 配置MyBatis： ```properties mybatis.mapper-locations=classpath:mapper/*.xml mybatis.type-aliases-package=com.example.demo.entity ``` 4. 编写Mapper接口和SQL映射文件。 整合MongoDB： 1. 引入MongoDB和Spring Data MongoDB依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> ``` 2. 配置MongoDB： ```properties spring.data.mongodb.host=localhost spring.data.mongodb.port=27017 spring.data.mongodb.database=test ``` 3. 编写MongoDB实体类和Repository接口。 整合Redis： 1. 引入Redis和Spring Data Redis依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2. 配置Redis： ```properties spring.redis.host=localhost spring.redis.port=6379 spring.redis.password= spring.redis.database=0 ``` 3. 编写Redis操作类。可以使用RedisTemplate或者StringRedisTemplate来操作Redis。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值