springboot整合mongodb

实现方式1

添加maven依赖

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

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

配置文件

server.port=8091

#数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root

#mybatis配置
mybatis.type-aliases-package=com.congge.entity
mybatis.mapper-locations=classpath:mybatis/*.xml

#mongodb配置
spring.data.mongodb.uri=mongodb://192.168.111.132:27017/congge

添加对应实体类

package com.congge.entity;

import java.util.Date;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Data
@Document(collection="book")
public class Book {
	
	@Id
	private String id;
	
	private Integer price;
	
	private String name;
	
	private String info;
	
	private String publish;
	
	private Date createTime;
	
	private Date updateTime;

}

service层代码实现

package com.congge.service;

import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
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.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import com.congge.entity.Book;

@Service
public class MongoDbService {

	private static final Logger logger = LoggerFactory.getLogger(MongoDbService.class);

	@Autowired
	private MongoTemplate mongoTemplate;

	/**
	 * 保存对象
	 * @param book
	 * @return
	 */
	public String saveObj(Book book) {
		book.setCreateTime(new Date());
		book.setUpdateTime(new Date());
		mongoTemplate.save(book);
		return "添加成功";
	}

	/**
	 * 查询所有
	 * @return
	 */
	public List<Book> findAll() {
		return mongoTemplate.findAll(Book.class);
	}

	/***
	 * 根据id查询
	 * @param id
	 * @return
	 */
	public Book getBookById(String id) {
		Query query = new Query(Criteria.where("_id").is(id));
		return mongoTemplate.findOne(query, Book.class);
	}

	/**
	 * 根据名称查询
	 *
	 * @param name
	 * @return
	 */
	public Book getBookByName(String name) {
		Query query = new Query(Criteria.where("name").is(name));
		return mongoTemplate.findOne(query, Book.class);
	}

	/**
	 * 更新对象
	 *
	 * @param book
	 * @return
	 */
	public String updateBook(Book book) {
		Query query = new Query(Criteria.where("_id").is(book.getId()));
		Update update = new Update().set("publish", book.getPublish()).set("info", book.getInfo()).set("updateTime",
				new Date());
		// updateFirst 更新查询返回结果集的第一条
		mongoTemplate.updateFirst(query, update, Book.class);
		// updateMulti 更新查询返回结果集的全部
		// mongoTemplate.updateMulti(query,update,Book.class);
		// upsert 更新对象不存在则去添加
		// mongoTemplate.upsert(query,update,Book.class);
		return "success";
	}

	/***
	 * 删除对象
	 * @param book
	 * @return
	 */
	public String deleteBook(Book book) {
		mongoTemplate.remove(book);
		return "success";
	}

	/**
	 * 根据id删除
	 *
	 * @param id
	 * @return
	 */
	public String deleteBookById(String id) {
		// findOne
		Book book = getBookById(id);
		// delete
		deleteBook(book);
		return "success";
	}
	
	/**
	 * 模糊查询
	 * @param search
	 * @return
	 */
	public List<Book> findByLikes(String search){
		Query query = new Query();
		Criteria criteria = new Criteria();
		//criteria.where("name").regex(search);
		Pattern pattern = Pattern.compile("^.*" + search + ".*$" , Pattern.CASE_INSENSITIVE);
		criteria.where("name").regex(pattern);
		List<Book> lists = mongoTemplate.findAllAndRemove(query, Book.class);
		return lists;
	}

}



controller层代码实现

package com.congge.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.congge.entity.Book;
import com.congge.service.MongoDbService;

@RestController
public class MongoDbController {
	
	@Autowired
	private MongoDbService mongoDbService;

	@PostMapping("/mongo/save")
	public String saveObj(@RequestBody Book book) {
		return mongoDbService.saveObj(book);
	}

	@GetMapping("/mongo/findAll")
	public List<Book> findAll() {
		return mongoDbService.findAll();
	}

	@GetMapping("/mongo/findOne")
	public Book findOne(@RequestParam String id) {
		return mongoDbService.getBookById(id);
	}

	@GetMapping("/mongo/findOneByName")
	public Book findOneByName(@RequestParam String name) {
		return mongoDbService.getBookByName(name);
	}

	@PostMapping("/mongo/update")
	public String update(@RequestBody Book book) {
		return mongoDbService.updateBook(book);
	}

	@PostMapping("/mongo/delOne")
	public String delOne(@RequestBody Book book) {
		return mongoDbService.deleteBook(book);
	}

	@GetMapping("/mongo/delById")
	public String delById(@RequestParam String id) {
		return mongoDbService.deleteBookById(id);
	}
	
