Spring-Boot 整合MongoDB

最新推荐文章于 2024-06-08 14:00:00 发布

怼怼_bml

最新推荐文章于 2024-06-08 14:00:00 发布

阅读量1.3k

点赞数

分类专栏：总结文章标签： mongodb 数据库 java

本文链接：https://blog.csdn.net/m0_56076357/article/details/129363461

版权

总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring-Boot 整合MongoDB

一、引入MongoDB依赖

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

二、配置yml文件

#mongodb配置
spring:
  data:
    mongodb:
      host: 127.0.0.1 #指定MongoDB服务地址
      port: 27017 #指定端口，默认就为27017
      database: article #指定使用的数据库(集合)
      authentication-database: admin # 登录认证的逻辑库名
      username: admin #用户名
      password: abc123456 #密码


      # uri: mongodb://<username>:<password>@127.0.0.1:27017/test
#      uri: mongodb://@127.0.0.1:27017/test

三、编写IBasicDao公共类

package com.example.demomoudle.common;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;

public interface IBasicDao<T> {
    /**
     * 查询数据
     *
     * @param query
     * @return
     */

    List<T> find(Query query);

    /**
     * 分页查询
     *
     * @param query
     * @param start
     * @param size
     * @return
     */
    List<T> findList(Query query, int start, int size);


    /**
     * 根据ID查询
     *
     * @param id
     * @return
     */
    T findOne(String id);

    /**
     * 插入一条数据
     *
     * @param entity
     */
    void insert(T entity);

    /**
     * 更新数据
     *
     * @param query
     * @param update
     * @return
     */
    UpdateResult update(Query query, Update update);

    /**
     * 根据实体类删除数据
     *
     * @param entity
     * @return
     */
    DeleteResult delete(T entity);


    /**
     * 根据query删除数据
     *
     * @param query
     * @return
     */

    DeleteResult remove(Query query);

    long count();

    long count(Query query);

    void save(T entity);

    List<T> findAll();

    List<T> findByKeyAndValue(String key, String Value);

    List<T> findByKeyAndValue(String key, String Value, int start, int limit);

    void upsert(Query query, Update update);

    MongoTemplate getMongoTemplate();


}

四、编写BasicDao公共类

package com.example.demomoudle.common;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
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 java.lang.reflect.ParameterizedType;
import java.util.List;

public class BasicDao<T> implements IBasicDao<T> {

    private Class<T> clazz;

    public BasicDao() {
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        clazz = (Class<T>) type.getActualTypeArguments()[0];
    }

    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public List<T> find(Query query) {
        return mongoTemplate.find(query, clazz);
    }

    @Override
    public List<T> findList(Query query, int start, int size) {

        //按照id升序排序
//        query.with(Sort.by(Sort.Order.asc("_id")));

//        改写了上面的方法， 注意观察是否会报错
        query.with(Sort.by(new Sort.Order(Sort.Direction.ASC, "_id")))
                .skip(start)
                .limit(size);
        return mongoTemplate.find(query, clazz);
    }

    @Override
    public T findOne(String id) {
        Query query = new Query();
//        query.addCriteria(Criteria.where("id").is(id));
        query.addCriteria(new Criteria("_id").is(id));
        return mongoTemplate.findOne(query, clazz);
    }

    @Override
    public void insert(T entity) {
        mongoTemplate.insert(entity);
    }

    @Override
    public UpdateResult update(Query query, Update update) {
        return mongoTemplate.updateMulti(query, update, clazz);
    }

    @Override
    public DeleteResult delete(T entity) {
        return mongoTemplate.remove(entity);
    }

    @Override
    public DeleteResult remove(Query query) {
        return mongoTemplate.remove(query, clazz);
    }

    public DeleteResult remove(String id) {
        Query query = new Query();
        query.addCriteria(Criteria.where("id").is(id));
        return mongoTemplate.remove(query, clazz);
    }

    @Override
    public long count() {
        Query query = new Query();
        return mongoTemplate.count(query, clazz);
    }

    @Override
    public long count(Query query) {
        return mongoTemplate.count(query, clazz);
    }

    @Override
    public void save(T entity) {
        mongoTemplate.save(entity);
    }

    @Override
    public List<T> findAll() {
        Query query = new Query();
        return find(query);
    }

    @Override
    public List<T> findByKeyAndValue(String key, String Value) {
        Query query = new Query(Criteria.where(key).is(Value));

        return mongoTemplate.find(query, clazz);
    }

    @Override
    public List<T> findByKeyAndValue(String key, String Value, int start, int limit) {
        Query query = new Query(Criteria.where(key).is(Value));
        query.skip(start).limit(limit);
        return mongoTemplate.find(query, clazz);
    }

    @Override
    public void upsert(Query query, Update update) {
        mongoTemplate.upsert(query, update, clazz);
    }

    @Override
    public MongoTemplate getMongoTemplate() {
        return mongoTemplate;
    }
}

