首页 › MongoDB论坛 › SpringBoot 整合 MongoDB 实战解说

龙乡飞同凡响 發表於 2022-8-31 17:36:00

SpringBoot 整合 MongoDB 实战解说

<h3 id="一介绍">一、介绍</h3>
<p>在前面的文章中，我们详细的介绍了 MongoDB 的配置和使用，如果你对 MongoDB 还不是很了解，也没关系，在 MongoDB 中有三个比较重要的名词：<strong>数据库、集合、文档</strong>！</p>
<ul>
<li><strong>数据库（Database）</strong>：和关系型数据库一样，每个数据库中有自己的用户权限，不同的项目组可以使用不同的数据库</li>
<li><strong>集合（Collection）</strong>： 集合指的是文档组（类似于 Mysql 中的表的概念），里面可以存储许多文档</li>
<li><strong>文档（Document）</strong>： 文档是 MongoDB 中最基本的数据单元，由键值对组成，类似于 JSON 格式，可以存储不同字段，字段的值可以包括其他文档、数组和文档数组</li>
</ul>
<p>搞懂这三个名词，基本就可以上手了，今天我们以 Java 语言为例，详细的介绍 Java 客户端改如何操作 MongoDB ！</p>
<p>话不多说，直接开撸！</p>
<h3 id="二java-客户端">二、Java 客户端</h3>
<h4 id="21mongodb-连接">2.1、MongoDB 连接</h4>
<p>Java 连接 MongoDB 服务器，与我们常用的连接关系型数据库方式类似！</p>
<p>标准 URI 连接语法：</p>
<pre><code>mongodb://username:password@host1:port1,host2:port2,...,hostN:portN/database?options
</code></pre>
<p>参数说明：</p>
<ul>
<li><code>mongodb://</code>：这是固定的格式，必须要指定</li>
<li><code>username:password@</code>：可选项，如果设置，在连接数据库服务器之后，驱动都会尝试登录这个数据库</li>
<li><code>host1:port1</code>：主机IP和端口号，必须指定至少一个host。如果要连接复制集，请指定多个主机地址</li>
<li><code>/database</code>：如果指定了<code>username:password@</code>，连接时会验证并登录指定数据库。若不指定，默认打开 test 数据库</li>
<li><code>?options</code>：连接可选项，例如<code>connectTimeoutMS=5000ms</code>，表示连接等待时间最长 5 秒</li>
</ul>
<p>例如，无密码连接 MongoDB</p>
<pre><code>mongodb://127.0.0.1:27017
</code></pre>
<p>使用用户名<code>test</code>，密码<code>test</code>登录 MongoDB 的<code>test_db</code>数据库</p>
<pre><code>mongodb://test:test@127.0.0.1:27017/test_db
</code></pre>
<p>无密码连接指定三台服务器 (端口 27017, 27018, 和27019)</p>
<pre><code>mongodb://127.0.0.1:27017,127.0.0.1:27018,127.0.0.1:27019
</code></pre>
<h4 id="22添加依赖包">2.2、添加依赖包</h4>
<p>和关系型数据库操作一样，在 Java 程序中如果要使用 MongoDB，先要添加对应的 MongoDB JDBC 驱动器，然后才能继续操作！</p>
<p>在选择的版本号的时候，注意需要和服务器中的安装版本匹配，具体的版本号选择可以从如下地址中获取到最新的版本：mongo-java-driver</p>
<pre><code class="language-xml">&lt;dependency&gt;
    &lt;groupId&gt;org.mongodb&lt;/groupId&gt;
    &lt;artifactId&gt;mongo-java-driver&lt;/artifactId&gt;
    &lt;version&gt;3.12.7&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
<h4 id="23连接数据库">2.3、连接数据库</h4>
<p>连接数据库的 Java 代码如下：</p>
<pre><code class="language-java">private static MongoClient mongoClient;