	@GetMapping("/mongo/findlikes")
	public List<Book> findByLikes(@RequestParam String search) {
		return mongoDbService.findByLikes(search);
	}
}



最后调用接口即可


实现方式2

maven依赖同上

配置文件

mongodb.host=192.168.110.171
mongodb.port=27017
mongodb.database=test
mongodb.username=user_01
mongodb.password=bsw23!@#xsddS

添加配置配置类

package com.pica.sso.report.config;

import com.pica.sso.report.utils.MongoUtil;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description mongo配置类
 * @Author Chongwen.jiang
 * @Date 2019/12/19 15:07
 * @ModifyDate 2019/12/19 15:18
 * @Params
 * @Return
 */
@Data
@Configuration
public class MongoBean {
    @Value("${mongodb.host}")
    private String mongdbHost;

    @Value("${mongodb.port}")
    private String mongdbPort;

    @Value("${mongodb.database}")
    private String mongodbDatabase;

    @Value("${mongodb.username}")
    private String mongodbUsername;

    @Value("${mongodb.password}")
    private String mongodbPassword;

    @Bean({"mongoUtil"})
    public MongoUtil mongoUtil() {
        MongoUtil util = MongoUtil.getInstance(this.getMongdbHost(), this.getMongdbPort(),
                this.getMongodbDatabase(), this.getMongodbUsername(), this.getMongodbPassword());
        return util;
    }
}


添加操作工具类

package com.pica.sso.report.utils;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.apache.commons.lang.StringUtils;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.regex.Pattern;

/**
 * @Description mongo操作工具类
 * @Author Chongwen.jiang
 * @Date 2019/12/19 15:18
 * @ModifyDate 2019/12/19 15:18
 * @Params
 * @Return
 */
public class MongoUtil {
    private static Logger logger = LoggerFactory.getLogger(MongoUtil.class);
    private static final String IDKEY = "_id";
    public static final String RESULT = "result";

    private static MongoClient mongoClient = null;
    private static MongoDatabase database = null;

    private MongoUtil() {

    }

    private static class MongoUtilSingle {
        private static MongoUtil mongoUtil = new MongoUtil();
    }

