尚硅谷hadoop资料下载 尚硅谷mongodb

目录：

（1）MongDB-SpringBoot整合-MongoTemplate操作

（2）MongoTemplate操作2

（3）MongoTemplate操作3

 （4）MongoDB-SpringBoot整合-MongoRepository操作

---

（1）MongDB-SpringBoot整合-MongoTemplate操作

1. 集成简介

spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb，MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。

2.1 初始化工程

使用 Spring Initializr 快速初始化一个 Spring Boot 工程

Group：com.atguigu

Artifact：mongodb

 

 

首先引入依赖：

 pom：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.atguigu</groupId>
    <artifactId>mongodb</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mongodb</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <!--springboot依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--mongdb依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>

        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

修改配置文件：application.properties：添加连接mogodb的配置：

spring.data.mongodb.uri=mongodb://192.168.23.128:27017/test

 创建实体类，跟mogodb中的集合相对应：User：

package com.atguigu.example.demomogo.entity;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Data  //注解设置get和set方法
@Document("User")  //注解指定对哪一个表(集合)进行操作
public class User {
    
    @Id //注解下划线id值生成的策略
    private String id;
    private String name;
    private Integer age;
    private String email;
    private String createDate;

}

3.2 实现

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

Query对象
1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
2、 精准条件：criteria.and(“key”).is(“条件”)
模糊条件：criteria.and(“key”).regex(“条件”)   and应该是where
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")))

在测试类中进行：

package com.atguigu.example.demomogo;

import com.atguigu.example.demomogo.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;

@SpringBootTest
class MongodbApplicationTests {

    //注入mongoTemplate
    @Autowired
    private MongoTemplate mongoTemplate;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        //创建User对象
        User user=new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("[e-mail]");

        User insert = mongoTemplate.insert(user);
        System.out.println(insert);
    }

}

运行测试：

 在Mongo中查看一下：成功添加：

 查询方法：

package com.atguigu.example.demomogo;

import com.atguigu.example.demomogo.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;

import java.util.List;

@SpringBootTest
class MongodbApplicationTests {

    //注入mongoTemplate
    @Autowired
    private MongoTemplate mongoTemplate;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        //创建User对象
        User user=new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("[e-mail]");

        User insert = mongoTemplate.insert(user);
        System.out.println(insert);
    }

    //查询数据
    @Test
    public void findAll(){
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
    }
}

 成功查询：

 （2）MongoTemplate操作2

根据id查询：

package com.atguigu.example.demomogo;

import com.atguigu.example.demomogo.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;

import java.util.List;

@SpringBootTest
class MongodbApplicationTests {

    //注入mongoTemplate
    @Autowired
    private MongoTemplate mongoTemplate;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        //创建User对象
        User user=new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("[e-mail]");

        User insert = mongoTemplate.insert(user);
        System.out.println(insert);
    }

    //查询数据
    @Test
    public void findAll(){
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
    }

    //根据id查询
    @Test
    public void findId(){
        User user = mongoTemplate.findById("63aea7d85e4daf62be00a603", User.class);
        System.out.println(user);
    }

}

 

条件查询：

//根据条件查询
    @Test
    public void findUserList(){
        //查询name=test 和age=20的条件  Criteria条件
        Query query = new Query(
                Criteria.where("name").is("test")
                        .and("age").is(20));

        List<User> users = mongoTemplate.find(query, User.class);
        System.out.println(users);
    }

 

条件查询模糊查询：

//模糊查询 name中含有est
    @Test
    public void findUsersLikeName() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");//构建匹配规则

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则
        Query query = new Query(
                Criteria.where("name").regex(pattern));//regex正则的方法
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

 分页查询：

//分页查询
    @Test
    public void findUsersPage() {

        int pageNo = 1;//当前页
        int pageSize = 3;//每页显示条数
        String name = "est";//条件 模糊查询

        /*String regex = String.format("%s%s%s", "^.*", name, ".*$");//构建匹配规则

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则
        Query query = new Query(
                Criteria.where("name").regex(pattern));//regex正则的方法*/

        //条件构建 Query里面可以先不加下面再添加
        Query query = new Query();
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则

        query.addCriteria(Criteria.where("name").regex(pattern));

        //分页构建
        //查询记录数
        int totalCount = (int) mongoTemplate.count(query, User.class);
        //分页 通过skip和limit   (pageNo - 1) * pageSize)查询的开始位置
        List<User> userList = mongoTemplate.find(
                query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);

        System.out.println(totalCount);
        System.out.println(userList);
    }

 （3）MongoTemplate操作3

 修改操作：

//修改
    @Test
    public void updateUser() {
        //先根据id查询出来
        User user = mongoTemplate.findById("63aea7d85e4daf62be00a603", User.class);
        //修改值
        user.setName("test_1");
        user.setAge(25);
        user.setEmail("[e-mail]");

        //调用方法修改
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        update.set("email", user.getEmail());

        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        //成功影响的行数 应该是1
        long count = result.getModifiedCount();
        System.out.println(count);
    }

