Spring Data Jpa+PostgreSQL对jsonb字段类型做映射实现

最新推荐文章于 2023-12-21 14:11:12 发布
最新推荐文章于 2023-12-21 14:11:12 发布
阅读量6.7k 收藏 9
点赞数 4
文章标签： jpa postgres json java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36599564/article/details/104015932
版权

PostgreSQL支持json字段类型，json 数据类型可以用来存储 JSON（JavaScript Object Notation）数据， 这样的数据也可以存储为 text，但是 json 数据类型更有利于检查每个存储的数值是可用的 JSON 值。

Spring Data Jpa若想使用json类型字段，需要自定义数据解析，具体实现方式就是实现UserType，重新方法实现编写解析逻辑代码解析数据以达到目的。

下面将详细说明实现方式（已测试通过）：

简单的Map格式实现：

  1. 定义自己的数据库方言
package com.cai.demo.config;

import org.hibernate.dialect.PostgreSQL95Dialect;
import java.sql.Types;

/**
 * @Description: 自定义PostgreSQL方言
 * @Author: caijun
 */
public class JsonbPostgresDialect extends PostgreSQL95Dialect {
    public JsonbPostgresDialect() {
        this.registerColumnType(Types.JAVA_OBJECT, "jsonb");
    }
}
  1. 配置自定义方言
spring:
  jpa:
    hibernate:
      database-platform: com.cai.demo.config.JsonbPostgresDialect
  1. 编写json类型转换代码
package com.cai.demo.config;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.SerializationException;
import org.hibernate.usertype.UserType;
import org.postgresql.util.PGobject;
import org.springframework.util.ObjectUtils;

import java.io.IOException;
import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.HashMap;
import java.util.Map;

/**
 * @Description: Jsonb类型转换
 * @Author: caijun
 */
public class JsonbType implements UserType {

    private final ObjectMapper mapper = new ObjectMapper();


