Spring-Boot 整合MongoDB

缺乏、安全感 2024-03-26 18:14 23阅读 0赞

## Spring-Boot 整合MongoDB ##

#### 一、引入MongoDB依赖 ####

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

#### 二、配置yml文件 ####

#mongodb配置
    spring:
      data:
        mongodb:
          host: 127.0.0.1 #指定MongoDB服务地址
          port: 27017 #指定端口，默认就为27017
          database: article #指定使用的数据库(集合)
          authentication-database: admin # 登录认证的逻辑库名
          username: admin #用户名
          password: abc123456 #密码
    
    
          # uri: mongodb://<username>:<password>@127.0.0.1:27017/test
    #      uri: mongodb://@127.0.0.1:27017/test

#### 三、编写IBasicDao公共类 ####

#### 四、编写BasicDao公共类 ####

package com.example.demomoudle.common;
    
    import com.mongodb.client.result.DeleteResult;
    import com.mongodb.client.result.UpdateResult;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Sort;
    import org.springframework.data.mongodb.core.MongoTemplate;
    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 java.lang.reflect.ParameterizedType;
    import java.util.List;
    
    public class BasicDao<T> implements IBasicDao<T> {
        
    
        private Class<T> clazz;
    
        public BasicDao() {
        
            ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
            clazz = (Class<T>) type.getActualTypeArguments()[0];
        }
    
        @Autowired
        private MongoTemplate mongoTemplate;
    
        @Override
        public List<T> find(Query query) {
        
            return mongoTemplate.find(query, clazz);
        }
    
        @Override
        public List<T> findList(Query query, int start, int size) {
        
    
            //按照id升序排序
    //        query.with(Sort.by(Sort.Order.asc("_id")));
    
    //        改写了上面的方法， 注意观察是否会报错
            query.with(Sort.by(new Sort.Order(Sort.Direction.ASC, "_id")))
                    .skip(start)
                    .limit(size);
            return mongoTemplate.find(query, clazz);
        }
    
        @Override
        public T findOne(String id) {
        
            Query query = new Query();
    //        query.addCriteria(Criteria.where("id").is(id));
            query.addCriteria(new Criteria("_id").is(id));
            return mongoTemplate.findOne(query, clazz);
        }
    
        @Override
        public void insert(T entity) {
        
            mongoTemplate.insert(entity);
        }
    
        @Override
        public UpdateResult update(Query query, Update update) {
        
            return mongoTemplate.updateMulti(query, update, clazz);
        }
    
        @Override
        public DeleteResult delete(T entity) {
        
            return mongoTemplate.remove(entity);
        }
    
        @Override
        public DeleteResult remove(Query query) {
        
            return mongoTemplate.remove(query, clazz);
        }
    
        public DeleteResult remove(String id) {
        
            Query query = new Query();
            query.addCriteria(Criteria.where("id").is(id));
            return mongoTemplate.remove(query, clazz);
        }
    
        @Override
        public long count() {
        
            Query query = new Query();
            return mongoTemplate.count(query, clazz);
        }
    
        @Override
        public long count(Query query) {
        
            return mongoTemplate.count(query, clazz);
        }
    
        @Override
        public void save(T entity) {
        
            mongoTemplate.save(entity);
        }
    
        @Override
        public List<T> findAll() {
        
            Query query = new Query();
            return find(query);
        }
    
        @Override
        public List<T> findByKeyAndValue(String key, String Value) {
        
            Query query = new Query(Criteria.where(key).is(Value));
    
            return mongoTemplate.find(query, clazz);
        }
    
        @Override
        public List<T> findByKeyAndValue(String key, String Value, int start, int limit) {
        
            Query query = new Query(Criteria.where(key).is(Value));
            query.skip(start).limit(limit);
            return mongoTemplate.find(query, clazz);
        }
    
        @Override
        public void upsert(Query query, Update update) {
        
            mongoTemplate.upsert(query, update, clazz);
        }
    
        @Override
        public MongoTemplate getMongoTemplate() {
        
            return mongoTemplate;
        }
    }

#### 五、新建实体类 ####

package com.example.demomoudle.entity;
    
    
    import io.swagger.annotations.ApiModel;
    import org.springframework.data.annotation.Id;
    import org.springframework.data.mongodb.core.mapping.Document;
    
    @ApiModel("用户管理表")
    @Document(collection = "userTable")
    public class User {
        
        @Id
        private String id;
        private String username;
        private String password;
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public String getUsername() {
        
            return username;
        }
    
        public void setUsername(String username) {
        
            this.username = username;
        }
    
        public String getPassword() {
        
            return password;
        }
    
        public void setPassword(String password) {
        
            this.password = password;
        }
    }

#### 六、编写Service类和ServiceImpl实现类 ####

package com.example.demomoudle.service;
    
    import com.example.demomoudle.common.IBasicDao;
    import com.example.demomoudle.entity.User;
    
    public interface userService extends IBasicDao<User> {
        
    }