static {
    try {
      //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
      mongoClient = MongoClients.create("mongodb://test:test@127.0.0.1:27017/test_db");
      System.out.println("Connect to database successfully");
    } catch (Exception e) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
    }
}
</code></pre>
<p>上文中采用的是用户名和密码方式登录数据库，因为数据库已经开启了权限验证，因此需要通过用户名和密码才能登录。</p>
<h4 id="24创建集合">2.4、创建集合</h4>
<p><code> com.mongodb.client</code>包里面都帮我们集成好了大部分常用的 api，我们可以通过<code>MongoDatabase</code>类中的<code>createCollection()</code>方法来创建集合。</p>
<p>创建一个<code>tb_role</code>集合，代码片段如下：</p>
<pre><code>/**
* 创建集合
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.createCollection("tb_role");
    System.out.println("集合创建成功");
}
</code></pre>
<p>如果想删除集合，操作也很简单！</p>
<pre><code>/**
* 删除集合
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.getCollection("tb_role").drop();
    System.out.println("集合 tb_role 删除成功");
}
</code></pre>
<h4 id="25创建文档">2.5、创建文档</h4>
<p>我们可以通过<code>MongoCollection</code>类中的<code>insertMany()</code>方法来插入一个文档。</p>
<p>向<code>tb_role</code>集合中插入文档，代码片段如下：</p>
<pre><code class="language-java">/**
* 插入文档
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection&lt;Document&gt; collection = mongoDatabase.getCollection("tb_role");

    //向集合中插入文档
    Document document = new Document("name", "管理员").
            append("code", "manager").
            append("sort", 100);
    List&lt;Document&gt; documents = new ArrayList&lt;&gt;();
    documents.add(document);
    collection.insertMany(documents);
    System.out.println("文档插入成功");
}
</code></pre>
<h4 id="26更新文档">2.6、更新文档</h4>
<p>我们可以通过<code>MongoCollection</code>类中的<code>updateMany()</code>方法来更新集合中的文档。</p>
<p>更新<code>tb_role</code>集合中的指定文档信息，代码片段如下：</p>
<pre><code class="language-java">/**
* 更新文档
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection&lt;Document&gt; collection = mongoDatabase.getCollection("tb_role");

    //更新文档
    collection.updateMany(Filters.eq("code", "manager"), new Document("$set",new Document("name","经理")));

    //遍历所有文档
    FindIterable&lt;Document&gt; findIterable = collection.find();
    MongoCursor&lt;Document&gt; mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
      System.out.println(mongoCursor.next());
    }
}
</code></pre>
<p>上文操作类似于 SQL语句中的<code>update tb_role set name = '经理' where code = 'manager'</code>！</p>
<h4 id="27删除文档">2.7、删除文档</h4>
<p>我们可以通过<code>MongoCollection</code>类中的<code>deleteOne()</code>或者<code>deleteMany</code>方法来删除集合中的文档。</p>
<p>删除<code>tb_role</code>集合中的指定文档信息，代码片段如下：</p>
<pre><code class="language-java">/**
* 删除文档
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection&lt;Document&gt; collection = mongoDatabase.getCollection("tb_role");

    //删除符合条件的第一个文档
    collection.deleteOne(Filters.eq("code", "manager"));
    //删除所有符合条件的文档
    collection.deleteMany (Filters.eq("code", "manager"));

    //遍历所有文档
    FindIterable&lt;Document&gt; findIterable = collection.find();
    MongoCursor&lt;Document&gt; mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
      System.out.println(mongoCursor.next());
    }
}
</code></pre>
<p>在这里需要注意一下，在删除的时候，官方推荐尽可能先查询一下这个数据是否存在，如果存在，然后在执行删除操作，可以调用<code>findOneAndDelete()</code>方法进行删除！</p>
<h4 id="28查询文档">2.8、查询文档</h4>
<p><code>MongoCollection</code>类中提供了非常丰富的检索文档的方法，例如，我们可以通过<code>find()</code>方法来获取集合中的所有文档。</p>
<p>检索<code>tb_role</code>集合中的文档信息，代码片段如下：</p>
<pre><code class="language-java">/**
* 查询文档
* @param args
*/
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection&lt;Document&gt; collection = mongoDatabase.getCollection("tb_role");

    //遍历所有文档
    FindIterable&lt;Document&gt; findIterable = collection.find();
    MongoCursor&lt;Document&gt; mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
      System.out.println(mongoCursor.next());
    }

    //查询当前集合所有文档数量
    long count = collection.countDocuments();
    System.out.println("当前文档数量:" + count);

    //带条件遍历文档
    FindIterable&lt;Document&gt; documentFindIterable = collection.find(Filters.eq("code", "manager"));
    MongoCursor&lt;Document&gt; documentMongoCursor = documentFindIterable.iterator();
    while(documentMongoCursor.hasNext()){
      System.out.println(documentMongoCursor.next());
    }
}
</code></pre>
<h3 id="三springboot-整合-mongodb">三、SpringBoot 整合 MongoDB</h3>
<p>采用 SpringBoot 来对接 MongoDB，可以说极其简单，下面就以常用的几个操作为例来介绍，过程如下！</p>
<h4 id="31创建-springboot-工程添加-mongodb-依赖包">3.1、创建 SpringBoot 工程，添加 MongoDB 依赖包</h4>
<pre><code>&lt;!-- 引入springboot --&gt;
&lt;parent&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-parent&lt;/artifactId&gt;
    &lt;version&gt;2.1.0.RELEASE&lt;/version&gt;
