使用IDEA搭建SpringBoot项目且整合mongoDB和mysql

最新推荐文章于 2024-04-24 16:23:13 发布
最新推荐文章于 2024-04-24 16:23:13 发布
阅读量1.7w 收藏 42
点赞数 10
分类专栏： spring-boot 文章标签： mongodb mysql spring-boot idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013259845/article/details/70231402
版权

SpringBoot项目相对SpringMVC项目有搭建迅速，配置更少的优点。创建springboot项目有很多种方式，本文使用idea创建一个整合mongoDB和mysql数据库的简单的springboot项目。文章末尾附源码地址。

搭建步骤：

主要是以截图的方式介绍搭建过程。

  • 进入新建项目界面，按照下图操作

这里写图片描述

这里写图片描述
这里写图片描述
这里写图片描述

经过以上步骤，基本项目框架就会搭建起来。因为项目中需要用到阿里的数据库连接池和json工具包，所以在pom文件中手动加入相应的依赖。

  • 完整pom文件
<?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.zxd</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <druid.version>1.0.29</druid.version>
        <fastjson.version>1.2.30</fastjson.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>


    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.RC1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>
  • 数据库的基本配置
    项目搭建成功之后，会发现在resources目录下会生成一个”application.properties”文件。这个文件是springboot项目的基本配置文件，可以重命名为 “application.yml”。本文的配置均在yml文件下配置，优点是层次结构清晰。
    配置文件内容如下：
spring:
#数据库配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/spring_boot
    username: root
    password: 123456
  # 配置初始化大小、最小、最大
    initialSize: 5
    minIdle: 5
    maxActive: 20
  # 配置获取连接等待超时的时间
    maxWait: 60000
  # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
  # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 30000
    validationQuery: SELECT 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
   # 打开PSCache，并且指定每个连接上PSCache的大小。如果用Oracle，则把poolPreparedStatements配置为true，mysql可以配置为false。分库分表较多的数据库，建议配置为false。
    poolPreparedStatements: false
    maxPoolPreparedStatementPerConnectionSize: 20
  # 配置监控统计拦截的filters
    filters: stat
#jpa配置
  jpa:
    database: mysql
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update
#mongo配置
  data:
    mongodb:
      database: spring_boot
      uri: mongodb://127.0.0.1:27017

经过以上配置。就可以启动项目了。
控制台打印出

2017-04-18 17:56:23.647  INFO 14748 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-04-18 17:56:23.656  INFO 14748 --- [           main] com.zxd.DemoApplication                  : Started DemoApplication in 13.982 seconds (JVM running for 15.253)

类似语句，就说明启动成功！
可以输出一个简单的语句，验证项目是否搭建成功！

package com.zxd.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author zxd
 * @create 2017-03-29 11:02
 **/
@RestController
public class Hello {

    @GetMapping("/")
    public String sayHello(){
        return "hello spring boot";
    }
}

重启项目，访问http://127.0.0.1:8080/，就会看到“hello spring boot”。

数据操作

在上面的配置中，已经配置好了数据库连接，并且启动成功。接下来就要对数据进行增删改查。

  • mysql数据库操作
    通过spring-data-jpa进行增删改查操作。

1.新建user类

package com.zxd.bean;

import com.alibaba.fastjson.JSON;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import org.hibernate.annotations.GenericGenerator;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 * @author zxd
 * @create 2017-03-31 14:41
 **/
@Entity
@DynamicUpdate
@DynamicInsert
public class User {

    @Id
    @GeneratedValue(generator = "system-uuid")
    @GenericGenerator(name = "system-uuid", strategy = "uuid.hex")
    @Column(name = "id", nullable = false, length = 32, unique = true)
    private String id;

    private int age;

    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this);
    }
}

2.新建Repository

package com.zxd.repository;

import com.zxd.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 15:17
 **/
@Repository
public interface UserRepository extends JpaRepository<User,String> {
    @Modifying
    @Query(value = "update User u set u.age = ?1 where u.id = ?2")
    int modifyAgeById(int age,String id);
}

直接继承JpaRepository就可以，泛型中的User就是User实体类，String是User的主键类型。modifyAgeById方法是自定义的修改方法。里面自带的有很多基本的增删改查方法，在接下来的service中可以看到。
3. 新建serivice和controller

package com.zxd.service;

import com.zxd.bean.User;
import com.zxd.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 17:03
 **/
