Mongodb搭建并使用

于 2023-02-07 14:32:38 发布
阅读量713 收藏
点赞数
文章标签： mongodb 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_39791232/article/details/128918065
版权

1、配置文件

1.1、添加pom文件

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

1.2、配置连接，账号密码可以自己设置

 data: 
    mongodb:
      uri: mongodb://xxx.xx.xxx.xxx:7017/uat_oms

2、创建分页MongoPage

@Data
@AllArgsConstructor
@NoArgsConstructor
public class MongoPage<T> extends MyPage{
    private long total;//总记录数
 private List<T> list;//分页结果
 private long totalSum;// 总页数
 public MongoPage(Integer pageNum,Integer pageSize){
        this.pageNum=pageNum;
 this.pageSize=pageSize;
 }
    public void setMongoPage(long total,long totalSum,List<T> list){
        this.total=total;
 this.list=list;
 this.totalSum=totalSum;
 }
}

3、创建类

@Data
public class FuzzyPage {

    //模糊查询时输入的字符串
    public String InputStr;

    //每页记录数
    public Integer pageSize;

    //页数
    public Integer pageNum;
}

4、创建类

public  class MongoMethod {
    public static final String INSERT = "INSERT";
    public static final String DELETE = "DELETE";
    public static final String UPDATE = "UPDATE";
    public static final String SELECT = "SELECT";
    public static final String PAGE = "PAGE";
    public static final String MONGOPage = "MONGOPage";
    public static final String fuzzyPage = "fuzzyPage";
    public static final String OMS_LOG = "oms_log";
}

5、创建类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class MyPage implements Serializable {
    protected Integer pageNum;//当前页
    protected Integer pageSize;//页大小
}
6、创建接口
package com.vx56.fpl.core.Mongodb;
import java.io.Serializable;
import java.util.List;
import java.util.Set;

/**
 * @author: CHENQU
 * @date:
 * @title mongodb服务接口类
 * @参数
 * @entity 实体对象
 * @collectionName 数据库中的集合名
 * @list   实体集合对象
 * @keys   键名数组
 * @values 键值数组
 * @fields 需要查询的列
 * @id     id值
 * @MyPage Page类，含有pageNum（当前页），pageSize（页大小）
 * @MongoPage MyPage的子类，多了total（总记录数）和list（实体集合）
 * @inputStr 模糊查询时输入的字符串
 * @updateTime 2022/9/28 11:34
 */

public interface MongoService<T> {

    /**
     * 查询表
     */
    Set<String> getCollectionNames();

    /**
     * 增
     */
    boolean save(T entity);

    boolean save(T entity, String collectionName);

    boolean saveList(List<T> list);

    boolean saveList(List<T> list, String collectionName);

    /**
     * 删
     */
    boolean removeById(T entity);

    boolean removeById(T entity, String collectionName);

    /**
     * 改,都是通过id
     *
     * @param keys   要修改的键名
     * @param values 要修改的键值
     *               相当于mysql中  update key1,key2,key3 set value1,value2,value3 where id=#{id} from collectionName
     */
    boolean updateById(String[] keys, Object[] values, Serializable id, Class<?> clazz);

    boolean updateById(String[] keys, Object[] values, Serializable id, String collectionName);

    boolean updateById(String[] keys, Object[] values, Serializable id, Class<?> clazz, String collectionName);

    /**
     * 查
     *
     * @finById 就是根据id查询单条记录
     * @findByMap 相当于条件查询, 查询出符合条件的所有内容
     * @findAll 查询表中所有记录
     */
    T findById(Serializable id, Class<?> clazz);

    T findById(Serializable id, Class<?> clazz, String collectionName);

    List<T> findByMap(String[] keys, Object[] values, Class<?> clazz);

    List<T> findByMap(String[] keys, Object[] values, Class<?> clazz, String collectionName);

    List<T> findAll(Class<?> clazz);

    List<T> findAll(Class<?> clazz, String collectionName);

    /**
     * 分页---无总记录数，只查一次
     */
    List<T> page(MyPage myPage, Class<?> clazz);

    List<T> page(MyPage myPage, Class<?> clazz, String collectionName);

    /**
     * 分页--有总记录数，查两次
     */
    MongoPage page(MongoPage mongoPage, Class<?> clazz);

    MongoPage page(MongoPage mongoPage, Class<?> clazz, String collectionName);

    /**
     * 模糊查询---分页
     */
    List<T> fuzzyPage(MyPage myPage, Class<?> clazz, String inputStr, String[] keys);

    List<T> fuzzyPage(MyPage myPage, Class<?> clazz, String collectionName, String inputStr, String[] keys);

    /**
     * 模糊查询---分页--有总记录数，查两次
     */
    MongoPage fuzzyPage(FuzzyPage fuzzyPage, Class<?> clazz, String[] keys);

