logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

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

 hongjing_z 2019-02-12

前言：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中添加相关依赖：

  1. <dependency>
  2.     <groupId>javax.persistence</groupId>
  3.     <artifactId>persistence-api</artifactId>
  4.     <version>1.0.2</version>
  5. </dependency>

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： hongjing_z > 《Idea》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多