@Transactional
@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public User findOne(String id) {
        return userRepository.findOne(id);
    }

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public int modifyAgeById(int age, String id) {
        return userRepository.modifyAgeById(age,id);
    }

    public void delete(String id) {
        userRepository.delete(id);
    }

    public void save(User user) {
        userRepository.save(user);
    }
}

package com.zxd.controller;

import com.alibaba.fastjson.JSON;
import com.zxd.bean.User;
import com.zxd.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 14:52
 **/
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;

    /**
     * 保存
     * @param user
     * @return
     */
    @PostMapping
    public String saveUser(User user){
        userService.save(user);
        return user.toString();
    }

    /**
     * 按id查找
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public String findUser(@PathVariable("id") final String id){
        System.out.println(id);
        User user = userService.findOne(id);
        return user.toString();
    }

    /**
     * 查找所有
     * @return
     */
    @GetMapping()
    public String findUserAll(){
        List<User> userList = userService.findAll();
        return JSON.toJSONString(userList);
    }

    /**
     * 更新年龄
     * @param id
     * @param age
     * @return
     */
    @PutMapping("/{id}")
    public String updateAge(@PathVariable("id") String id,@RequestParam("age") int age){
       return userService.modifyAgeById(age,id)+"";
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    public String delete(@PathVariable("id") String id){
        userService.delete(id);
        return "删除成功！";
    }
}
  • mongoDB数据库操作
    通过spring-data-jpa和mongoTemplate进行增删改查操作。
    1.新建Order类
package com.zxd.bean;

import com.alibaba.fastjson.JSON;
import org.springframework.data.mongodb.core.mapping.Document;

import javax.persistence.Id;

/**
 * 订单
 *
 * @author zxd
 * @create 2017-03-31 16:34
 **/
@Document
public class Order {
    @Id
    private String id;

    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return JSON.toJSONString(this);
    }
}

2.新建Repository

package com.zxd.repository;

import com.zxd.bean.Order;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 16:36
 **/
@Repository
public interface OrderRepository extends MongoRepository<Order,String> {

}

这个接口里面没有写任何代码。基本的增删改查功能jpa已经实现了，直接在service调用就行。一些复杂的功能我们可以写一个通用的dao类由mongoTemplate实现。
3.建立公共的dao

package com.zxd.dao.impl;

import com.zxd.dao.IPublicDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Repository;

/**
 * @author zxd
 * @create 2017-03-31 18:06
 **/
@Repository
public class PublicDaoImpl<T> implements IPublicDao{
    @Autowired
    private MongoTemplate mongoTemplate;
    @Override
    public void update(Query query, Update update, Class t) {
        mongoTemplate.updateMulti(query,update,t);
    }
}

这里只贴出实现类的代码，接口定义自行补充。里面也只有一个简单的修改方法，这里只是起一个抛砖引玉的作用，可自行扩展。
4. 新建service和controller

package com.zxd.service;

import com.zxd.bean.Order;
import com.zxd.dao.IPublicDao;
import com.zxd.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author zxd
 * @create 2017-03-31 17:06
 **/
@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private IPublicDao<Order> publicDao;
    public void save(Order order) {
        orderRepository.save(order);
    }

    public Order findOne(String id) {
        return orderRepository.findOne(id);
    }

    public List<Order> findAll() {
        return orderRepository.findAll();
    }

    public int updateNameById(String id, String name) {
        Query query = new Query(Criteria.where("_id").is(id));
        Update update = Update.update("name",name);
        publicDao.update(query,update,Order.class);
        return 1;
    }

    public void deleteById(String id) {
        orderRepository.delete(id);
    }
}

package com.zxd.controller;

