「Spring整合组件」MongoDB

MongoDB简介

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。

特点:高性能、易部署、易使用,存储数据非常方便。

主要功能特性:

Ø 面向集合存储,易存储对象类型的数据

Ø 模式自由

Ø 支持动态查询

Ø 支持完全索引,包含内部对象

Ø 支持复制和故障恢复

Ø 使用高效的二进制数据存储,包括大型对象(如视频等)

Ø 自动处理碎片,以支持云计算层次的扩展性

Ø 文件存储格式为BSON(一种JSON的扩展)

不足:MongoDB作为一个非关系型数据库有其局限性。MongoDB不支持事务操作,所以需要用到事务的应用建议不用MongoDB,另外MongoDB目前不支持join操作,需要复杂查询的应用也不建议使用MongoDB。

mongodb是属于内存还是硬盘存储?

mongodb的数据是存储在硬盘上的,只不过需要经常读取的数据会被加载到内存中,这样提高查询效率,即所谓的内存数据映射,所以mongodb本身很吃内存。不过MongoDB3.0版本以后会好很多。

快速入门

pom配置

<!-- MongoDB驱动-->
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>3.12.1</version>
</dependency>
<!--spring-data-mongodb-->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>2.0.2.RELEASE</version>
</dependency>

<!--分页组件-->
<dependency>
    <groupId>com.github.jsqlparser</groupId>
    <artifactId>jsqlparser</artifactId>
    <version>4.0</version>
</dependency>

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.2.0</version>
</dependency>

配置MongoDB

import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoClientFactoryBean;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

@EnableMongoRepositories
@ComponentScan(basePackages = "com.spring.mongodb.repository") //指定@Repository注解的包
@Configuration
public class MongoDBConfig {

    /**
     * 创建MongoClient
     *
     * @return
     * @throws Exception
     */
    @Bean
    public MongoClientFactoryBean mongoClient() throws Exception {
        MongoClientFactoryBean mongoClientFactoryBean = new MongoClientFactoryBean();
        mongoClientFactoryBean.setHost("127.0.0.1");
        mongoClientFactoryBean.setPort(27017);
        MongoCredential credential = MongoCredential.createCredential("root", "test", "root".toCharArray());
        mongoClientFactoryBean.setCredentials(new MongoCredential[]{credential});
        return mongoClientFactoryBean;
    }

    /**
     * 配置MongoTemplate基于模板的访问
     *
     * @param mongoClient
     * @return
     */
    @Bean
    public MongoTemplate mongoTemplate(MongoClient mongoClient) {
        return new MongoTemplate(mongoClient, "test");
    }
}

基础操作类 MongodbDao

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
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.Repository;

import com.github.pagehelper.PageInfo;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

/**
 * mongodb 基础操作类
 *
 * @param <T>
 * @author linhongwei
 */
@Repository
public class MongodbDao<T extends IdEntity> {

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

    private static final int DEFAULT_SKIP = 0;
    private static final int DEFAULT_LIMIT = 200;
    private Class<T> entityClass;

    @Autowired
    protected MongoTemplate mongoTemplate;

    public MongodbDao() {
        //通过反射机制获取泛型的类类型
        Type type = this.getClass().getGenericSuperclass(); // generic 泛型
        if(type instanceof ParameterizedType){
            // 强制转化“参数化类型”
            ParameterizedType parameterizedType = (ParameterizedType) type;
            // 参数化类型中可能有多个泛型参数
            Type[] types = parameterizedType.getActualTypeArguments();
            // 获取数据的第一个元素(User.class)
            entityClass = (Class<T>) types[0]; // com.oa.shore.entity.User.class
        }
    }

    // ======= 增 ============
    public void save(T t) {
        mongoTemplate.save(t);
        logger.debug("save entity: {}", t);
    }

    public void insertAll(List<T> list) {
        mongoTemplate.insertAll(list);
    }

    // ======= 删 ============

    /**
     * 删除对象
     *
     * @param t
     */
    public void delete(T t) {
        mongoTemplate.remove(t);
    }

    /**
     * 根据id 删除对象
     *
     * @param id
     */
    public void deleteById(String id) {
        Criteria criteria = Criteria.where("id").is(id);
        Query query = new Query(criteria);
        mongoTemplate.remove(query, entityClass);
    }

    /**
     * 根据条件删除
     */
    public void delete(Query query) {
        mongoTemplate.remove(query, entityClass);
    }

