Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

I. Introduzione

Nello sviluppo del progetto Springboot, un database relazionale viene generalmente utilizzato come database principale per archiviare i dati. A volte gli scenari aziendali richiedono l'estensione delle informazioni aziendali personalizzate sulla struttura della tabella esistente. In questo scenario viene generalmente utilizzata l'archiviazione di tipo json. Questo articolo riassume la soluzione pratica per utilizzare JSON nel progetto Springboot con l'aiuto di Mybatis-plus.

2. Stack tecnologico

Spring boot + Mybatis-plus + PostgreSQL, un determinato campo nel database PostgreSQL è di tipo json.

3. Analisi del contesto

In MyBatis, il gestore del tipo (TypeHandler) svolge il ruolo di ponte tra JavaType e JdbcType. Vengono utilizzati per impostare il valore di un oggetto Java su un PreparedStatement durante l'esecuzione di un'istruzione SQL o per recuperare un valore da un ResultSet o CallableStatement.

MyBatis-Plus ti fornisce alcuni processori di tipo integrato, che possono essere TableField Le annotazioni vengono rapidamente inserite nel contenitore MyBatis, semplificando il processo di sviluppo. Documento di riferimento ufficiale del processore di tipo campo MyBatis-Plus:Processore di tipo campo |. MyBatis-Plus (baomidou.com)

Gestore del tipo di campo JSON

MyBatis-Plus ha una varietà di processori di tipo JSON integrati, inclusi AbstractJsonTypeHandler e le sue sottocategorieFastjson2TypeHandler、FastjsonTypeHandler、GsonTypeHandler、JacksonTypeHandler Aspettare. Questi processori possono convertire stringhe JSON da e verso oggetti Java.

4. Analisi del programma

4.1 Memorizza direttamente gli oggetti json nel database PostgreSQL

I campi del database PostgreSQL sono mostrati nella figura sopra: param_config è un campo di tipo json.

Passaggio 1: scrittura delle entità DO

Il tipo di dati del campo è com.alibaba.fastjson2.JSONObject 。

@Data
@Accessors(chain = true)
@TableName(autoResultMap = true)
public class User {
    
    private Long id;

    ...

    /**
   	 * 关键代码！！！
     * 必须开启映射注解
     *
     * @TableName(autoResultMap = true)
     *
     * 选择对应的 JSON 处理器，并确保存在对应的 JSON 解析依赖包
     */
    @TableField(value = "param_config", typeHandler = JacksonTypeHandler.class)
    // 或者使用 FastjsonTypeHandler
    // @TableField(typeHandler = FastjsonTypeHandler.class)
    private JSONObject paramConfig;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Passaggio 2: metodo di scrittura corrispondente alla configurazione XML

<!-- 关键代码！！！！！！！ -->
<!-- 单个字段的类型处理器配置 -->
<result column="param_config" jdbcType="VARCHAR" property="paramConfig" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />

<!-- 多个字段中某个字段的类型处理器配置 -->
<resultMap id="departmentResultMap" type="com.baomidou...DepartmentVO">
    <result property="director" column="director" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />
</resultMap>
<select id="selectPageVO" resultMap="departmentResultMap">
   select id,name,director from department ...
</select>
1
2
3
4
5
6
7
8
9
10
11

Visualizza i risultati salvati nel database, come mostrato di seguito:

4.2 Memorizzazione di stringhe json nel database PostgreSQL

Aggiungere innanzitutto dopo l'URL del database PostgreSQL &stringtype=non specificato, tieni presente che se questa configurazione è direttamente preceduta dal nome del database, è necessario & Sostituirlo con? 。

Passaggio 1: scrittura della classe di entità DO

@TableField(value = "param_config", typeHandler = JacksonTypeHandler.class)
private String paramConfig;
1
2

Passaggio 2: metodo di scrittura corrispondente alla configurazione XML

<!-- 单个字段的类型处理器配置 -->
<result column="param_config" jdbcType="VARCHAR" property="paramConfig" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler" />
1
2

Visualizza i risultati salvati nel database, come mostrato di seguito:

5. Processore di tipo personalizzato

In MyBatis-Plus, oltre a utilizzare il processore di tipo integrato, gli sviluppatori possono anche personalizzare i processori di tipo secondo necessità.

Ad esempio, quando si utilizza un database PostgreSQL, potresti incontrare campi di tipo JSON. In questo caso, puoi creare un processore di tipo personalizzato per elaborare i dati JSON.

5.1 Definizione dei gestori di tipo

Di seguito è riportato un esempio di un processore di tipo JSON personalizzato:

package com.ruoyi.common.utils.pg;

import com.ruoyi.common.utils.StringUtils;
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.MappedTypes;
import org.postgresql.util.PGobject;

import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @ClassName: JsonTypeHandlerPg
 * @Description: json对象处理
 * @Author: hjm
 * @Date: 2024-07-11 10:34
 */
@MappedTypes(String.class)
public class JsonTypeHandlerPg extends BaseTypeHandler<String> {

    /**
     * 引入PGSQL提供的工具类PGobject
     */
    private static final PGobject JSON_OBJECT = new PGobject();
    public static final String JSON_TYPE = "json";

    /**
     * 关键位置!!!
     */
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String param, JdbcType jdbcType) throws SQLException {
        JSON_OBJECT.setType(JSON_TYPE);
        JSON_OBJECT.setValue(param);
        ps.setObject(i, JSON_OBJECT);
    }

    @Override
    public String getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String sqlJson = rs.getString(columnName);
        if (StringUtils.isNotBlank(sqlJson)) {
            return sqlJson;
        }
        return null;
    }

    // 根据列索引，获取可以为空的结果
    @Override
    public String getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String sqlJson = rs.getString(columnIndex);
        if (StringUtils.isNotBlank(sqlJson)) {
            return sqlJson;
        }
        return null;
    }

    @Override
    public String getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        String sqlJson = cs.getString(columnIndex);
        if (StringUtils.isNotBlank(sqlJson)) {
            return sqlJson;
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

5.2 Utilizzo di processori di tipo personalizzato

Nella classe entità, passa TableField Le annotazioni specificano i gestori di tipi personalizzati:

/**
 * 测试对象
 *
 * @author hjm
 * @date 2024-07-11
 */
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("data_test")
public class DataTest extends BaseEntity {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id")
    private Long id;
    
    /**
     * 关键位置!!!
     */
    @TableField(typeHandler = JsonTypeHandlerPg.class)
    private String jsonData;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Modifica il file del mappatore

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ruoyi.dt.mapper.DataTestMapper">

    <resultMap type="com.ruoyi.dt.domain.DataTest" id="DataTestResult">
        <result property="id" column="id"/>
		<!-- 关键位置!!! -->
        <result property="jsonData" column="json_data" typeHandler="com.ruoyi.common.utils.pg.JsonTypeHandlerPg"/>
        <result property="createBy" column="create_by"/>
        <result property="createTime" column="create_time"/>
        <result property="updateBy" column="update_by"/>
        <result property="updateTime" column="update_time"/>
    </resultMap>

</mapper>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Codice aziendale

    /**
     * 新增数据
     */
    @Override
    public Boolean insertByAo(DataTestAo ao) {
        DataTest add = BeanUtil.toBean(ao, DataTest.class);
        // 关键位置!!!
		add.setJsonData(JSONUtil.toJsonStr(ao));
        validEntityBeforeSave(add);
        boolean flag = baseMapper.insert(add) > 0;
        if (flag) {
            ao.setId(add.getId());
        }
        return flag;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Questo articolo è finito!