import com.alibaba.fastjson.JSON;
import com.zxd.bean.Order;
import com.zxd.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author zxd
 * @create 2017-03-31 16:45
 **/
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 保存
     * @param order
     * @return
     */
    @PostMapping
    public String saveOrder(Order order){
        orderService.save(order);
        return order.toString();
    }

    /**
     * 按照id查找
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public String findOrder(@PathVariable("id") String id){
        return orderService.findOne(id).toString();
    }

    /**
     * 查找全部
     * @return
     */
    @GetMapping
    public String findAll(){
        return JSON.toJSONString(orderService.findAll());
    }

    /**
     * 修改
     * @param id
     * @param name
     * @return
     */
    @PutMapping("/{id}")
    public String updateName(@PathVariable(value = "id") String id,@RequestParam("name") String name){
        return orderService.updateNameById(id,name)+"";
    }

    /**
     * 删除
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    public String delete(@PathVariable("id") String id){
        orderService.deleteById(id);
        return "删除成功！";
    }
}

可以用RESTful测试工具进行调用测试。这里不做测试演示。
至此，一个简单的springboot项目搭建完成！
项目源码地址：https://github.com/devzxd/springboot

devzxd
关注
  • 10
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
在springBoot中同时使用mysql和MongoDB
weixin_42551921的博客
11-20 945
在SpringBoot中非关系向数据库MongoDB和关系型数据库MySQL都可通过引入相关依赖并按照指定配置单独集成；
在IDEA下的MongoDB项目搭建过程，实现增删查改，springboot+MongoDB
smx6666668的博客
10-04 1285
在IDEA下的MongoDB项目搭建过程，实现增删查改，springboot+MongoDB
springboot2.1.3 + mysql(mybatis) + mongodb maven项目
10-28
springboot2.1.3 + mysql(mybatis) + mongodb maven项目
Java学习——springboot整合mysql、redis、mongodb
RX1125的博客
07-16 1180
springboot快速整合mysql,redis,mongodb
在IDEA中创建一个SpringBoot项目（超详细教学）
最新发布
Alaiks的博客
04-24 4694
使用Maven的好处主要是：1.成熟和稳定：Maven是比较早期的构建工具，已经得到了广泛的应用和社区支持。**值得一提的是：**如果你这里选择的是使用服务器URL来创建项目，则应该是不支持Java8的，毕竟版本实在是太老了。也就是这里的JDK版本应该也是不支持的，如果出现这种问题，有两个解决办法：1.去官网下载指定的JDK版本，并在项目中引入。插件系统丰富，提供了大量的构建和扩展功能。SNAPSHOT意义: 表示这是一个开发中的版本，它可能包含了最新的代码更改和新功能，但还没有经过正式的测试和验证。
springboot同时使用MySQL和mongodb
weixin_35757531的博客
01-03 1275
在 Spring Boot 中同时使用 MySQL 和 MongoDB 是非常容易的。首先，你需要在 pom.xml 文件中添加对 MySQL 和 MongoDB 的依赖，如下所示： <dependencies> <dependency> <groupId>org.springframework.boot</groupId> ...
Springboot 整合MySQL 和 MongoDB 同时支持两种数据库事务
u010169334的博客
10-12 7737
一、配置spirngboot数据源 # mybatis数据源 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url= spring.datasource.username= spring.datasource.password= #mongodb数据源，主副使用逗号分隔 spring.data.mongodb.uri=mongodb://192.168.10.150:27018,192.1
Springboot配置多数据源（MySQL与MongoDB）与Mongodb TTL索引
weixin_42123075的博客
11-30 1661
Springboot项目配置MySQL与MongoDB两个数据源，默认数据源为MySQL，MongoDB创建TTL数据过期索引。
Spring + Spring Boot + MyBatis + MongoDB的整合教程
08-28
使用IntelliJ IDEA创建一个新的Spring Boot项目，选择Spring Initializr，并添加所需的依赖，包括Web、MyBatis、MongoDB和MySQL驱动。 2. **目录结构**： 通常我们会按照约定的目录结构组织代码，如`Controller`...
自动创建 springboot+mybatis+mysql 示例项目
08-27
创建一个"SpringBoot+MyBatis+MySQL"的示例项目，首先你需要在本地环境安装并配置好MySQL服务器，然后通过IDEA或Eclipse等开发工具创建一个新的SpringBoot项目，添加相应的依赖。在`pom.xml`文件中，你需要引入...
springboot-demo.zip
11-27
SpringBoot 是一个由 Pivotal 团队开发的框架，旨在简化...这个入门项目是学习 SpringBoot、MyBatis 和 MySQL 整合开发的好起点。通过阅读源码，了解各个组件的配置和交互，可以帮助初学者快速掌握这三大技术栈的使用。
springboot整合mongodb+redis+mybatis+mysql
08-15
springboot整合mongodb+redis+mybatis+mysql,只有个简单的demo,配置详细。下了不后悔啊。
SpringBoot-OneNet.zip
03-03
在本项目中，"SpringBoot-OneNet.zip" 文件是一个整合了SpringBoot框架和IoT（物联网）技术的应用，主要用于与OneNet云平台交互。以下是该项目的关键知识点和详细说明： 1. **SpringBoot**： SpringBoot是Spring...
springboot+sql完整实例导入可用，代码通过阿里规约检测没有任何错误，适合初学者。
01-11
通过这个实例，初学者不仅可以掌握 SpringBoot 和 MySQL 的基本使用，还能了解到良好的编码习惯和项目组织方式，为后续的开发工作打下坚实的基础。如果在学习过程中遇到问题，可以参考实例中的注释，或者联系提供者...
IDEA中创建一个SpringBoot+Mysql+MongoDB项目(一)
Sinder小德的博客
02-22 3885
创建一个SpringBoot服务 1、打开IDEA，File中选择New Project新建一个项目，选择Spring Initializr以及java jdk，选择Next下一步，图； 2、接下来第一个就是填写项目的基本信息了，Group是项目组织结构路径，Artifact是项目根目录名称。 然后Next。 3、添加初始化的maven依赖，这里可以根据自己的需要去选，我这里没有选...
springboot整合mysql和mongodb双数据源
you_ran_jian的博客
11-11 7266
因为业务需求,需要在一个项目中同时使用myslq和mongodb数据库,在网上找了好久都没有,只有相同数据库的双数据源,当时就想如果按照相同数据库的双数据源配置分别配置myslq和mongodb。 一、先看一下pom文件 <dependencies> <dependency> <groupId>org.springframework.boot<...
spring mysql mongdb_Spring Boot中使用MongoDB数据库的方法 _ 蚂蚁视界
weixin_42360762的博客
02-11 232
我们在产物顶用到 NoSQL 数据库 MongoDB 。下面就来简单先容一下 MongoDB ，而且经由过程一个例子来先容 Spring Boot 中对 MongoDB 拜访的设置装备摆设和使用。MongoDB简介MongoDB是一个基于散布式文件存储的数据库，它是一个介于关系数据库和非关系数据库之间的产物，其主要目的是在键/值存储方式(提供了高机能和高度伸缩性)和传统的RDBMS体系(具有丰硕的...
Springboot集成MongoDB存储文件、读取文件
harlan的博客
04-14 1543
Springboot集成mongodb实现文件存储，GridFS存储。
yaml 部署 mongodb
weixin_45480359的博客
01-25 963
需要先安装 nfs镜像拉取地址：https://hub.docker.com/_/mongo/tags注意如果之前已经使用没有鉴权的方式部署过 MongoDB，并且做了持久化，那么再改动 YMAL 文件重新部署是不会起作用的。进入 mongodb 客户端执行如下命令创建用户即可。
用代码演示springboot项目整合mongodb
05-05
好的，下面是一个简单的Spring Boot项目整合MongoDB的示例： 1. 首先，需要在 `pom.xml` 文件中添加 MongoDB 的依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> ``` 2. 然后，需要在 `application.properties` 文件中配置 MongoDB 的连接信息，例如： ```properties spring.data.mongodb.uri=mongodb://localhost:27017/mydb ``` 3. 接着，创建一个实体类，例如： ```java @Document(collection = "users") public class User { @Id private String id; private String name; private int age; // getter 和 setter 略 } ``` 这里使用了 `@Document` 注解来指定该实体类对应的 MongoDB 的集合名称。 4. 创建一个 `UserRepository` 接口，继承自 `MongoRepository` 接口，例如： ```java public interface UserRepository extends MongoRepository<User, String> { } ``` 这里使用了 `MongoRepository` 接口，它提供了一些常用的 CRUD 操作方法。可以根据需要自定义方法。 5. 编写业务逻辑，例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public User save(User user) { return userRepository.save(user); } public List<User> findAll() { return userRepository.findAll(); } public Optional<User> findById(String id) { return userRepository.findById(id); } public void deleteById(String id) { userRepository.deleteById(id); } } ``` 这里使用了 `@Service` 注解来声明该类为一个服务类，使用 `@Autowired` 注解来注入 `UserRepository` 实例。 6. 最后，编写一个控制器类，例如： ```java @RestController @RequestMapping("/users") public class UserController { @Autowired private UserService userService; @PostMapping public User save(@RequestBody User user) { return userService.save(user); } @GetMapping public List<User> findAll() { return userService.findAll(); } @GetMapping("/{id}") public Optional<User> findById(@PathVariable String id) { return userService.findById(id); } @DeleteMapping("/{id}") public void deleteById(@PathVariable String id) { userService.deleteById(id); } } ``` 这里使用了 `@RestController` 注解来声明该类为一个 RESTful 风格的控制器类，使用 `@Autowired` 注解来注入 `UserService` 实例，使用 `@PostMapping`、`@GetMapping`、`@DeleteMapping` 等注解来声明不同的 HTTP 请求方法，分别对应新增、查询、删除操作。 以上就是一个简单的 Spring Boot 项目整合 MongoDB 的示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值