Hibernate给表和字段设置前后缀及分隔符

在《一口一口吃掉Hibernate（一）——使用SchemaExport生成数据表》中介绍了如何生成数据表。但是这只是最基本的。hibernate在生成或者操作数据库时，会受一些限制。比如一开始设计表的时候，直接写成了user(id,name,password,createTime)  这种格式的。但是客户后来要求表名称要以“t_”开头，字段名要以“stu_”开头，可以是一些数据库的关键字，单词之间以“_”隔开，方便他们维护.例如：T_User(stu_Id,stu_Name,stu_Create_Time)。

对于上面的问题，常规的方法就是去修改Hibernate_cfg.xml中的表，为每个表添加“t_”，或者写table属性，字段也重新使用column属性来修改。如果你有100张表，每个表平均有10个字段，你还会去一个一个修改么？还有可能漏掉或者改错。最“可恶”的是，如果客户再让你改成其他的呢，是不是还要全部修改一次？

有没有一种方法，不修改原先的配置，添加并配置一下表和字段的前后缀及分隔符等等，既可以完成呢？？经过尝试，终于被我拿下了，现在拿出来与大家分享。

针对上述问题，我主要用的是NamingStrategy接口。这个接口很有意思，可以作为业务类规范和数据库表规范的桥梁，它可以表和列的映射关系的转变和处理。例如一个数据对象User，对应数据库表是T_USER，如果所有映射关系都是这样的情况，可以使用NamingStrategy做为一个桥梁衔接，而不用再hbm.xml映射文件中指定class对应的物理table。

先说一下Hibernate读取映射文件的简要过程：循环读取class标签，判断class标签的table属性值是否为null，若为null，则调用NamingStrategy接口的classToTableName方法将class值转换并处理（按命名策略NamingStrategy处理）的表名。若不为null，则说明设置了table，那么调用NamingStrategy接口的tableName方法获取处理过的表名。循环遍历property，判断property标签的column属性值是否为null，若为null，则首先调用propertyToColumnName方法，将属性值转化为列名，再调用logicalColumnName方法。若不为null，则直接调用NamingStrategy接口的logicalColumnName方法，再调用columnName方法进行处理（按命名策略NamingStrategy处理）。

了解了上面说的这个过程，只要我们实现NamingStrategy这个接口，就可以随心所欲的修改表映射了。不多说了，直接上代码吧：

【MyNamingStrategy】自定义的命名策略，可对表、字段进行统一处理。

