springboot 整合MongoDB

springboot 整合MongoDB

一 ，maven依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
</dependency>
<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
</dependency>
<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
</dependency>

二 ，application.properties

spring.application.name=spring-boot-mongodb
spring.data.mongodb.uri=mongodb://127.0.0.1:27017/test
server.port=8888

三，代码开发

1 ，首先是实体类，@Document(collection = “user”)会在MongoDB中对应生成user集合，@Id主键

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

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

@Setter
@Getter
@Document(collection = "user")
public class UserEntity implements Serializable {
    @Id
    private Long id;

    private String name;

    private String age;

    private String sex;

    private String homeAddress;

    private String workAddress;

    private String salary;

    private String[] likeSport;

    private String[] likeFood;

    private String[] likeCourse;

    private String tel;
    private TeacherEntity teacher;

    private List<TeacherEntity> teachers;
}

2 service

import com.mongodb.client.result.DeleteResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.LookupOperation;
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 org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class MongoDBService {
    @Autowired
     private MongoTemplate mongoTemplate;
    public UserEntity mongoDBAdd(UserEntity ue){
        return mongoTemplate.save(ue);
    }

    public DeleteResult mongoDBRemove(UserEntity ue){
        return mongoTemplate.remove(ue);
    }

    public String mongoDBUpdate(UserEntity ue){
        Query query = new Query(Criteria.where("id").is(ue.getId()));

        Update update = new Update();
        update.set("tel",ue.getTel());

        mongoTemplate.updateFirst(query, update, UserEntity.class);
        return "ok";
    }

    public UserEntity mongoDBQuery(UserEntity ue){
        Query query = new Query(Criteria.where("id").is(ue.getId()));
        UserEntity demoEntity = mongoTemplate.findOne(query, UserEntity.class);

        Query query1 = new Query(Criteria.where("id").gt(ue.getId()));
        List<UserEntity> lists = mongoTemplate.find(query1, UserEntity.class);

        Query query2 = new Query(new Criteria().orOperator(
                Criteria.where("id").is(ue.getId()),
                new Criteria().andOperator(
                        Criteria.where("name").is(ue.getName()),
                        Criteria.where("age").is(ue.getAge())
                )
            )
        );
        List<UserEntity> lists2 = mongoTemplate.find(query2, UserEntity.class);
        return demoEntity;
    }

    public UserEntity mongoDBLookUpQuery(UserEntity ue){
        LookupOperation lookupOperation= LookupOperation.newLookup().
                from("teacher").  //关联从表名
                localField("userid").     //主表关联字段
                foreignField("teacherid").//从表关联的字段
                as("result");   //查询结果名
//组合筛选条件Criteria ，从联表查询结果中筛选需要的结果
//       Criteria criteria0=Criteria.where("xxx").is(xx);   
//        Criteria criteria1=Criteria.where("xxx").is(xx);
 //       AggregationOperation match1= Aggregation.match(criteria1);
//        AggregationOperation match = Aggregation.match(criteria0);
//        Aggregation resultCriteria= Aggregation.newAggregation(match1,lookupOperation,match).;
        Aggregation aggregation=Aggregation.newAggregation(lookupOperation);
        //聚合查询必须是查询的主表名“user”，从表名在lookUpOpretion中以确定
        List<AggUserEntity> results = mongoTemplate.aggregate(aggregation,"user", AggUserEntity.class).getMappedResults();
        
        return null;
    }

    public UserEntity mongoDBAggQuery(UserEntity ue){

        Aggregation aggregation=Aggregation.newAggregation(
                Aggregation.project("age","homeAddress","workAddress"),
                Aggregation.match(Criteria.where("homeAddress").is(ue.getHomeAddress())),             
                Aggregation.group("age").count().as("ldd").last("homeAddress").as("homeAddress").last("workAddress").as("workAddress")
        );
        List<AggUserEntity> results = mongoTemplate.aggregate(aggregation,"user", AggUserEntity.class).getMappedResults();
        return null;
    }

}

3 controller

@RestController
@RequestMapping("/MongoDB/t")
public class MongoDBTController {
    @Autowired
    private MongdbService_t mongdbService;
    @PostMapping("add")
    public String mongoDBAdd(TeacherEntity ue){
        mongdbService.mongoDBAdd(ue);
        return "ok";
    }

    @PostMapping("remove")
    public String mongoDBRemove(TeacherEntity ue){
        mongdbService.mongoDBRemove(ue);
        return "ok";
    }

    @PostMapping("query")
    public String mongoDBQuery(TeacherEntity ue){
        mongdbService.mongoDBQuery(ue);
        return "ok";
    }

    @PostMapping("update")
    public String mongoDBUpdate(TeacherEntity ue){
        mongdbService.mongoDBUpdate(ue);
        return "ok";
    }
}