    /**
     * 删除该collection 的所有的数据
     */
    public void deleteAll() {
        mongoTemplate.dropCollection(entityClass);
    }

    // ======= 改 ============
    public void update(Query query, Update update) {
        mongoTemplate.findAndModify(query, update, entityClass);
    }

    // ======= 查 ============
    public List<T> findAll() {
        return mongoTemplate.findAll(entityClass);
    }

    /**
     * 根据查询query 查找list
     *
     * @param query
     * @return
     */
    public List<T> find(Query query) {
        return mongoTemplate.find(query, entityClass);
    }

    /**
     * 按照字段排序 - 顺序  <br/>
     *
     * @param query      查询条件  <br/>
     * @param properties 排序字段  <br/>
     * @return
     */
    public List<T> findWithOrderAsc(Query query, String... properties) {
        Sort sort = new Sort(Direction.ASC, properties);
        query.with(sort);
        return mongoTemplate.find(query, entityClass);
    }


    /**
     * 按照字段排序 - 逆序 <br/>
     *
     * @param query      查询条件  <br/>
     * @param properties 排序字段  <br/>
     * @return
     */
    public List<T> findWithOrderDesc(Query query, String... properties) {
        Sort sort = new Sort(Direction.DESC, properties);
        query.with(sort);
        return mongoTemplate.find(query, entityClass);
    }


    /**
     * 根据查询query 查找一个对象
     *
     * @param query
     * @return
     */
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, entityClass);
    }

    /**
     * 根据 id 查询对象
     *
     * @param id
     * @return
     */
    public T findById(String id) {
        return mongoTemplate.findById(id, entityClass);
    }

    /**
     * 根据id 和 集合名字查询对象
     *
     * @param id
     * @param collectionName
     * @return
     */
    public T findById(String id, String collectionName) {
        return mongoTemplate.findById(id, entityClass, collectionName);
    }

    /**
     * 查询分页  tips:[不要skip 太多的页数,如果跳过太多会严重影响效率。最大不要skip 20000页]
     *
     * @param page
     * @param query
     * @return
     */
    public PageInfo<T> findPage(PageInfo<T> page, Query query) {
        long count = this.count(query);
        page.setTotal(count);
        int pageNumber = page.getPageNum();
        int pageSize = page.getPageSize();
        query.skip((pageNumber - 1) * pageSize).limit(pageSize);
        List<T> list = this.find(query);
        page.setList(list);
        return page;
    }

    public long count(Query query) {
        return mongoTemplate.count(query, entityClass);
    }

    /**
     * 获取collection的名字,默认是dao范型T的名字 <br/>
     * 例如: StudentScoreDao extends MongodbDao <b>&lt;StudentScore&gt;</b> <br/>
     * 则返回的名字是:<b>StudentScore</b>
     *
     * @return
     */
    private String getCollectionName() {
        return entityClass.getSimpleName();
    }

}

基础实体类 IdEntity

import java.io.Serializable;

/**
 * 实体基础类,所有的实体都继承该类
 * @author linhongwei
 */
public class IdEntity implements Serializable {
    private static final long serialVersionUID = -8279493522154678891L;
    private String id;

    public String getId() {
        return id;
    }

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

}

测试

1、实体类 StudentScore

import java.io.Serializable;
import java.util.List;
 
/**
 * 测试实体类
 * @author linhongwei
 */
public class StudentScore extends IdEntity implements Serializable {

    private static final long serialVersionUID = 1126745404897398026L;
    /**
     * 学生姓名
     */
    private String username;
 
 
    /**
     * 学生成绩
     */
    private List<Double> scoreList;
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public List<Double> getScoreList() {
        return scoreList;
    }
 
    public void setScoreList(List<Double> scoreList) {
        this.scoreList = scoreList;
    }

    @Override
    public String toString() {
        return "StudentScore{" +
                "username='" + username + '\'' +
                ", scoreList=" + scoreList +
                '}';
    }
}

2、实体类的dao操作类 StudentScoreDao

import com.spring.mongodb.MongodbDao;
import com.spring.mongodb.document.StudentScore;
import org.springframework.stereotype.Repository;

/**
 * 继承MongodbDao<br/>
 * 此类对StudentScore对增删改查和分页方法都已经有了<br/>
 * @author linhongwei
 */
@Repository
public class StudentScoreDao extends MongodbDao<StudentScore> {

}

