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

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

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();
}

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;
    }
}

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 + '\'' +
                '}';
    }
}

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> {
}

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();
    }
}

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);
    }
}

@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;