1. package com.tgb.hibernate.neatlyDB;
2. import org.hibernate.cfg.Configuration;
3. import org.hibernate.cfg.NamingStrategy;
4. import org.hibernate.util.StringHelper;
5. /**
6. * 数据库命名策略，可定制表、字段等的前后缀
7. *
8. * @author Longxuan
9. *
10. */
11. public class MyNamingStrategy implements NamingStrategy {
12. /**
13. * 数据库命名策略单一实例
14. */
15. private static MyNamingStrategy instance = null;
16. /**
17. * 数据库配置信息类
18. */
19. private static DatabaseConfiguration dbcfg = null;
20. /**
21. * 私有化构造方法
22. */
23. private MyNamingStrategy() {
24. }
25. /**
26. * 使用单利模式，获取数据库命名策略的唯一实例
27. *
28. * @return
29. */
30. public static synchronized MyNamingStrategy getInstance() {
31. // 默认读取hibernate.cfg.xml文件
32. Configuration cfg = new Configuration().configure();
33. return getInstance(cfg);
34. }
35. /**
36. * 使用单利模式，获取数据库命名策略的唯一实例，同时使用默认Hibernate.cfg.xml更新命名策略信息
37. *
38. * @param cfg
39. *            配置文件信息
40. * @return
41. */
42. public static synchronized MyNamingStrategy getInstance(Configuration cfg) {
43. if (instance == null) {
44. instance = new MyNamingStrategy();
45. }
46. MyNamingStrategy.dbcfg = new DatabaseConfiguration(cfg);
47. return instance;
48. }
49. /**
50. * 使用单利模式，获取数据库命名策略的唯一实例，同时更新命名策略信息
51. *
52. * @param cfg
53. *            配置文件信息
54. * @return
55. */
56. public static synchronized MyNamingStrategy getInstance(
57. DatabaseConfiguration dbcfg) {
58. if (instance == null) {
59. instance = new MyNamingStrategy();
60. }
61. MyNamingStrategy.dbcfg = dbcfg;
62. return instance;
63. }
64. /**
65. * 设置或更新数据库配置信息
66. *
67. * @param dbcfg
68. */
69. public void setDBConfig(DatabaseConfiguration dbcfg) {
70. MyNamingStrategy.dbcfg = dbcfg;
71. }
72. /**
73. * 转化为物理表名
74. *
75. * @param className hbm.xml中的对应表的class值
76. */
77. @Override
78. public String classToTableName(String className) {
79. if(className == null ) return null;
80. //改变大小写
81. String str =UpdateStyle(className,dbcfg.getTableStyle().name());
82. //添加前后缀
83. str = addPrefixORStuffix(str, dbcfg.getTablePrefix(),dbcfg.getTableSuffix());
84. //添加分隔符
85. str = addSeparator(str,dbcfg.getTableSeparator());
86. return str;
87. }
88. @Override
89. public String collectionTableName(String ownerEntity,
90. String ownerEntityTable, String associatedEntity,
91. String associatedEntityTable, String propertyName) {
92. return null;
93. }
94. /**
95. * 将读取到的列名传递过来进行加工处理，变为物理表的字段名
96. *
97. * @param columnName logicalColumnName方法读取到的列名
98. */
99. @Override
100. public String columnName(String columnName) {
101. //先调用logicalColumnName方法，拿到处理过的值，
102. //再传递到该方法中，所以可以在这两个方法中任一选择修改。
103. //return columnName;
104. if(columnName == null ) return null;
105. //改变大小写
106. String str =UpdateStyle(columnName,dbcfg.getColumnTyle().name());
107. //添加前后缀
108. str = addPrefixORStuffix(StringHelper.unqualify(str), dbcfg.getColumnPrefix(),dbcfg.getColumnSuffix());
109. //添加分隔符
110. str = addSeparator(str,dbcfg.getColumnSeparator());
111. return str;
112. }
113. /**
114. * 处理外键列名
115. *
116. */
117. @Override
118. public String foreignKeyColumnName(String propertyName,
119. String propertyEntityName, String propertyTableName,
120. String referencedColumnName) {
121. if(referencedColumnName == null ) return null;
122. //改变大小写
123. String str =UpdateStyle(referencedColumnName,dbcfg.getColumnTyle().name());
124. //添加前后缀
125. str = addPrefixORStuffix(StringHelper.unqualify(str), dbcfg.getColumnPrefix(),dbcfg.getColumnSuffix());
126. //添加分隔符
127. str = addSeparator(str,dbcfg.getColumnSeparator());
128. return str;
129. }
130. /**
131. * 关联键的名称
132. */
133. @Override
134. public String joinKeyColumnName(String joinedColumn, String joinedTable) {
135. if(joinedColumn == null ) return null;
136. //改变大小写
137. String str =UpdateStyle(joinedColumn,dbcfg.getColumnTyle().name());
138. //添加前后缀
139. str = addPrefixORStuffix(StringHelper.unqualify(str), dbcfg.getColumnPrefix(),dbcfg.getColumnSuffix());
140. //添加分隔符
141. str = addSeparator(str,dbcfg.getColumnSeparator());
142. return str;
143. }
144. @Override
145. public String logicalCollectionColumnName(String columnName,
146. String propertyName, String referencedColumn) {
147. return null;
148. }
149. @Override
150. public String logicalCollectionTableName(String tableName,
151. String ownerEntityTable, String associatedEntityTable,
152. String propertyName) {
153. return null;
154. }
155. /**
156. * 处理逻辑列名
157. * <b>若设置了column属性，会直接调用调用该方法</b>
158. *
159. * @param columnName    列名
160. * @param propertyName  实体列名
161. */
162. @Override
163. public String logicalColumnName(String columnName, String propertyName) {
164. //name值对应propertyName，column值对应columnName
165. //判断columnName是否设置，若设置了，则返回column值，否则返回propertyName值
166. return columnName == null || columnName =="" ? propertyName:columnName;
167. }
168. /**
169. * 处理逻辑列名
170. * <b>若未设置column属性，则先调用该方法，再调用logicalColumnName方法</b>
171. *
172. * @param propertyName  实体列名
173. */
174. @Override
175. public String propertyToColumnName(String propertyName) {
176. if(propertyName == null ) return null;
177. //改变大小写
178. String str =UpdateStyle(propertyName,dbcfg.getColumnTyle().name());
179. //添加前后缀
180. str = addPrefixORStuffix(StringHelper.unqualify(str), dbcfg.getColumnPrefix(),dbcfg.getColumnSuffix());
181. //添加分隔符
182. str = addSeparator(str,dbcfg.getColumnSeparator());
183. return str;
184. }
185. /**
186. * 处理表名
187. * <b>若设置了table属性，才会调用该方法</b>
188. */
189. @Override
190. public String tableName(String tableName) {
191. if(tableName == null ) return null;
192. //改变大小写
193. String str =UpdateStyle(tableName,dbcfg.getTableStyle().name());
194. //添加前后缀
195. str = addPrefixORStuffix(StringHelper.unqualify(str), dbcfg.getTablePrefix(),dbcfg.getTableSuffix());
196. //添加分隔符
197. str = addSeparator(str,dbcfg.getTableSeparator());
198. return str;
199. }
200. /**
201. * 单词分隔符
202. *
203. * @param name
204. * @return
205. */
206. private String addSeparator(String str, String flag) {
207. StringBuffer buf = new StringBuffer(str.substring(str.lastIndexOf(".")+1));
208. for (int i = 1; i < buf.length() - 1; i++) {
209. if (‘_‘ != buf.charAt(i - 1)
210. && Character.isUpperCase(buf.charAt(i))
211. && !Character.isUpperCase(buf.charAt(i + 1))) {
212. // buf.insert(i++, ‘_‘);
213. buf.insert(i++, flag);
214. }
215. }
216. return buf.toString();
217. }
218. /**
219. * 添加前后缀
220. *
221. * @param str
222. *            字符串
223. * @param prefix
224. *            前缀
225. * @param suffix
226. *            后缀
227. * @return
228. */
229. private String addPrefixORStuffix(String str, String prefix, String suffix) {
230. StringBuffer buf = new StringBuffer(str.substring(str.lastIndexOf(".")+1));
231. buf.insert(buf.length(), suffix).insert(0, prefix);
232. return buf.toString();
233. }
234. /**
235. * 更新样式
236. * @param str
237. * @param style
238. * @return
239. */
240. private String UpdateStyle(String str, String style) {
241. if ("AU".equals(style)) {
242. str = str.toUpperCase();
243. } else if ("AL".equals(style)) {
244. str = str.toLowerCase();
245. } else if ("FU".equals(style)) {
246. StringBuffer buf = new StringBuffer(str.substring(str.lastIndexOf(".")+1));
247. String upper =buf.substring(0,1).toUpperCase();
248. buf.delete(0, 1).insert(0, upper);
249. str = buf.toString();
250. } else if ("FL".equals(style)) {
251. StringBuffer buf = new StringBuffer(str.substring(str.lastIndexOf(".")+1));
252. String lower =buf.substring(0,1).toLowerCase();
253. buf.delete(0, 1).insert(0, lower);
254. str = buf.toString();
255. }  else{
256. }
257. return str;
258. }
259. }