3、测试验证

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={RootConfig.class, WebConfig.class}) //如果是Java Config配置的,指定相关的配置类
@WebAppConfiguration
public class MongoDbTest {

    @Autowired
    private StudentScoreDao studentScoreDao;

    @Test
    public void test(){
        StudentScore studentScore = new StudentScore();
        studentScore.setUsername("hello");
        studentScore.setId("1234567");
        studentScore.setScoreList(Arrays.asList(95d, 97d, 78d));
        studentScoreDao.save(studentScore);

        StudentScore info = studentScoreDao.findById("1234567");
        System.out.println(info.toString());
    }
}

MongoTemplate API

常用的方法:

  • mongoTemplate.findAll(Student.class): 查询Student文档的全部数据
  • mongoTemplate.findById(<id>, Student.class): 查询Student文档id为id的数据
  • mongoTemplate.find(query, Student.class);: 根据query内的查询条件查询
  • mongoTemplate.upsert(query, update, Student.class): 修改
  • mongoTemplate.remove(query, Student.class): 删除
  • mongoTemplate.insert(student): 新增

Query对象:

(1)创建一个query对象(用来封装所有条件对象),再创建一个criteria对象(用来构建条件)

(2)精准条件:criteria.and(“key”).is(“条件”) ;模糊条件:criteria.and(“key”).regex(“条件”)

(3)封装条件:query.addCriteria(criteria)

(4)大于(创建新的criteria):Criteria gt = Criteria.where(“key”).gt(“条件”)

小于(创建新的criteria):Criteria lt = Criteria.where(“key”).lt(“条件”)

(5)Query.addCriteria(new Criteria().andOperator(gt,lt));

(6)一个query中只能有一个andOperator()。其参数也可以是Criteria数组。

(7)排序 :query.with(new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))

 

推荐这些技术文章:

Spring Boot MongoDB

1.  Linux下启动MongoDB并使用mongosh连接
启动方式有两种:

systemctl start mongod
mongod  <选项参数>

启动的时候有可能会报类似如下的错误:

ExecStart=/usr/bin/mongod $OPTIONS (code=exited, status=14)
mongod.service: Contro...

Spring中MongoDB Aggregation的使用

简介
MongoDB 中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等),并返回计算后的数据结果。
db.collection.aggregate()方法是基于数据处理的聚合管道,每个文档通过一个由多个阶段(stage)组成的管道,可以对每个阶段的管道进行分组、过滤等功能,然后经过一系列的处理,输出相应的结果。

可以多个管道,能方便的进行数据的处理。
聚合效率非常高。
每个...

Spring中如何动态切换mongodb的库

问题
mongodb数据库,涉及到两个库,现在代码已经写死到一个库中做查询操作,现在想调整一下能不能在spring配置中动态的来选择不一样的库,或者在少代码代码的情况如何改变代码(代码可以通过前端传递年份来选择是那个库,库是根据年份来命名的),有思路的给点思虑

最佳回答
可以。在application.xml中配置,然后再在config.p...

Spring Data MongoDB之upsert简单用法

String collectionName = "fieldSort"; Query query = new Query(); query.addCriteria(Criteria.where("entId").is(dbo.get("entId"))); query.addCriteria(Criteria.where...

Spring Boot JPA query 传送值为null的parameter

当parameter tagId 是 null 时 query 会无法找到正确的结果
因为在sql中判断一个值是否为null 不是用 = null 而是 is null 所以一下代码无法获得tag 是null 的tasks

@Query("select t from Task t where t.tag.tagId = ?1 AND t.taskStatus.taskStatusId = ?2...

spring整合mybatis报错处理

1、org/springframework/dao/support/DaoSupport
没有有导入事务管理包

<dependency>-->
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
...

SpringBoot整合Mongodb

1导入Mongodb的pom依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId></dependency>
2.配置yml客户端
s...

springboot整合mongodb

1、MongoDB简介
 
MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
 
MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的,它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。
 
MongoDB...

springboot整合mongoDB相关配置文件

 1.添加pom依赖

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

2.在配置文件中添加mon...

springboot整合mongodb (MongoTemplate 和MongoRepository)

 
引入依赖

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

文章标题:「Spring整合组件」MongoDB
文章链接:https://www.dianjilingqu.com/4090.html
本文章来源于网络,版权归原作者所有,如果本站文章侵犯了您的权益,请联系我们删除,联系邮箱:saisai#email.cn,感谢支持理解。
THE END
< <上一篇
下一篇>>