五、新建实体类

package com.example.demomoudle.entity;


import io.swagger.annotations.ApiModel;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@ApiModel("用户管理表")
@Document(collection = "userTable")
public class User {
    @Id
    private String id;
    private String username;
    private String password;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

六、编写Service类和ServiceImpl实现类

package com.example.demomoudle.service;

import com.example.demomoudle.common.IBasicDao;
import com.example.demomoudle.entity.User;

public interface userService extends IBasicDao<User> {
}

package com.example.demomoudle.service.impl;

import com.example.demomoudle.common.BasicDao;
import com.example.demomoudle.service.userService;
import com.example.demomoudle.entity.User;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Service(value = "userService")
public class userServiceImpl extends BasicDao<User> implements userService {
}

七、编写contronller类

package com.example.demomoudle.contronller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.demomoudle.Tools.QueryTools;
import com.example.demomoudle.entity.User;
import com.example.demomoudle.service.impl.userServiceImpl;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
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.web.bind.annotation.*;

import java.util.List;

@Api(tags = "用户管理")
@RestController()
@RequestMapping("/user")
@CrossOrigin(value = "*", maxAge = 3600)
public class userController {

    @Autowired
    private userServiceImpl userService;

    /**
     * 新增
     */
    @ApiOperation("新增")
    @GetMapping("add")
    public void add(User user) {
        userService.insert(user);
    }

    /**
     * 修改
     */
    @ApiOperation("修改")
    @PostMapping("update")
    public void update(@RequestParam("id") String id, @RequestBody User user) {

        Query query = new Query(Criteria.where("id").is(id));

        Update update = new Update();
        String str = JSON.toJSONString(user);
        JSONObject jQuery = JSON.parseObject(str);
        jQuery.forEach((key, value) -> {
            //因为id相当于传统数据库中的主键，这里使用时就不支持更新，所以需要剔除掉
            if (!key.equals("id")) {
                update.set(key, value);
            }
        });
        userService.update(query, update);
    }

    /**
     * 根据id查询
     */
    @ApiOperation("根据ID查询")
    @GetMapping("findOne/{id}")
    public List<User> findOne(@PathVariable(name = "id") String id) {
        List<User> list = userService.find(QueryTools.getUserById(id));
        return list;

    }

    /**
     * 分页查询全部数据
     */
    @ApiOperation("分页查询")
    @GetMapping("/find")
    public List<User> find(int start, int sum) {
        List<User> users = userService.find(QueryTools.findByPages(start, sum));
        return users;
    }

    /**
     * 根据Id删除
     */
    @ApiOperation("删除")
    @GetMapping("delete")
    public void remove(String id) {
        userService.remove(QueryTools.removeById(id));
    }

}

八、编写工具类，方便按照不同的查询条件生成Query

package com.example.demomoudle.Tools;

import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

import java.util.HashMap;

public class QueryTools {


    public static Query getUserById(String id) {
        Query query = new Query();
        query.addCriteria(Criteria.where("id").is(id));
        return query;
    }

    public static Query removeById(String id) {
        Query query = new Query();
        query.addCriteria(Criteria.where("id").is(id));
        return query;
    }

    public static Query findByPages(int start, int sum) {
        Query query = new Query();
        query.skip(start);
        query.limit(sum);
        return query;

    }

    public static Query getQueryByTitle(int page, int size, String title) {
        Query query = new Query();
        //设置起始
        query.skip(page - 1 * size);
        //设置条数
        query.limit(size);
        query.addCriteria(Criteria.where("title").regex(".*?" + title + ".*"));
        return query;
    }

    public static Query queryByParamsMap(HashMap<String, String> maps) {
        Query query = new Query();
        for (String key : maps.keySet()) {
            query.addCriteria(Criteria.where(key).is(maps.get(key)));
        }
        return query;
    }

    public static Query querySearch(String id, Integer page, Integer size, String evalue) {
        Query query = new Query();
        query.skip((page - 1) * size);
        query.limit(size);
        if (evalue.equals("yes") || evalue == "yes") {
            query.addCriteria(Criteria.where("props.score").exists(true));
        } else if (evalue.equals("no") || evalue == "no") {
            query.addCriteria(Criteria.where("props.score").exists(false));
        }
        query.addCriteria(Criteria.where("id").is(id));
        return query;
    }

    public static Query querySearchOr(String name, Long startTime, Long endTime) {
        Query query = new Query();
        Criteria criteria = new Criteria();

        Criteria criteriaOr = new Criteria();

        Criteria[] criterias = new Criteria[2];
        if (name != null) {
            criterias[0] = Criteria.where("showName").regex(".*?" + name + ".*");
            criterias[1] = Criteria.where("name").regex(".*?" + name + ".*");
            criteriaOr.orOperator(criterias);
            query.addCriteria(criteriaOr);
        }

        query.addCriteria(criteria.and("time").gte(startTime).lte(endTime));
        return query;
    }
}