让Hibernate生成的DDL脚本自动增加注释

我们知道可以通过Hibernate对象自动生成DDL建表语句，通过PowerDesigner工具可以反向工程生成数据字典，但是在生成的DDL中一直不能写上中文的注释，这就使我们生成的数据字典不具有可用性。

这个假期宅在家里调试代码，发现Hibernate的Dialect,Table,Column的映射中已经做了comment的处理，只是Hibernate团队认为这个功能的重要性太小，一直没有时间提供这个需求，于是就自己动手实现这个功能了，这可是使用我们的数据对象代码与数据字典文档同步的关键一环啊！

通过对Hibernate代码的跟踪发现了处理映射的逻辑是在代码AnnotationBinder中，我们不需要在运行期间处理comment，只是在用SchemaExport时处理就可以，于是简单的实现了此功能：

1. 增加一个注解 @Comment("这是表的说明，也可以是字段的说明")，适用在类名和属性名

2. 复制org.hibernate.cfg.AnnotationBuilder代码为org.hibernate.cfg.MyAnnotationBuilder，处理注解@Comment

3. 复制org.hibernate.cfg.Configuration为org.hibernate.cfg.MyConfiguration，将AnnotationBuilder的调用换成MyAnnotationBuilder

3. 实现SchemaExportTool类，传入MyConfiguration处理Hibernate对象的映射关系，并生成DDL

 

以上思路在基于Hibernate 4.2.3版本在MySql 5.1上测试成功，因为代码只是在开发期运行，不需要良好的结构和优化，所以只是简单实现了，需要此功能的朋友可以自己实现。

 

以下是处理结果示例：

[java] view plain copy print ?

1. @Entity  
2. @Table(name = "AuditRecord_")  
3. @Comment("系统审计表")  
4. @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)  
5. public class AuditRecord implements Serializable {  
6.   
7.     private static final long serialVersionUID = 8844543936912679937L;  
8.     @Id  
9.     @GeneratedValue  
10.     @Comment("ID主键")  
11.     private Long id;  
12.     @Comment("审计类型")  
13.     @Column(length = 30)  
14.     private String auditType;  
15.     @Comment("操作人")  
16.     @ManyToOne  
17.     @JoinColumn(name = "userId")  
18.     private Passport operator;  
19.     // 操作简述   
20.     @Comment("操作简述")  
21.     @Column(length = 4000)  
22.     private String description;  
23.     @Comment("创建时间")  
24.     private Date creationTime;  
25. }  

@Entity
@Table(name = "AuditRecord_")
@Comment("系统审计表")
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public class AuditRecord implements Serializable {

	private static final long serialVersionUID = 8844543936912679937L;
	@Id
	@GeneratedValue
	@Comment("ID主键")
	private Long id;
	@Comment("审计类型")
	@Column(length = 30)
	private String auditType;
	@Comment("操作人")
	@ManyToOne
	@JoinColumn(name = "userId")
	private Passport operator;
	// 操作简述
	@Comment("操作简述")
	@Column(length = 4000)
	private String description;
	@Comment("创建时间")
	private Date creationTime;
}

生成的DDL如下：

[sql] view plain copy print ?

1. create table audit_record_ (  
2.         id bigint not null auto_increment comment 'ID主键',  
3.         audit_type varchar(30) comment '审计类型',  
4.         creation_time datetime comment '创建时间',  
5.         description longtext comment '操作简述',  
6.         user_id bigint comment '操作人',  
7.         primary key (id)  
8.     ) comment='系统审计表';  

create table audit_record_ (
        id bigint not null auto_increment comment 'ID主键',
        audit_type varchar(30) comment '审计类型',
        creation_time datetime comment '创建时间',
        description longtext comment '操作简述',
        user_id bigint comment '操作人',
        primary key (id)
    ) comment='系统审计表';

 

主要代码片断如下：

 

[java] view plain copy print ?

