SpringBoot整合MongoDB

最新推荐文章于 2024-06-15 16:29:34 发布
最新推荐文章于 2024-06-15 16:29:34 发布
阅读量343 收藏
点赞数
分类专栏： springboot mongodb 文章标签： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a185589690/article/details/100069297
版权

  • spring-data对MongoDB做了支持，使用spring-data-mongodb可以简化MongoDB的操作。

    • 有两种实现方式

      • dao层接口继承MongoRepository 和 Spring data jpa差不多

      • 通过MongoTemplate实现, 我用的就是这个

  • 导入依赖

    •     <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
            <version>3.9.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

       

  • 配置文件properties:

    • spring.data.mongodb.uri=mongodb://172.0.0.1:27017/testdb
//多ip可以使用
spring.data.mongodb.uri=mongodb://user:pwd@ip1:port1,ip2:port2/database

       

  • 定义一个dao层的公共接口

    • import java.io.Serializable;
import java.util.List;
import org.springframework.data.domain.Page;

/**
 * 公共的dao接口
 */
public interface IBaseDao<T> {

	void save(T entity);

	void update(T entity);

	void delete(Serializable... ids);

	T find(Serializable id);

	List<T> findAll();

	List<T> findAll(String order);

	List<T> findByProp(String propName,Object value);

	List<T> findByProp(String propName,Object value,String order);

	List<T> findByProps(String[] propName,Object[] values);

	List<T> findByProps(String[] propName,Object[] values,String order);

	T uniqueByProp(String propName,Object value);

	T uniqueByProps(String[] propName,Object[] values);

	int countByCondition(String[] params,Object[] values);
}

       

    • 后面的实体dao接口都要继承IBaseDao接口,并且把实体类传入

      • /**
 * 用户的操作接口
 */
public interface UserDao extends IBaseDao<User>{

}

         

    • 写BaseDaoImpl 实现IBaseDao接口

      • import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.annotation.Id;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
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.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
*抽象接口 继承类的类 需要重写getEntityClass方法.返还操作的class字节码
*/
public abstract class BaseDaoImpl<T> implements IBaseDao<T> {

    protected abstract Class<T> getEntityClass();

    @Autowired
    protected MongoTemplate mongoTemplate;

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

    @Override
    public void update(T entity) {
        Map<String, Object> map = null;
        try {
            map = parseEntity(entity);
        } catch (Exception e) {
            e.printStackTrace();
        }
        String id = null;
        Object value = null;
        Update update = new Update();
        if (map != null && map.size() > 0) {
            for (String key : map.keySet()) {
                if (key.startsWith("{")) {
                    id = key.substring(key.indexOf("{") + 1, key.indexOf("}"));
                    value = map.get(key);
                } else {
                    update.set(key, map.get(key));
                }
            }
        }
        mongoTemplate.updateFirst(new Query().addCriteria(Criteria.where(id).is(value)), update, getEntityClass());
    }

    @Override
    public void delete(Serializable... ids) {
        if (ids != null && ids.length > 0) {
            for (Serializable id : ids) {
                mongoTemplate.remove(mongoTemplate.findById(id, getEntityClass()));
            }
        }

    }

    @Override
    public T find(Serializable id) {
        return mongoTemplate.findById(id, getEntityClass());
    }

    @Override
    public List<T> findAll() {
        return mongoTemplate.findAll(getEntityClass());
    }

    @SuppressWarnings("deprecation")
    @Override
    public List<T> findAll(String order) {
        List<Order> orderlist = parseOrder(order);
        if (orderlist == null || orderlist.size() == 0) {
            return findAll();
        }

        return mongoTemplate.find(new Query().with(new Sort(orderlist)), getEntityClass());
    }

    @Override
    public List<T> findByProp(String propName, Object value) {
        return findByProp(propName, value, null);
    }

    @SuppressWarnings("deprecation")
    @Override
    public List<T> findByProp(String propName, Object value, String order) {
        Query query = new Query();
        query.addCriteria(Criteria.where(propName).is(value));
        List<Order> orderlist = parseOrder(order);
        if (orderlist != null && orderlist.size() > 0) {
            query.with(new Sort(orderlist));
        }
        return null;
    }

