봄 부팅 MongoDB를 통합 데이터베이스

A. 알고 MongoDB를
MongoDB를 관계형 데이터베이스처럼 부유 한 가장들 관계형 데이터베이스와 비 관계형 데이터베이스, 비 관계형 데이터베이스 기능과 기능을 가진 제품입니다. 더 복잡한 데이터를 보관하는 것이 가능하고, 데이터 구조는 매우 느슨 유사한 형식 bson json으로 지원한다. 몽고의 가장 큰 특징은 구문은 대부분의 기능은 거의 단일 테이블이 관계형 데이터베이스와 유사한 쿼리 달성뿐만 아니라 데이터 인덱싱에 대한 지원을 할 수있다, 객체 지향 질의 언어에 다소 유사하다, 매우 강력한 쿼리 언어를 지원한다는 것입니다.
II. 봄 부팅 프로젝트 통합 MongoDB를
1. 추가가 MongoDB에 의존

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

연결 MongoDB의 구성

spring：
    data:
            mongodb:
                #uri: mongodb://localhost:27017/data_exploration
                uri: mongodb://root:[email protected]:27017/data_exploration?authSource=admin&authMechanism=SCRAM-SHA-1

분석 : URI는 상기 로컬 구성과 원격 연결 나타내는
3 가동베이스
(1)에 저장

@Repository
public class ExplorationJobDao {

    @Autowired
    MongoTemplate mongoTemplate;

    public void save(ExplorationJob explorationJob) {
        mongoTemplate.save(explorationJob);
    }
}

(2) 상기 ID 데이터에 기초하여 변형 (제 1 원리에 부합하는 ID 데이터를 삭제하고 제 조회 결과)

public void updateExecutionStatusById(int executionStatus, String jobId) {
            Query query = new Query(Criteria.where("jobId").is(jobId));
            Update update = new Update().set("executionStatus", executionStatus);
            mongoTemplate.updateFirst(query, update, ExplorationJob.class);
    }

(3) 제 따른 데이터 수정 복수 (ID 데이터가, 모든 데이터를 수정하는 모든 쿼리와 일치)

public void update(BusinessExploration businessExploration) {
        Query query = new Query(Criteria.where("_id").is(businessExploration.getId()));
        Update update = new Update().set("sourceUnit", businessExploration.getSourceUnit())
                .set("appSystem", businessExploration.getAppSystem())
                .set("businessImplication", businessExploration.getBusinessImplication())
                .set("safetyRequire", businessExploration.getSafetyRequire());
        mongoTemplate.updateMulti(query, update, TableExploration.class);
    }

(4) 삭제 (ID에 따라 삭제)

public void delExplorationJobById(String jobId) {
         Query query=new Query(Criteria.where("jobId").is(jobId));
         mongoTemplate.remove(query,ExplorationJob.class);
    }

쿼리 (5) 조건 (ID 별 검색어)

public ExplorationJob getExplorationJobByJobId(String jobId) {
        Query query = new Query(Criteria.where("jobId").is(jobId));
        ExplorationJob explorationJob = mongoTemplate.findOne(query, ExplorationJob.class);
        return explorationJob;
    }

(6) 검색

mongoTemplate.findAll(TableExploration.class);

(7) 멀티 기준 동적 쿼리

public List<ExplorationJob> getExplorationByCondition(ExplorationJob explorationJob) {
        Query query = new Query();
        if (explorationJob.getJobName() != null) {
             Pattern pattern = Pattern.compile("^.*" + explorationJob.getJobName() + ".*$", Pattern.CASE_INSENSITIVE);
             query.addCriteria(Criteria.where("jobName").regex(pattern));
        }
        if (explorationJob.getDsType() != null) {
            query.addCriteria(Criteria.where("dsType").is(explorationJob.getDsType()));
        }
        if (explorationJob.getExecutionStatus() != null) {
             query.addCriteria(Criteria.where("executionStatus").lte(explorationJob.getExecutionStatus()));
        }
        List<ExplorationJob> explorationJobs=mongoTemplate.find(query, ExplorationJob.class);
        return explorationJobs;
    }

(8)은 최대 질의

public Date getMaxExplorationDate(String tableName) {
        FindIterable<Document> iterable = mongoTemplate.getCollection("tableExploration")
                .find(new BasicDBObject("tableName", tableName)).sort(new BasicDBObject("explorationDate", -1)).skip(0)
                .limit(1);
        Document doc =null;
        if (getDocuments(iterable).size()>0) {
            doc=getDocuments(iterable).get(0);
            Date date = doc.getDate("explorationDate");
            return date;
        }else {
            return null;
        }
    }

    /**
     * 工具方法
     * 
     * @param iterable
     * @return
     */
    public static List<Document> getDocuments(FindIterable<Document> iterable) {
        List<Document> results = new ArrayList<Document>();
        if (null != iterable) {
            MongoCursor<Document> cursor = iterable.iterator();
            Document doc = null;
            while (cursor.hasNext()) {
                doc = cursor.next();
                results.add(doc);
            }
        }
        return results;
    }

(사용이 종류의 제조) 쿼리를 그룹화 (9)

public List<TableExploration> getAllTableExplorationGroupByTableName(String jobId){
        Aggregation aggregation = Aggregation.newAggregation(
                Aggregation.match(Criteria.where("jobId").is(jobId)),
                Aggregation.sort(new Sort(Direction.DESC,"explorationDate")),
                Aggregation.group("tableName")
                .first("_id").as("tableName")
                .first("databaseType").as("databaseType")
                .first("databaseName").as("databaseName")
                .first("networkSituation").as("networkSituation")
                .first("userName").as("userName")
                .first("password").as("password")
                .first("url").as("url")
                .first("dataStorage").as("dataStorage")
                .first("dataIncrement").as("dataIncrement")
                .first("explorationDate").as("explorationDate")
                //.push("columnExplorations").as("columnExplorations")
                .first("jobId").as("jobId")
                );
        AggregationResults<TableExploration> aggregationResults= mongoTemplate.aggregate(aggregation, "tableExploration", TableExploration.class);
        List<TableExploration> tableExplorations=aggregationResults.getMappedResults();
        return tableExplorations;

                                                                                                                                                                                                【常用操作总结完毕】