Intellij如何导出手动配置的JPA自定义类型映射？

以下是几种可行的实现方式：

1. 通过JPA元数据API（基于Hibernate底层）导出 #

利用EntityManagerFactory提供的元数据接口，可直接获取实体的类型映射信息，包括自定义类型配置。示例代码如下：

import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.ManagedType;
import jakarta.persistence.metamodel.Metamodel;
import org.hibernate.type.CustomType;
import org.hibernate.type.Type;

import java.util.HashMap;
import java.util.Map;

public class JpaTypeExporter {
    private final EntityManagerFactory emf;

    public JpaTypeExporter(EntityManagerFactory emf) {
        this.emf = emf;
    }

    public Map<String, Map<String, String>> exportCustomTypeMappings() {
        Map<String, Map<String, String>> mappings = new HashMap<>();
        Metamodel metamodel = emf.getMetamodel();

        for (ManagedType<?> managedType : metamodel.getManagedTypes()) {
            String entityName = managedType.getJavaType().getSimpleName();
            Map<String, String> fieldMappings = new HashMap<>();

            for (Attribute<?, ?> attribute : managedType.getAttributes()) {
                // 获取Hibernate底层类型信息
                Type hibernateType = emf.unwrap(org.hibernate.SessionFactory.class)
                        .getMetamodel()
                        .entityPersister(managedType.getJavaType().getName())
                        .getPropertyType(attribute.getName());

                if (hibernateType instanceof CustomType) {
                    CustomType customType = (CustomType) hibernateType;
                    String javaType = attribute.getJavaType().getSimpleName();
                    String customTypeClass = customType.getUserType().getClass().getSimpleName();
                    String dbType = customType.getSqlTypeCodes()[0] != 0 
                            ? org.hibernate.type.SqlTypes.sqlTypeName(customType.getSqlTypeCodes()[0]) 
                            : "自定义数据库类型";

                    fieldMappings.put(attribute.getName(), 
                        String.format("Java类型: %s | 自定义类型实现: %s | 数据库类型: %s", 
                            javaType, customTypeClass, dbType));
                }
            }

            if (!fieldMappings.isEmpty()) {
                mappings.put(entityName, fieldMappings);
            }
        }

        return mappings;
    }

    // 示例：导出为控制台输出或文件
    public static void main(String[] args) {
        // 需提前获取EntityManagerFactory，Spring环境下可通过@Autowired注入
        EntityManagerFactory emf = ...; 
        JpaTypeExporter exporter = new JpaTypeExporter(emf);
        Map<String, Map<String, String>> mappings = exporter.exportCustomTypeMappings();

        mappings.forEach((entity, fields) -> {
            System.out.println("实体类: " + entity);
            fields.forEach((field, info) -> System.out.println("  字段: " + field + " -> " + info));
        });
    }
}

这段代码会遍历所有实体类，筛选出使用自定义类型的字段，提取Java类型、自定义Type实现类以及对应数据库类型，输出结构化的映射信息。

2. 扫描实体类注解生成映射文档 #

如果自定义类型通过@Type注解或@Column(columnDefinition)配置，可通过反射扫描实体类，提取注解信息生成可读文档：

import jakarta.persistence.Column;
import org.hibernate.annotations.Type;

import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.Set;

public class AnnotationTypeScanner {
    public static void scanAndExport(String basePackage, String outputPath) throws IOException {
        // 扫描指定包下的所有实体类（可自行实现包扫描逻辑，或使用Reflections等第三方库）
        Set<Class<?>> entityClasses = ...; 

        StringBuilder sb = new StringBuilder();
        sb.append("# JPA自定义类型映射配置\n\n");

        for (Class<?> entityClass : entityClasses) {
            sb.append("## ").append(entityClass.getSimpleName()).append("\n");
            for (Field field : entityClass.getDeclaredFields()) {
                Type typeAnnotation = field.getAnnotation(Type.class);
                Column columnAnnotation = field.getAnnotation(Column.class);

                if (typeAnnotation != null) {
                    sb.append("- 字段: `").append(field.getName()).append("`\n");
                    sb.append("  - Java类型: `").append(field.getType().getSimpleName()).append("`\n");
                    sb.append("  - 自定义Type: `").append(typeAnnotation.value().getSimpleName()).append("`\n");
                    if (columnAnnotation != null && !columnAnnotation.columnDefinition().isEmpty()) {
                        sb.append("  - 数据库类型: `").append(columnAnnotation.columnDefinition()).append("`\n");
                    }
                    sb.append("\n");
                }
            }
        }

        // 写入Markdown文件，方便团队共享
        try (FileWriter writer = new FileWriter(outputPath)) {
            writer.write(sb.toString());
        }
    }
}

这种方式无需启动JPA容器，直接通过反射解析注解生成结构化文档，适合团队协作场景。

3. 利用Hibernate日志输出 #

开启Hibernate的org.hibernate.type.descriptor.sql日志级别为DEBUG，启动时会输出所有类型映射细节。虽然输出内容较零散，但可通过日志过滤提取自定义类型相关信息。配置示例（application.properties）：

logging.level.org.hibernate.type.descriptor.sql=DEBUG

内容的提问来源于stack exchange，提问作者zangetsu