Spring Boot MongoDB

1.  Linux下啟動MongoDB並使用mongosh連接

啟動方式有兩種：

• systemctl start mongod
• mongod  <選項參數>

啟動的時候有可能會報類似如下的錯誤：

ExecStart=/usr/bin/mongod $OPTIONS (code=exited, status=14)

mongod.service: Control process exited, code=exited status=14

當看到這種“code=exited, status=14”的時候，一般是文件或目錄權限問題，即執行mongodb啟動命令的用戶對某些文件或目錄沒有訪問權限，此時應檢查一些幾個文件或目錄：

• /var/run/mongodb/
• /var/log/mongodb/
• /var/lib/mongo/
• /tmp/*.sock

看看這些文件或目錄的所有者和所屬組是否正確

chown -R mongodb:mongodb /var/lib/mongodb
chown -R mongodb:mongodb /var/log/mongodb/
chown -R mongodb:mongodb /var/run/mongodb/
chown mongodb:mongodb /tmp/mongodb-27017.sock

首先，不啟用訪問控制，創建一個用戶管理員

然后，啟用訪問控制，用用戶管理員認證，再創建其它用戶

備忘錄

ls -l /var/run/mongodb/
ls -l /var/log/mongodb/
ls -l /var/lib/mongo/
ls -l /tmp/*.sock

id

rm -rf /tmp/mongodb-27017.sock

systemctl start mongod

mongosh

test> use admin
admin> db.createUser(
      {
          user: "myUserAdmin",
          pwd: passwordPrompt(),
          roles: [
              { role: "userAdminAnyDatabase", db: "admin" },
              { role: "readWriteAnyDatabase", db: "admin" }
          ]
        }
    )


sudo vim /etc/mongod.conf
sudo systemctl restart mongod

mongosh --port 27017  --authenticationDatabase "admin"  -u "myUserAdmin" -p

test> use book
switched to db book
book> db.chinese.insertOne({title:"語文"})

test> use admin
switched to db admin
admin> db.auth("myUserAdmin","123456")
{ ok: 1 }
admin> use book
switched to db book
book> db.createUser({user:"zhangsan",pwd:"123456",roles:[{role:"readWrite",db:"book"}]})
{ ok: 1 }
book> db.auth("zhangsan","123456")
{ ok: 1 }
book> show collections

2.  Docker 運行 MongoDB

方式一：另啟一個容器去連接（PS：相當於遠程連接）

docker run -d --network my-network --name my-mongo \
    -e MONGO_INITDB_ROOT_USERNAME=mongoroot \
    -e MONGO_INITDB_ROOT_PASSWORD=123456 \
    -v /data/mongo/db:/data/db \
    -p 27017:27017 \
    mongo


docker run -it --rm --network my-network mongo \
    mongosh --host my-mongo \
        -u mongoroot \
        -p 123456 \
        --authenticationDatabase admin 

方式二：從運行MongoDB實例的容器內部進行連接（PS：相當於本地連接）

docker run -d --network my-network --name my-mongo \
    -e MONGO_INITDB_ROOT_USERNAME=mongoroot \
    -e MONGO_INITDB_ROOT_PASSWORD=123456 \
    -v /data/mongo/db:/data/db \
    -p 27017:27017 \
    mongo


docker exec -it my-mongo mongosh

備忘錄

docker run -d --network my-network --name my-mongo \
    -e MONGO_INITDB_ROOT_USERNAME=mongoroot \
    -e MONGO_INITDB_ROOT_PASSWORD=123456 \
    -v /data/mongo/db:/data/db \
    -p 27017:27017 \
    mongo

docker run -it --rm --network my-network mongo \
    mongosh --host my-mongo \
        -u mongoroot \
        -p 123456 \
        --authenticationDatabase admin 


docker exec -it my-mongo mongosh 

docker run -it --rm mongo mongosh --help
docker exec -it some-mongo bash
docker logs -f some-mongo

docker exec -it my-mongo mongosh 
use admin
db.auth("myUserAdmin","123456")
db.createUser({user:"hello",pwd:"world",roles:[{role:"readWrite",db:"movie"}]})

補充

不建議用root用戶來運行MongoDB

https://docs.mongodb.com/manual/tutorial/install-mongodb-on-red-hat/

3.  Spring Boot 集成 MongoDB

maven依賴

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

完整的pom.xml如下：

<?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.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cjs.example</groupId>
    <artifactId>demo-mongodb</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo-mongodb</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>
    <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-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

application.yml

spring:
  data:
    mongodb:
      host: 192.168.28.32
      port: 27017
      database: movie
      username: hello
      password: world
#      uri: mongodb://192.168.28.32:27017

連接字符串格式，參見  https://docs.mongodb.com/manual/reference/connection-string/

方式一：MongoTemplate

首先，定義一個實體類

package com.cjs.example.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.List;

/**
 * @Author ChengJianSheng
 * @Date 2022/1/12
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(collection = "film")
public class Film implements Serializable {

    @Id
    private String id;

    private String name;

    private List<String> category;
}

然后，利用MongoTemplate進行操作

package com.cjs.example;

import com.cjs.example.domain.Film;
import com.cjs.example.repository.FilmRepository;
import org.junit.jupiter.api.Test;
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 javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
class DemoMongodbApplicationTests {

    @Resource
    private MongoTemplate mongoTemplate;


    /**
     * movie> db.createUser({user:"hello",pwd:"world",roles:["readWrite"]})
     */
    @Test
    void contextLoads() {
        Film film = new Film();
        film.setName("我和我的父輩");
        film.setCategory(Arrays.asList("劇情"));
        mongoTemplate.insert(film);
    }

    @Test
    void testQuery() {
        List<Film> filmList = mongoTemplate.findAll(Film.class);
        System.out.println(filmList);

        Query query = new Query();
        query.addCriteria(Criteria.where("name").is("我和我的父輩").and("category").in("愛情","戰爭","劇情"));
        Film film = mongoTemplate.findOne(query, Film.class);
        System.out.println(film);
    }

    @Test
    void testSave() {
        Film film = new Film();
        film.setId("asdfgh");
        film.setName("長津湖");
        film.setCategory(Arrays.asList("戰爭","歷史"));
        mongoTemplate.save(film);
    }

}