【DatabaseConfiguration】数据库样式配置，包括前后缀、分隔符、大小写等

1. package com.tgb.hibernate.neatlyDB;
2. import org.hibernate.cfg.Configuration;
3. /**
4. * 数据库模式配置
5. * @author Longxuan
6. *
7. */
8. public final class DatabaseConfiguration {
9. /**
10. * 列名样式
11. * AU-all upper case
12. * AL-all lower case
13. * FU-first upper case per word
14. * FL-first lower case ,Other first letter upper case
15. */
16. public static enum ColumnTyle {
17. AU,AL,FU,FL;
18. }
19. /**
20. * 表名称样式
21. * AU-all upper case
22. * AL-all lower case
23. * FU-first upper case per word
24. * FL-first lower case ,Other first letter upper case
25. */
26. public static enum TableStyle{
27. AU,AL,FU,FL;
28. }
29. /**
30. * 列名样式
31. * AU-all upper case
32. * AL-all lower case
33. * FU-first upper case per word
34. * FL-first lower case ,Other first letter upper case
35. */
36. private ColumnTyle columnTyle = ColumnTyle.FL;
37. /**
38. * 表名称样式
39. * AU-all upper case
40. * AL-all lower case
41. * FU-first upper case per word
42. * FL-first lower case ,Other first letter upper case
43. */
44. private TableStyle tableStyle = TableStyle.FU;
45. /**
46. * 表名称前缀
47. */
48. private String tablePrefix = "";
49. /**
50. * 表名称后缀
51. */
52. private String tableSuffix = "";
53. /**
54. * 表名称分隔符
55. */
56. private String tableSeparator = "";
57. /**
58. * 列名前缀
59. */
60. private String columnPrefix = "";
61. /**
62. * 列名后缀
63. */
64. private String columnSuffix = "";
65. /**
66. * 列名分隔符
67. */
68. private String columnSeparator = "";
69. public ColumnTyle getColumnTyle() {
70. return columnTyle;
71. }
72. public void setColumnTyle(ColumnTyle columnTyle) {
73. this.columnTyle = columnTyle;
74. }
75. public TableStyle getTableStyle() {
76. return tableStyle;
77. }
78. public void setTableStyle(TableStyle tableStyle) {
79. this.tableStyle = tableStyle;
80. }
81. public String getTablePrefix() {
82. return tablePrefix;
83. }
84. public void setTablePrefix(String tablePrefix) {
85. this.tablePrefix = tablePrefix;
86. }
87. public String getTableSuffix() {
88. return tableSuffix;
89. }
90. public void setTableSuffix(String tableSuffix) {
91. this.tableSuffix = tableSuffix;
92. }
93. public String getTableSeparator() {
94. return tableSeparator;
95. }
96. public void setTableSeparator(String tableSeparator) {
97. this.tableSeparator = tableSeparator;
98. }
99. public String getColumnPrefix() {
100. return columnPrefix;
101. }
102. public void setColumnPrefix(String columnPrefix) {
103. this.columnPrefix = columnPrefix;
104. }
105. public String getColumnSuffix() {
106. return columnSuffix;
107. }
108. public void setColumnSuffix(String columnSuffix) {
109. this.columnSuffix = columnSuffix;
110. }
111. public String getColumnSeparator() {
112. return columnSeparator;
113. }
114. public void setColumnSeparator(String columnSeparator) {
115. this.columnSeparator = columnSeparator;
116. }
117. /**
118. * 初始化，读取配置参数,默认读取Hibernate.cfg.xml
119. * @param cfg
120. */
121. public DatabaseConfiguration(){
122. ReadConfig(new Configuration().configure());
123. }
124. /**
125. * 初始化，读取配置文件
126. * @param cfg
127. */
128. public DatabaseConfiguration(Configuration cfg){
129. ReadConfig(cfg);
130. }
131. /**
132. * 自动读取配置信息
133. * @param cfg
134. */
135. private void ReadConfig(Configuration cfg){
136. tableStyle = cfg.getProperty("tablestyle")==""?TableStyle.FU:TableStyle.valueOf(cfg.getProperty("tablestyle"));
137. tablePrefix = cfg.getProperty("tablePrefix");
138. tableSuffix = cfg.getProperty("tablesuffix");
139. tableSeparator = cfg.getProperty("tableseparator");
140. columnTyle = cfg.getProperty("columntyle")==""?ColumnTyle.FL:ColumnTyle.valueOf(cfg.getProperty("columntyle"));
141. columnPrefix = cfg.getProperty("columnPrefix");
142. columnSuffix = cfg.getProperty("columnsuffix");
143. columnSeparator = cfg.getProperty("columnseparator");
144. }
145. }