    /**
     * @Description 获取MongoUtil单例
     * @Author Chongwen.jiang
     * @Date 2019/12/19 15:16
     * @ModifyDate 2019/12/19 15:16
     * @Params [host, ports, databases, userName, password]
     * @Return com.pica.sso.report.utils.MongoUtil
     */
    public static MongoUtil getInstance(String host, String ports, String databases, String userName, String password) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            logger.error("MongoUtil.getInstance() error:" + e.getMessage(), e);
        }

        if (StringUtils.isBlank(userName)) {
            mongoClient = new MongoClient(new ServerAddress(host, Integer.parseInt(ports)));
        } else {
            List<ServerAddress> addresses = new ArrayList<>();
            MongoCredential credential = MongoCredential.createCredential(userName, databases, password.toCharArray());
            List<MongoCredential> creList = new ArrayList<>();
            addresses.add(new ServerAddress(host, Integer.parseInt(ports)));
            creList.add(credential);
            mongoClient = new MongoClient(addresses, creList);
        }
        database = mongoClient.getDatabase(databases);

        return MongoUtilSingle.mongoUtil;
    }

    /**
     * @Description 获取mongodb的collection
     * @Author Chongwen.jiang
     * @Date 2019/12/19 15:18
     * @ModifyDate 2019/12/19 15:18
     * @Params [collName]
     * @Return com.mongodb.client.MongoCollection<org.bson.Document>
     */
    public MongoCollection<Document> getCollection(String collName) {
        if (database != null) {
            return database.getCollection(collName);
        }
        return null;
    }

    public static String fieldWithDoublePrefix(String field) {
        return new StringBuilder("$$").append(field).toString();
    }

    public static String fieldWithPrefix(String field) {
        return new StringBuilder("$").append(field).toString();
    }

    public static String resultFieldWithPrefix(String field) {
        return new StringBuilder("$").append(RESULT).append(".").append(field).toString();
    }

    public static String fieldWithPrefix(String field1, String field2) {
        return new StringBuilder("$").append(field1).append(".").append(field2).toString();
    }

    public static BasicDBObject firstRecord(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject("$first", "$$ROOT");
        }
        BasicDBObject resFields = new BasicDBObject();
        for (String field : fields) {
            resFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$first", resFields);
    }

    public static BasicDBObject allRecord(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject("$push", "$$ROOT");
        }
        BasicDBObject resFields = new BasicDBObject();
        for (String field : fields) {
            resFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$push", resFields);
    }

    public static BasicDBObject sortBy(BasicDBObject basicDBObject) {
        return new BasicDBObject("$sort", basicDBObject);
    }

    public static BasicDBObject sortBy(List<String> ascFields, List<String> descFields) {
        BasicDBObject orderFields = new BasicDBObject();
        if (ascFields != null) {
            for (String field : ascFields) {
                orderFields.append(field, 1);
            }
        }
        if (descFields != null) {
            for (String field : descFields) {
                orderFields.append(field, -1);
            }
        }
        if (orderFields.isEmpty()) {
            orderFields.append(IDKEY, 1);
        }
        return sortBy(orderFields);
    }

    private static BasicDBObject sortBy(int direct, String... fields) {
        if (fields.length == 0) {
            return null;
        }
        BasicDBObject sort = new BasicDBObject();
        for (String field : fields) {
            sort = sort.append(field, direct);
        }
        return sortBy(sort);
    }

    public static BasicDBObject sortAscBy(String... fields) {
        return sortBy(1, fields);
    }

    public static BasicDBObject sortDescBy(String... fields) {
        return sortBy(-1, fields);
    }

    public static BasicDBObject base() {
        return new BasicDBObject();
    }

    public static BasicDBObject blank() {
        return null;
    }

    public static BasicDBObject sumBy() {
        return new BasicDBObject("$sum", 1);
    }

    public static BasicDBObject sumBy(String field) {
        return new BasicDBObject("$sum", fieldWithPrefix(field));
    }

    public static BasicDBObject sumResultBy(String field) {
        return new BasicDBObject("$sum", resultFieldWithPrefix(field));
    }

    public static BasicDBObject sumBy(BasicDBObject basicDBObject) {
        return new BasicDBObject("$sum", basicDBObject);
    }

    public static BasicDBObject cond(BasicDBObject match) {
        return new BasicDBObject("$cond", Arrays.asList(match, 1, 0).toArray());
    }

    public static BasicDBObject cond(BasicDBObject match, String field) {
        return new BasicDBObject("$cond", Arrays.asList(match, fieldWithPrefix(field), 0).toArray());
    }

    public static BasicDBObject avgBy(String field) {
        return new BasicDBObject("$avg", fieldWithPrefix(field));
    }

    public static BasicDBObject avgResultBy(String field) {
        return new BasicDBObject("$avg", resultFieldWithPrefix(field));
    }

    public static BasicDBObject groupBy(List<String> fieldList) {
        return groupBy(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject groupBy(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject(IDKEY, 0);
        }
        BasicDBObject groupFields = new BasicDBObject();
        for (String field : fields) {
            groupFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject(IDKEY, groupFields);
    }

    public static BasicDBObject groupResultBy(List<String> fieldList) {
        return groupResultBy(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject groupResultBy(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject(IDKEY, 0);
        }
        BasicDBObject groupFields = new BasicDBObject();
        for (String field : fields) {
            groupFields.append(field, resultFieldWithPrefix(field));
        }
        return new BasicDBObject(IDKEY, groupFields);
    }

    public static List<BasicDBObject> group(BasicDBObject basicDBObject) {
        BasicDBObject param = new BasicDBObject("$group", basicDBObject);
        return Arrays.asList(param, project(param));
    }

    public static BasicDBObject project(List<String> fieldList) {
        return project(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject project(String... fields) {
        BasicDBObject basicDBObject = new BasicDBObject(IDKEY, 0);
        for (String field : fields) {
            basicDBObject.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$project", basicDBObject);
    }

    public static BasicDBObject project(BasicDBObject group) {
        //{"$group":{"_id":{"course_id":"$course_id"},"totalCount":{"$sum":1}}}
        //{"$project":{"_id":0,"course_id":"$_id.course_id","totalCount":"$totalCount"}}
        String groupKey = "$group";
        if (!group.containsField(groupKey)) {
            return null;
        }

        BasicDBObject groupValue = (BasicDBObject) group.get(groupKey);
        BasicDBObject basicDBObject = new BasicDBObject(IDKEY, false);
        for (String keyInGroup : groupValue.keySet()) {
            if (IDKEY.equals(keyInGroup)) {
                Object obj = groupValue.get(keyInGroup);
                if (Boolean.class.equals(obj.getClass())) {
                    basicDBObject.append(keyInGroup, obj);
                } else if (!BasicDBObject.class.equals(obj.getClass())) {
                    basicDBObject.append(keyInGroup, fieldWithPrefix(keyInGroup));
                } else {
                    BasicDBObject childValue = (BasicDBObject) obj;
                    for (String childKey : childValue.keySet()) {
                        basicDBObject.append(childKey, fieldWithPrefix(keyInGroup, childKey));
                    }
                }
            } else {
                basicDBObject.append(keyInGroup, fieldWithPrefix(keyInGroup));
            }
        }
        return new BasicDBObject("$project", basicDBObject);
    }

    public static BasicDBObject match(BasicDBObject basicDBObject) {
        return new BasicDBObject("$match", basicDBObject);
    }

    public static BasicDBObject andBy(List<BasicDBObject> basicDBObjects) {
        return andBy(basicDBObjects.toArray(new BasicDBObject[0]));
    }

    public static BasicDBObject andBy(BasicDBObject... basicDBObjects) {
        //andBy need at least two object.
        List<BasicDBObject> params = new ArrayList<>();
        for (BasicDBObject basicDBObject : basicDBObjects) {
            if (basicDBObject != null && basicDBObject.size() > 0) {
                params.add(basicDBObject);
            }
        }
        return new BasicDBObject("$and", params);
    }

    public static BasicDBObject orBy(List<BasicDBObject> basicDBObjects) {
        return orBy(basicDBObjects.toArray(new BasicDBObject[0]));
    }

    public static BasicDBObject orBy(BasicDBObject... basicDBObjects) {
        //orBy need at least two object.
        List<BasicDBObject> params = new ArrayList<>();
        for (BasicDBObject basicDBObject : basicDBObjects) {
            if (basicDBObject != null && basicDBObject.size() > 0) {
                params.add(basicDBObject);
            }
        }
        return new BasicDBObject("$or", params);
    }

    public static BasicDBObject inBy(String field, Object[] values) {
        return new BasicDBObject(field, new BasicDBObject("$in", values));
    }

    public static<T> BasicDBObject inBy(String field, List<T> values) {
        return new BasicDBObject(field, new BasicDBObject("$in", values));
    }

    public static BasicDBObject ninBy(String field, Object[] values) {
        return new BasicDBObject(field, new BasicDBObject("$nin", values));
    }

    public static<T> BasicDBObject ninBy(String field, List<T> values) {
        return new BasicDBObject(field, new BasicDBObject("$nin", values));
    }

    public static BasicDBObject ltBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$lt", value));
    }

    public static BasicDBObject lteBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$lte", value));
    }

    public static BasicDBObject gtBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$gt", value));
    }

    public static BasicDBObject gteBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$gte", value));
    }

    public static BasicDBObject neBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$ne", value));
    }

    public static BasicDBObject eqBy(String field, Object value) {
        return new BasicDBObject(field, value);
    }

    public static BasicDBObject condInBy(String field, Object[] values) {
        return new BasicDBObject("$in", Arrays.asList(fieldWithPrefix(field), values).toArray());
    }

    public static BasicDBObject condLtBy(String field, Object value) {
        return new BasicDBObject("$lt", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLteBy(String field, Object value) {
        return new BasicDBObject("$lte", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGtBy(String field, Object value) {
        return new BasicDBObject("$gt", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGteBy(String field, Object value) {
        return new BasicDBObject("$gte", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condNeBy(String field, Object value) {
        return new BasicDBObject("$ne", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condEqBy(String field, Object value) {
        return new BasicDBObject("$eq", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLtResultBy(String field, Object value) {
        return new BasicDBObject("$lt", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLteResultBy(String field, Object value) {
        return new BasicDBObject("$lte", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGtResultBy(String field, Object value) {
        return new BasicDBObject("$gt", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGteResultBy(String field, Object value) {
        return new BasicDBObject("$gte", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condNeResultBy(String field, Object value) {
        return new BasicDBObject("$ne", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condEqResultBy(String field, Object value) {
        return new BasicDBObject("$eq", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject regexBy(String field, String regex) {
        return new BasicDBObject(field, Pattern.compile(
                new StringBuilder("^.*").append(regex).append(".*$").toString(),
                Pattern.CASE_INSENSITIVE));
    }

    public static List<BasicDBObject> join(String collectionName, BasicDBObject fieldMap) {
        if (fieldMap == null || fieldMap.size() == 0) {
            return Collections.emptyList();
        }
        /** BasicDBObject fieldMap eg:
         * "project_id":null,
         * "doctor_id":null,
         * "course_id":5210
         */
        BasicDBObject lookup = new BasicDBObject("from", collectionName);
        BasicDBObject lets = new BasicDBObject();
        List<BasicDBObject> andBy = new ArrayList<>();
        for (String field : fieldMap.keySet()) {
            if (fieldMap.get(field) == null) {
                lets = lets.append(field, fieldWithPrefix(field));
            } else {
                lets = lets.append(field, fieldMap.get(field));
            }
            andBy.add(condEqBy(field, fieldWithDoublePrefix(field)));
        }
        lookup.append("let", lets);
        lookup.append("pipeline", Arrays.asList(
                new BasicDBObject("$match", new BasicDBObject("$expr", andBy(andBy))),
                new BasicDBObject("$limit", 1)
        ));
        lookup.append("as", "result");

        List<BasicDBObject> list = new ArrayList<>();
        list.add(new BasicDBObject("$lookup", lookup));
        list.add(match(andBy(eqBy("result", Collections.emptyList()))));
        list.add(new BasicDBObject("$project", new BasicDBObject("result", 0)));
        return list;
    }

    public static List<BasicDBObject> page(int pageNo, int pageSize) {
        return page(pageNo, pageSize, 0);
    }

    public static List<BasicDBObject> page(int pageNo, int pageSize, int skipCount) {
        List<BasicDBObject> list = new ArrayList<>();
        if (pageNo > 1 && pageSize > 0) {
            list.add(new BasicDBObject("$skip", (pageNo - 1) * pageSize + skipCount));
        }
        if (pageSize > 0) {
            list.add(new BasicDBObject("$limit", pageSize));
        }
        return list;
    }

    public static BasicDBObject page(int pageNo, int pageSize, BasicDBObject basicDBObject) {
        if (pageNo > 1 && pageSize > 0) {
            basicDBObject.put("$skip", (pageNo - 1) * pageSize);
        }
        if (pageSize > 0) {
            basicDBObject.put("$limit", pageSize);
        }
        return basicDBObject;
    }

    public static BasicDBObject skip(int pageNo, int pageSize) {
        if (pageNo <= 1 || pageSize <= 0) {
            return null;
        }
        return new BasicDBObject("$skip", (pageNo - 1) * pageSize);
    }

    public static BasicDBObject limit(int pageSize) {
        if (pageSize <= 0) {
            return null;
        }
        return new BasicDBObject("$limit", pageSize);
    }

    public static BasicDBObject let(String key1, String v1,
                                    String key2, String v2) {
        return new BasicDBObject(key1, v1).append(key2, v2);
    }

    public static Bson lookup(BasicDBObject let, String from,
                                       List<BasicDBObject> pipeline, String as) {
        BasicDBObject lookupBase = new BasicDBObject();
        lookupBase.put("from", "lr_project_progress");
        lookupBase.put("let", let);
        lookupBase.put("pipeline", pipeline);
        lookupBase.put("as", as);
        return new BasicDBObject("$lookup", lookupBase);
    }


}



剩下的在service业务层通过工具类去调用方法即可
### Spring Boot 整合 MongoDB 示例教程 #### 配置 `application.yml` 文件中的 MongoDB 连接信息 为了使Spring Boot应用能够连接MongoDB,在项目的资源目录下的`application.yml`文件中指定MongoDB的相关参数: ```yaml spring: data: mongodb: host: localhost port: 27017 database: test ``` 当MongoDB实例未设置认证机制时,也可以采用URI形式简化配置[^3]。 #### 创建实体类映射文档结构 定义一个Java类来表示存储于MongoDB集合内的文档模型。例如,创建名为`Comment.java`的POJO(Plain Old Java Object),它代表评论表单的数据对象并标注适当注解以便ORM框架识别其为持久化实体。 ```java package com.example.demo_mongodb.po; import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document; @Document(collection = "comments") public class Comment { @Id private String id; private String content; private Long timestamp; // Getters and Setters... } ``` #### 定义数据访问接口继承自 `MongoRepository` 通过扩展`MongoRepository<T, ID>`接口的方式快速获得CRUD功能支持,无需编写具体实现逻辑即可完成对特定类型的增删改查操作。这里展示了一个简单的仓库接口声明——`CommentRepository.java`: ```java package com.example.demo_mongodb.dao; import com.example.demo_mongodb.po.Comment; import org.springframework.data.mongodb.repository.MongoRepository; public interface CommentRepository extends MongoRepository<Comment, String> { } ``` 上述代码片段展示了如何利用Spring Data JPA提供的特性轻松地与MongoDB交互,从而专注于业务逻辑而非底层细节处理[^5]。 #### 测试服务层方法验证整合效果 最后一步是在控制器或者其他组件里注入之前建立好的仓储接口,并调用相应的方法来进行测试。这有助于确认整个系统的连通性和预期行为的一致性。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值