Intellij IDEA 通过数据库表生成带注解的实体类详细步骤

前言：idea 功能很强大，以前不知道有这样的提升工作效率的方法，虽然有的工具确实可以直接生成实体类，mapper文件，还有dao接口，但是个人觉得涉及到复杂业务还是只生成实体类比较好，后面部分就自己搞定就可以了。

一、连接数据库

打开项目：

1、点击右侧的datesource图标，要是没有该图标，请去自行百度

2、点击 + 号

3、选择 datasource

4、选择 mysql

1、填写一个连接名，随便填什么都行

2、不用选择，默认就行

3、填写数据库连接的 IP地址，比如本地数据库可以填写：localhost或者127.0.0.1

4、填写数据库开放的端口号，一般没设置的话默认都是3306

5、填写你需要连接的数据库名

6、填写数据库的用户名

7、填写数据库密码

8、这里会有一个驱动需要点击下载，图中是已经下载好了

9、填写自己的数据库连接url，然后可以点击9所在按钮进行测试连接，本地连接失败检查是否开启了mysql服务

 

连接好了如上图所示，可以看到自己的数据库和表，选择一个表右键，网上教程一般到这里结束，都是选择说Generate POJOs.groovy，然后在弹出窗口选择需要生成的文件夹所在即可。

我选择一张表进行生成示例如下：

表明去除了“_”然后以驼峰方式生成了类名，而且开始的package 路径也不对，重点是没有注释，没有注释，没有注释！

网上搜了一些方法，都不太行，要不就是到处报错，没辙只能自己瞎琢磨。没想到最后也不难，下面就是实现：

右键选择表，在选择Generate POJOs.groovy 的下面那一项：

进来只有Generate POJOs.groovy，右键新建另外一个比如我的叫做：Generate MyPOJOs.groovy，里面内容如下：

