1. 인덱스 없을시 explain 결과
repl_set:PRIMARY> db.test_multikey_index.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test_db.test_multikey_index"
        }
]
 
 
repl_set:PRIMARY> db.test_multikey_index.find({topic:'server-3'}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test_db.test_multikey_index",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "topic" : {
                                "$eq" : "server-3"
                        }
                },
                "queryHash" : "28760B72",
                "planCacheKey" : "28760B72",
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "topic" : {
                                        "$eq" : "server-3"
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "localhost.localdomain",
                "port" : 27017,
                "version" : "4.2.8",
                "gitVersion" : "43d25964249164d76d5e04dd6cf38f6111e21f5f"
        },
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Timestamp(1596622293, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(1596622293, 1)
}
 
 
 
 
 
 
  1. 인덱스 존재시 explain결과
repl_set:PRIMARY> db.test_multikey_index.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "test_db.test_multikey_index"
        },
        {
                "v" : 2,
                "key" : {
                        "topic" : 1
                },
                "name" : "topic_1",
                "ns" : "test_db.test_multikey_index"
        }
]
 
 
 
repl_set:PRIMARY> db.test_multikey_index.find({topic:'server-3'}).explain()
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "test_db.test_multikey_index",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "topic" : {
                                "$eq" : "server-3"
                        }
                },
                "queryHash" : "28760B72",
                "planCacheKey" : "9C0A2855",
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "topic" : 1
                                },
                                "indexName" : "topic_1",
                                "isMultiKey" : true,
                                "multiKeyPaths" : {
                                        "topic" : [
                                                "topic"
                                        ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "topic" : [
                                                "[\"server-3\", \"server-3\"]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "serverInfo" : {
                "host" : "localhost.localdomain",
                "port" : 27017,
                "version" : "4.2.8",
                "gitVersion" : "43d25964249164d76d5e04dd6cf38f6111e21f5f"
        },
        "ok" : 1,
        "$clusterTime" : {
                "clusterTime" : Timestamp(1596622053, 1),
                "signature" : {
                        "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
                        "keyId" : NumberLong(0)
                }
        },
        "operationTime" : Timestamp(1596622053, 1)
}
 
 
 
  1. 참고 - 테스트용 프로그램
package com.biz.mongodb;
 
 
import com.mongodb.BasicDBObject;
import com.mongodb.Block;
import com.mongodb.MongoClientSettings;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoDatabase;
import com.mongodb.connection.ClusterSettings;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
 
 
import java.util.*;
 
 
/**
* 멀티키 Index 테스트
*
* @author 엄승하
*/
@Slf4j
public class FindMultiKeyIndexSample {
 
 
   private static final String dbAddr = "192.168.56.1"; //로컬 vm에 mongodb 4.2를 설치함
   private static final String dbName = "test_db"; //db명
 
 
   private static String colNm = "test_multikey_index";
   private static String indexField = "topic"; //인덱스 필드
 
 
   private static final int testDataSize = 100_000; //테스트 데이터 생성 갯수
 
 
   private static MongoDatabase mongoDB;
 
 
   public static void main(String[] args) {
 
 
      List<ServerAddress> serverList = Arrays.asList(new ServerAddress(dbAddr, 27017));
      Block<ClusterSettings.Builder> clusterSettings = builder -> builder.hosts(serverList);
 
 
      MongoClient mongoClient = MongoClients.create(MongoClientSettings.builder().applyToClusterSettings(clusterSettings).build());
      mongoDB = mongoClient.getDatabase(dbName);
 
 
      //컬렉션 추가
      mongoDB.createCollection(colNm);
      mongoDB.getCollection(colNm).createIndex(new BasicDBObject(indexField, 1)); //인덱스 추가
 
 
      saveBulkData(colNm, testDataSize); //테스트 데이터 저장
 
 
      mongoClient.close(); //DB커넥션 반환
 
 
      System.out.println("\n\n === 프로그램 종료 ===");
   }
 
 
   /**
    * bulk로 데이터 저장
    *
    * @param colNm 저장할 컬렉션명
    * @param dataSize 저장할 데이터 갯수
    */
   public static void saveBulkData(String colNm, int dataSize) {
 
 
      Date now = new Date();
      List<Document> docs = new ArrayList<>(dataSize);
 
 
      List<String> case1 = new ArrayList<>();
      case1.add("server-1");
      case1.add("server-2");
 
 
      List<String> case2 = new ArrayList<>();
      case2.add("server-2");
      case2.add("server-3");
 
 
      for (int i = 1; i <= dataSize; i++) {
 
 
         Document doc = new Document();
         doc.append("i", i);
         doc.append("uuid", UUID.randomUUID().toString());
         if (i % 2 == 0) { // 2가지의 경우로 데이터 저장
            doc.append("topic", case1);
         } else {
            doc.append("topic", case2);
         }
 
 
         doc.append("doc_make_date", now);
         docs.add(doc);
      }
 
 
      mongoDB.getCollection(colNm).insertMany(docs); //N개 insert
 
 
      //Thread.sleep(10); //부하분산 목적
   }
}
 
  1. 목적
    1. 최신버전의 redis를 로컬 virtualbox의 centos에 설치해보고 프로그램으로도 저장해봄
       
  2. Install Redis
sudo yum -y install http://rpms.remirepo.net/enterprise/remi-release-7.rpm
sudo yum --enablerepo=remi install redis
 
  1. Start Redis
sudo systemctl start redis
 
 
#버전확인
redis-cli -v
 
  1. 재 부팅시 자동으로 시작되도록 처리
sudo systemctl enable redis
 
 
#확인
systemctl list-unit-files | grep redis
 
  1. 추가로 redis conf 튜닝 예
Redis Conf 튜닝 예(sudo vim /etc/redis.conf)
 
 
#방화벽으로 관리할 경우라서 편의성 문제로 모든 IP에서 접근 허용
bind 0.0.0.0
 
 
#아래 file save옵션 부분 주석처리(메모리 캐쉬로만 사용하기 위해서)
#save 900 1
#save 300 10
#save 60 10000
 
 
859라인쯤에 아래 추가(최대 메모리 제한)
maxmemory 256m
 
적용 : sudo systemctl restart redis
 
 
  1. 참고 : 삭제 방법
yum erase $(rpm -qa | grep redis)
 
  1. 결과
    1. install
       
    2. redis-cli 접속 후 key-value 테스트
          
 
 
  1. 목적
    1. mongodb Zstandard(이하 zstd)압축 알고리즘 효과 및 압축옵션 적용시 find 성능에 문제가 없는지 확인
  2. 환경
    1. mongodb 4.2 서버
    2. java 드라이버 4.0.4
  3. 방법
    1. 압축 옵션 적용/미 적용시 압축율과 find 성능 확인
  4. 테스트 결과
    1. 용량 절약에 효과가 있으며 find 성능 문제 없음
    2. 상세 내용은 하단 참고
 

 
[필요사항]
  1. 테스트용 java 프로그램(하단 참고)
 
mongodb 드라이버 maven dependency
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-core</artifactId>
    <version>4.0.4</version>   
</dependency>
 
 
테스트용 java 소스
package com.biz.mongodb;


import com.mongodb.BasicDBObject;
import com.mongodb.Block;
import com.mongodb.MongoClientSettings;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Indexes;
import com.mongodb.connection.ClusterSettings;
import org.bson.Document;


import java.util.*;


/**
* 몽고DB 서버의 압축 효율 테스트
*  - DB서버의 압축 옵션을 적용/ 미 적용 후 bulk 데이터 저장 후 find 성능 확인
*
* @author 엄승하
*/
public class MongodbNotCompressTest {


   private static final String dbAddr = "192.168.56.1"; //로컬 vm에 mongodb 4.2를 설치함
   private static final String dbName = "compress_test_db"; //db명


   private static final int bulkSaveDataSize = 1_000_000; //bulk 데이터 저장 갯수
   private static final String dummyTest = "Zstandard is a real-time compression algorithm, providing high compression ratios. It offers a very wide range of compression / speed trade-off, while being backed by a very fast decoder";


   private static MongoDatabase mongoDB;


   public static void main(String[] args) {


      MongoClient mongoClient = getNewMongoClient(dbAddr);
      mongoDB = mongoClient.getDatabase(dbName);


      final String colNm = "no_compress";
      //final String colNm = "compress"; //압축 테스트때 사용하는 컬렉션명


      mongoDB.getCollection(colNm).createIndex(Indexes.ascending("uuid")); //인덱스 추가


      long startSave = System.currentTimeMillis();


      //100만건을 insert해봄
      saveBulkData(colNm, bulkSaveDataSize);


      long duSaveMills = System.currentTimeMillis() - startSave;
      System.out.println(String.format("테스트 데이터 저장 소요시간: '%s'", duSaveMills));


      //1건을 추가로 insert 후 find 속도 확인
      final String addedUuid = "last-uuid";


      Document addLastDoc = new Document();
      addLastDoc.append("i", bulkSaveDataSize + 1);
      addLastDoc.append("uuid", addedUuid);
      addLastDoc.append("dummy_text", dummyTest);
      addLastDoc.append("doc_make_date", new Date());
      mongoDB.getCollection(colNm).insertOne(addLastDoc);


      findByUuid(colNm, addedUuid); //find


      mongoClient.close();
   }


   /**
    * UUID로 데이터 찾기
    *
    * @param colNm 컬렉션명
    * @param uuid 찾을 UUID
    */
   public static void findByUuid(String colNm, String uuid) {


      long startFind = System.currentTimeMillis();
      MongoCursor<Document> cur = mongoDB.getCollection(colNm).find(new BasicDBObject("uuid", uuid)).iterator(); //find
      while (cur.hasNext()) {


         Document doc = cur.next();
         System.out.println("\nfind결과:" + doc);
      }


      long duFindMills = System.currentTimeMillis() - startFind;
      System.out.println(String.format("\nfind 소요시간: '%s'", duFindMills));
   }


   /**
    * bulk로 데이터 저장
    *
    * @param colNm 저장할 컬렉션명
    * @param dataSize 저장할 데이터 갯수
    */
   public static void saveBulkData(String colNm, int dataSize) {


      Date now = new Date();
      List<Document> docs = new ArrayList<>(dataSize);


      for (int i = 1; i <= dataSize; i++) {


         Document doc = new Document();
         doc.append("i", i);
         doc.append("uuid", UUID.randomUUID().toString());
         doc.append("dummy_text", dummyTest);
         doc.append("doc_make_date", now);


         docs.add(doc);
      }


      mongoDB.getCollection(colNm).insertMany(docs); //N개 insert


      //Thread.sleep(10); //부하분산 목적
   }


   public static MongoClient getNewMongoClient(String dbAddr) {


      List<ServerAddress> serverList = Arrays.asList(new ServerAddress(dbAddr, 27017));
      Block<ClusterSettings.Builder> clusterSettings = builder -> builder.hosts(serverList);


      //mongo와 실제 커넥션 생성(mongo client생성)
      return MongoClients.create(MongoClientSettings.builder().applyToClusterSettings(clusterSettings).build());
   }


}
 
[결과]
  1. 압축 옵션 미 적용시
    1. 파일 사이즈
       
    2. 소요시간
       
       
  2. 압축 zstd 적용시
    1. 파일 사이즈
       
    2. 소요시간
 
 

 

참고  
 
#OS튜닝
# nofile 및 nprc 갯수 튜닝
echo "*    soft nofile  64000" >> /etc/security/limits.conf
echo "*    hard nofile  64000" >> /etc/security/limits.conf
echo "*    soft nproc  64000" >> /etc/security/limits.conf
echo "*    hard nproc  64000" >> /etc/security/limits.conf
 
vim /etc/security/limits.d/20-nproc.conf 후에 64000으로 변경
 
Run the sysctl command below to apply the changed limits to the system:
sysctl -p
 
ulimit -a 명령어로 확인 가능
 
# repo 추가(red hat 계열) : 참고
vi /etc/yum.repos.d/mongodb-org-4.2.repo 이후 아래 입력
 
[mongodb-org-4.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc
 
# repo 추가(amazon ami 이미지의 경우) : 참고
vi /etc/yum.repos.d/mongodb-org-4.2.repo 이후 아래 입력
 
[mongodb-org-4.2]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/amazon/2/mongodb-org/4.2/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-4.2.asc
 
# 설치
yum install -y mongodb-org
 
# 기본 설정 작업
#huge 설정
echo never > /sys/kernel/mm/transparent_hugepage/defrag
echo never > /sys/kernel/mm/transparent_hugepage/enabled
 
#재 부팅시 자동으로 시작(필요시)
systemctl enable mongod
 
#몽고 데이터 저장 디렉토리 생성 및 mongod계정의 소유로 변경(예)
mkdir -p /data/mongo/repl_0
chown -R mongod:mongod /data
 
 
#인증모드 적용 작업
#key 생성 -> 생성된 키는 모든 replica 멤버 몽고DB서버에 복사해야함
openssl rand -base64 755 > /data/mongo/mongo_repl.key
chown mongod.mongod /data/mongo/mongo_repl.key
chmod 400 /data/mongo/mongo_repl.key
 
#설정에 인증 활성화
vi /etc/mongod.conf 후 아래 내용 추가
security:
  keyFile: /data/mongo/mongo_repl.key
  authorization: enabled
 
 

#참고: 몽고DB authorization enable설정시 key파일 생성 방법

#Primary에서 key 파일 생성 (mongodb 간 접속을 위해서 필요)

#해당 key파일은 Secondary에 복사

 

sudo openssl rand -base64 756 > /data/mongo/mongo_repl.key

sudo chown mongod.mongod /data/mongo/mongo_repl.key

sudo chmod 400 /data/mongo/mongo_repl.key

 

# 아래 내용 복사하여 Secondary 에 동일하게 구성

cat /data/mongo/mongo_repl.key

 

 

#테스트(필요시 진행)

mongo 커맨드로 mongo접속 후

use admin

db.createUser({ user: "admin", pwd: "admin", roles: [ "root" ] })

db.auth("admin", "admin")

 

show dbs

 

#DB에 저장 및 find되는지 테스트

use test_db

db.test_col.insert({msg:"test insert message"})

db.test_col.find()

 
# 몽고 시작
#몽고 서비스 시작
systemctl start mongod
 
#몽고 프롬프트에 접속
mongo
 
 
#참고 : 몽고 삭제
systemctl stop mongod
 
#Remove any MongoDB packages that you had previously installed.
yum erase $(rpm -qa | grep mongodb-org)
 
#Remove MongoDB databases and log files.
rm -rf /var/log/mongodb
rm -rf /var/lib/mongo
 
#필요시
rm -rf /data
 
 
#참고 : 몽고 설정(/etc/mongod.conf)   
 
# mongod.conf
 
# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/
 
# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  logRotate: rename 
  path: /var/log/mongodb/mongod.log
  #quiet: true
 
 
# Where and how to store data.
storage:
  engine: wiredTiger
  directoryPerDB: true
  wiredTiger:
      engineConfig:
         journalCompressor: snappy
         #journalCompressor: zstd
         #cacheSizeGB: 0.5
      collectionConfig:
         blockCompressor: snappy
         #blockCompressor: zstd
      indexConfig:
         prefixCompression: true
 
  dbPath: /data/mongo/repl_0
  journal:
      enabled: true
 
 
# how the process runs
processManagement:
  fork: true  # fork and run in background
  pidFilePath: /var/run/mongodb/mongod.pid  # location of pidfile
  timeZoneInfo: /usr/share/zoneinfo
 
 
# network interfaces
net:
  port: 27017
  bindIp: 0.0.0.0  # Enter 0.0.0.0,:: to bind to all IPv4 and IPv6 addresses or, alternatively, use the net.bindIpAll setting.(AWS에서는 SG로 보안처리 하고 있어서 편의상 모두 허용하기도 함)
 
 
#security:
#  keyFile: /data/mongo/mongo_repl.key
#  authorization: enabled
 
#replication:
replication:
  replSetName: repl_set
 
 
#참고 : 몽고 replica 설정
primary가 될 서버에서 몽고 콘솔로 접속 : mongo
 
#Replica set 초기화
rs.initiate()
 
#Secondary 노드 추가
rs.add("secondary장비의 IP:27017")
 
#Arbiter 노드 추가
rs.add("arbiter장비IP:37017",arbiterOnly:true)
 
 
# 잘 저장되는지 테스트
use testdb
db.test_collection.insert({'msg':'test message'})
db.test_collection.find()
 
 
#Secondary에서는 아래 명령 실행 후 조회해 보면 됨
db.slaveOk(true)
 
 
#참고: 계정 생성 방법
-- 유저 생성 및 권한 부여
use DB명 후;
db.createUser({ user: "유저ID입력    ", pwd: "암호입력", roles: [ "롤코드 입력" ] })
예) db.createUser({ user: "test-user", pwd: "pwd-1231", roles: [ "readWrite" ] })
 
 
 
 
-- 서버 접속 후 인증 방법
db.auth("<username>", "<password>" )
 
 
#root 권한으로 계정 생성 방법
use admin;
db.createUser({ user: "ID입력", pwd: "암호입력", roles: [ "root" ] })
 
 
#특정 DB만 엑세스 가능한 계정 생성 방법
use DB명 입력;
db.createUser({ user: "ID입력", pwd: "암호입력", roles: [ "readWrite" ] })
 
 
 

nginx에서 아래 내용 추가

proxy_pass_header  Server;

2023-07-13 내용 추가

배민 회원시스템쪽에서 자세히 설명해두셔서 링크 추가

  - https://youtu.be/b65zIH7sDug?t=1094 

 - https://techblog.woowahan.com/7835/ 

Transactonal Outbox Pattern

 

 

테이블 DDL 샘플

----

 

분산트랙잭션을 구현하는 여러 가지 방법이 있는데 그 중 outbox 패턴 방식 메모

 - 많이 쓰는 로컬 RDB를 이용하는 방법이라서 쉽게 적용 가능한 장점이 있음

 

참고 링크

 - https://www.popit.kr/msa%EC%97%90%EC%84%9C-%EB%A9%94%EC%8B%9C%EC%A7%95-%ED%8A%B8%EB%9E%9C%EC%9E%AD%EC%85%98-%EC%B2%98%EB%A6%AC%ED%95%98%EA%B8%B0

 

MSA에서 메시징 트랜잭션 처리하기 | Popit

비동기 메시지를 사용하여 상호 간에 통신하는 방식을 메시징 Messaging[1] 이라고 부른다. 마이크로서비스 환경에서 비동기 처리 시 보통 카프카 Kafka 나 래빗엠큐 RabbitMQ 같은 메시지 브로커 Message

www.popit.kr

 - https://debezium.io/blog/2019/02/19/reliable-microservices-data-exchange-with-the-outbox-pattern/

 

Reliable Microservices Data Exchange With the Outbox Pattern · Debezium

In order to provide their functionality, microservices will typically have their own local data store. For instance, the order service may use a relational database to persist the information about purchase orders. When a new order is placed, this may resu

debezium.io

 

- https://sarc.io/index.php/cloud/1944-msa-transactional-outbox-pattern

 

MSA - Transactional Outbox Pattern

Tech Note 정보 애리얼 님이 작성하신 글입니다. 카테고리: [ Cloud Computing & MSA ] 게시됨: 19 May 2020 작성됨: 19 May 2020 최종 변경: 26 May 2020 조회수: 3664 1. 개요 MSA에서는 서비스 간 결합도가 낮아야 하기

sarc.io

 

  1. MongoDB 드라이버를 maven pom.xml에 추가

<!-- MongoDB 드라이버를 maven pom.xml에 추가 -->

<dependency>

<groupId>org.mongodb</groupId>

<artifactId>mongodb-driver-sync</artifactId>

<version>4.0.4</version>

</dependency>

 

  1. MongoDB에 계정 생성 추가 방법

#root 권한으로 계정 생성

use admin;

db.createUser({ user: "ID입력", pwd: "암호입력", roles: [ "root" ] })

 

 

#특정 DB만 엑세스 가능한 계정 생성

use DB명 입력;

db.createUser({ user: "ID입력", pwd: "암호입력", roles: [ "readWrite" ] })

 

 

  1. java 샘플 소스

 

import com.mongodb.Block;

import com.mongodb.MongoClientSettings;

import com.mongodb.MongoCredential;

import com.mongodb.ServerAddress;

import com.mongodb.client.MongoClient;

import com.mongodb.client.MongoClients;

import com.mongodb.connection.ConnectionPoolSettings;

import org.bson.Document;

 

 

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.concurrent.TimeUnit;

 

 

/**

* 몽고DB java 4.0.4 드라이버 사용시 커넥션 소스 샘플

*  - 몽고DB 4.2에 데이터 저장하는 샘플소스

*  - DB서버는 인증모드와 replica모드가 적용되어 있음

*

* @author 엄승하

*/

public class MongoDBConnectWithAuth {

 

 

   public static void main(String[] args) {

 

 

      final String dbAddr = "DB서버주소";

 

 

      final String dbName = "DB명입력필요";

      final String user = "ID입력필요";

      final String pwd = "암호입력필요";

 

 

      final String colNm = "저장할 컬렉션명 입력 필요";

 

 

      //인증정보

      MongoCredential credential = MongoCredential.createCredential(user, dbName, pwd.toCharArray());

 

 

      //커넥션풀 설정

      Block<ConnectionPoolSettings.Builder> poolSetting = builder -> builder.maxWaitTime(4, TimeUnit.SECONDS).maxConnectionIdleTime(10000,

         TimeUnit.SECONDS).maxConnectionLifeTime(58, TimeUnit.SECONDS);

 

 

      //클러스터 또는 replica 설정

      List<ServerAddress> serverList = Arrays.asList(new ServerAddress(dbAddr, 27017));

      Block<com.mongodb.connection.ClusterSettings.Builder> clusterSettings = builder -> builder.hosts(serverList);

 

 

      //mongo와 실제 커넥션 생성(mongo client생성)

      MongoClient mongoClient = MongoClients.create(

         MongoClientSettings.builder().credential(credential).applyToConnectionPoolSettings(poolSetting).applyToClusterSettings(clusterSettings).build());

 

 

      int docsCnt = 10000;

      List<Document> docs = new ArrayList<>(docsCnt);

 

 

      for (int i = 1; i <= docsCnt; i++) {

         Document doc = new Document();

         doc.put("doc_id", i);

         doc.put("dt_ms", System.currentTimeMillis());

 

 

         docs.add(doc);

      }

 

 

      mongoClient.getDatabase(dbName).getCollection(colNm).insertMany(docs); //bulk insert

      mongoClient.close(); //자원 반환

   }

}

 

 

  1. 결과

    1. 아래와 같이 데이터가 정상적으로 저장됨을 확인 가능

 

 

www.eversql.com

'DB > 기타' 카테고리의 다른 글

웹에서 ERD 그릴수 있는 툴(무료)  (0) 2017.05.25

+ Recent posts