&lt;/parent&gt;

&lt;dependency&gt;
    &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
    &lt;artifactId&gt;spring-boot-starter-data-mongodb&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
<h4 id="32添加配置文件">3.2、添加配置文件</h4>
<p>在<code>application.properties</code>文件中添加<code>mongodb</code>配置</p>
<pre><code>#配置数据库连接地址
spring.data.mongodb.uri=mongodb://test123:test123@127.0.0.1:27017/test_db
</code></pre>
<h4 id="33创建实体类">3.3、创建实体类</h4>
<p>创建用于示例中测试的实体类<code>Person</code>。</p>
<p>其中注解<code>@Document(collection="persons")</code>用于指定当前文档属于集合<code>persons</code>。</p>
<p>注解<code>@Id</code>表示当前<code>id</code>字段属于主键类型。</p>
<pre><code class="language-java">/**
* 使用@Document注解指定集合名称
*/
@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

    /**
   * 使用@Id注解指定MongoDB中的 _id 主键
   */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

    private Date createTime;

    //...get/set

    @Override
    public String toString() {
      return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}
</code></pre>
<h4 id="34操作-mongodb">3.4、操作 MongoDB</h4>
<p>Springboot 操作 MongoDB 有两种方式。</p>
<ul>
<li>
<p>第一种方式是采用 Springboot 官方推荐的 JPA 方式，这种操作方式，使用简单但是灵活性比较差。</p>
</li>
<li>
<p>第二种方式是采用 Spring Data MongoDB 封装的 MongoDB 官方 Java 驱动 MongoTemplate 对 MongoDB 进行操作，这种方式非常灵活，能满足绝大部分需求。</p>
</li>
</ul>
<p>本文将采用第二种方式进行介绍！</p>
<h4 id="35插入文档">3.5、插入文档</h4>
<p><code>MongoTemplate</code>提供了<code>insert()</code>方法，用于插入文档，示例代码如下：</p>
<ul>
<li>用于插入文档</li>
</ul>
<blockquote>
<p>没指定集合名称时，会取<code>@Document</code>注解中的集合名称</p>
</blockquote>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 插入文档
   * @throws Exception
   */
    @Test
    public void insert() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());
      mongoTemplate.insert(person);
    }
}
</code></pre>
<ul>
<li>自定义集合名称，插入文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 自定义集合，插入文档
   * @throws Exception
   */
    @Test
    public void insertCustomCollection() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());
      mongoTemplate.insert(person, "custom_person");
    }
}
</code></pre>
<ul>
<li>自定义集合，批量插入文档</li>
</ul>
<blockquote>
<p>如果采用批量插入文档，必须指定集合名称</p>
</blockquote>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 自定义集合，批量插入文档
   * @throws Exception
   */
    @Test
    public void insertBatch() throws Exception {
      List&lt;Person&gt; personList = new ArrayList&lt;&gt;();
      Person person1 =new Person();
      person1.setId(10l);
      person1.setUserName("张三");
      person1.setPassWord("123456");
      person1.setCreateTime(new Date());
      personList.add(person1);

      Person person2 =new Person();
      person2.setId(11l);
      person2.setUserName("李四");
      person2.setPassWord("123456");
      person2.setCreateTime(new Date());
      personList.add(person2);

      mongoTemplate.insert(personList, "custom_person");
    }
}
</code></pre>
<h4 id="36存储文档">3.6、存储文档</h4>
<p><code>MongoTemplate</code>提供了<code>save()</code>方法，用于存储文档。</p>
<p>在存储文档的时候会通过主键ID进行判断，如果存在就更新，否则就插入，示例代码如下：</p>
<ul>
<li>存储文档，如果没有插入，否则通过<code>主键ID</code>更新</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 存储文档，如果没有插入，否则更新
   * @throws Exception
   */
    @Test
    public void save() throws Exception {
      Person person =new Person();
      person.setId(13l);
      person.setUserName("八八");
      person.setPassWord("123456");
      person.setAge(40);
      person.setCreateTime(new Date());
      mongoTemplate.save(person);
    }
}
</code></pre>
<ul>
<li>自定义集合，存储文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 自定义集合，存储文档
   * @throws Exception
   */
    @Test
    public void saveCustomCollection() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());
      mongoTemplate.save(person, "custom_person");
    }
}
</code></pre>
<h4 id="37更新文档">3.7、更新文档</h4>
<p><code>MongoTemplate</code>提供了<code>updateFirst()</code>和<code>updateMulti()</code>方法，用于更新文档，示例代码如下：</p>
<ul>
<li>更新文档，匹配查询到的文档数据中的第一条数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 更新文档，匹配查询到的文档数据中的第一条数据
   * @throws Exception
   */
    @Test
    public void updateFirst() throws Exception {
      //更新对象
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三123");
      person.setPassWord("123456");
      person.setCreateTime(new Date());

      //更新条件
      Query query= new Query(Criteria.where("id").is(person.getId()));

      //更新值
      Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
      //更新查询满足条件的文档数据（第一条）
      UpdateResult result =mongoTemplate.updateFirst(query,update, Person.class);
      if(result!=null){
            System.out.println("更新条数：" + result.getMatchedCount());
      }
    }
}
</code></pre>
<ul>
<li>更新文档，匹配查询到的文档数据中的所有数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 更新文档，匹配查询到的文档数据中的所有数据
   * @throws Exception
   */
    @Test
    public void updateMany() throws Exception {
      //更新对象
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());

      //更新条件
      Query query= new Query(Criteria.where("id").is(person.getId()));

      //更新值
      Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
      //更新查询满足条件的文档数据（全部）
      UpdateResult result = mongoTemplate.updateMulti(query, update, Person.class);
      if(result!=null){
            System.out.println("更新条数：" + result.getMatchedCount());
      }
    }
}
</code></pre>
<h4 id="38删除文档">3.8、删除文档</h4>
<p><code>MongoTemplate</code>提供了<code>remove()</code>、<code>findAndRemove()</code>和<code>findAllAndRemove()</code>方法，用于删除文档，示例代码如下：</p>
<ul>
<li>删除符合条件的所有文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 删除符合条件的所有文档
   * @throws Exception
   */
    @Test
    public void remove() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());

      Query query = new Query(Criteria.where("userName").is(person.getUserName()));
      DeleteResult result = mongoTemplate.remove(query, Person.class);
      System.out.println("删除条数：" + result.getDeletedCount());
    }
}
</code></pre>
<ul>
<li>删除符合条件的单个文档，并返回删除的文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 删除符合条件的单个文档，并返回删除的文档
   * @throws Exception
   */
    @Test
    public void findAndRemove() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());

      Query query = new Query(Criteria.where("id").is(person.getId()));
      Person result = mongoTemplate.findAndRemove(query, Person.class);
      System.out.println("删除的文档数据：" + result.toString());
    }
}
</code></pre>
<ul>
<li>删除符合条件的所有文档，并返回删除的文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 删除符合条件的所有文档，并返回删除的文档
   * @throws Exception
   */
    @Test
    public void findAllAndRemove() throws Exception {
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());

      Query query = new Query(Criteria.where("id").is(person.getId()));
      List&lt;Person&gt; result = mongoTemplate.findAllAndRemove(query, Person.class);
      System.out.println("删除的文档数据：" + result.toString());
    }
}
</code></pre>
<h4 id="39查询文档">3.9、查询文档</h4>
<p><code>MongoTemplate</code>提供了非常多的文档查询方法，日常开发中用的最多的就是<code>find()</code>方法，示例代码如下：</p>
<ul>
<li>查询集合中的全部文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 查询集合中的全部文档数据
   * @throws Exception
   */
    @Test
    public void findAll() throws Exception {
      List&lt;Person&gt; result = mongoTemplate.findAll(Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>查询集合中指定的ID文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 查询集合中指定的ID文档数据
   * @throws Exception
   */
    @Test
    public void findById() {
      long id = 1l;
      Person result = mongoTemplate.findById(id, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据条件查询集合中符合条件的文档，返回第一条数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据条件查询集合中符合条件的文档，返回第一条数据
   */
    @Test
    public void findOne() {
      String userName = "张三";
      Query query = new Query(Criteria.where("userName").is(userName));
      Person result = mongoTemplate.findOne(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据条件查询集合中符合条件的文档</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据条件查询集合中符合条件的文档
   */
    @Test
    public void findByCondition() {
      String userName = "张三";
      Query query = new Query(Criteria.where("userName").is(userName));
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据【AND】关联多个查询条件，查询集合中的文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据【AND】关联多个查询条件，查询集合中的文档数据
   */
    @Test
    public void findByAndCondition() {
      // 创建条件
      Criteria criteriaUserName = Criteria.where("userName").is("张三");
      Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
      // 创建条件对象，将上面条件进行 AND 关联
      Criteria criteria = new Criteria().andOperator(criteriaUserName, criteriaPassWord);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据【OR】关联多个查询条件，查询集合中的文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据【OR】关联多个查询条件，查询集合中的文档数据
   */
    @Test
    public void findByOrCondition() {
      // 创建条件
      Criteria criteriaUserName = Criteria.where("userName").is("张三");
      Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
      // 创建条件对象，将上面条件进行 OR 关联
      Criteria criteria = new Criteria().orOperator(criteriaUserName, criteriaPassWord);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据【IN】关联多个查询条件，查询集合中的文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据【IN】关联多个查询条件，查询集合中的文档数据
   */
    @Test
    public void findByInCondition() {
      // 设置查询条件参数
      List&lt;Long&gt; ids = Arrays.asList(1l, 10l, 11l);
      // 创建条件
      Criteria criteria = Criteria.where("id").in(ids);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据【逻辑运算符】查询集合中的文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据【逻辑运算符】查询集合中的文档数据
   */
    @Test
    public void findByOperator() {
      // 设置查询条件参数
      int min = 20;
      int max = 35;
      Criteria criteria = Criteria.where("age").gt(min).lte(max);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据【正则表达式】查询集合中的文档数据</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据【正则表达式】查询集合中的文档数据
   */
    @Test
    public void findByRegex() {
      // 设置查询条件参数
      String regex = "^张*";
      Criteria criteria = Criteria.where("userName").regex(regex);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据条件查询集合中符合条件的文档，获取其文档列表并排序</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 根据条件查询集合中符合条件的文档，获取其文档列表并排序
   */
    @Test
    public void findByConditionAndSort() {
      String userName = "张三";
      Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("age"));
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>根据单个条件查询集合中的文档数据，并按指定字段进行排序与限制指定数目</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
   * 根据单个条件查询集合中的文档数据，并按指定字段进行排序与限制指定数目
   */
    @Test
    public void findByConditionAndSortLimit() {
      String userName = "张三";
      //从第一行开始，查询2条数据返回
      Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("createTime")).limit(2).skip(1);
      List&lt;Person&gt; result = mongoTemplate.find(query, Person.class);
      System.out.println("查询结果：" + result.toString());
    }
}
</code></pre>
<ul>
<li>统计集合中符合【查询条件】的文档【数量】</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
   * 统计集合中符合【查询条件】的文档【数量】
   */
    @Test
    public void countNumber() {
      // 设置查询条件参数
      String regex = "^张*";
      Criteria criteria = Criteria.where("userName").regex(regex);
      // 创建查询对象，然后将条件对象添加到其中
      Query query = new Query(criteria);
      long count = mongoTemplate.count(query, Person.class);
      System.out.println("统计结果：" + count);
    }
}
</code></pre>
<h4 id="40创建索引">4.0、创建索引</h4>
<p>索引在所有的数据库中，暂居的位置非常重要，例如当你检索一张上百万的数据表的时候，如果没走索引，查询效率会极其缓慢，对于 MongoDB 来说，同样如此。</p>
<p>示例如下：</p>
<ul>
<li>创建升序索引</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
   * 创建升序索引
   */
    @Test
    public void createAscendingIndex() {
      // 设置字段名称
      String field = "userName";
      // 创建索引
      mongoTemplate.getCollection("persons").createIndex(Indexes.ascending(field));
    }
}
</code></pre>
<ul>
<li>移除索引</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
   * 根据索引名称移除索引
   */
    @Test
    public void removeIndex() {
      // 设置字段名称
      String field = "userName";
      // 删除索引
      mongoTemplate.getCollection("persons").dropIndex(field);
    }
}
</code></pre>
<ul>
<li>查询集合中所有的索引</li>
</ul>
<pre><code class="language-java">@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
   * 查询集合中所有的索引
   */
    @Test
    public void getIndexAll() {
      // 获取集合中所有列表
      ListIndexesIterable&lt;Document&gt; indexList = mongoTemplate.getCollection("persons").listIndexes();
      // 获取集合中全部索引信息
      for (Document document : indexList) {
            System.out.println("索引列表：" + document);
      }
    }
}
</code></pre>
<ul>
<li>我们还可以通过在实体类上加注解方式来创建索引</li>
</ul>
<pre><code class="language-java">/**
* 使用@Document注解指定集合名称
*/
@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

    /**
   * 使用@Id注解指定MongoDB中的 _id 主键
   */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

    /**
   * 创建一个5秒之后文档自动删除的索引
   */
    @Indexed(expireAfterSeconds=5)
    private Date createTime;

    //...get/set

    @Override
    public String toString() {
      return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}
</code></pre>
<h4 id="41引入-mongodb-中的事务">4.1、引入 MongoDB 中的事务</h4>
<blockquote>
<p>单节点 mongodb 不支持事务，需要搭建 MongoDB 复制集。</p>
</blockquote>
<pre><code class="language-java">/**
* 配置事务管理器
*
*/
@Configuration
public class TransactionConfig {

    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
      return new MongoTransactionManager(dbFactory);
    }

}
</code></pre>
<p>事务服务测试！</p>
<pre><code class="language-java">@Service
public class TransactionExample {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Transactional(rollbackFor = Exception.class)
    public Object transactionTest(){
      Person person =new Person();
      person.setId(1l);
      person.setUserName("张三");
      person.setPassWord("123456");
      person.setCreateTime(new Date());
      Person newPerson = mongoTemplate.insert(person);
      // 抛出异常，观察数据是否进行回滚
      if(1 == 1){
            throw new RuntimeException("异常");
      }
      return newPerson;
    }
}
</code></pre>
<h3 id="四小结">四、小结</h3>
<p>本文主要围绕 MongoDB 的 Java 客户端使用进行基本的增删改查操作介绍，在实际的业务场景中，可能还需要用到聚合函数等高级查询，大家如果有这种需求，可以访问如下地址获取更加详细的 api 文档介绍：MongoDB 文档查询 api 介绍</p>
<h3 id="五参考">五、参考</h3>
<p>1、菜鸟教程 - mongodb</p>
<p>2、超级小豆丁 - MongoDB 介绍</p>


</div>
<div id="MySignature" role="contentinfo">
    <p style="border-top: #e0e0e0 1px dashed; border-right: #e0e0e0 1px dashed; border-bottom: #e0e0e0 1px dashed; border-left: #e0e0e0 1px dashed; padding-top: 5px; padding-right: 10px; padding-bottom: 10px; padding-left: 165px; background: url(&quot;//img2024.cnblogs.com/blog/1078540/202406/1078540-20240614164402310-1763967680.jpg&quot;) #e5f1f4 no-repeat 1% 50%;background-size: 150px; font-family: 微软雅黑; font-size: 11px" id="PSignature">
    <br>
    作者：<span style="font-weight: bold; font-size: large;">潘志的研发笔记</span>
    <br>
    出处：pzblog.cn
    <br>
    资源：微信搜<strong>【潘志的研发笔记】</strong>关注我，回复 <strong style=" font-size: 15px;">【技术资料】</strong>有我准备的一线程序必备计算机书籍、大厂面试资料和免费电子书。 <strong>希望可以帮助大家提升技术和能力。</strong>
    <br>
    <br>
</p><br><br>
来源：https://www.cnblogs.com/dxflqm/p/16643981.html

查看完整版本: SpringBoot 整合 MongoDB 实战解说