    @Override
    public List<T> findByProps(String[] propName, Object[] values) {
        return findByProps(propName, values, null);
    }

    @Override
    public List<T> findByProps(String[] propName, Object[] values, String order) {
        Query query = createQuery(propName, values, order);
        return mongoTemplate.find(query, getEntityClass());
    }

    @Override
    public T uniqueByProp(String propName, Object value) {
        return mongoTemplate.findOne(new Query().addCriteria(Criteria.where(propName).is(value)), getEntityClass());
    }

    @Override
    public T uniqueByProps(String[] propName, Object[] values) {
        Query query = createQuery(propName, values, null);
        return mongoTemplate.findOne(query, getEntityClass());
    }

    @Override
    public int countByCondition(String[] params, Object[] values) {
        Query query = createQuery(params, values, null);
        Long count = mongoTemplate.count(query, getEntityClass());
        return count.intValue();
    }


    protected Map<String, Object> parseEntity(T t) throws Exception {
        Map<String, Object> map = new HashMap<>();
        String id = "";
        Field[] declaredFields = getEntityClass().getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.isAnnotationPresent(Id.class)) {
                field.setAccessible(true);
                map.put("{" + field.getName() + "}", field.get(t));
                id = field.getName();
                break;
            }
        }

        Method[] declaredMethods = getEntityClass().getDeclaredMethods();
        if (declaredFields != null && declaredFields.length > 0) {
            for (Method method : declaredMethods) {
                if (method.getName().startsWith("get") && method.getModifiers() == Modifier.PUBLIC) {
                    String fieldName = parse2FieldName(method.getName());
                    if (!fieldName.equals(id)) {
                        map.put(fieldName, method.invoke(t));
                    }
                }
            }
        }
        return map;
    }

    private String parse2FieldName(String method) {
        String name = method.replace("get", "");
        name = name.substring(0, 1).toLowerCase() + name.substring(1);
        return name;
    }

    @SuppressWarnings("deprecation")
    public Query createQuery(String[] propName, Object[] values, String order) {
        Query query = new Query();
        //where
        if (propName != null && values != null) {
            for (int i = 0; i < propName.length; i++) {
                query.addCriteria(Criteria.where(propName[i]).is(values[i]));
            }
        }

        List<Order> orderlist = parseOrder(order);
        if (orderlist != null && orderlist.size() > 0) {
            query.with(new Sort(orderlist));
        }
        return query;
    }

    public List<Order> parseOrder(String order) {
        List<Order> list = null;
        if (order != null && !"".equals(order)) {
            list = new ArrayList<>();
            String[] fields = order.split(",");
            Order o = null;
            String[] items = null;
            for (int i = 0; i < fields.length; i++) {
                if (fields[i] == null) {
                    continue;
                }
                items = fields[i].split(" ");
                if (items.length == 1) {
                    o = new Order(Direction.ASC, items[0]);
                } else if (items.length == 2) {
                    o = new Order("desc".equalsIgnoreCase(items[1]) ? Direction.DESC : Direction.ASC, items[0]);
                } else {
                    throw new RuntimeException("order field parse error");
                }
                list.add(o);
            }
        }
        return list;
    }
}

         

      • UserDaoImpl 继承BaseDaoImpl 实现UserDao接口

        • @Repository
public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao{
	@Override
	protected Class<User> getEntityClass() {
		return User.class;
	}
}

           

      • 然后就可以通过注入来dao接口来实现功能了.

