springboot2 连接mongodb4

最新推荐文章于 2025-12-03 19:18:17 发布

原创最新推荐文章于 2025-12-03 19:18:17 发布 · 1.1k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#springboot #mongodb #连接

MongoDB 专栏收录该内容

2 篇文章

订阅专栏

本文详细介绍如何在SpringBoot项目中整合MongoDB，包括pom.xml依赖配置、application.yml连接配置、实体类定义、MongoRepository接口实现CRUD操作，以及基于MongoTemplate的原生操作示例。

Win10 安装 MongoDB4

创建项目时引入mongodb

项目结构

pom.xml

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

application.yml

spring:
  data:
    mongodb:
      database: spring
      uri: mongodb://127.0.0.1:27017

Programmer.java (Bean)

package com.heibaiying.springboot.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;

import java.util.Date;

/**
 * @author : heibaiying
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Programmer {

    @Id
    private String name;

    private Integer age;

    private Float salary;

    private Date birthday;

    private Boolean flag;
}

ProgrammerRepository.java (Dao)

package com.heibaiying.springboot.repository;

import com.heibaiying.springboot.bean.Programmer;
import org.springframework.data.mongodb.repository.MongoRepository;

/**
 * @author : heibaiying
 * @description : jpa 方式查询 对于mongo而言 更推荐这种查询方式 比起原生的语法更加简洁
 */
public interface ProgrammerRepository extends MongoRepository<Programmer, String> {

    void deleteAllByName(String name);

    Programmer findAllByName(String names);

    Programmer findByNameAndAge(String name, Integer age);

}

MongoJPATests.java (基于MongoRepository的方式)

package com.heibaiying.springboot;

import com.heibaiying.springboot.bean.Programmer;
import com.heibaiying.springboot.repository.ProgrammerRepository;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MongoJPATests {

    @Autowired
    private ProgrammerRepository repository;

    @Test
    public void insert() {
        // 单条插入
        repository.save(new Programmer("python", 23, 21832.34f, new Date(), true));
        // 批量插入
        List<Programmer> programmers = new ArrayList<Programmer>();
        programmers.add(new Programmer("java", 21, 52200.21f, new Date(), false));
        programmers.add(new Programmer("Go", 34, 500.21f, new Date(),false));
        repository.saveAll(programmers);
    }

    // 条件查询
    @Test
    public void select() {
        Programmer java = repository.findByNameAndAge("java", 21);
        Assert.assertEquals(java.getSalary(), 52200.21f, 0.01);
    }


    // 更新数据
    @Test
    public void MUpdate() {
        repository.save(new Programmer("Go", 8, 500.21f, new Date(), false));
        Programmer go = repository.findAllByName("Go");
        Assert.assertEquals(go.getAge(), new Integer(8));
    }

    // 删除指定数据
    @Test
    public void delete() {
        repository.deleteAllByName("python");
        Optional<Programmer> python = repository.findById("python");
        Assert.assertFalse(python.isPresent());
    }

}

MongoOriginalTests.java (基于MongoTemplate的方式)

package com.heibaiying.springboot;

import com.heibaiying.springboot.bean.Programmer;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Query.query;
import static org.springframework.data.mongodb.core.query.Update.update;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MongoOriginalTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public void insert() {
        // 单条插入
        mongoTemplate.insert(new Programmer("xiaoming", 12, 5000.21f, new Date(),true));
        List<Programmer> programmers = new ArrayList<Programmer>();
        // 批量插入
        programmers.add(new Programmer("xiaohong", 21, 52200.21f, new Date(),false));
        programmers.add(new Programmer("xiaolan", 34, 500.21f, new Date(),false));
        mongoTemplate.insert(programmers, Programmer.class);
    }

    // 条件查询
    @Test
    public void select() {
        Criteria criteria = new Criteria();
        criteria.andOperator(where("name").is("xiaohong"), where("age").is(21));
        Query query = new Query(criteria);
        Programmer one = mongoTemplate.findOne(query, Programmer.class);
        System.out.println(one);
    }


    // 更新数据
    @Test
    public void MUpdate() {
        UpdateResult updateResult = mongoTemplate.updateMulti(query(where("name").is("xiaoming")), update("age", 35), Programmer.class);
        System.out.println("更新记录数：" + updateResult.getModifiedCount());
    }

    // 删除指定数据
    @Test
    public void delete() {
        DeleteResult result = mongoTemplate.remove(query(where("name").is("xiaolan")), Programmer.class);
        System.out.println("影响记录数：" + result.getDeletedCount());
        System.out.println("是否成功：" + result.wasAcknowledged());
    }

}

jpa支持很多方法命名规则来自动生成查询语句

Keyword	Sample	Logical result
After	findByBirthdateAfter(Date date)	{“birthdate” : {“$gt” : date}}
GreaterThan	findByAgeGreaterThan(int age)	{“age” : {“$gt” : age}}
GreaterThanEqual	findByAgeGreaterThanEqual(int age)	{“age” : {“$gte” : age}}
Before	findByBirthdateBefore(Date date)	{“birthdate” : {“$lt” : date}}
LessThan	findByAgeLessThan(int age)	{“age” : {“$lt” : age}}
LessThanEqual	findByAgeLessThanEqual(int age)	{“age” : {“$lte” : age}}
Between	findByAgeBetween(int from, int to)	{“age” : {“$gt” : from, “$lt” : to}}
In	findByAgeIn(Collection ages)	{“age” : {“$in” : [ages…]}}
NotIn	findByAgeNotIn(Collection ages)	{“age” : {“$nin” : [ages…]}}
IsNotNull, NotNull	findByFirstnameNotNull()	{“firstname” : {“$ne” : null}}
IsNull, Null	findByFirstnameNull()	{“firstname” : null}
Like, StartingWith, EndingWith	findByFirstnameLike(String name)	{“firstname” : name} (name as regex)
NotLike, IsNotLike	findByFirstnameNotLike(String name)	{“firstname” : { “$not” : name }} (name as regex)
Containing on String	findByFirstnameContaining(String name)	{“firstname” : name} (name as regex)
NotContaining on String	findByFirstnameNotContaining(String name)	{“firstname” : { “$not” : name}} (name as regex)
Containing on Collection	findByAddressesContaining(Address address)	{“addresses” : { “$in” : address}}
NotContaining on Collection	findByAddressesNotContaining(Address address)	{“addresses” : { “$not” : { “$in” : address}}}
Regex	findByFirstnameRegex(String firstname)	{“firstname” : {“$regex” : firstname }}
(No keyword)	findByFirstname(String name)	{“firstname” : name}
Not	findByFirstnameNot(String name)	{“firstname” : {“$ne” : name}}
Near	findByLocationNear(Point point)	{“location” : {“$near” : [x,y]}}
Near	findByLocationNear(Point point, Distance max)	{“location” : {“$near” : [x,y], “$maxDistance” : max}}
Near	findByLocationNear(Point point, Distance min, Distance max)	{“location” : {“$near” : [x,y], “$minDistance” : min, “$maxDistance” : max}}
Within	findByLocationWithin(Circle circle)	{“location” : {“$geoWithin” : {“$center” : [ [x, y], distance]}}}
Within	findByLocationWithin(Box box)	{“location” : {“$geoWithin” : {“$box” : [ [x1, y1], x2, y2]}}}
IsTrue, True	findByActiveIsTrue()	{“active” : true}
IsFalse, False	findByActiveIsFalse()	{“active” : false}
Exists	findByLocationExists(boolean exists)	{“location” : {“$exists” : exists }}