package com.example.demomoudle.service.impl;
    
    import com.example.demomoudle.common.BasicDao;
    import com.example.demomoudle.service.userService;
    import com.example.demomoudle.entity.User;
    import org.springframework.stereotype.Repository;
    import org.springframework.stereotype.Service;
    
    @Service(value = "userService")
    public class userServiceImpl extends BasicDao<User> implements userService {
        
    }

#### 七、编写contronller类 ####

package com.example.demomoudle.contronller;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.example.demomoudle.Tools.QueryTools;
    import com.example.demomoudle.entity.User;
    import com.example.demomoudle.service.impl.userServiceImpl;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    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.web.bind.annotation.*;
    
    import java.util.List;
    
    @Api(tags = "用户管理")
    @RestController()
    @RequestMapping("/user")
    @CrossOrigin(value = "*", maxAge = 3600)
    public class userController {
        
    
        @Autowired
        private userServiceImpl userService;
    
        /**
         * 新增
         */
        @ApiOperation("新增")
        @GetMapping("add")
        public void add(User user) {
        
            userService.insert(user);
        }
    
        /**
         * 修改
         */
        @ApiOperation("修改")
        @PostMapping("update")
        public void update(@RequestParam("id") String id, @RequestBody User user) {
        
    
            Query query = new Query(Criteria.where("id").is(id));
    
            Update update = new Update();
            String str = JSON.toJSONString(user);
            JSONObject jQuery = JSON.parseObject(str);
            jQuery.forEach((key, value) -> {
        
                //因为id相当于传统数据库中的主键，这里使用时就不支持更新，所以需要剔除掉
                if (!key.equals("id")) {
        
                    update.set(key, value);
                }
            });
            userService.update(query, update);
        }
    
        /**
         * 根据id查询
         */
        @ApiOperation("根据ID查询")
        @GetMapping("findOne/{id}")
        public List<User> findOne(@PathVariable(name = "id") String id) {
        
            List<User> list = userService.find(QueryTools.getUserById(id));
            return list;
    
        }
    
        /**
         * 分页查询全部数据
         */
        @ApiOperation("分页查询")
        @GetMapping("/find")
        public List<User> find(int start, int sum) {
        
            List<User> users = userService.find(QueryTools.findByPages(start, sum));
            return users;
        }
    
        /**
         * 根据Id删除
         */
        @ApiOperation("删除")
        @GetMapping("delete")
        public void remove(String id) {
        
            userService.remove(QueryTools.removeById(id));
        }
    
    }

#### 八、编写工具类，方便按照不同的查询条件生成Query ####

package com.example.demomoudle.Tools;
    
    import org.springframework.data.mongodb.core.query.Criteria;
    import org.springframework.data.mongodb.core.query.Query;
    
    import java.util.HashMap;
    
    public class QueryTools {
        
    
    
        public static Query getUserById(String id) {
        
            Query query = new Query();
            query.addCriteria(Criteria.where("id").is(id));
            return query;
        }
    
        public static Query removeById(String id) {
        
            Query query = new Query();
            query.addCriteria(Criteria.where("id").is(id));
            return query;
        }
    
        public static Query findByPages(int start, int sum) {
        
            Query query = new Query();
            query.skip(start);
            query.limit(sum);
            return query;
    
        }
    
        public static Query getQueryByTitle(int page, int size, String title) {
        
            Query query = new Query();
            //设置起始
            query.skip(page - 1 * size);
            //设置条数
            query.limit(size);
            query.addCriteria(Criteria.where("title").regex(".*?" + title + ".*"));
            return query;
        }
    
        public static Query queryByParamsMap(HashMap<String, String> maps) {
        
            Query query = new Query();
            for (String key : maps.keySet()) {
        
                query.addCriteria(Criteria.where(key).is(maps.get(key)));
            }
            return query;
        }
    
        public static Query querySearch(String id, Integer page, Integer size, String evalue) {
        
            Query query = new Query();
            query.skip((page - 1) * size);
            query.limit(size);
            if (evalue.equals("yes") || evalue == "yes") {
        
                query.addCriteria(Criteria.where("props.score").exists(true));
            } else if (evalue.equals("no") || evalue == "no") {
        
                query.addCriteria(Criteria.where("props.score").exists(false));
            }
            query.addCriteria(Criteria.where("id").is(id));
            return query;
        }
    
        public static Query querySearchOr(String name, Long startTime, Long endTime) {
        
            Query query = new Query();
            Criteria criteria = new Criteria();
    
            Criteria criteriaOr = new Criteria();
    
            Criteria[] criterias = new Criteria[2];
            if (name != null) {
        
                criterias[0] = Criteria.where("showName").regex(".*?" + name + ".*");
                criterias[1] = Criteria.where("name").regex(".*?" + name + ".*");
                criteriaOr.orOperator(criterias);
                query.addCriteria(criteriaOr);
            }
    
            query.addCriteria(criteria.and("time").gte(startTime).lte(endTime));
            return query;
        }
    }