单人影i
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
springboot整合mongodb详解
08-03
SpringBoot整合MongoDB详解 MongoDB是一款高性能、无模式的分布式文档型数据库，适用于处理大量数据的场景，尤其适合处理半结构化或非结构化的数据。SpringBoot是Spring框架的一个轻量级模块，旨在简化Spring应用的...
SpringBoot 整合MongoDB
深圳市多克创新科技有限公司
02-09 3393
MongoDB简介及SpringBoot整合
【Mongodb-02】springboot整合mongodb(详解)
最新发布
zhenghuishengq的博客
06-15 1354
springboot整合mongodb详解
SpringBoot整合MongoDB常用方法
热门推荐
Venus's Blog
08-06 3万+
jdk 17SpringBoot 3.1.0Mongo 6.0.8mybatis-plus 2.0.2安装教程请查看：一文搞定(linux+windows+docker)安装MongoDB整合教程：SpringBoot整合MongoDB 🌵保存/修改 🌵插入列表 🌵查询单个数据 🌵根据id查询 🌵查询所有 🌵 保存/更新 (存在就更新，不存在就插入) 🌵 更新查询到的第一个 🌵批量更新 🌵 根据条件删除 🌵 批量删除 ​ 🌵查询该集合中的所有文档 💡Criteri
Springboot整合mongodb
m0_63837020的博客
07-31 3677
总结的关于springboot如何整理mongodb的一些用法
springboot整合mongoDb
z_hy2018的博客
06-15 433
mongoDB集成、mongoTemplate使用
springboot整合MongoDB
qq_62408075的博客
07-26 429
【代码】springboot整合MongoDB。
SpringBoot 整合 MongoDB
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
06-29 951
Springboot整合Mongodb
weixin_61307867的博客
12-22 1662
springBoot整合mongodb实现简单增删改查
SpringBoot整合MongoDb
市民景先生
03-13 264
5.支持属性的练级查询，但如若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接。每次只能新增一个数据，如果主键存在则对重复的数据进行修改。一次可以插入一个举几个的数据，如果插入数据主键存则报错。修改，如果修改不了则会添加新数据的字段。save根据_id在原有的数据进行操作,如果没有_id则直接进行添加操作。insert直接插入数据，如果_id重复则会报错。2.查询方法以find|read|get开头。3.涉及条件查询时，条件的属性用关键字连接。
springboot整合mongodb changestream代码
02-23
在本文中，我们将深入探讨如何在Spring Boot应用中整合MongoDB的Change Stream功能。Change Stream是MongoDB提供的一种强大特性，允许我们实时监控数据库中的变化，例如文档的插入、更新和删除操作。这对于构建实时...
SpringBoot整合MongoDB测试demo
02-15
在本文中，我们将深入探讨如何将SpringBoot框架与MongoDB数据库进行整合，以便在Java应用中轻松地存储和检索数据。MongoDB是一个流行的NoSQL数据库，以其灵活性、高性能和易于扩展性而受到开发者喜爱。SpringBoot是...
springboot整合MongoDB初级入门
07-21
SpringBoot整合MongoDB是现代Java开发中常见的技术组合，尤其对于快速构建轻量级、高可伸缩性的Web应用来说。MongoDB是一个流行的NoSQL数据库，以其灵活性、高性能和易于扩展性著称，而SpringBoot则简化了Java应用的...
@ComponentScan过滤不需要的类
单人影的博客
02-09 3184
@ComponentScan过滤不需要的类前言一、excludeFilters属性需要传递@ComponentScan.Filter注解二、示例指定排除类指定排除注解自定义@ComponentScanIgnore实现过滤器自定义过滤器MyTypeFilter表达式总结 前言 因为maven工程互相依赖,但是不需要依赖子项目的某些切面和配置类,这时项目会配置@ComponentScan扫码子工程的包，由于启动的时候已经加载到了容器类里面，于是就用上了@ComponentScan的excludeFilter
java 静态方法里边如何使用spring的注入对象
单人影的博客
09-15 2864
大家都知道，Java静态资源（静态代码块，静态方法，静态属性）在类加载的时候进行加载，那么加载时机肯定是在spring对象注入之前的，所以我们在调用实际的静态方法时就会出现空指针。这种可能在实际开发中出现在我们的util工具类中.
WebSocket 和 MongoDB 搭建简单的聊天系统
单人影的博客
08-27 1372
使用技术: Spring WebSocket Spring-data-MongoDB pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值