【hibernate.cfg.xml】设置数据库样式配置信息

1. <!DOCTYPE hibernate-configuration PUBLIC
2. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
3. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
4. <hibernate-configuration>
5. <session-factory name="foo">
6. <!--
7. name:       配置的名称
8. style:      类型 枚举AU-all upper case
9. AL-all lower case
10. FU-first letter upper case per word
11. FL-first letter lower case ,Other first letters upper case
12. befix:      前缀
13. suffix:     后缀
14. separator:  分隔符
15. -->
16. <property name="tablestyle">FU</property>
17. <property name="tablePrefix" >T_</property>
18. <property name="tablesuffix" ></property>
19. <property name="tableseparator" >_</property>
20. <property name="columntyle">FU</property>
21. <property name="columnPrefix">[stu_</property>
22. <property name="columnsuffix">]</property>
23. <property name="columnseparator">_</property>
24. <property name="hibernate.dialect" >org.hibernate.dialect.MySQLDialect</property>
25. <property name="hibernate.show_sql">true</property><!-- 设置是否显示生成sql语句 -->
26. <property name="hibernate.format_sql">false</property><!-- 设置是否格式化sql语句-->
27. <mapping resource="com/bjpowernode/hibernate/User.hbm.xml" />
28. </session-factory>
29. </hibernate-configuration>