1. import java.io.IOException;  
2. import java.util.Properties;  
3.   
4. import javax.persistence.Embeddable;  
5. import javax.persistence.Entity;  
6. import javax.persistence.MappedSuperclass;  
7.   
8. import org.hibernate.MappingException;  
9. import org.hibernate.cfg.MyConfiguration;  
10. import org.hibernate.tool.hbm2ddl.SchemaExport;  
11. import org.springframework.core.io.Resource;  
12. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;  
13. import org.springframework.core.io.support.ResourcePatternResolver;  
14. import org.springframework.core.io.support.ResourcePatternUtils;  
15. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;  
16. import org.springframework.core.type.classreading.MetadataReader;  
17. import org.springframework.core.type.classreading.MetadataReaderFactory;  
18. import org.springframework.core.type.filter.AnnotationTypeFilter;  
19. import org.springframework.core.type.filter.TypeFilter;  
20. import org.springframework.util.ClassUtils;  
21.   
22. public class SchemaExportTool extends MyConfiguration {  
23.   
24.     private static final long serialVersionUID = 1L;  
25.   
26.     private static final String RESOURCE_PATTERN = "/**/*.class";  
27.   
28.     private static final String PACKAGE_INFO_SUFFIX = ".package-info";  
29.   
30.     private static final TypeFilter[] ENTITY_TYPE_FILTERS = new TypeFilter[] {  
31.             new AnnotationTypeFilter(Entity.class, false),  
32.             new AnnotationTypeFilter(Embeddable.class, false),  
33.             new AnnotationTypeFilter(MappedSuperclass.class, false) };  
34.     private final ResourcePatternResolver resourcePatternResolver;  
35.   
36.     public SchemaExportTool() {  
37.         this.resourcePatternResolver = ResourcePatternUtils  
38.                 .getResourcePatternResolver(new PathMatchingResourcePatternResolver());  
39.     }  
40.   
41.     public static void main(String[] args) {  
42.         try {  
43.             Properties p = new Properties();  
44.             p.setProperty("hibernate.dialect",  
45.                     "org.hibernate.dialect.MySQLDialect");  
46.             SchemaExportTool cfg = new SchemaExportTool();  
47.             cfg.addProperties(p);  
48.             cfg.setNamingStrategy(new ImprovedMyNamingStrategy());  
49.             cfg.scanPackage("com.share.passport.domain",  
50.                     "com.share.authority.domain", "com.share.utils.domain");  
51.   
52.             SchemaExport se = new SchemaExport(cfg);  
53.             if (null != args && args.length > 1)  
54.                 if ("-f".equals(args[0]))  
55.                     se.setOutputFile(args[1]);  
56.                 else  
57.                     se.setOutputFile("create_table.sql");  
58.             else  
59.                 se.setOutputFile("create_table.sql");  
60.             se.setDelimiter(";");  
61.             // se.drop(false, false);   
62.             se.create(false, false);  
63.   
64.         } catch (Exception e) {  
65.             e.printStackTrace();  
66.         }  
67.   
68.     }  
69.   
70.     private SchemaExportTool scanPackage(String... packagesToScan) {  
71.         try {  
72.             for (String pkg : packagesToScan) {  
73.                 String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX  
74.                         + ClassUtils.convertClassNameToResourcePath(pkg)  
75.                         + RESOURCE_PATTERN;  
76.                 Resource[] resources = this.resourcePatternResolver  
77.                         .getResources(pattern);  
78.                 MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(  
79.                         this.resourcePatternResolver);  
80.                 for (Resource resource : resources) {  
81.                     if (resource.isReadable()) {  
82.                         MetadataReader reader = readerFactory  
83.                                 .getMetadataReader(resource);  
84.                         String className = reader.getClassMetadata()  
85.                                 .getClassName();  
86.                         if (matchesEntityTypeFilter(reader, readerFactory)) {  
87.                             addAnnotatedClass(this.resourcePatternResolver  
88.                                     .getClassLoader().loadClass(className));  
89.                         } else if (className.endsWith(PACKAGE_INFO_SUFFIX)) {  
90.                             addPackage(className.substring(  
91.                                     0,  
92.                                     className.length()  
93.                                             - PACKAGE_INFO_SUFFIX.length()));  
94.                         }  
95.                     }  
96.                 }  
97.             }  
98.             return this;  
99.         } catch (IOException ex) {  
100.             throw new MappingException(  
101.                     "Failed to scan classpath for unlisted classes", ex);  
102.         } catch (ClassNotFoundException ex) {  
103.             throw new MappingException(  
104.                     "Failed to load annotated classes from classpath", ex);  
105.         }  
106.     }  
107.   
108.     /** 
109.      * Check whether any of the configured entity type filters matches the 
110.      * current class descriptor contained in the metadata reader. 
111.      */  
112.     private boolean matchesEntityTypeFilter(MetadataReader reader,  
113.             MetadataReaderFactory readerFactory) throws IOException {  
114.         for (TypeFilter filter : ENTITY_TYPE_FILTERS) {  
115.             if (filter.match(reader, readerFactory)) {  
116.                 return true;  
117.             }  
118.         }  
119.         return false;  
120.     }  
121.   
122. }  

