在Spring Boot应用中处理和存储非结构化的JSON数据，可以通过如下的几种方式来进行处理。

• 通过MongoDB进行存储
• 通过结构化的JSON字段存储
• 通过ElasticSearch进行存储

下面我们就来详细介绍一下这几种实现方式的具体实现。

使用MongoDB

MongoDB是一个文档数据库，适合存储非结构化的JSON数据，我们可以通过Spring Data MongoDB来实现非结构化JSON数据的存储。

首先需要引入POM依赖配置，如下所示。

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

添加MongoDB的数据库链接

spring.data.mongodb.uri=mongodb://localhost:27017/yourdatabase

创建一个用来进行测试存储的文档类型数据，如下所示。

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "yourcollection")
public class JsonDocument {
    @Id
    private String id;
    private Map<String, Object> data;

    // getters and setters
}

创建数据库访问层的对象，来进行数据存储操作。

//持久层访问
import org.springframework.data.mongodb.repository.MongoRepository;

public interface JsonDocumentRepository extends MongoRepository<JsonDocument, String> {
}

// 服务层访问
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class JsonDocumentService {
    @Autowired
    private JsonDocumentRepository repository;

    public JsonDocument save(Map<String, Object> jsonData) {
        JsonDocument document = new JsonDocument();
        document.setData(jsonData);
        return repository.save(document);
    }
}

关系型数据库中的JSON字段存储

PostgreSQL和MySQL中都支持对于JSON数据的存储，可以存储非结构化的JSON数据。如下所示。

可以引入PostgreSQL依赖，通过PostgreSQL来实现。

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

创建一个实体类用来存储非结构的JSON数据，如下所示。

@Entity
@TypeDef(name = "jsonb", typeClass = JsonBinaryType.class)
public class JsonEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Type(type = "jsonb")
    @Column(columnDefinition = "jsonb")
    private Map<String, Object> data;

    // getters and setters
}

调用持久层框架来进行JSON数据的存储，如下所示。

//数据存储
import org.springframework.data.jpa.repository.JpaRepository;

public interface JsonEntityRepository extends JpaRepository<JsonEntity, Long> {
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class JsonEntityService {
    @Autowired
    private JsonEntityRepository repository;

    public JsonEntity save(Map<String, Object> jsonData) {
        JsonEntity entity = new JsonEntity();
        entity.setData(jsonData);
        return repository.save(entity);
    }
}

动态存储（ElasticSearch）

在之前的文章中有提到，ElasticSearch是一个分布式搜索和分析引擎，并且支持存储和查询非结构化的JSON数据，而且性能表现还不错。

第一步、引入ElasticSearch的POM依赖配置，如下所示。

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

在application.properties中配置ElasticSearch的连接，如下所示。

spring.elasticsearch.rest.uris=http://localhost:9200

第三步、创建需要存储的文档对象类，如下所示。

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import java.util.Map;

@Document(indexName = "yourindex")
public class JsonElasticDocument {
    @Id
    private String id;
    private Map<String, Object> data;

    // getters and setters
}

第四步、创建数据存储操作，如下所示。

import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

public interface JsonElasticDocumentRepository extends ElasticsearchRepository<JsonElasticDocument, String> {
}

//数据存储
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class JsonElasticDocumentService {
    @Autowired
    private JsonElasticDocumentRepository repository;

    public JsonElasticDocument save(Map<String, Object> jsonData) {
        JsonElasticDocument document = new JsonElasticDocument();
        document.setData(jsonData);
        return repository.save(document);
    }
}

总结

以上这些方法实现都可以解决在SpringBoot中动态的存储非结构化的JSON数据的需求，当然我们也可以使用Redis等一些缓存来完成持久化存储的需求，但是实际需要根据具体需求和系统环境来选择合适的实现方案。