• MongoDB 应用实战

    1、MongoDB的适用场景

    • 网站数据：Mongo 非常适合实时的插入,更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
    • 缓存：由于性能很高，Mongo 也适合作为信息基础设施的缓存层。在系统重启之后，由Mongo搭建的持久化缓存层可以避免下层的数据源过载。
    • 大尺寸、低价值的数据：使用传统的关系型数据库存储一些大尺寸低价值数据时会比较浪费，在此之前，很多时候程序员往往会选择传统的文件进行存储。
    • 高伸缩性的场景：Mongo 非常适合由数十或数百台服务器组成的数据库，Mongo 的路线图中已经包含对MapReduce 引擎的内置支持以及集群高可用的解决方案。
    • 用于对象及JSON 数据的存储：Mongo 的BSON 数据格式非常适合文档化格式的存储及查询。

    2、MongoDB的行业具体应用场景

    • 游戏场景，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、更新。
    • 物流场景，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来。
    • 社交场景，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能。
    • 物联网场景，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析。
    • 直播，使用 MongoDB 存储用户信息、礼物信息等。

    3、如何抉择是否使用MongoDB

    应用特征Yes / No
    应用不需要事务及复杂 join 支持必须 Yes
    新应用，需求会变，数据模型无法确定，想快速迭代开发?
    应用需要2000-3000以上的读写QPS（更高也可以）?
    应用需要TB甚至 PB 级别数据存储?
    应用发展迅速，需要能快速水平扩展?
    应用要求存储的数据不丢失?
    应用需要99.999%高可用?
    应用需要大量的地理位置查询、文本查询?

    4、Java 访问MongoDB

    （1）导入依赖

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     
    7.     <groupId>com.lagougroupId>
    8.     <artifactId>mongo_java_demoartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.mongodbgroupId>
    14.             <artifactId>mongo-java-driverartifactId>
    15.             <version>3.12.11version>
    16.         dependency>
    17.     dependencies>
    18.     <build>
    19.         <plugins>
    20.             <plugin>
    21.                 <groupId>org.apache.maven.pluginsgroupId>
    22.                 <artifactId>maven-compiler-pluginartifactId>
    23.                 <version>3.5.1version>
    24.                 <configuration>
    25.                     <source>1.8source>
    26.                     <target>1.8target>
    27.                 configuration>
    28.             plugin>
    29.         plugins>
    30.     build>
    31.  
    32. project>

    （2）文档添加操作

    1. package com.lagou.test;
    2.  
    3. import com.mongodb.MongoClient;
    4. import com.mongodb.client.MongoCollection;
    5. import com.mongodb.client.MongoDatabase;
    6. import org.bson.Document;
    7.  
    8. public class DocumentInsertTest {
    9.     public static void main(String[] args) {
    10.         MongoClient mongoClient = new MongoClient("127.0.0.1:27017");
    11.         // 获取数据库对象
    12.         MongoDatabase mongoDatabase = mongoClient.getDatabase("lg_resume");
    13.         // 获取集合对象
    14.         MongoCollection collection = mongoDatabase.getCollection("lg_resume_preview");
    15.         // 构建Document对象，并插入到集合中
    16.         Document document = Document.parse("{name:'lisi', city:'北京',birthday:new ISODate('2000-06-08'), expectSalary:19999}");
    17.         collection.insertOne(document);
    18.         mongoClient.close();
    19.     }
    20. }

    （3）文档查询操作

    1. package com.lagou.test;
    2.  
    3. import com.mongodb.MongoClient;
    4. import com.mongodb.client.FindIterable;
    5. import com.mongodb.client.MongoCollection;
    6. import com.mongodb.client.MongoDatabase;
    7. import org.bson.Document;
    8.  
    9. public class DocumentFindTest {
    10.     public static void main(String[] args) {
    11.         MongoClient mongoClient = new MongoClient("127.0.0.1:27017");
    12.         // 获取数据库对象
    13.         MongoDatabase mongoDatabase = mongoClient.getDatabase("lg_resume");
    14.         // 获取集合对象
    15.         MongoCollection collection = mongoDatabase.getCollection("lg_resume_preview");
    16.         //按expectSalary降序排列
    17.         Document sortDocument = new Document();
    18.         // 塞入排序条件
    19.         sortDocument.append("expectSalary", -1);
    20.         // 直接调用find方法查询的是所有
    21.         FindIterable findIterable = collection.find().sort(sortDocument);
    22.         for (Document document : findIterable) {
    23.             System.out.println(document);
    24.         }
    25.         mongoClient.close();
    26.     }
    27. }

    （4）文档查询过滤

    1. package com.lagou.test;
    2.  
    3. import com.mongodb.MongoClient;
    4. import com.mongodb.client.FindIterable;
    5. import com.mongodb.client.MongoCollection;
    6. import com.mongodb.client.MongoDatabase;
    7. import com.mongodb.client.model.Filters;
    8. import org.bson.Document;
    9.  
    10. public class DocumentFiltersTest {
    11.     public static void main(String[] args) {
    12.         MongoClient mongoClient = new MongoClient("127.0.0.1:27017");
    13.         // 获取数据库对象
    14.         MongoDatabase mongoDatabase = mongoClient.getDatabase("lg_resume");
    15.         // 获取集合对象
    16.         MongoCollection collection = mongoDatabase.getCollection("lg_resume_preview");
    17.         // 按expectSalary降序排列
    18.         Document sortDocument = new Document();
    19.         // 塞入排序条件
    20.         sortDocument.append("expectSalary", -1);
    21.         // FindIterable findIterable = collection.find(Document.parse("{expectSalary:{$gt:15000}}")).sort(sortDocument); // 这种方式使用的是mongo原生的过滤方式
    22.         // 这种是Java给我们提供一个Filters过滤器类，通过调用里面的方法完成条件查询操作
    23.         FindIterable findIterable = collection.find(Filters.gt("expectSalary", 15000)).sort(sortDocument);
    24.         for (Document document : findIterable) {
    25.             System.out.println(document);
    26.         }
    27.         mongoClient.close();
    28.     }
    29. }

    5、Spring 访问MongoDB

    （1）导入依赖

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     
    7.     <groupId>com.lagougroupId>
    8.     <artifactId>mongo_spring_demoartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframework.datagroupId>
    14.             <artifactId>spring-data-mongodbartifactId>
    15.             <version>2.0.9.RELEASEversion>
    16.         dependency>
    17.     dependencies>
    18.     
    19.     <build>
    20.         <plugins>
    21.             <plugin>
    22.                 <groupId>org.apache.maven.pluginsgroupId>
    23.                 <artifactId>maven-compiler-pluginartifactId>
    24.                 <version>3.5.1version>
    25.                 <configuration>
    26.                     <source>1.8source>
    27.                     <target>1.8target>
    28.                 configuration>
    29.             plugin>
    30.         plugins>
    31.     build>
    32. project>

    （2）创建applicationContext.xml配置文件

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:mongo="http://www.springframework.org/schema/data/mongo"
    6.        xsi:schemaLocation="
    7.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    8.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    9.     http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">
    10.     
    11.     <mongo:db-factory id="mongoDbFactory" client-uri="mongodb://127.0.0.1:27017/lg_resume"/>
    12.     
    13.     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
    14.         <constructor-arg index="0" ref="mongoDbFactory"/>
    15.     bean>
    16.     
    17.     <context:component-scan base-package="com.lagou"/>
    18. beans>

    （3）创建映射实体类

    1. package com.lagou.bean;
    2.  
    3. import java.util.Date;
    4.  
    5. public class Resume {
    6.     private String id; // 注意这里的id等同于MongoDB中的 _id
    7.     private String name;
    8.     private String city;
    9.     private Date birthday;
    10.     private double expectSalary;
    11.  
    12.     public Resume() {
    13.     }
    14.  
    15.     public Resume(String id, String name, String city, Date birthday, double expectSalary) {
    16.         this.id = id;
    17.         this.name = name;
    18.         this.city = city;
    19.         this.birthday = birthday;
    20.         this.expectSalary = expectSalary;
    21.     }
    22.  
    23.     public String getId() {
    24.         return id;
    25.     }
    26.  
    27.     public void setId(String id) {
    28.         this.id = id;
    29.     }
    30.  
    31.     public String getName() {
    32.         return name;
    33.     }
    34.  
    35.     public void setName(String name) {
    36.         this.name = name;
    37.     }
    38.  
    39.     public String getCity() {
    40.         return city;
    41.     }
    42.  
    43.     public void setCity(String city) {
    44.         this.city = city;
    45.     }
    46.  
    47.     public Date getBirthday() {
    48.         return birthday;
    49.     }
    50.  
    51.     public void setBirthday(Date birthday) {
    52.         this.birthday = birthday;
    53.     }
    54.  
    55.     public double getExpectSalary() {
    56.         return expectSalary;
    57.     }
    58.  
    59.     public void setExpectSalary(double expectSalary) {
    60.         this.expectSalary = expectSalary;
    61.     }
    62.  
    63.     @Override
    64.     public String toString() {
    65.         return "Resume{" +
    66.                 "id='" + id + '\'' +
    67.                 ", name='" + name + '\'' +
    68.                 ", city='" + city + '\'' +
    69.                 ", birthday=" + birthday +
    70.                 ", expectSalary=" + expectSalary +
    71.                 '}';
    72.     }
    73. }

    （4）创建接口

    1. package com.lagou.dao;
    2.  
    3. import com.lagou.bean.Resume;
    4.  
    5. import java.util.List;
    6.  
    7. public interface ResumeDao {
    8.     void insertResume(Resume resume);
    9.  
    10.     // 根据name获取resume对象
    11.     Resume findByName(String name);
    12.  
    13.     // 根据name 和 expectSalary 进行多条件查询
    14.     List findListByNameAndSalary(String name, int expectSalary);
    15.  
    16. }

    （5）创建接口实现类

    1. package com.lagou.dao.impl;
    2.  
    3. import com.lagou.bean.Resume;
    4. import com.lagou.dao.ResumeDao;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.data.mongodb.core.MongoTemplate;
    7. import org.springframework.data.mongodb.core.query.Criteria;
    8. import org.springframework.data.mongodb.core.query.Query;
    9. import org.springframework.stereotype.Repository;
    10.  
    11. import java.util.List;
    12.  
    13. @Repository("resumeDao")
    14. public class ResumeDaoImpl implements ResumeDao {
    15.     @Autowired
    16.     private MongoTemplate mongoTemplate;
    17.  
    18.     @Override
    19.     public void insertResume(Resume resume) { // 不指定集合名时，默认集合名就是类型名首字母小写，也就是这里的resume
    20.         // mongoTemplate.insert(resume);
    21.         mongoTemplate.insert(resume, "lg_resume"); // 插入数据并且指定集合名
    22.     }
    23.  
    24.     @Override
    25.     public Resume findByName(String name) {
    26.         // 构建查询对象
    27.         Query query = new Query();
    28.         // 向查询对象中封装数据
    29.         query.addCriteria(Criteria.where("name").is(name));
    30.         return mongoTemplate.findOne(query, Resume.class, "lg_resume"); // 使用findOne方法查询某一字段时，必须要保证该字段唯一否则就会报错，若该字段不为一时，使用find方法
    31.     }
    32.  
    33.     @Override
    34.     public List findListByNameAndSalary(String name, int expectSalary) {
    35.         Query query = new Query();
    36.         // 封装条件，根据名字进行查询并且expectSalary大于传入的期望薪水，
    37.         query.addCriteria(Criteria.where("name").is(name).andOperator(Criteria.where("expectSalary").gt(expectSalary)));
    38.         return mongoTemplate.find(query, Resume.class, "lg_resume");
    39.     }
    40. }

    （6）调用方法，进行测试

    1. package com.lagou;
    2.  
    3. import com.lagou.bean.Resume;
    4. import com.lagou.dao.ResumeDao;
    5. import org.springframework.context.support.ClassPathXmlApplicationContext;
    6.  
    7. import java.text.ParseException;
    8. import java.text.SimpleDateFormat;
    9. import java.util.Date;
    10. import java.util.List;
    11.  
    12. public class MongoTemplateMain {
    13.     public static void main(String[] args) {
    14.         ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    15.         ResumeDao resumeDao = applicationContext.getBean("resumeDao", ResumeDao.class);
    16.       /*   Resume resume = new Resume();
    17.         // resume.setId("1010111"); // 如果我们这里设置了id值，那么MongoDB就不会在为我们产生id值了
    18.         resume.setName("Jack");
    19.         resume.setCity("chongqing");
    20.         Date date = null;
    21.         String dateStr = "yy-MM-dd hh:mm:ss";
    22.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateStr);
    23.         try {
    24.             date = simpleDateFormat.parse("2022-9-13 17:20:15");
    25.         } catch (ParseException e) {
    26.             throw new RuntimeException(e);
    27.         }
    28.         resume.setBirthday(date);
    29.         resume.setExpectSalary(28000);
    30.         resumeDao.insertResume(resume); */
    31.  
    32.         Resume resume = resumeDao.findByName("Jack");
    33.         System.out.println(resume);
    34.  
    35.         List list = resumeDao.findListByNameAndSalary("Jack", 200000);
    36.         System.out.println(list.toString());
    37.     }
    38. }

    （7）注意：如果我们想要保持某一字段的唯一性（也就是不能进行重复插入相同数据），可以给该字段创建索引，并添加属性unique

    db.集合名.createIndex({字段名:排序条件}, {unique:true})

    这样创建索引之后，如果我们重复插入相同数据时，则会报错。

    6、Spring Boot 访问 MongoDB

    方式一：MongoTemplate 的方式

    注意：使用这种方式大部分步骤都与spring方式访问MongoDB相同，因此下面我只介绍其不同的部分，两者相同的部分，就省略了

    （1）导入依赖

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     
    7.     <groupId>com.lagougroupId>
    8.     <artifactId>mongo_springboot_templateartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframework.bootgroupId>
    14.             <artifactId>spring-boot-starter-data-mongodbartifactId>
    15.             <version>2.2.2.RELEASEversion>
    16.         dependency>
    17.     dependencies>
    18.     
    19.     <build>
    20.         <plugins>
    21.             <plugin>
    22.                 <groupId>org.apache.maven.pluginsgroupId>
    23.                 <artifactId>maven-compiler-pluginartifactId>
    24.                 <version>3.5.1version>
    25.                 <configuration>
    26.                     <source>1.8source>
    27.                     <target>1.8target>
    28.                 configuration>
    29.             plugin>
    30.         plugins>
    31.     build>
    32. project>

    （2）创建配置文件application.yml

    1. spring:
    2.   data:
    3.     mongodb:
    4.       host: 8.142.8.105
    5.       port: 27017
    6.       database: lg_resume

    （3）启动类，进行方法测试

    1. package com.lagou;
    2.  
    3. import com.lagou.bean.Resume;
    4. import com.lagou.dao.ResumeDao;
    5. import org.springframework.boot.SpringApplication;
    6. import org.springframework.boot.autoconfigure.SpringBootApplication;
    7. import org.springframework.context.ApplicationContext;
    8. import org.springframework.context.ConfigurableApplicationContext;
    9. import org.springframework.context.support.ClassPathXmlApplicationContext;
    10.  
    11. import java.text.SimpleDateFormat;
    12. import java.util.Date;
    13. import java.util.List;
    14.  
    15. @SpringBootApplication
    16. public class MongoTemplateMain {
    17.     public static void main(String[] args) {
    18.         /*  ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");*/  // spring方式获取bean
    19.         ApplicationContext applicationContext = SpringApplication.run(MongoTemplateMain.class, args); // SpringBoot方式获取bean
    20.         ResumeDao resumeDao = applicationContext.getBean("resumeDao", ResumeDao.class);
    21.  
    22.        /*  Resume resume = new Resume();
    23.         // resume.setId("1010111"); // 如果我们这里设置了id值，那么MongoDB就不会在为我们产生id值了
    24.         resume.setName("Jack");
    25.         resume.setCity("chongqing");
    26.         Date date = null;
    27.         String dateStr = "yy-MM-dd hh:mm:ss";
    28.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat(dateStr);
    29.         try {
    30.             date = simpleDateFormat.parse("2022-9-13 17:20:15");
    31.         } catch (Exception e) {
    32.             throw new RuntimeException(e);
    33.         }
    34.         resume.setBirthday(date);
    35.         resume.setExpectSalary(28000);
    36.         resumeDao.insertResume(resume); */
    37.  
    38.         Resume resume = resumeDao.findByName("Jack");
    39.         System.out.println(resume);
    40.  
    41.         List list = resumeDao.findListByNameAndSalary("Jack", 200);
    42.         System.out.println(list.toString());
    43.     }
    44. }

    方式二：MongoRepository 的方式

    （1）导入依赖

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.     
    7.     <groupId>com.lagougroupId>
    8.     <artifactId>mongo_springboot_repositoryartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.     
    11.     <dependencies>
    12.         <dependency>
    13.             <groupId>org.springframework.bootgroupId>
    14.             <artifactId>spring-boot-starter-data-mongodbartifactId>
    15.             <version>2.2.2.RELEASEversion>
    16.         dependency>
    17.     dependencies>
    18.     
    19.     <build>
    20.         <plugins>
    21.             <plugin>
    22.                 <groupId>org.apache.maven.pluginsgroupId>
    23.                 <artifactId>maven-compiler-pluginartifactId>
    24.                 <version>3.5.1version>
    25.                 <configuration>
    26.                     <source>1.8source>
    27.                     <target>1.8target>
    28.                 configuration>
    29.             plugin>
    30.         plugins>
    31.     build>
    32. project>

    （2）创建application.yml配置文件

    1. spring:
    2.   data:
    3.     mongodb:
    4.       host: 8.142.8.105
    5.       port: 27017
    6.       database: lg_resume

    （3）编写实体类 并在实体类上打@Document(“集合名”)

    这个与上面的几种方式都不同

    1. package com.lagou.bean;
    2.  
    3. import org.springframework.data.mongodb.core.mapping.Document;
    4.  
    5. import java.util.Date;
    6.  
    7. @Document("lg_resume") // 指定集合名
    8. public class Resume {
    9.     private String id; // 注意这里的id等同于MongoDB中的 _id
    10.     private String name;
    11.     private String city;
    12.     private Date birthday;
    13.     private double expectSalary;
    14.  
    15.     public Resume() {
    16.     }
    17.  
    18.     public Resume(String id, String name, String city, Date birthday, double expectSalary) {
    19.         this.id = id;
    20.         this.name = name;
    21.         this.city = city;
    22.         this.birthday = birthday;
    23.         this.expectSalary = expectSalary;
    24.     }
    25.  
    26.     public String getId() {
    27.         return id;
    28.     }
    29.  
    30.     public void setId(String id) {
    31.         this.id = id;
    32.     }
    33.  
    34.     public String getName() {
    35.         return name;
    36.     }
    37.  
    38.     public void setName(String name) {
    39.         this.name = name;
    40.     }
    41.  
    42.     public String getCity() {
    43.         return city;
    44.     }
    45.  
    46.     public void setCity(String city) {
    47.         this.city = city;
    48.     }
    49.  
    50.     public Date getBirthday() {
    51.         return birthday;
    52.     }
    53.  
    54.     public void setBirthday(Date birthday) {
    55.         this.birthday = birthday;
    56.     }
    57.  
    58.     public double getExpectSalary() {
    59.         return expectSalary;
    60.     }
    61.  
    62.     public void setExpectSalary(double expectSalary) {
    63.         this.expectSalary = expectSalary;
    64.     }
    65.  
    66.     @Override
    67.     public String toString() {
    68.         return "Resume{" +
    69.                 "id='" + id + '\'' +
    70.                 ", name='" + name + '\'' +
    71.                 ", city='" + city + '\'' +
    72.                 ", birthday=" + birthday +
    73.                 ", expectSalary=" + expectSalary +
    74.                 '}';
    75.     }
    76. }

    （3）编写 Repository 接口 继承 MongoRepository

    1. package com.lagou.repository;
    2.  
    3. import com.lagou.bean.Resume;
    4. import org.springframework.data.mongodb.repository.MongoRepository;
    5.  
    6. import java.util.List;
    7.  
    8. public interface ResumeRepository extends MongoRepository {
    9.     // 指定根据名字进行查询
    10.     List findByNameEquals(String name);
    11. }

            注：这种方式与JPA类似都是继承一个接口，然后就可以使用它里面自带的方法，如果内置方法不够用就自己定义 如:定义find|read|get 等开头的方法进行查询。

    详细定义格式：请点击

    （4）从Spring容器中获取Repository对象，进行测试

    1. package com.lagou;
    2.  
    3. import com.lagou.bean.Resume;
    4. import com.lagou.repository.ResumeRepository;
    5. import org.springframework.boot.SpringApplication;
    6. import org.springframework.boot.autoconfigure.SpringBootApplication;
    7. import org.springframework.context.ApplicationContext;
    8.  
    9. import java.util.List;
    10.  
    11. @SpringBootApplication
    12. public class MongoRepositoryMain {
    13.     public static void main(String[] args) {
    14.         ApplicationContext applicationContext = SpringApplication.run(MongoRepositoryMain.class, args);
    15.         ResumeRepository resumeRepository = applicationContext.getBean(ResumeRepository.class);
    16.         List list = resumeRepository.findAll();
    17.         System.out.println(list);
    18.         System.out.println(resumeRepository.findByNameEquals("Jack"));
    19.  
    20.     }
    21. }
  • 相关阅读:
    Mac安装Mysql，并启动
    Ant design table实现单选和点击行选中
    太神了！开源大佬的SpringBoot+微服务架构笔记,一般人真肝不出来
    LeaRun.Java快速开发平台 高效代码自动化生成
    go-zero整合单机版ClickHouse并实现增删改查
    [操作系统笔记]基本分页存储管理
    python常用命令
    【Android 标题文字居中 快速实现】
    LLM推理入门指南②：深入解析KV缓存
    零售商贩mysql表设计：banner管理表
  • 原文地址：https://blog.csdn.net/weixin_52851967/article/details/126845269