    MongoPage fuzzyPage(FuzzyPage fuzzyPage, Class<?> clazz, String collectionName, String[] keys);

}

7、创建接口实现类

@Slf4j
@Service
public class MongoServiceImpl<T> implements MongoService<T> {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public Set<String> getCollectionNames() {
        try {
            Set<String> set = this.mongoTemplate.getCollectionNames();
            return set;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public boolean save(T entity) {
        try {
            mongoTemplate.save(entity);
            mongoLogByConsole(MongoMethod.INSERT, entity.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }
    @Async
    @Override
    public boolean save(T entity, String collectionName) {
        try {
            mongoTemplate.save(entity, collectionName);
            mongoLogByConsole(MongoMethod.INSERT, entity.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean saveList(List<T> list) {
        try {
            mongoTemplate.insertAll(list);
            mongoLogByConsole(MongoMethod.INSERT, list.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean saveList(List<T> list, String collectionName) {
        try {
            mongoTemplate.insert(list, collectionName);
            mongoLogByConsole(MongoMethod.INSERT, list.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean removeById(T entity) {
        try {
            mongoTemplate.remove(entity);
            mongoLogByConsole(MongoMethod.DELETE, entity.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean removeById(T entity, String collectionName) {
        try {
            mongoTemplate.remove(entity, collectionName);
            mongoLogByConsole(MongoMethod.DELETE, collectionName + ":" + entity.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean updateById(String[] keys, Object[] values, Serializable id, Class<?> clazz) {
        Criteria criteria = Criteria.where("_id").is(id);
        Query query = new Query(criteria);
        Update update = new Update();
        for (int i = 0; i < keys.length; i++) {
            update.set(keys[i], values[i]);
        }
        try {
            mongoTemplate.updateFirst(query, update, clazz);
            mongoLogByConsole(MongoMethod.UPDATE, update.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean updateById(String[] keys, Object[] values, Serializable id, String collectionName) {
        Criteria criteria = Criteria.where("_id").is(id);
        Query query = new Query(criteria);
        Update update = new Update();
        for (int i = 0; i < keys.length; i++) {
            update.set(keys[i], values[i]);
        }
        try {
            mongoTemplate.updateFirst(query, update, collectionName);
            mongoLogByConsole(MongoMethod.UPDATE, update.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public boolean updateById(String[] keys, Object[] values, Serializable id, Class<?> clazz, String collectionName) {
        Criteria criteria = Criteria.where("_id").is(id);
        Query query = new Query(criteria);
        Update update = new Update();
        for (int i = 0; i < keys.length; i++) {
            update.set(keys[i], values[i]);
        }
        try {
            mongoTemplate.updateFirst(query, update, clazz, collectionName);
            mongoLogByConsole(MongoMethod.UPDATE, update.toString());
            return true;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return false;
        }
    }

    @Override
    public T findById(Serializable id, Class<?> clazz) {
        T result;
        try {
            Criteria criteria = Criteria.where("_id").is(id);
            Query query = Query.query(criteria);
            result = (T) mongoTemplate.findOne(query, clazz);
            mongoLogByConsole(MongoMethod.SELECT, result.toString());
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public T findById(Serializable id, Class<?> clazz, String collectionName) {
        T result;
        try {
            Criteria criteria = Criteria.where("_id").is(id);
            Query query = Query.query(criteria);
            result = (T) mongoTemplate.findOne(query, clazz, collectionName);
            mongoLogByConsole(MongoMethod.SELECT, result.toString());
            return result;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> findByMap(String[] keys, Object[] values, Class<?> clazz) {
        Criteria criteria = null;
        List<T> list;
        try {
            for (int i = 0; i < keys.length; i++) {
                if (i == 0) {
                    criteria = Criteria.where(keys[i]).is(values[i]);
                } else {
                    criteria.and(keys[i]).is(values[i]);
                }
            }
            Query query = Query.query(criteria);
            list = (List<T>) mongoTemplate.find(query, clazz);
            mongoLogByConsole(MongoMethod.SELECT, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> findByMap(String[] keys, Object[] values, Class<?> clazz, String collectionName) {
        Criteria criteria = null;
        List<T> list;
        try {
            for (int i = 0; i < keys.length; i++) {
                if (i == 0) {
                    criteria = Criteria.where(keys[i]).is(values[i]);
                } else {
                    criteria.and(keys[i]).is(values[i]);
                }
            }
            Query query = Query.query(criteria);
            list = (List<T>) mongoTemplate.find(query, clazz, collectionName);
            mongoLogByConsole(MongoMethod.SELECT, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }


    @Override
    public List<T> findAll(Class<?> clazz) {
        List<T> list;
        try {
            list = (List<T>) mongoTemplate.findAll(clazz);
            mongoLogByConsole(MongoMethod.SELECT, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> findAll(Class<?> clazz, String collectionName) {
        List<T> list;
        try {
            list = (List<T>) mongoTemplate.find(new Query(), clazz, collectionName);
            mongoLogByConsole(MongoMethod.SELECT, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> page(MyPage myPage, Class<?> clazz) {
        Integer pageSize = myPage.getPageSize();
        Integer pageNum = myPage.getPageNum();
        List<T> list;
        try {
            Query query = new Query(new Criteria());
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz);
            mongoLogByConsole(MongoMethod.PAGE, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> page(MyPage myPage, Class<?> clazz, String collectionName) {
        Integer pageSize = myPage.getPageSize();
        Integer pageNum = myPage.getPageNum();
        List<T> list;
        try {
            Query query = new Query(new Criteria());
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz, collectionName);
            mongoLogByConsole(MongoMethod.PAGE, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }


    @Override
    public MongoPage page(MongoPage mongoPage, Class<?> clazz) {
        Integer pageSize = mongoPage.getPageSize();
        Integer pageNum = mongoPage.getPageNum();
        long total;
        List<T> list;
        try {
            Query query = new Query(new Criteria());
            //返回总记录数
            total = mongoTemplate.count(query, clazz);
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz);
            mongoPage.setMongoPage(total, getTotalSum(total, pageSize), list);
            mongoLogByConsole(MongoMethod.MONGOPage, mongoPage.toString());
            return mongoPage;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public MongoPage page(MongoPage mongoPage, Class<?> clazz, String collectionName) {
        Integer pageSize = mongoPage.getPageSize();
        Integer pageNum = mongoPage.getPageNum();
        long total;
        List<T> list;
        try {
            Query query = new Query(new Criteria());
            //返回总记录数
            total = mongoTemplate.count(query, clazz);
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz, collectionName);
            mongoPage.setMongoPage(total, getTotalSum(total, pageSize), list);
            mongoLogByConsole(MongoMethod.MONGOPage, mongoPage.toString());
            return mongoPage;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> fuzzyPage(MyPage myPage, Class<?> clazz, String inputStr, String[] keys) {
        Integer pageSize = myPage.getPageSize();
        Integer pageNum = myPage.getPageNum();
        List<T> list;
        try {
            if (judgeLength(keys.length)) {
                return null;
            }
            Query query = new Query(getCriteria(inputStr, keys));
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz);
            mongoLogByConsole(MongoMethod.fuzzyPage, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public List<T> fuzzyPage(MyPage myPage, Class<?> clazz, String collectionName, String inputStr, String[] keys) {
        Integer pageSize = myPage.getPageSize();
        Integer pageNum = myPage.getPageNum();
        List<T> list;
        try {
            if (judgeLength(keys.length)) {
                return null;
            }
            Query query = new Query(getCriteria(inputStr, keys));
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz, collectionName);
            mongoLogByConsole(MongoMethod.fuzzyPage, list.toString());
            return list;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public MongoPage fuzzyPage(FuzzyPage fuzzyPage, Class<?> clazz, String[] keys) {
        String inputStr = fuzzyPage.getInputStr();
        Integer pageSize = fuzzyPage.getPageSize();
        Integer pageNum = fuzzyPage.getPageNum();
        long total;
        List<T> list;
        MongoPage mongoPage = new MongoPage(pageNum, pageSize);
        try {
            if (judgeLength(keys.length)) {
                return null;
            }
            Query query = new Query(getCriteria(inputStr, keys));
            //返回总记录数
            total = mongoTemplate.count(query, clazz);
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz);
            mongoPage.setMongoPage(total, getTotalSum(total, pageSize), list);
            mongoLogByConsole(MongoMethod.fuzzyPage, mongoPage.toString());
            return mongoPage;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }

    @Override
    public MongoPage fuzzyPage(FuzzyPage fuzzyPage, Class<?> clazz, String collectionName, String[] keys) {
        String inputStr = fuzzyPage.getInputStr();
        Integer pageSize = fuzzyPage.getPageSize();
        Integer pageNum = fuzzyPage.getPageNum();
        long total;
        List<T> list;
        MongoPage mongoPage = new MongoPage(pageNum, pageSize);
        try {
            if (judgeLength(keys.length)) {
                return null;
            }
            Query query = new Query(getCriteria(inputStr, keys));
            //返回总记录数
            total = mongoTemplate.count(query, clazz);
            //默认值为5，
            pageSize = pageSize < 0 ? 5 : pageSize;
            query.limit(pageSize);
            query.skip((pageNum - 1) * pageSize);
            list = (List<T>) mongoTemplate.find(query, clazz, collectionName);
            mongoPage.setMongoPage(total, getTotalSum(total, pageSize), list);
            mongoLogByConsole(MongoMethod.fuzzyPage, mongoPage.toString());
            return mongoPage;
        } catch (Exception e) {
            log.error("mongo报错->", e);
            return null;
        }
    }


    /**
     * 用于模糊查询忽略大小写
     *
     * @param str
     * @return
     */
    private Pattern getPattern(String str) {
        Pattern pattern = Pattern.compile("^.*" + str + ".*$", Pattern.CASE_INSENSITIVE);
        return pattern;
    }

    /**
     * 用于模糊查询
     *
     * @param keys     匹配的字段数组
     * @param inputStr 输入的字符
     * @return
     */
    private Criteria getCriteria(String inputStr, String[] keys) {
        Pattern pattern = getPattern(inputStr);
        Criteria criteria = null;
        switch (keys.length) {
            case 1:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern));
                break;
            case 2:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern)
                );
                break;
            case 3:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern)
                );
                break;
            case 4:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern)
                );
                break;
            case 5:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern)
                );
                break;
            case 6:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern),
                        Criteria.where(keys[5]).regex(pattern)
                );
                break;
            case 7:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern),
                        Criteria.where(keys[5]).regex(pattern),
                        Criteria.where(keys[6]).regex(pattern)
                );
                break;
            case 8:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern),
                        Criteria.where(keys[5]).regex(pattern),
                        Criteria.where(keys[6]).regex(pattern),
                        Criteria.where(keys[7]).regex(pattern)
                );
                break;
            case 9:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern),
                        Criteria.where(keys[5]).regex(pattern),
                        Criteria.where(keys[6]).regex(pattern),
                        Criteria.where(keys[7]).regex(pattern),
                        Criteria.where(keys[8]).regex(pattern)
                );
                break;
            case 10:
                criteria = Criteria.where("").orOperator(
                        Criteria.where(keys[0]).regex(pattern),
                        Criteria.where(keys[1]).regex(pattern),
                        Criteria.where(keys[2]).regex(pattern),
                        Criteria.where(keys[3]).regex(pattern),
                        Criteria.where(keys[4]).regex(pattern),
                        Criteria.where(keys[5]).regex(pattern),
                        Criteria.where(keys[6]).regex(pattern),
                        Criteria.where(keys[7]).regex(pattern),
                        Criteria.where(keys[8]).regex(pattern),
                        Criteria.where(keys[9]).regex(pattern)
                );
                break;
        }
        return criteria;
    }

    /**
     * 用于判断keys长度
     */
    private boolean judgeLength(int length) {
        if (length > 10 || length == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取总页数
     *
     * @param total
     * @param pageSize
     * @return
     */
    private long getTotalSum(long total, Integer pageSize) {
        long totalSum = 0;
        if (total % pageSize == 0) {//能够整除
            totalSum = total / pageSize;
        } else {
            totalSum = total / pageSize + 1;
        }
        return totalSum;
    }

    /**
     * Mongodb控制台日志
     *
     * @param method
     * @param toString
     */
    private void mongoLogByConsole(String method, String toString) {
        String outPut = "MongoDB";
        switch (method) {
            case MongoMethod.INSERT:
                outPut = outPut + "  insert:" + toString;
                break;
            case MongoMethod.DELETE:
                outPut = outPut + "  delete:" + toString;
                break;
            case MongoMethod.UPDATE:
                outPut = outPut + "  update:" + toString;
                break;
            case MongoMethod.SELECT:
                outPut = outPut + "  query:" + toString;
                break;
            case MongoMethod.PAGE:
                outPut = outPut + "  page:" + toString;
                break;
            case MongoMethod.MONGOPage:
                outPut = outPut + "  mongoPage:" + toString;
                break;
            case MongoMethod.fuzzyPage:
                outPut = outPut + "  fuzzyPage:" + toString;
                break;
        }
        log.info("mongo执行类型{}" + outPut);
    }
}
8、Controller测试
@RestController
@RequestMapping("/mongo")
public class MongoDBController {

    @Autowired
    private MongoService mongoService;

    @GetMapping("/save")
    public DataResp<String> save() {
        UserTest userTest = new UserTest();
        userTest.setAge(100);
        userTest.setName("一杯冰美式丶");
        userTest.setId("63340589c1aa7ac3222e45c11500c111");
        mongoService.save(userTest);
       // mongoService.findAll(UserTest.class,"oms_log");
       /* Object resutl =mongoService.removeById(userTest, MongoMethod.OMS_LOG);*/
        /*mongoTemplate.save(userTest,"omsLog");*/
        //mongoService.findAll(UserTest.class,MongoMethod.OMS_LOG);
        return DataResp.ok(JSON.toJSONString(null));
    }

}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值