脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 数据库 → MongoDB → mongodb出现_class字段

如何去掉保存mongodb数据时出现的_class字段

 更新时间：2024年02月22日 08:43:15   作者：huas_mcfeng  
这篇文章主要给大家介绍了如何去掉保存mongodb数据时出现的_class字段,文中通过代码示例给大家介绍的非常详细,对大家的学习或工作有一定的帮助,需要的朋友可以参考下

配置如下：

application.yml文件内容如下

spring:
  data:
    mongodb:
      host: 192.168.9.234 #指定MongoDB服务地址
      port: 27017 #指定端口，默认就为27017
      database: blog #指定使用的数据库(集合)
      authentication-database: admin # 登录认证的逻辑库名
      username: admin #用户名
      password: 123456 #密码
  main:
    banner-mode: off
server:
  port: 8080

公共类如下

IBasicDao类：

package com.zingrow.blog.common;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import java.util.List;

public interface IBasicDao<T> {
    /**
     * 查询数据
     *
     * @param query
     * @return
     */

    List<T> find(Query query);

    /**
     * 分页查询
     *
     * @param query
     * @param start
     * @param size
     * @return
     */
    List<T> findList(Query query, int start, int size);


    /**
     * 根据ID查询
     *
     * @param id
     * @return
     */
    T findOne(String id);

    /**
     * 插入一条数据
     *
     * @param entity
     */
    void insert(T entity);

    /**
     * 更新数据
     *
     * @param query
     * @param update
     * @return
     */
    UpdateResult update(Query query, Update update);

    /**
     * 根据实体类删除数据
     *
     * @param entity
     * @return
     */
    DeleteResult delete(T entity);


    /**
     * 根据query删除数据
     *
     * @param query
     * @return
     */

    DeleteResult remove(Query query);

    long count();

    long count(Query query);

    void save(T entity);

    List<T> findAll();

    List<T> findByKeyAndValue(String key, String Value);

    List<T> findByKeyAndValue(String key, String Value, int start, int limit);

    void upsert(Query query, Update update);

    MongoTemplate getMongoTemplate();
}

其实现类BasicDao内容如下

package com.zingrow.blog.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) {
        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(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;
    }
}

实体类（Article）如下

package com.zingrow.blog.entity;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "article")
public class Article {

    @Id
    private String id;
    private String title;
    private String classify;
    private String content;
    private String time;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getClassify() {
        return classify;
    }

    public void setClassify(String classify) {
        this.classify = classify;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    public Article(String id, String title, String classify, String content, String time) {
        this.id = id;
        this.title = title;
        this.classify = classify;
        this.content = content;
        this.time = time;
    }

    @Override
    public String toString() {
        return "Article{" +
                "id='" + id + '\'' +
                ", title='" + title + '\'' +
                ", classify='" + classify + '\'' +
                ", content='" + content + '\'' +
                ", time='" + time + '\'' +
                '}';
    }
}

服务实现类（ArticleServiceImpl）

package com.zingrow.blog.service;
import com.zingrow.blog.common.BasicDao;
import com.zingrow.blog.entity.Article;
import org.springframework.stereotype.Service;

@Service
public class ArticleServiceImpl extends BasicDao<Article> {
}

控制类（ArticleController）

package com.zingrow.blog.contronller;
import com.zingrow.blog.entity.Article;
import com.zingrow.blog.service.ArticleServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(value = "*", maxAge = 300)
public class ArticleController {
    @Autowired
    private ArticleServiceImpl articleService;
    @GetMapping("add")
    public String add(Article article) {
        articleService.insert(article);
        return article.toString();
    }
}

成功插入数据后

发现多了个_class字段，解决办法如下

新建配置类（MongoConfig）

package com.zingrow.blog.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.DbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

@Configuration
public class MongoConfig {