【User.hbm.xml】映射文件可以比较随意的修改或者设定了

1. <?xml version="1.0"?>
2. <!DOCTYPE hibernate-mapping PUBLIC
3. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
5. <hibernate-mapping>
6. <class name="com.bjpowernode.hibernate.User" table="Users">
7. <id name="id" column="pid">
8. <generator class="uuid" />
9. </id>
10. <property name="name" column="userName"></property>
11. <property name="password" column="pwd"></property>
12. <property name="createTime"></property>
13. <property name="expireTime"></property>
14. </class>
15. </hibernate-mapping>

最后修改一下【ExportDB】，主要是修改必须先设置NamingStrategy,在调用configure方法

1. package com.bjpowernode.hibernate;
2. import org.hibernate.cfg.Configuration;
3. import org.hibernate.tool.hbm2ddl.SchemaExport;
4. import com.tgb.hibernate.neatlyDB.DatabaseConfiguration;
5. import com.tgb.hibernate.neatlyDB.MyNamingStrategy;
6. /**
7. * 将hbm生成ddl
8. * @author Longxuan
9. *
10. */
11. public class ExportDB {
12. /**
13. * @param args
14. */
15. public static void main(String[] args) {
16. //默认读取hibernate.cfg.xml文件，并按照命名策略修改表、字段的名称
17. //Configuration cfg = new Configuration().configure();
18. //注意，必须先设置NamingStrategy,在调用configure方法
19. Configuration cfg = new Configuration().setNamingStrategy(MyNamingStrategy.getInstance()).configure();
20. SchemaExport export = new SchemaExport(cfg);
21. //true 在控制台打印ddl语句，true 导入ddl语句到数据库，即可执行
22. export.create(true, true);
23. }
24. }

看一下结果图吧：表名，字段名都已经修改过了。

上面演示的是生成数据表。在对数据库的增删改查时，只要同样设置NamingStrategy即可。

为了大家更为方便的使用，已经做成jar包分享给大家了，点这里下载。