查看数据可成功修改：

 删除操作：

//删除操作
    @Test
    public void delete() {
        Query query =
                new Query(Criteria.where("_id").is("63aea7d85e4daf62be00a603"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        //删除影响的行数
        long count = result.getDeletedCount();
        System.out.println(count);
    }

 查询成功删除：

全部代码：

package com.atguigu.example.demomogo;
import com.atguigu.example.demomogo.entity.User;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;


@SpringBootTest
class MongodbApplicationTests {

    //注入mongoTemplate
    @Autowired
    private MongoTemplate mongoTemplate;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        //创建User对象
        User user=new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("[e-mail]");

        User insert = mongoTemplate.insert(user);
        System.out.println(insert);
    }

    //查询数据
    @Test
    public void findAll(){
        List<User> all = mongoTemplate.findAll(User.class);
        System.out.println(all);
    }

    //根据id查询
    @Test
    public void findId(){
        User user = mongoTemplate.findById("63aea7d85e4daf62be00a603", User.class);
        System.out.println(user);
    }

    //根据条件查询
    @Test
    public void findUserList(){
        //查询name=test 和age=20的条件  Criteria条件
        Query query = new Query(
                Criteria.where("name").is("test")
                        .and("age").is(20));

        List<User> users = mongoTemplate.find(query, User.class);
        System.out.println(users);
    }

    //模糊查询 name中含有est
    @Test
    public void findUsersLikeName() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");//构建匹配规则

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则
        Query query = new Query(
                Criteria.where("name").regex(pattern));//regex正则的方法

        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }


    //分页查询
    @Test
    public void findUsersPage() {

        int pageNo = 1;//当前页
        int pageSize = 3;//每页显示条数
        String name = "est";//条件 模糊查询

        /*
        String regex = String.format("%s%s%s", "^.*", name, ".*$");//构建匹配规则

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则
        Query query = new Query(
                Criteria.where("name").regex(pattern));//regex正则的方法*/

        //条件构建 Query里面可以先不加下面再添加
        Query query = new Query();
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);//匹配规则

        query.addCriteria(Criteria.where("name").regex(pattern));

        //分页构建
        //查询记录数
        int totalCount = (int) mongoTemplate.count(query, User.class);
        //分页 通过skip和limit   (pageNo - 1) * pageSize)查询的开始位置
        List<User> userList = mongoTemplate.find(
                query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);

        System.out.println(totalCount);
        System.out.println(userList);
    }

    //修改
    @Test
    public void updateUser() {
        //先根据id查询出来
        User user = mongoTemplate.findById("63aea7d85e4daf62be00a603", User.class);
        //修改值
        user.setName("test_1");
        user.setAge(25);
        user.setEmail("[e-mail]");

        //调用方法修改
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        update.set("email", user.getEmail());

        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        //成功影响的行数 应该是1
        long count = result.getModifiedCount();
        System.out.println(count);
    }

    //删除操作
    @Test
    public void delete() {
        Query query =
                new Query(Criteria.where("_id").is("63aea7d85e4daf62be00a603"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        //删除影响的行数
        long count = result.getDeletedCount();
        System.out.println(count);
    }




}

 

 （4）MongoDB-SpringBoot整合-MongoRepository操作

1. 基于MongoRepository开发CRUD

4.1 实现

Spring Data提供了对mongodb数据访问的支持，我们只需要继承MongoRepository类，按照Spring Data规范就可以了

SpringData 方法定义规范

1、不是随便声明的，而需要符合一定的规范
2、 查询方法以find | read | get开头
3、 涉及条件查询时，条件的属性用条件关键字连接
4、 要注意的是：条件属性首字母需要大写
5、 支持属性的级联查询，但若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接

首先创建interface，继承MongoRepository

UserRepository：

package com.atguigu.example.demomogo.repository;

import com.atguigu.example.demomogo.entity.User;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface UserRepository extends MongoRepository<User, String> {
}

 在重新创建一个测试类：

MongodbApplicationTests1 ：

添加方法：

package com.atguigu.example.demomogo;

import com.atguigu.example.demomogo.entity.User;
import com.atguigu.example.demomogo.repository.UserRepository;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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.util.List;
import java.util.regex.Pattern;


@SpringBootTest
class MongodbApplicationTests1 {

    //注入mongoTemplate
    @Autowired
    private UserRepository userRepository;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        User user=new User();
        user.setName("mary");
        user.setAge(30);
        user.setEmail("[e-mail]");

        User u = userRepository.save(user);
        System.out.println(u);
    }

  
}

 

 数据库查看一下成功添加：

查询数据： 

 

//查询数据
    @Test
    public void findAll(){
        List<User> all = userRepository.findAll();
        System.out.println(all);
    }

根据id查询

//根据id查询
    @Test
    public void findId(){
        User user = userRepository.findById("63aecf5f12b1471f724915b8").get();
        System.out.println(user);
    }