    @Override
    public Object deepCopy(Object originalValue) throws HibernateException {
        if (originalValue != null) {
            try {
                return mapper.readValue(mapper.writeValueAsString(originalValue), returnedClass());
            } catch (IOException e) {
                throw new HibernateException("Failed to deep copy object", e);
            }
        }
        return null;
    }


    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException {
        PGobject o = (PGobject) rs.getObject(names[0]);
        // 具体实现逻辑
        if (o != null && o.getValue() != null) {
            try {
                return mapper.readValue(o.getValue(), Map.class);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return new HashMap<String, Object>();
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        Object copy = deepCopy(value);

        if (copy instanceof Serializable) {
            return (Serializable) copy;
        }

        throw new SerializationException(String.format("Cannot serialize '%s', %s is not Serializable.", value, value.getClass()), null);
    }

    @Override
    public Object assemble(Serializable cached, Object owner) throws HibernateException {
        return deepCopy(cached);
    }

    @Override
    public Object replace(Object original, Object target, Object owner) throws HibernateException {
        return deepCopy(original);
    }

    @Override
    public boolean isMutable() {
        return true;
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        if (x == null) {
            return 0;
        }

        return x.hashCode();
    }


    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws HibernateException, SQLException {
        if (value == null) {
            st.setNull(index, Types.OTHER);
        } else {
            try {
                st.setObject(index, mapper.writeValueAsString(value), Types.OTHER);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return ObjectUtils.nullSafeEquals(x, y);
    }

    @Override
    public Class<?> returnedClass() {
        return Map.class;
    }

    @Override
    public int[] sqlTypes() {
        return new int[]{Types.JAVA_OBJECT};
    }
}
  1. 实体类添加注解
@Getter
@Setter
@ToString
@Entity
@Table(name = "test_tb")
@TypeDef(name = "JsonbType", typeClass = JsonbType.class)
public class TestEntity implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * 主键id
     */
    @Id
    @Column(name = "pri_id")
    private Integer priId;

	@Column(name = "test_json_field", columnDefinition = "jsonb")
    @Type(type = "JsonbType")
    private Map<String, List<String>> testJsonField;
}

'test_json_field’字段需要存储如以下格式的数据：
{“2019-11-16”: [“0-24”], “2019-11-17”: [“0-24”], “2019-11-18”: [“0-24”]}

  1. 测试
/**
 * 测试'jsonb'字段类型映射（测试通过）
 */
@Test
public void testJsonField() {
	// jpa查询实体对象
    TestEntity testEntity = testRepository.findById(1).get();
    log.info(testEntity.toString());
    // 增加新的值
    Map<String, List<String>> map = testEntity.getTestJsonField();
    List<String> list = ImmutableList.of("8-9");
    map.put("2019-11-19", list);
    testEntity.setTestJsonField(map);
    // 保存
    testRepository.save(testEntity);
}

对象直接映射：

  1. 定义自己的数据库方言
package com.cai.demo.config;

import org.hibernate.dialect.PostgreSQL95Dialect;
import java.sql.Types;

/**
 * @Description: 自定义PostgreSQL方言
 * @Author: caijun
 */
public class JsonbPostgresDialect extends PostgreSQL95Dialect {
    public JsonbPostgresDialect() {
    	super();
        this.registerColumnType(Types.JAVA_OBJECT, "jsonb");
        registerHibernateType(Types.ARRAY, StringType.class.getName());
    }
}
  1. 配置自定义方言
spring:
  jpa:
    hibernate:
      database-platform: com.cai.demo.config.JsonbPostgresDialect
  1. 编写json类型转换代码
package com.cai.demo.config;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.hibernate.HibernateException;
import org.hibernate.boot.registry.classloading.internal.ClassLoaderServiceImpl;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.SerializationException;
import org.hibernate.usertype.ParameterizedType;
import org.hibernate.usertype.UserType;
import org.postgresql.util.PGobject;
import org.springframework.util.ObjectUtils;

import java.io.IOException;
import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Properties;

/**
 * @Description: Jsonb类型转换
 * @Author: caijun
 */
public class JsonbType implements UserType, ParameterizedType {

    private final ObjectMapper mapper = new ObjectMapper();

    private static final ClassLoaderService classLoaderService = new ClassLoaderServiceImpl();

    public static final String CLASS = "CLASS";

    private Class<?> jsonClassType;

    @Override
    public void nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session) throws HibernateException, SQLException {
        if (value == null) {
            st.setNull(index, Types.OTHER);
        } else {
            try {
                st.setObject(index, mapper.writeValueAsString(value), Types.OTHER);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    @Override
    public Object deepCopy(Object originalValue) throws HibernateException {
        if (originalValue != null) {
            try {
                return mapper.readValue(mapper.writeValueAsString(originalValue),
                        returnedClass());
            } catch (IOException e) {
                throw new HibernateException("Failed to deep copy object", e);
            }
        }
        return null;
    }

    @Override
    public Object nullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException {
        PGobject o = (PGobject) rs.getObject(names[0]);
        // 具体实现逻辑
        if (o != null && o.getValue() != null) {
            return JSON.parseObject(o.getValue(), jsonClassType);
        }
        return null;
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        Object copy = deepCopy(value);

        if (copy instanceof Serializable) {
            return (Serializable) copy;
        }

        throw new SerializationException(String.format("Cannot serialize '%s', %s is not Serializable.", value, value.getClass()), null);
    }

    @Override
    public Object assemble(Serializable cached, Object owner) throws HibernateException {
        return deepCopy(cached);
    }

    @Override
    public Object replace(Object original, Object target, Object owner) throws HibernateException {
        return deepCopy(original);
    }

    @Override
    public boolean isMutable() {
        return true;
    }

    @Override
    public int hashCode(Object x) throws HibernateException {
        if (x == null) {
            return 0;
        }

        return x.hashCode();
    }

    @Override
    public boolean equals(Object x, Object y) throws HibernateException {
        return ObjectUtils.nullSafeEquals(x, y);
    }

    @Override
    public Class<?> returnedClass() {
        return jsonClassType;
    }

    @Override
    public int[] sqlTypes() {
        return new int[]{Types.JAVA_OBJECT};
    }

    @Override
    public void setParameterValues(Properties properties) {
        final String clazz = (String) properties.get(CLASS);
        if (clazz != null) {
            jsonClassType = classLoaderService.classForName(clazz);
        }
    }
}
  1. 实体类添加注解
@Data
@Entity
@Table(name = "test_tb")
@TypeDef(name = "entityJsonbType1", typeClass = JsonbType.class, parameters = {
        @Parameter(name = JsonbType.CLASS, value = "com.cai.demo.entity.TestEntity2")
})
public class TestEntity implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * 主键id
     */
    @Id
    @Column(name = "pri_id")
    private Integer priId;

	@Column(name = "entity_json_field", columnDefinition = "jsonb")
    @Type(type = "entityJsonbType1")
    private TestEntity2 testEntityJson;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@Entity
@Table(name = "test_tb_2")
public class TestEntity2 implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
     * 主键id
     */
    @Id
    @Column(name = "pri_id")
    private Integer priId;

	@Column(name = "name")
    private String name;
}
  1. 测试
@Test
public void testJsonbEntity() {
    TestEntity testEntity = testRepository.findById(1).get();

    TestEntity2 testEntity2 = new TestEntity2(11, "testEntity2");
    // 添加
    testEntity.setTestEntityJson(testEntity2);
    testRepository.save(testEntity);

    // 修改保存
    TestEntity testEntity1_1 = testRepository.findById(1).get();
    TestEntity2 testEntity2_1 = testEntity1_1.getTestEntityJson();
    testEntity2_1.setName("testEntity2_1");
    testEntity1_1.setTestEntityJson(testEntity2_1);
    testRepository.save(testEntity1_1);

    // 删除
    TestEntity testEntity1_2 = testRepository.findById(1).get();
    testEntity1_2.setTestEntityJson(null);
    testRepository.save(testEntity1_2);
}
菜菌
关注
Spring Data JPA与PostgreSQL的jsonb类型集成与支持
汪云飞记录本
06-27 5968
在我们项目中经常会遇到数据结构不定的情况，这时普通的关系型数据库不能满足我们的要求。Postgres为我们提供了jsonb数据类型，我们可在此类型的字段存储json数据，并可对此数据进行查询。本例将结合hibernate,Spring Data JPA,Spring Boot来实现。 1. 自定义方言 public class JsonbPostgresDialect extends Pos...
SpringData JPA 答案整理，最新面试题
最新发布
Miss_SunHengYang的博客
07-18 483
根据需求选择适合的继承策略，如单表继承（@Inheritance(strategy = InheritanceType.SINGLE_TABLE)）、每类一表继承（@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)）或连接表继承（@Inheritance(strategy = InheritanceType.JOINED)）。通过@EntityGraph注解的attributePaths属性指定需要立即加载的关联对象，减少懒加载带来的性能问题。
springboot jpa json字段和实体转换
wnfff的博客
12-21 1255
springboot jpa json字段和实体转换
将postgresql中的json类型映射到java（Hibernate、JPA）
weixin_46240244的博客
02-04 2163
工具：JPA 2.5.1、Hibernate、postgresql。
Spring data Jpa整合Postgresq无法生成jsonb类型字段纠错
weixin_41276238的博客
01-07 388
spring data jpa 通过实体类生成表,发现有一个字段生成jsonb失败, 原有代码: 生成的表中字段类型为uuid 原因是 @Column注解添加属性columnDefinition 值为 jsonb 即可. ...
解决在springboot+mybatis+postgresql时，数据库字段类型为json时，如何与mybatis进行映射
热门推荐
二十同学
05-29 8万+
pg 数据库中 某字段类型为jsonJava实体中对应类型是 jsonObject private JSONObject info;在mybatis的xml中,常规无法直接进行映射，需要自己写一个TypeHandler，自定义一个JSONTypeHandlerPg类具体代码：package com.geovis.common.config; import java.sql.Callable...
spring-boot入门实例（jpa+postgresql+aop实现valid切面式校验）
05-23
Spring Data JPA是Spring对JPA的扩展，它提供了更多的便捷功能，如自动查询生成，使数据库操作变得更加简单。 PostgreSQL是一种开源的关系型数据库管理系统，以其强大的功能和稳定性著称。在Spring Boot应用中，...
SpringBoot 中JPA集成PostgreSql（详细步骤）避坑！
qq_38973118的博客
10-13 4622
SpringBoot 中JPA集成PostgreSql(详细步骤) 什么是JPA？（Java Persistence API） Spring Data JPA, part of the larger Spring Data family, makes it easy to easily implement JPA based repositories. This module deals with enhanced support for JPA based data access layers. It m
Spring Data JPA 常用注解
一只特立独行的猪
04-30 385
1. 创建表 @Entity声明该类对应一个数据表实体（万事万物皆为对象）。 @Table 设置表名 @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private St...
使用Spring Data JPA实现数据持久化操作
Spring Data JPA是基于Spring框架的一个对JPA规范的更高层次的抽象，它简化了数据持久化操作的开发过程。JPA（Java Persistence API）是Java EE的一个持久化标准，用于将Java对象映射到数据库中的数据表。 ## 1.2 ...
mysql-JPA对数据库中JSON类型数据的支持
JavaSupeMan的博客
07-26 2441
代码】mysql-JPA对数据库中JSON类型数据的支持。
sprinboot jpa实体支持mysql json字段配置
码农记事本
01-07 1482
类型也可以换成自字义实体，并实现。
criteria mysql filed_SpringData JPA--Specification实现mysql中json字段查询
weixin_29625619的博客
01-26 675
1.mysql中实现json字段查询select * from item where is_remove = 0 and json_extract(item_info,'$.GoodType') ='cat'2.JPA @Query实现mysql中json字段查询@Query(value = "select * from item where json_extract(item_info,?1) ...
Spring Data Jpa使用总结——使用@Query返回指定json格式的数据
Hello World !
09-05 4099
数据库中有student表： 表中有数据： 现需要获取表中name和address字段的值，并以下列json格式返回： 编写代码： 1、student表对应的实体类 package com.example.demo; import lombok.Data; import javax.persistence.Column; import javax.persist...
在spring data jpa + mysql 5.7 使用mysql字段的json类型
weixin_44808592的博客
12-06 6192
前言 mysql5.7之后支持了字段的json格式。这样更加方便了我们进行对象形式的数据存储，例如 在电商平台中，存储商品的属性可能会用到json格式，快递中储存货物信息也可能会用到json格式。 下面是在jpa中使用json格式的示例。 1，添加依赖 <dependency> <groupId>com.vladmihalcea</groupId> ...
Postgresql的jsonb格式在做映射的时候总是说无法解析
qq_44627822的博客
12-21 395
postgresql的jsonb格式在mybatis使用的时候无法解析jsonb
JPA操作PgSQL的JSON类型(org.postgresql.util.PSQLException: ERROR: column xxx is of type json问题)
★【World Of Moshow 郑锴】★
05-16 7420
遇到org.postgresql.util.PSQLException: ERROR: column xxx is of type json问题 可以再jdbc连接后面增加stringtype=unspecified来把JSON类型当STRING类型存储 jdbc:postgresql://localhost:5432/dbname?stringtype=unspecified...
spring data jpa 查询自定义字段，转换为自定义实体
zhu562002124的博客
07-14 7万+
目标：查询数据库中的字段，然后转换成 JSON 格式的对象，返回前台。背景：首先建立 entity 映射数据库（非专业 java 不知道这怎么说）@Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值