import java.io.IOException;
import java.util.Properties;

import javax.persistence.Embeddable;
import javax.persistence.Entity;
import javax.persistence.MappedSuperclass;

import org.hibernate.MappingException;
import org.hibernate.cfg.MyConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.AnnotationTypeFilter;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.util.ClassUtils;

public class SchemaExportTool extends MyConfiguration {

	private static final long serialVersionUID = 1L;

	private static final String RESOURCE_PATTERN = "/**/*.class";

	private static final String PACKAGE_INFO_SUFFIX = ".package-info";

	private static final TypeFilter[] ENTITY_TYPE_FILTERS = new TypeFilter[] {
			new AnnotationTypeFilter(Entity.class, false),
			new AnnotationTypeFilter(Embeddable.class, false),
			new AnnotationTypeFilter(MappedSuperclass.class, false) };
	private final ResourcePatternResolver resourcePatternResolver;

	public SchemaExportTool() {
		this.resourcePatternResolver = ResourcePatternUtils
				.getResourcePatternResolver(new PathMatchingResourcePatternResolver());
	}

	public static void main(String[] args) {
		try {
			Properties p = new Properties();
			p.setProperty("hibernate.dialect",
					"org.hibernate.dialect.MySQLDialect");
			SchemaExportTool cfg = new SchemaExportTool();
			cfg.addProperties(p);
			cfg.setNamingStrategy(new ImprovedMyNamingStrategy());
			cfg.scanPackage("com.share.passport.domain",
					"com.share.authority.domain", "com.share.utils.domain");

			SchemaExport se = new SchemaExport(cfg);
			if (null != args && args.length > 1)
				if ("-f".equals(args[0]))
					se.setOutputFile(args[1]);
				else
					se.setOutputFile("create_table.sql");
			else
				se.setOutputFile("create_table.sql");
			se.setDelimiter(";");
			// se.drop(false, false);
			se.create(false, false);

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	private SchemaExportTool scanPackage(String... packagesToScan) {
		try {
			for (String pkg : packagesToScan) {
				String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
						+ ClassUtils.convertClassNameToResourcePath(pkg)
						+ RESOURCE_PATTERN;
				Resource[] resources = this.resourcePatternResolver
						.getResources(pattern);
				MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(
						this.resourcePatternResolver);
				for (Resource resource : resources) {
					if (resource.isReadable()) {
						MetadataReader reader = readerFactory
								.getMetadataReader(resource);
						String className = reader.getClassMetadata()
								.getClassName();
						if (matchesEntityTypeFilter(reader, readerFactory)) {
							addAnnotatedClass(this.resourcePatternResolver
									.getClassLoader().loadClass(className));
						} else if (className.endsWith(PACKAGE_INFO_SUFFIX)) {
							addPackage(className.substring(
									0,
									className.length()
											- PACKAGE_INFO_SUFFIX.length()));
						}
					}
				}
			}
			return this;
		} catch (IOException ex) {
			throw new MappingException(
					"Failed to scan classpath for unlisted classes", ex);
		} catch (ClassNotFoundException ex) {
			throw new MappingException(
					"Failed to load annotated classes from classpath", ex);
		}
	}

	/**
	 * Check whether any of the configured entity type filters matches the
	 * current class descriptor contained in the metadata reader.
	 */
	private boolean matchesEntityTypeFilter(MetadataReader reader,
			MetadataReaderFactory readerFactory) throws IOException {
		for (TypeFilter filter : ENTITY_TYPE_FILTERS) {
			if (filter.match(reader, readerFactory)) {
				return true;
			}
		}
		return false;
	}

}

[java] view plain copy print ?

1. /** 
2.  * $Id:$ 
3.  */  
4. package com.share.utils.hibernate;  
5.   
6. import org.hibernate.annotations.common.reflection.XClass;  
7. import org.hibernate.annotations.common.reflection.XProperty;  
8. import org.hibernate.cfg.Ejb3Column;  
9. import org.hibernate.mapping.PersistentClass;  
10.   
11. import com.share.annotations.Comment;  
12.   
13. public class CommentBinder {  
14.     public static void bindTableComment(XClass clazzToProcess, PersistentClass persistentClass) {  
15.         if (clazzToProcess.isAnnotationPresent(Comment.class)) {  
16.             String tableComment = clazzToProcess.getAnnotation(Comment.class).value();  
17.             persistentClass.getTable().setComment(tableComment);  
18.   
19.         }  
20.     }  
21.   
22.     public static void bindColumnComment(XProperty property, Ejb3Column[] columns) {  
23.         if (null != columns)  
24.   
25.             if (property.isAnnotationPresent(Comment.class)) {  
26.                 String comment = property.getAnnotation(Comment.class).value();  
27.                 for (Ejb3Column column : columns) {  
28.                     column.getMappingColumn().setComment(comment);  
29.                 }  
30.   
31.             }  
32.     }  
33.   
34.     public static void bindColumnComment(XProperty property, Ejb3Column column) {  
35.         if (null != column)  
36.             if (property.isAnnotationPresent(Comment.class)) {  
37.                 String comment = property.getAnnotation(Comment.class).value();  
38.   
39.                 column.getMappingColumn().setComment(comment);  
40.   
41.             }  
42.     }  
43. }  

/**
 * $Id:$
 */
package com.share.utils.hibernate;

import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.annotations.common.reflection.XProperty;
import org.hibernate.cfg.Ejb3Column;
import org.hibernate.mapping.PersistentClass;

import com.share.annotations.Comment;

public class CommentBinder {
    public static void bindTableComment(XClass clazzToProcess, PersistentClass persistentClass) {
        if (clazzToProcess.isAnnotationPresent(Comment.class)) {
            String tableComment = clazzToProcess.getAnnotation(Comment.class).value();
            persistentClass.getTable().setComment(tableComment);

        }
    }

    public static void bindColumnComment(XProperty property, Ejb3Column[] columns) {
        if (null != columns)

            if (property.isAnnotationPresent(Comment.class)) {
                String comment = property.getAnnotation(Comment.class).value();
                for (Ejb3Column column : columns) {
                    column.getMappingColumn().setComment(comment);
                }

            }
    }

    public static void bindColumnComment(XProperty property, Ejb3Column column) {
        if (null != column)
            if (property.isAnnotationPresent(Comment.class)) {
                String comment = property.getAnnotation(Comment.class).value();

                column.getMappingColumn().setComment(comment);

            }
    }
}

[java] view plain copy print ?

1. /** 
2.  * $Id:$ 
3.  */  
4. package com.share.annotations;  
5.   
6. import java.lang.annotation.ElementType;  
7. import java.lang.annotation.Retention;  
8. import java.lang.annotation.RetentionPolicy;  
9. import java.lang.annotation.Target;  
10.   
11. @Target({ElementType.TYPE,ElementType.FIELD})  
12. @Retention(RetentionPolicy.RUNTIME)  
13. public @interface Comment {  
14.     String value() default "";  
15. }  

/**
 * $Id:$
 */
package com.share.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Comment {
    String value() default "";
}