根据条件查询：

//根据条件查询
    @Test
    public void findUserList(){
        //查询的条件 name=mary 和age=30  使用Example
        User user=new User();
        user.setName("mary");
        user.setAge(30);
        Example<User> userExample=Example.of(user);

        List<User> users = userRepository.findAll(userExample);
        System.out.println(users);
    }

 

 模糊查询：

//模糊查询 name中含有m
    @Test
    public void findUsersLikeName() {
        //设置模糊查询的匹配规则 ExampleMatcher.StringMatcher.CONTAINING模糊匹配 .withIgnoreCase(true)忽略大小写
        ExampleMatcher matcher=ExampleMatcher.matching()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)
                .withIgnoreCase(true);

        User user=new User();
        user.setName("m");
        Example<User> userExample=Example.of(user,matcher);

        List<User> users = userRepository.findAll(userExample);
        System.out.println(users);
    }

 分页查询：

//分页查询
    @Test
    public void findUsersPage() {
        //设置分页参数  0：代表第一页  3:代表每页显示条数
        Pageable pageable=PageRequest.of(0,3);


        //查询的条件 name=mary 和age=30  使用Example
        User user=new User();
        user.setName("mary");
        Example<User> userExample=Example.of(user);

        Page<User> page = userRepository.findAll(userExample, pageable);//返回Page对象 Page对象中有分页的所有内容
        //如：
        int totalPages = page.getTotalPages();//总页数
        System.out.println(totalPages);
        System.out.println(page);

    }

修改：

 

//修改
    @Test
    public void updateUser() {
        //先根据id查询出来
        User user = userRepository.findById("63aecf5f12b1471f724915b8").get();
        //修改值
        user.setName("mary_11");
        user.setAge(100);
        user.setEmail("[e-mail]");
        //调用的也是save方法，此时有id做修改操作
        User save = userRepository.save(user);
        System.out.println(save);
    }

 成功修改：

 删除操作：

 

//删除操作
    @Test
    public void delete() {

        userRepository.deleteById("63aecf5f12b1471f724915b8");
    }

 查询数据库：成功删除：

 总代码：

package com.atguigu.example.demomogo;

import com.atguigu.example.demomogo.entity.User;
import com.atguigu.example.demomogo.repository.UserRepository;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.*;
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.util.List;
import java.util.regex.Pattern;


@SpringBootTest
class MongodbApplicationTests1 {

    //注入mongoTemplate
    @Autowired
    private UserRepository userRepository;

    //第一个方法向（表）集合User中添加数据
    @Test
    public void create() {
        User user=new User();
        user.setName("mary");
        user.setAge(30);
        user.setEmail("[e-mail]");

        User u = userRepository.save(user);
        System.out.println(u);
    }

    //查询数据
    @Test
    public void findAll(){
        List<User> all = userRepository.findAll();
        System.out.println(all);
    }

    //根据id查询
    @Test
    public void findId(){
        User user = userRepository.findById("63aecf5f12b1471f724915b8").get();
        System.out.println(user);
    }

    //根据条件查询
    @Test
    public void findUserList(){
        //查询的条件 name=mary 和age=30  使用Example
        User user=new User();
        user.setName("mary");
        user.setAge(30);
        Example<User> userExample=Example.of(user);

        List<User> users = userRepository.findAll(userExample);
        System.out.println(users);
    }

    //模糊查询 name中含有m
    @Test
    public void findUsersLikeName() {
        //设置模糊查询的匹配规则 ExampleMatcher.StringMatcher.CONTAINING模糊匹配 .withIgnoreCase(true)忽略大小写
        ExampleMatcher matcher=ExampleMatcher.matching()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)
                .withIgnoreCase(true);

        User user=new User();
        user.setName("m");
        Example<User> userExample=Example.of(user,matcher);

        List<User> users = userRepository.findAll(userExample);
        System.out.println(users);
    }


    //分页查询
    @Test
    public void findUsersPage() {
        //设置分页参数  0：代表第一页  3:代表每页显示条数
        Pageable pageable=PageRequest.of(0,3);


        //查询的条件 name=mary 和age=30  使用Example
        User user=new User();
        user.setName("mary");
        Example<User> userExample=Example.of(user);

        Page<User> page = userRepository.findAll(userExample, pageable);//返回Page对象 Page对象中有分页的所有内容
        //如：
        int totalPages = page.getTotalPages();//总页数
        System.out.println(totalPages);
        System.out.println(page);

    }

   //修改
    @Test
    public void updateUser() {
        //先根据id查询出来
        User user = userRepository.findById("63aecf5f12b1471f724915b8").get();
        //修改值
        user.setName("mary_11");
        user.setAge(100);
        user.setEmail("[e-mail]");
        //调用的也是save方法，此时有id做修改操作
        User save = userRepository.save(user);
        System.out.println(save);
    }

    //删除操作
    @Test
    public void delete() {

        userRepository.deleteById("63aecf5f12b1471f724915b8");
    }




}