Java 如何在Spring中设置MongoDB集合的名称，而不使用'；我没有豆子课

我有一个使用MongoDB的Spring项目（Java1.8）。JSON保存在数据库中而不使用Bean类。这意味着，即使JSON结构发生更改，我也会毫无问题地保存它。 问题是为了实现这一点，我直接使用预定义的JsonNode类。这使得Spring默认采用该类的名称，并将其用作集合名称。 . 因为我没有Bean类，所以不能使用@Document（collection=“”）

我目前有一个配置文件，可以为我处理转换。 如果没有Bean类，如何修改集合名称

控制器类：

package com.envira.gijonin.centros.centros;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.envira.gijonin.centros.utils.Utils;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;

@RestController
@RequestMapping(path="api")
public class CentrosController {
    
    
    private final CentrosService centrosService;    
    
    @Autowired
    public CentrosController(CentrosService centrosService) {       
        this.centrosService = centrosService;
    }
    
    
    @PostMapping("/postcentros")
    public void guardarCentros(@RequestBody String body) throws JsonProcessingException {
        
        JsonNode jsonNode= Utils.validateJsonUsingSchema(body,"schema.json");
                
         centrosService.guardarCentros(jsonNode);
        
    }
}

服务类别：

package com.envira.gijonin.centros.centros;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.fasterxml.jackson.databind.JsonNode;

@Service
public class CentrosService {   
    
    @Autowired
    CentrosRepository rpo;
    
    public void guardarCentros(JsonNode jsonNode) {
        
        // recuperamos el campo "centros"que es el que contiene el array de centros
        JsonNode jsnArray =jsonNode.get("centros"); 
        
        for (JsonNode jsonNodeItems : jsnArray) {
            rpo.save(jsonNodeItems);
        } 
        
    }
}

存储库：

package com.envira.gijonin.centros.centros;




import org.springframework.data.mongodb.repository.MongoRepository;
import com.fasterxml.jackson.databind.JsonNode;

public interface CentrosRepository extends MongoRepository<JsonNode, String> {

}

package com.envira.gijonin.centros.centros；
导入org.springframework.data.mongodb.repository.MongoRepository；
导入com.fasterxml.jackson.databind.JsonNode；
公共接口中心存储库扩展了MongoRepository{
}

MongoConfig：

package com.envira.gijonin.centros.config;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.data.convert.WritingConverter;
import org.springframework.data.mongodb.core.convert.MongoCustomConversions;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class MongoConfig {

    @Bean
    public MongoCustomConversions mongoCustomConversions() {
        List<Converter<?, ?>> converters = new ArrayList<>();
        converters.add(JsonNodeToDocumentConverter.INSTANCE);
        converters.add(DocumentToJsonNodeConverter.INSTANCE);
        return new MongoCustomConversions(converters);
    }

    @WritingConverter
    enum JsonNodeToDocumentConverter implements Converter<JsonNode, Document> {
        INSTANCE;

        public Document convert(JsonNode source) {
            if(source == null)
                return null;

            return Document.parse(source.toString());
        }
    }

    @ReadingConverter
    enum DocumentToJsonNodeConverter implements Converter<Document, JsonNode> {
        INSTANCE;

        public JsonNode convert(Document source) {
            if(source == null)
                return null;

            ObjectMapper mapper = new ObjectMapper();
            try {
                return mapper.readTree(source.toJson());
            } catch (IOException e) {
                throw new RuntimeException("Unable to parse DbObject to JsonNode", e);
            }
        }
    }
    
    
    
}

package com.envira.gijonin.centros.config；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.List；
导入org.bson.Document；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.core.convert.converter.converter；
导入org.springframework.data.convert.ReadingConverter；
导入org.springframework.data.convert.WritingConverter；
导入org.springframework.data.mongodb.core.convert.MongoCustomConversions；
导入com.fasterxml.jackson.databind.JsonNode；
导入com.fasterxml.jackson.databind.ObjectMapper；
@配置
公共类MongoConfig{
@豆子
公共MongoCustomConversions MongoCustomConversions（）{
列表0）抛出新的RuntimeException（“请修复jason！”+错误组合）；
否则返回jsonNode；
}
}

package com.envira.gijonin.centros.utils;

import java.io.InputStream;
import java.util.Set;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;

public class Utils {
    
    private Utils() {}
    
    public static JsonNode validateJsonUsingSchema(String requestStr, String schemaPath) throws JsonProcessingException{
        
                
        InputStream schemaAsStreams = Utils.class.getClassLoader().getResourceAsStream(schemaPath);
        JsonSchema schema = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4).getSchema(schemaAsStreams);

        
        
        ObjectMapper om = new ObjectMapper();
        //om.setPropertyNamingStrategy(PropertyNamingStrategy.KEBAB_CASE);
        
        JsonNode jsonNode = om.readTree(requestStr);
                
        Set<ValidationMessage> errors = schema.validate(jsonNode);
        String errorsCombined ="";
//      for(ValidationMessage error: errors) {
//          //log.error("Validation error:{}",error);
//          errorsCombined+=error.toString()+"\n";          
//      }       
        
        if(errors.size()>0) throw new RuntimeException("Please fix your jason!"+ errorsCombined);
        else return jsonNode;       
        
    }
    
    

}