Spring Boot mongodb integrated database

One. Know MongoDB
MongoDB is a product with function between relational databases and non-relational databases, non-relational database functions among the richest and most like a relational database. It supports data structure is very loose, the json bson similar format, it is possible to store more complex data types. Mongo biggest feature is that it supports very powerful query language, its syntax is somewhat similar to the object-oriented query language, most of the functionality can be achieved almost single-table queries similar to a relational database, but also support for data indexing.
two. Spring boot project integration mongodb
1. Add rely mongodb

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

Configuring the connection mongodb

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

Analysis: uri above represent the local configuration and remote connections
3. Operation database
(1) Save

@Repository
public class ExplorationJobDao {

    @Autowired
    MongoTemplate mongoTemplate;

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

(2) a modified based on the ID data (ID data in line with the principle first, and then delete the first query results)

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) a plurality of data modification in accordance with Article (ID data are consistent with all the query, then all data modifications)

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) Delete (delete according to ID)

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

(5) The conditions of a query (query by 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) Search

mongoTemplate.findAll(TableExploration.class);

(7) multi-criteria dynamic query

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) queries the maximum

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) grouping queries (where use is made of the sort)

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;

                                                                                                                                                                                                【常用操作总结完毕】