方式二：Spring Data MongoDB Repositories 

定義一個Repository

package com.cjs.example.repository;

import com.cjs.example.domain.Film;
import org.springframework.data.repository.CrudRepository;

import java.util.List;

/**
 * @Author ChengJianSheng
 * @Date 2022/1/12
 */
public interface FilmRepository extends CrudRepository<Film, String> {
    
    List<Film> findByName(String name);
}

完整測試代碼如下：

package com.cjs.example;

import com.cjs.example.domain.Film;
import com.cjs.example.repository.FilmRepository;
import org.junit.jupiter.api.Test;
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 javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

@SpringBootTest
class DemoMongodbApplicationTests {

    @Resource
    private MongoTemplate mongoTemplate;

    @Resource
    private FilmRepository filmRepository;

    /**
     * movie> db.createUser({user:"hello",pwd:"world",roles:["readWrite"]})
     */
    @Test
    void contextLoads() {
        Film film = new Film();
        film.setName("我和我的父輩");
        film.setCategory(Arrays.asList("劇情"));
        mongoTemplate.insert(film);
    }

    @Test
    void testQuery() {
        List<Film> filmList = mongoTemplate.findAll(Film.class);
        System.out.println(filmList);

        Query query = new Query();
        query.addCriteria(Criteria.where("name").is("我和我的父輩").and("category").in("愛情","戰爭","劇情"));
        Film film = mongoTemplate.findOne(query, Film.class);
        System.out.println(film);
    }

    @Test
    void testSave() {
        Film film = new Film();
        film.setId("asdfgh");
        film.setName("長津湖");
        film.setCategory(Arrays.asList("戰爭","歷史"));
        mongoTemplate.save(film);
    }

    @Test
    void testSaveByRepository() {
        filmRepository.save(new Film("1234", "火影忍者", Arrays.asList("動畫","喜劇","動作","冒險")));
    }

    @Test
    void testQueryByRepository() {
        Film film = filmRepository.findById("1234").orElse(null);
        System.out.println(film);
        film = filmRepository.findByName("火影忍者").get(0);
        System.out.println(film);

        filmRepository.findAll().forEach(System.out::println);
    }
}

工程結構如下：