    @Bean(name = "mongoTemplate")
    public MongoTemplate mongoTemplate(MongoDatabaseFactory mongoDatabaseFactory, MongoMappingContext mongoMappingContext) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDatabaseFactory);
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, mongoMappingContext);
        //去掉_class字段
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return new MongoTemplate(mongoDatabaseFactory,mappingConverter);
    }
}

结果如下

失败案例：

新建配置类（在实际项目引入时可能会报MongoDbFactory已被废弃）

@Configuration
public class MongoConfig {
 
    @Bean
    public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory, MongoMappingContext context, BeanFactory beanFactory) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
        try {
            mappingConverter.setCustomConversions(beanFactory.getBean(CustomConversions.class));
        } catch (NoSuchBeanDefinitionException ignore) {
        }
 
        // Don't save _class to mongo
        mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
        return mappingConverter;

以上就是如何去掉保存mongodb数据时出现的_class字段的详细内容，更多关于mongodb出现_class字段的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Mongodb单字段索引应用详解

    Mongodb单字段索引应用详解

    mongodb支持在文档中的任何一个字段建立单字段索引,包括文档的顶级字段,针对嵌入式文档建立索引或者针对嵌入式文档的某个字段建立索引,本文给大家介绍Mongodb单字段索引的相关知识,感兴趣的朋友一起看看吧
    2024-07-07
  • Mongodb的oplog详解

    Mongodb的oplog详解

    这篇文章主要介绍了Mongodb的oplog详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2019-07-07
  • MongoDB的mongo shell常用操作方法及操作脚本笔记

    MongoDB的mongo shell常用操作方法及操作脚本笔记

    mongo shell即相当于SQL语句在关系型数据库中的作用,MongoDB使用JavaScript作为shell操作命令,这里我们就来整理MongoDB的mongo shell常用操作方法及操作脚本笔记
    2016-07-07
  • MongoDB副本集丢失数据的测试实例教程

    MongoDB副本集丢失数据的测试实例教程

    这篇文章主要给大家介绍了关于MongoDB副本集丢失数据的测试的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用MongoDB具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
    2019-05-05
  • MongoDB 事务支持详解

    MongoDB 事务支持详解

    这篇文章主要介绍了MongoDB 事务支持详解的相关资料,需要的朋友可以参考下
    2022-12-12
  • Mongodb 启动命令mongod参数说明（中文翻译）

    Mongodb 启动命令mongod参数说明（中文翻译）

    这篇文章主要介绍了Mongodb 启动命令mongod参数说明（中文翻译）的相关资料,需要的朋友可以参考下
    2016-10-10
  • 开发分布式医疗挂号系统MongoDB集成实现上传医院接口

    开发分布式医疗挂号系统MongoDB集成实现上传医院接口

    这篇文章主要介绍了开发分布式医疗挂号系统MongoDB集成实现上传医院接口，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-04-04
  • MongoDB释放空闲空间的几种常用方法

    MongoDB释放空闲空间的几种常用方法

    这篇文章主要给大家介绍了关于MongoDB释放空闲空间的几种常用方法，分别包括compact、db.repairDatabase()、secondary节点重同步以及db.copyDatabase()这几种方法，需要的朋友可以参考借鉴，下面来一起看看吧
    2018-07-07
  • 数据库MongoDB启动的三种方式

    数据库MongoDB启动的三种方式

    MongoDB是一个流行的分布式文档型数据库,用于存储非结构化数据,本文给大家总结了数据库MongoDB启动的三种方式,讲解的非常详细,具有一定的参考价值,需要的朋友可以参考下
    2024-07-07
  • MongoDB搭建高可用集群的完整步骤（3个分片+3个副本）

    MongoDB搭建高可用集群的完整步骤（3个分片+3个副本）

    这篇文章主要给大家介绍了关于MongoDB搭建高可用集群（3个分片+3个副本）的完整步骤，文中通过示例代码介绍的非常详细，对大家学习或者使用MongoDB具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
    2019-08-08

最新评论