`FastjsonTypeHandler` 是一个自定义的 MyBatis 类型处理器，它负责将 `com.alibaba.fastjson.JSONObject` 类型的数据转换为数据库中存储的字符串（通常是 `TEXT` 或 `VARCHAR` 类型），并且在查询时将数据库中的字符串转换回 `JSONObject` 类型。

下面是如何实现一个 `FastjsonTypeHandler` 的完整示例：

### 1. 创建 `FastjsonTypeHandler` 类

`FastjsonTypeHandler` 类继承 `BaseTypeHandler`，并实现三个方法：

- `setNonNullParameter`：将 `JSONObject` 转换为字符串并设置到 `PreparedStatement` 中。
- `getNullableResult`：从 `ResultSet` 中获取字符串并转换为 `JSONObject`。
- `getNullableResult`（重载）：从 `CallableStatement` 中获取字符串并转换为 `JSONObject`。

```java
import org.apache.ibatis.type.BaseTypeHandler;
import org.apache.ibatis.type.JdbcType;
import com.alibaba.fastjson.JSONObject;

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

public class FastjsonTypeHandler extends BaseTypeHandler<JSONObject> {

    /**
     * 设置非空的参数，将 JSONObject 转为字符串，并设置到 PreparedStatement 中。
     */
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, JSONObject parameter, JdbcType jdbcType) throws SQLException {
        // 如果 parameter 为 null，就设置为 NULL，否则将 JSONObject 转为字符串存储
        if (parameter != null) {
            ps.setString(i, parameter.toJSONString());
        } else {
            ps.setNull(i, JdbcType.VARCHAR.TYPE_CODE);
        }
    }

    /**
     * 从 ResultSet 获取字段值并转换为 JSONObject
     */
    @Override
    public JSONObject getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String jsonString = rs.getString(columnName);
        return jsonString == null ? null : JSONObject.parseObject(jsonString);
    }

    /**
     * 从 ResultSet 获取字段值并转换为 JSONObject
     */
    @Override
    public JSONObject getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String jsonString = rs.getString(columnIndex);
        return jsonString == null ? null : JSONObject.parseObject(jsonString);
    }

    /**
     * 从 CallableStatement 获取字段值并转换为 JSONObject
     */
    @Override
    public JSONObject getNullableResult(java.sql.CallableStatement cs, int columnIndex) throws SQLException {
        String jsonString = cs.getString(columnIndex);
        return jsonString == null ? null : JSONObject.parseObject(jsonString);
    }
}
```

### 2. 配置 `FastjsonTypeHandler`

你需要将这个类型处理器注册到 MyBatis 或 MyBatis-Plus 配置中。可以通过两种方式来注册类型处理器：

#### 2.1. 在 `application.properties` 或 `application.yml` 中配置 `typeHandlersPackage`

在 `application.properties` 或 `application.yml` 中配置 `typeHandlersPackage`，指明类型处理器所在的包路径。

```properties
# application.properties
mybatis-plus.configuration.typeHandlersPackage=com.yourpackage.handler
```

或者在 `application.yml` 中：

```yaml
mybatis-plus:
  configuration:
    typeHandlersPackage: com.yourpackage.handler
```

确保 `FastjsonTypeHandler` 类在该包路径下。

#### 2.2. 或者在 MyBatis 配置文件中注册

如果你使用 MyBatis 的 XML 配置文件，可以在 `mybatis-config.xml` 中手动注册类型处理器。

```xml
<configuration>
    <typeHandlers>
        <typeHandler handler="com.yourpackage.handler.FastjsonTypeHandler"/>
    </typeHandlers>
</configuration>
```

### 3. 在实体类中使用自定义的 `FastjsonTypeHandler`

在实体类中，使用 `@TableField` 注解指定字段的 `typeHandler`，告诉 MyBatis 使用自定义的 `FastjsonTypeHandler` 来处理 `keyValue` 字段。

```java
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import org.apache.ibatis.type.JdbcType;
import com.alibaba.fastjson.JSONObject;
import com.yourpackage.handler.FastjsonTypeHandler;

@TableName("your_table")  // 对应数据库中的表名
public class YourEntity {

    private Integer id;

    // 使用自定义的 FastjsonTypeHandler 来处理 keyValue 字段
    @TableField(value = "key_value", jdbcType = JdbcType.OTHER, typeHandler = FastjsonTypeHandler.class)
    private JSONObject keyValue;

    // getter 和 setter
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public JSONObject getKeyValue() {
        return keyValue;
    }

    public void setKeyValue(JSONObject keyValue) {
        this.keyValue = keyValue;
    }
}
```

### 4. 使用 MyBatis-Plus 或 MyBatis 插入和查询数据

现在，你可以在 MyBatis-Plus 的控制器或服务层中插入和查询数据：

#### 4.1. 插入数据

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject;

@RestController
public class YourEntityController {

    @Autowired
    private YourEntityMapper yourEntityMapper;

    @RequestMapping("/insert")
    public String insertData() {
        // 创建一个 JSONObject
        JSONObject json = new JSONObject();
        json.put("key", "value");
        json.put("name", "Spring Boot");

        // 创建实体对象并设置 ID 和 key_value
        YourEntity entity = new YourEntity();
        entity.setId(1);
        entity.setKeyValue(json);  // 设置 key_value 为 JSONObject

        // 插入数据到数据库
        yourEntityMapper.insert(entity);

        return "Data inserted successfully!";
    }
}
```

#### 4.2. 查询数据

```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class YourEntityController {

    @Autowired
    private YourEntityMapper yourEntityMapper;

    @RequestMapping("/get")
    public String getData() {
        // 查询数据库中的数据
        YourEntity entity = yourEntityMapper.selectById(1);
        
        // 获取 key_value 字段（它是一个 JSONObject 对象）
        JSONObject json = entity.getKeyValue();
        
        // 输出 JSON 中的内容
        return "Key: " + json.getString("key") + ", Name: " + json.getString("name");
    }
}
```

### 小结

1. **`FastjsonTypeHandler`** 是自定义的 MyBatis 类型处理器，用于将 `JSONObject` 类型与数据库中的字符串字段进行转换。
2. **注册 `FastjsonTypeHandler`**：可以在 `application.properties` 或 `application.yml` 中注册，也可以通过 MyBatis 配置文件进行注册。
3. 在 **实体类中使用 `typeHandler`**：指定 `@TableField` 注解中的 `typeHandler` 参数，告诉 MyBatis 使用自定义的类型处理器。

通过上述步骤，你就能够成功地将 `JSONObject` 存储到数据库中，并在查询时将数据库中的 JSON 字符串转换为 `JSONObject` 对象。如果还有其他问题，欢迎继续提问！