springboot整合mongodb MongoTemplate和MongoRepository的用法

最新推荐文章于 2024-09-05 15:08:58 发布

程序员修炼

最新推荐文章于 2024-09-05 15:08:58 发布

阅读量5.2k

点赞数 5

分类专栏： SpringBoot 文章标签： sprinngboot mongodb mongoTemplate MongoReposity

本文链接：https://blog.csdn.net/jingyoushui/article/details/102842394

版权

SpringBoot 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

mongodb的安装

我采用的是docker的方式，安装和配置的方式在docker安装mongodb

springboot整合mongodb

1.添加依赖：
在pom文件中添加mongodb的依赖

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

2.在application.properties中配置mongodb相关的连接信息

#配置mongodb
spring.data.mongodb.authentication-database=admin
spring.data.mongodb.database=assesment
spring.data.mongodb.host=192.168.1.175
spring.data.mongodb.port=27017
spring.data.mongodb.username=lixing
spring.data.mongodb.password=123456

第一行是验证登录，通常是admin。第二行是要连接到的数据库，第三行是ip地址，在本机docker中就使用本机地址，第四个是端口，最后是用户名和密码，在docker中都可以进行配置。

3.创建你的实体类
如下，我创建一个自定义表单的实体类，用来保存前端生成的自定义表单信息。

package com.nju.software.assessment.bean;

import org.springframework.data.mongodb.core.mapping.Document;

import javax.persistence.Id;
import java.util.List;

@Document
public class Form {
    //自定义表单id
    @Id
    private Integer id;
    //表单标题
    private String title;
    //表单描述
    private String miaoshu;
    //组件的个数
    private Integer num;
    //表单组件标题
    private List<Object> inputbt;
    //表单组件类型
    private List<Object> optiontype;
    //单选按钮的选项个数
    private List<Object> radionum;
    //单选按钮名字
    private String radioname;
    //多选按钮的选项个数
    private List<Object> checkboxnum;
    //多选按钮名字
    private String checkboxname;
    //下拉框的选项个数
    private List<Object> selectnum;
    //下拉框名字
    private String selectname;
//省掉构造函数，get,set方法

@Document注解表明这是一个文档类型。标注在实体类上，类似于hibernate的entity注解，表示由mongo来维护该表。
@Id是主键，不可重复，自带索引，可以在定义的列名上标注，需要自己生成并维护不重复的约束。如果自己不设置@Id主键，mongo会自动生成一个唯一主键，并且插入时效率远高于自己设置主键。
@Transient，被该注解标注的，将不会被录入到数据库中。只作为普通的javaBean属性。
@CompoundIndex，复合索引，加复合索引后通过复合索引字段查询将大大提高速度。

3.编写Dao层

@Repository
public interface FormDao extends MongoRepository<Form,Integer> {
    Form findFormById(Integer id);

}

定义一个接口，继承MongoRepository，MongoRepository中已经预定义了一些增删查的方法，根据JPA的命名规范可以定义一些查询方法，不需要具体实现，底层会帮你实现。

4.创建Service层

@Service
public class FormService {

    @Autowired
    FormDao formDao;

    public void save(Form form){
        formDao.save(form);
    }

    public Form findFormById(Integer id){
        return formDao.findFormById(id);
    }
}

自动注入FormDao，实现一个保存和一个查询的方法。保存也可以调用insert方法插入数据。

5.创建Controller层


@Controller
@EnableAutoConfiguration
public class FormController {

    @Autowired
    FormService formService;
    