1. import com.intellij.database.model.DasTable  
2. import com.intellij.database.model.ObjectKind  
3. import com.intellij.database.util.Case  
4. import com.intellij.database.util.DasUtil  
5. import java.io.*  
6. import java.text.SimpleDateFormat  
7.   
8. /* 
9.  * Available context bindings: 
10.  *   SELECTION   Iterable<DasObject> 
11.  *   PROJECT     project 
12.  *   FILES       files helper 
13.  */  
14. packageName = ""  
15. typeMapping = [  
16.         (~/(?i)tinyint|smallint|mediumint/)      : "Integer",  
17.         (~/(?i)int/)                             : "Long",  
18.         (~/(?i)bool|bit/)                        : "Boolean",  
19.         (~/(?i)float|double|decimal|real/)       : "Double",  
20.         (~/(?i)datetime|timestamp|date|time/)    : "Date",  
21.         (~/(?i)blob|binary|bfile|clob|raw|image/): "InputStream",  
22.         (~/(?i)/)                                : "String"  
23. ]  
24.   
25.   
26. FILES.chooseDirectoryAndSave("Choose directory", "Choose where to store generated files") { dir ->  
27.     SELECTION.filter { it instanceof DasTable && it.getKind() == ObjectKind.TABLE }.each { generate(it, dir) }  
28. }  
29.   
30. def generate(table, dir) {  
31. //    def className = javaClassName(table.getName(), true)  
32.     def className = javaName(table.getName(), true)  
33.     def fields = calcFields(table)  
34.     packageName = getPackageName(dir)  
35.     PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(new FileOutputStream(new File(dir, className + ".java")), "UTF-8"))  
36.     printWriter.withPrintWriter {out -> generate(out, className, fields,table)}  
37.   
38. //    new File(dir, className + ".java").withPrintWriter { out -> generate(out, className, fields,table) }  
39. }  
40.   
41. // 获取包所在文件夹路径  
42. def getPackageName(dir) {  
43.     return dir.toString().replaceAll("\\\\", ".").replaceAll("/", ".").replaceAll("^.*src(\\.main\\.java\\.)?", "") + ";" 
44. } 
45.  
46. def generate(out, className, fields,table) { 
47.     out.println "package $packageName" 
48.     out.println "" 
49.     out.println "import javax.persistence.Column;" 
50.     out.println "import javax.persistence.Entity;" 
51.     out.println "import javax.persistence.Table;" 
52.     out.println "import java.io.Serializable;" 
53. //    out.println "import lombok.Getter;" 
54. //    out.println "import lombok.Setter;" 
55. //    out.println "import lombok.ToString;" 
56.     Set types = new HashSet() 
57.  
58.     fields.each() { 
59.  
60.         types.add(it.type) 
61.     } 
62.  
63.     if (types.contains("Date")) { 
64.         out.println "import java.util.Date;" 
65.     } 
66.  
67.     if (types.contains("InputStream")) { 
68.         out.println "import java.io.InputStream;" 
69.     } 
70.     out.println "" 
71.     out.println "/**\n" + 
72.             " * @Description  \n" + 
73.             " * @Author  zhj\n" + 
74.             " * @Date "+ new SimpleDateFormat("yyyy-MM-dd").format(new Date()) + " \n" + 
75.             " */" 
76.     out.println "" 
77. //    out.println "@Setter" 
78. //    out.println "@Getter" 
79. //    out.println "@ToString" 
80.     out.println "@Entity" 
81.     out.println "@Table ( name =\""+table.getName() +"\" )"  
82.     out.println "public class $className  implements Serializable {"  
83.     out.println ""  
84.     out.println genSerialID()  
85.     fields.each() {  
86.         out.println ""  
87.         // 输出注释  
88.         if (isNotEmpty(it.commoent)) {  
89.             out.println "\t/**"  
90.             out.println "\t * ${it.commoent.toString()}"  
91.             out.println "\t */"  
92.         }  
93.   
94.         if (it.annos != "") out.println "   ${it.annos.replace("[@Id]", "")}"  
95.   
96.         // 输出成员变量  
97.         out.println "\tprivate ${it.type} ${it.name};"  
98.     }  
99.   
100.     // 输出get/set方法  
101.     fields.each() {  
102.         out.println ""  
103.         out.println "\tpublic ${it.type} get${it.name.capitalize()}() {"  
104.         out.println "\t\treturn this.${it.name};"  
105.         out.println "\t}"  
106.         out.println ""  
107.   
108.         out.println "\tpublic void set${it.name.capitalize()}(${it.type} ${it.name}) {"  
109.         out.println "\t\tthis.${it.name} = ${it.name};"  
110.         out.println "\t}"  
111.     }  
112.     out.println ""  
113.     out.println "}"  
114. }  
115.   
116. def calcFields(table) {  
117.     DasUtil.getColumns(table).reduce([]) { fields, col ->  
118.         def spec = Case.LOWER.apply(col.getDataType().getSpecification())  
119.   
120.         def typeStr = typeMapping.find { p, t -> p.matcher(spec).find() }.value  
121.         def comm =[  
122.                 colName : col.getName(),  
123.                 name :  javaName(col.getName(), false),  
124.                 type : typeStr,  
125.                 commoent: col.getComment(),  
126.                 annos: "\t@Column(name = \""+col.getName()+"\" )"]  
127.         if("id".equals(Case.LOWER.apply(col.getName())))  
128.             comm.annos +=["@Id"]  
129.         fields += [comm]  
130.     }  
131. }  
132.   
133. // 处理类名（这里是因为我的表都是以t_命名的，所以需要处理去掉生成类名时的开头的T，  
134. // 如果你不需要那么请查找用到了 javaClassName这个方法的地方修改为 javaName 即可）  
135. def javaClassName(str, capitalize) {  
136.     def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)  
137.             .collect { Case.LOWER.apply(it).capitalize() }  
138.             .join("")  
139.             .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")  
140.     // 去除开头的T  http://developer.51cto.com/art/200906/129168.htm  
141.     s = s[1..s.size() - 1]  
142.     capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]  
143. }  
144.   
145. def javaName(str, capitalize) {  
146. //    def s = str.split(/(?<=[^\p{IsLetter}])/).collect { Case.LOWER.apply(it).capitalize() }  
147. //            .join("").replaceAll(/[^\p{javaJavaIdentifierPart}]/, "_")  
148. //    capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]  
149.     def s = com.intellij.psi.codeStyle.NameUtil.splitNameIntoWords(str)  
150.             .collect { Case.LOWER.apply(it).capitalize() }  
151.             .join("")  
152.             .replaceAll(/[^\p{javaJavaIdentifierPart}[_]]/, "_")  
153.     capitalize || s.length() == 1? s : Case.LOWER.apply(s[0]) + s[1..-1]  
154. }  
155.   
156. def isNotEmpty(content) {  
157.     return content != null && content.toString().trim().length() > 0  
158. }  
159.   
160. static String changeStyle(String str, boolean toCamel){  
161.     if(!str || str.size() <= 1)  
162.         return str  
163.   
164.     if(toCamel){  
165.         String r = str.toLowerCase().split('_').collect{cc -> Case.LOWER.apply(cc).capitalize()}.join('')  
166.         return r[0].toLowerCase() + r[1..-1]  
167.     }else{  
168.         str = str[0].toLowerCase() + str[1..-1]  
169.         return str.collect{cc -> ((char)cc).isUpperCase() ? '_' + cc.toLowerCase() : cc}.join('')  
170.     }  
171. }  
172.   
173. static String genSerialID()  
174. {  
175.     return "\tprivate static final long serialVersionUID =  "+Math.abs(new Random().nextLong())+"L;"  
176. }  

完成后，点击此处，选择project 切换回来：

这时，我们再次选择表，右键，选择我们自己新建的 groovy，然后选择生成存放的文件夹路径，生成：

可以看到，生成的类名，package路径，以及已经实现了序列化，也加上了注解，指明了每个属性对应的表字段，如果@Table和@Column没有引入包，还请在maven中添加相关依赖：

<dependency>
    <groupId>javax.persistence</groupId>
    <artifactId>persistence-api</artifactId>
    <version>1.0.2</version>
</dependency>