springboot集成MongoDB

最新推荐文章于 2021-01-15 18:59:48 发布

原创最新推荐文章于 2021-01-15 18:59:48 发布 · 208 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#mongodb #java

java 同时被 2 个专栏收录

46 篇文章

订阅专栏

mongodb

2 篇文章

订阅专栏

本文详细介绍了如何在Spring Boot项目中配置并使用MongoDB进行数据的增删改查操作，包括配置文件设置、实体类定义、Service接口及其实现类的具体代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一步配置文件配置

spring:
data:
mongodb:
host: 172.18.0.88 #IP地址
database: mongodb #数据库名称
port: 27017 #端口号

第二步使用

实现类

package com.zzh.elite.service.impl;

import com.zzh.elite.dto.MongodbDTO;
import com.zzh.elite.entity.MongodbTest;
import com.zzh.elite.service.MongodbService;
import com.zzh.elite.utils.CommonUtils;
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;

@Service
public class MongodbServiceImpl implements MongodbService {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public void saveTest(MongodbDTO mongodbDTO) {
        MongodbTest mongodbTest= CommonUtils.newInstance(mongodbDTO,MongodbTest.class);
        mongoTemplate.save(mongodbTest);
    }

    @Override
    public MongodbTest findTestByName(String name) {
        Query query=new Query(Criteria.where("name").is(name));
        MongodbTest mgt =  mongoTemplate.findOne(query , MongodbTest.class);
        return mgt;
}

    @Override
    public void updateTest(MongodbDTO mongodbTest) {
        Query query=new Query(Criteria.where("id").is(mongodbTest.getId()));
        Update update= new Update().set("age", mongodbTest.getAge()).set("name", mongodbTest.getName());//更新查询返回结果集的第一条
        mongoTemplate.updateFirst(query,update,MongodbTest.class);        //更新查询返回结果集的所有
        mongoTemplate.updateMulti(query,update,MongodbTest.class);
    }

    @Override
    public void deleteTestById(Integer id) {
        Query query=new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query,MongodbTest.class);
    }
}

---------------------------------------------------------------------------------------------------------------------------------

package com.zzh.elite.service;

import com.zzh.elite.dto.MongodbDTO;
import com.zzh.elite.entity.MongodbTest;

public interface MongodbService {
     void saveTest(MongodbDTO mongodbDTO);
     MongodbTest findTestByName(String Name);
     void updateTest(MongodbDTO mongodbDTO);
     void deleteTestById(Integer id);
}

--------------------测试---------------------------------------------------

package com.zzh.elite.controller;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.zzh.elite.dto.MongodbDTO;
import com.zzh.elite.dto.MysqlTestDTO;
import com.zzh.elite.dto.RedisTestDTO;
import com.zzh.elite.entity.MongodbTest;
import com.zzh.elite.entity.UserLog;
import com.zzh.elite.service.MongodbService;
import com.zzh.elite.service.UserService;
import com.zzh.elite.utils.CommonUtils;
import com.zzh.elite.utils.RedisUtils;
import com.zzh.elite.viewModel.ResponseMessage;
import com.zzh.elite.vo.MysqlTestVO;
import com.zzh.elite.vo.RedisTestVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.AbstractJavaTypeMapper;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@Slf4j
@RestController("elite")
@ApiOperation("配置测试")
public class EliteController {
    @Autowired
    RedisUtils redisUtils;
    @Autowired
    UserService userService;
    @Autowired
    private ObjectMapper objectMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private Environment env;
    @Autowired
    MongodbService mongodbService;
    @RequestMapping(value = "test/swagger",method = RequestMethod.POST)
    @ApiOperation("swagger测试")
    public ResponseMessage<Object> login(){
        log.info("成功");
        return CommonUtils.okResponseVO(null);
    }
    @RequestMapping(value = "test/redis",method = RequestMethod.POST)
    @ApiOperation("redis测试")
    public ResponseMessage<RedisTestVO> redis(@RequestBody RedisTestDTO redisTestDTO){
        redisUtils.set(redisTestDTO.getRedisKey(),redisTestDTO.getRedisValue());
        RedisTestVO redisTestVO=new RedisTestVO();
        redisTestVO.setRedisKey(redisTestDTO.getRedisKey());
        redisTestVO.setRedisValue(redisUtils.get(redisTestDTO.getRedisKey()));
        return CommonUtils.okResponseVO(redisTestVO);
    }
    @RequestMapping(value = "test/mysql",method = RequestMethod.POST)
    @ApiOperation("mysql测试")
    public ResponseMessage<MysqlTestVO> mysql(@RequestBody MysqlTestDTO mysqlTestDTO){
        return CommonUtils.okResponseVO(userService.mysql(mysqlTestDTO));
    }
    @RequestMapping(value = "test/rabbitMq",method = RequestMethod.POST)
    @ApiOperation("rabbitMq 生产者测试")
    public ResponseMessage<MysqlTestVO> rabbitMq(@RequestBody MysqlTestDTO mysqlTestDTO){
        try {
            UserLog userLog = new UserLog(mysqlTestDTO.getUser(), "Login", objectMapper.writeValueAsString(mysqlTestDTO));//
            userLog.setCreateTime(new Date());
            rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
            rabbitTemplate.setExchange(env.getProperty("log.user.exchange.name"));
            rabbitTemplate.setRoutingKey(env.getProperty("log.user.routing.key.name"));
            Message message = MessageBuilder.withBody(objectMapper.writeValueAsBytes(userLog)).setDeliveryMode(MessageDeliveryMode.PERSISTENT).build();
            message.getMessageProperties().setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, MessageProperties.CONTENT_TYPE_JSON);
            rabbitTemplate.convertAndSend(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return CommonUtils.okResponseVO(null);
    }
    @RequestMapping(value = "test/mongo/save",method = RequestMethod.POST)
    @ApiOperation("mongodb新增测试")
    public ResponseMessage<Object> mongoSave(@RequestBody MongodbDTO mongodbDTO){
        mongodbService.saveTest(mongodbDTO);
        return CommonUtils.okResponseVO(null);
    }
    @RequestMapping(value = "test/mongo/find",method = RequestMethod.POST)
    @ApiOperation("mongodb查询测试")
    public ResponseMessage<MongodbTest> mongoSave(String Name){
        return CommonUtils.okResponseVO(mongodbService.findTestByName(Name));
    }
    @RequestMapping(value = "test/mongo/update",method = RequestMethod.POST)
    @ApiOperation("mongodb修改测试")
    public ResponseMessage<MongodbTest> mongoUpdate(MongodbDTO mongodbDTO){
        mongodbService.updateTest(mongodbDTO);
        return CommonUtils.okResponseVO(null);
    }
    @RequestMapping(value = "test/mongo/delete",method = RequestMethod.POST)
    @ApiOperation("mongodb删除测试")
    public ResponseMessage<MongodbTest> mongoDelete(Integer id){
        mongodbService.deleteTestById(id);
        return CommonUtils.okResponseVO(null);
    }
}

注：以上方法是对滴部分代码没贴