    @ResponseBody
    @RequestMapping(value = "/addform")
    public void addmuban( Form form){
        try{
           formService.save(form);
        }catch (Exception e){
            System.out.println(e);
        }

        System.out.println(form.toString());
    }

@EnableAutoConfiguration表示开启自动配置

上面是采用Repository的方式实现的，Repository 提供了最基本的数据访问功能，其几个子接口则扩展了一些功能。它们的继承关系如下：

Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类
CrudRepository：继承 Repository，实现了一组 CRUD 相关的方法
PagingAndSortingRepository：继承 CrudRepository，实现了一组分页排序相关的方法
MongoRepository：继承 PagingAndSortingRepository，实现一组 mongodb规范相关的方法

6.MongoTemplate方式

除了继承MongoRepository的方式，还可以使用MongoTemplate操作mongo数据库，如果开发者没有提供MongoTemplate，默认会注册一个MongoTemplate进入Spring容器，所以开发者可以直接使用MongoTemplate。

如下在测试类中的测试：

 @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private FormDao formDao;
    
    @Test
    public void testMongodb(){
        Query query=new Query(Criteria.where("_id").is(39));
        Form form = mongoTemplate.findOne(query,Form.class);
        System.out.println(form.toString());
    }

1.MongoTemplate实现了interface MongoOperations。
2.MongoDB documents和domain classes之间的映射关系是通过实现了MongoConverter这个interface的类来实现的。
3.MongoTemplate提供了非常多的操作MongoDB的方法。它是线程安全的，可以在多线程的情况下使用。
4.MongoTemplate实现了MongoOperations接口, 此接口定义了众多的操作方法如"find", “findAndModify”, “findOne”, “insert”, “remove”, “save”, “update” and "updateMulti"等。
5.MongoTemplate转换domain object为DBObject,缺省转换类为MongoMappingConverter,并提供了Query, Criteria, and Update等流式API。

可以使用JPA的方式查询，也可以使用MongoTemplate核心操作类：Criteria和Query

Criteria类：封装所有的语句，以方法的形式查询。
Query类：将语句进行封装或者添加排序之类的操作。

具体的一些用法如下：


/**
         * 添加文档主要介绍两种方式：
         *  mongoTemplate.insert("实体对象","集合名");   往集合插入数据的方式
         *  mongoTemplate.save(对象，集合名（可省略）);  参数必须是对象
         *      insert和save都适用
         *          不写集合名，默认对象类名作为集合名（如实体类是A  集合名是a）
         *          写集合名，则把数据写到对应集合下
         *          1.void save(Object var1);                传入对象，不传集合名
         *          2.void save(Object var1, String var2);   传入对象，传集合名
         *          3.void insert(Object var1);              传入对象，不传集合名
         *          4.void insert(Object var1, String var2); 传入对象，传集合名
         *          5.void insert(Collection<? extends Object> var1, Class<?> var2);  下面三个方法是批量插入的实现方法
         *          6.void insert(Collection<? extends Object> var1, String var2);
         *          7.void insertAll(Collection<? extends Object> var1);
         * 查询mongodb的操作：
         *      find 和findone方法都有两种实现
         *          1.List<T> find(Query var1, Class<T> var2)               不指定集合名
         *          2.List<T> find(Query var1, Class<T> var2, String var3)  指定集合名
         *          3.<T> T findOne(Query var1, Class<T> var2);             不指定集合名
         *          4.<T> T findOne(Query var1, Class<T> var2, String var3);指定集合名
         *           eg。
         *              maxvalue在数据库中就对应一个集合，可以不指定集合名直接查询
         *              Sl6512014 在数据对应很多集合  必须知道集合名才能查询出数据
         *
         *        findall
         *              1.<T> List<T> findAll(Class<T> var1);   根据类型查询所有
         *              2.<T> List<T> findAll(Class<T> var1, String var2);  查询集合下的该类型数据
         *
         *       findById:
         *              <T> T findById(Object var1, Class<T> var2);                 var1  是mongodb的_id子段值
         *              <T> T findById(Object var1, Class<T> var2, String var3);    指定集合名
         *  更新操作：
         *         updateFirst  更新符合条件的第一条   updateMulti  更新多个，符合条件都会更改
         *           //修改第一条符合条件数据
         *           1.WriteResult updateFirst(Query var1, Update var2, Class<?> var3);                 指定类型
         *           2.WriteResult updateFirst(Query var1, Update var2, String var3);                   更新操作指定集合名
         *           3.WriteResult updateFirst(Query var1, Update var2, Class<?> var3, String var4);    详细指定类型和集合名
         *           //批量修改
         *           4.WriteResult updateMulti(Query var1, Update var2, Class<?> var3);                 指定类型
         *           5.WriteResult updateMulti(Query var1, Update var2, String var3);                   指定集合名
         *           6.WriteResult updateMulti(Query var1, Update var2, Class<?> var3, String var4);    详细指定类型和集合名
         *           //同updateFirst
         *           7.WriteResult upsert(Query var1, Update var2, Class<?> var3);
         *           8.WriteResult upsert(Query var1, Update var2, String var3);
         *           9.WriteResult upsert(Query var1, Update var2, Class<?> var3, String var4);
         * 删除操作：
         *           1.WriteResult remove(Object var1);
         *           2.WriteResult remove(Object var1, String var2);
         *           3.WriteResult remove(Query var1, Class<?> var2);                根据条件删除
         *           4.WriteResult remove(Query var1, Class<?> var2, String var3);   详细指定类型和集合名进行删除
         *           5.WriteResult remove(Query var1, String var2);                 指定集合名进行删除
         *  其他一些操作：简单介绍：
         *          //查询出后删除
         *            <T> List<T> findAllAndRemove(Query var1, String var2);    指定集合名
                      <T> List<T> findAllAndRemove(Query var1, Class<T> var2);   指定类型
                      <T> List<T> findAllAndRemove(Query var1, Class<T> var2, String var3); 在集合下查询删除的类型数据
                    //查处后修改
                     <T> T findAndModify(Query var1, Update var2, Class<T> var3);    指定修改类型
                     <T> T findAndModify(Query var1, Update var2, Class<T> var3, String var4);  在集合下修改的数据类型
                     <T> T findAndModify(Query var1, Update var2, FindAndModifyOptions var3, Class<T> var4);
                     <T> T findAndModify(Query var1, Update var2, FindAndModifyOptions var3, Class<T> var4, String var5);
                     <T> T findAndRemove(Query var1, Class<T> var2);
                     <T> T findAndRemove(Query var1, Class<T> var2, String var3);
                    //判断是否存在
                     boolean exists(Query var1, String var2);
                     boolean exists(Query var1, Class<?> var2);
                     boolean exists(Query var1, Class<?> var2, String var3);
	       * is相当于等于
	         * in相当于sql中的in
	         * ne相当于不等于
	         * orOperator接受多个条件，组成or逻辑  addOperator同理
	         * Criteria.where("author").is("mongodb")  author = mongodb的数据
	         * Criteria.where("serial").lte(500).and("st").is("1703230781").and("c").in("5.7")   多条件的查询
	         * Criteria.where("st").exists(true)   判断这个字段存在
	         * Criteria.where("serial").ne(1)    不等于1的数据
	         * Criteria.where("serial").nin(1)    nin 不在这个范围中
	         * Criteria.where("serial").is(3).orOperator().is().andOperator() 追加or条件或者and条件
	         * Criteria.where("a").regex("1")   模糊查询   可以用正则表达式
	         * query6.with(new Sort(Sort.Direction.DESC,"a"));  按照a字段把结果降序
	         * query6.skip(n);    跳过结果集的第n个   超过总条数就是啥都不输出   n<=0  时 查询到结束不跳过
	         * query6.skip(n).limit(m)   跳过n条并显示m条记录
	         *  query6.addCriteria(Criteria.where("b").is("11"));   再加条件  查询子段不能是上一个query查询过的子段
	         *  query6.maxScan(6).skip(-2);   先截取六条数据再跳过两条
	         * 
	         * 分页查询               query.with(new PageRequest(1, 5));

	         * */