如何使用myeclipse反向生成实体类

1         创建Web项目

1.1     MyEclipse中创建Java Web项目工程。项目工程名自己定，J2EE Specification Level选择Java EE 5.0

2  添加项目的Hibernate支持

2.1  点击MyEclipse右上角的透视图切换扭，打开透视图切换窗。

选择MyEclipseHibernate透视图。

2.2  在MyEclipse Hibernate 透视图右侧的DB Browser窗口中点击右键选择New…新建，创建一个数据库连接。d出DataBase Driver的对话框

2.3 DataBaseDriver对话框中依次选择：

Driver Template ——数据连接的类型

Driver Name ——连接的名称（自己定）

Connection URL ——数据库连接字符串

User name —— 数据库连接用户名

Password —— 数据库连接密码

然后在Driver JARs中添加数据库的驱动jar文件。

点击“Test Driver”按钮测试连接是否正常。

选中Save Password可以保存密码。

设置全部正确后，点“Finish”按钮。数据库连接创建成功后可以在右侧DB Broswer窗口中看见新建的连接。

2.4  连接创建成功后切换回MyEclipse Java Enterprise透视图

在刚刚创建的项目工程上点击右键，选择MyEclipse->Add Hibernate Capabilities...给项目工程添加Hibernate支持。

2.5  给项目工程添加Hibernate支持是通过向导的方式一步步完成的。

第一步，选择Hibernate版本。使用默认项，直接点Next

第二步，Hibernate的配置文件。新项目MyEclipse会帮助创建一个，直接Next

第三步，配置Hibernate的数据库连接。在DB Driver列表中选择刚刚创建的数据库连接。

第四步，生成Hibernate的辅助工具类HibernateSessionFactory。由于后期使用Spring框架来提供Hibernate访问支持，所以这个类在这个阶段可以创建，也可以不建。但如果创建的话，最好把它保存到自定义的util子包中。

好了！项目工程中Hibernate的支持就做好了。MyEclipse会在 *** 作完成后自动打开hibernate.cfg.xml文件，可以用可视化的方式配置hibernate的相关设置。

2.6为项目工程添加如下这些包

2.7切换回MyEclipse Hibernate透视图。

在右侧DB Browser窗口中双击刚刚创建的数据库连接项，打开连接。成功和数据库建立连接后，找到我们在数据库连接时用户名所对应的节点，然后打开TABLE就可以看见事先创建好的数据库表了。

2.8通常情况是，在DB Browser窗口的已打开连接节点中选中用户创建的所有的表。然后点右键，选择Hibernate ReverseEngineering…，使用Hibernate反向工程。通过反向工程来帮助我们生产出和数据库表结构对应的Hibernate实体类和实体类映射文件(hbm.xml文件)。

2.9   反向工程也是需要几个步骤

第一步就是配置数据表到实体类之间的映射。

Java src folder ——指定把反向工程生成的文件放入到那个项目中（这里要指向到src文件夹才可以）

Java package ——实体类和映射文件存放到哪个包当中。（这里通常是项目中的entity包里）

Create POJO<>DB Table mapping information —— 是否生成对应的映射文件(*.hbm.xml文件)

Add Hibernate Mapping Annotations to POJO ——  使用注解配置实体类（注意！上述两者中选择一种即可，要么是实体类+.hbm.xml，实体类+注解）

Java Data Object (POJO <>DB Table) —— 是否生成实体类文件（注意！下面的Createabstract class不要选！因为实体类不需要抽象父类）

第二步是配置类型映射的细节，基本上用默认项就都可以了。直接Next 下一步

第三步是实体类及关联的细节定制。

在左侧可以看见我们需要生成实体类和映射文件的数据表。当选中某张表的时候，可以在右侧的Table details项中设置

Class name: 表所对应的实体类的名字【注意：在这里直接把包名和类名完整些出来是最合适的写法】

Id Generator: 当前这张表中主键列的生成策略

下面的两项定制就是关于实体的映射关系了。

Generate support for ListedTable(fk)->UnlistedTable:确认是否生成当前这个实体类的多对一关联映射。

Generate support for UnlistedTable(fk)->ListedTable:确认是否生成当前这个实体类的一对多关联映射。

注意！如果数据库表之间没有添加外键约束，映射不会生成。

全部设置完成后，点击“Finish”按钮。需要的实体类，实体类映射文件，以及Hibernate配置文件中的映射添加就全部自动完成了。

首先有几点声明：

1、代码是在别人的基础进行改写的；

2、大家有什么改进的意见可以告诉我，也可以自己改好共享给其他人；

3、刚刚毕业，水平有限，肯定有许多不足之处；

4、希望刚刚学习java的同学能有所启发。

//这个是做转换的类，里面的DB只是封装了数据库的连接，大家可以用自己的，随意

package com.tt.util.gen.entity.tool

import java.io.File

import java.io.FileWriter

import java.io.IOException

import java.io.InputStream

import java.io.PrintWriter

import java.sql.Connection

import java.sql.DatabaseMetaData

import java.sql.DriverManager

import java.sql.PreparedStatement

import java.sql.ResultSet

import java.sql.ResultSetMetaData

import java.sql.SQLException

import java.util.ArrayList

import java.util.Date

import java.util.List

import java.util.Properties

import com.tt.util.DB

public class GenEntityMysql {

private String packageOutPath// 指定实体生成所在包的路径

private String authorName// 作者名字

private String tablename// 表名

private String databasename// 数据库名

private List<String>tablenames// 拿到对应数据库中所有的实体类（实体类需要与其他表明做区分）

private List<String>colnames// 列名集合

private List<String>colTypes// 列名类型集合

private boolean f_util = false// 是否需要导入包java.util.*

private boolean f_sql = false// 是否需要导入包java.sql.*

/*

* 构造函数

*/

public GenEntityMysql() {

// 使用properties读取配置文件

Properties prop = new Properties()

try {

InputStream genentity = getClass().getResourceAsStream(

"/genentity.properties")

prop.load(genentity)

if (genentity != null) {

genentity.close()

}

} catch (Exception e) {

System.out.println("file " + "catalogPath.properties"

+ " not found!\n" + e)

}

this.databasename = prop.getProperty("databasename").toString()

this.tablename = prop.getProperty("tablename").toString()

this.packageOutPath = prop.getProperty("packageOutPath").toString()

this.authorName = prop.getProperty("authorName").toString()

}

// 创建多个实体类

private void genEntity(List<String>tablenames, Connection conn) {

// 使用第归生成文件

for (String tablename : tablenames) {

this.genEntity(tablename, conn)

}

}

// 创建单个实体类

private void genEntity(String tablename, Connection conn) {

String sql = "select * from " + tablename

PreparedStatement pstmt = null

ResultSetMetaData rsmd = null

try {

pstmt = DB.getPStmt(conn, sql)

rsmd = pstmt.getMetaData()

int size = rsmd.getColumnCount()// 统计列

colnames = new ArrayList<String>()

colTypes = new ArrayList<String>()

for (int i = 0i <sizei++) {

colnames.add(rsmd.getColumnName(i + 1))

colTypes.add(rsmd.getColumnTypeName(i + 1))

if (colTypes.get(i).equalsIgnoreCase("datetime")) {

f_util = true

}

if (colTypes.get(i).equalsIgnoreCase("image")

|| colTypes.get(i).equalsIgnoreCase("text")) {

f_sql = true

}

}

System.out.println(colnames)

System.out.println(colTypes)

} catch (SQLException e1) {

// TODO Auto-generated catch block

e1.printStackTrace()

} finally {

DB.close(pstmt)

}

// 在内存中生成代码

String content = parse(tablename)

// 写入到文件中

try {

File directory = new File("")

String outputPath = directory.getAbsolutePath() + "/src/"

+ this.packageOutPath.replace(".", "/") + "/"

System.out.println("写出的路径:" + outputPath)

// 检测路径是否存在，不存在就创建路径

File path = new File(outputPath)

if (!path.exists() &&!path.isDirectory()) {

path.mkdir()

System.out.println(path.exists())

}

// 创建文件

outputPath += initcap(tablename) + ".java"

File file = new File(outputPath)

if (!file.exists()) {

file.createNewFile()

}

// 写出到硬盘

FileWriter fw = new FileWriter(file)

PrintWriter pw = new PrintWriter(fw)

pw.println(content)

pw.flush()

pw.close()

} catch (IOException e) {

e.printStackTrace()

}

}

private void getAllEntityTable(Connection conn, List<String>tablenames) {

ResultSet rs = null

try {

DatabaseMetaData dmd = (DatabaseMetaData) conn.getMetaData()

/*

* TABLE_CAT String =>表类别（可为 null）

* TABLE_SCHEM String =>表模式（可为null）

* TABLE_NAME String =>表名称

* TABLE_TYPE String =>表类型

*/

rs = dmd.getTables(null, null, "%", null)

while (rs.next()) {

tablenames.add(rs.getString("TABLE_NAME"))

}

} catch (SQLException e) {

e.printStackTrace()

} finally {

try {

rs.close()

} catch (SQLException e) {

e.printStackTrace()

}

}

}

/**

*

* @param tablename

* @return

*/

private String parse(String tablename) {

StringBuffer sb = new StringBuffer()

// 判断是否导入工具包

if (f_util) {

sb.append("import java.util.Date\r\n")

}

if (f_sql) {

sb.append("import java.sql.*\r\n")

}

sb.append("package " + this.packageOutPath + "\r\n")

sb.append("\r\n")

// 注释部分

sb.append(" /**\r\n")

sb.append("* " + tablename + " 实体类\r\n")

sb.append("* " + new Date() + " " + this.authorName + "\r\n")

sb.append("*/ \r\n")

// 实体部分

sb.append("\r\n\r\npublic class " + initcap(tablename) + "{\r\n")

processAllAttrs(sb)// 属性

processAllMethod(sb)// get set方法

sb.append("}\r\n")

return sb.toString()

}

/**

* 功能：生成所有属性

*

* @param sb

*/

private void processAllAttrs(StringBuffer sb) {

for (int i = 0i <colnames.size()i++) {

sb.append("\tprivate " + sqlType2JavaType(colTypes.get(i)) + " "

+ colnames.get(i) + "\r\n")

}

}

/**

* 功能：生成所有方法

*

* @param sb

*/

private void processAllMethod(StringBuffer sb) {

for (int i = 0i <colnames.size()i++) {

sb.append("\tpublic void set" + initcap(colnames.get(i)) + "("

+ sqlType2JavaType(colTypes.get(i)) + " " + colnames.get(i)

+ "){\r\n")

sb.append("\t\tthis." + colnames.get(i) + "=" + colnames.get(i)

+ "\r\n")

sb.append("\t}\r\n")

sb.append("\tpublic " + sqlType2JavaType(colTypes.get(i)) + " get"

+ initcap(colnames.get(i)) + "(){\r\n")

sb.append("\t\treturn " + colnames.get(i) + "\r\n")

sb.append("\t}\r\n")

}

}

/**

* 功能：将输入字符串的首字母改成大写

*

* @param str

* @return

*/

private String initcap(String str) {

char[] ch = str.toCharArray()

if (ch[0] >= 'a' &&ch[0] <= 'z') {

ch[0] = (char) (ch[0] - 32)

}

return new String(ch)

}

/**

* 功能：获得列的数据类型

*

* @param sqlType

* @return

*/

private String sqlType2JavaType(String sqlType) {

if (sqlType.equalsIgnoreCase("bit")) {

return "boolean"

} else if (sqlType.equalsIgnoreCase("tinyint")) {

return "byte"

} else if (sqlType.equalsIgnoreCase("smallint")) {

return "short"

} else if (sqlType.equalsIgnoreCase("int")) {

return "int"

} else if (sqlType.equalsIgnoreCase("bigint")) {

return "long"

} else if (sqlType.equalsIgnoreCase("float")) {

return "float"

} else if (sqlType.equalsIgnoreCase("decimal")

|| sqlType.equalsIgnoreCase("numeric")

|| sqlType.equalsIgnoreCase("real")

|| sqlType.equalsIgnoreCase("money")

|| sqlType.equalsIgnoreCase("smallmoney")) {

return "double"

} else if (sqlType.equalsIgnoreCase("varchar")

|| sqlType.equalsIgnoreCase("char")

|| sqlType.equalsIgnoreCase("nvarchar")

|| sqlType.equalsIgnoreCase("nchar")

|| sqlType.equalsIgnoreCase("text")) {

return "String"

} else if (sqlType.equalsIgnoreCase("datetime")) {

return "Date"

} else if (sqlType.equalsIgnoreCase("image")) {

return "Blod"

}

return null

}

/**

* 出口 TODO

*

* @param args

*/

public static void main(String[] args) {

new GenEntityMysql().start()

}

private void start() {

// 创建连接

Connection conn = DB.getConn()

if (databasename != null &&!databasename.equals("")

&&tablename != null &&!tablename.equals("")) {

System.out.println("databasename 和 tablename 不能同时存在")

} else {

// 如果配置文件中有数据库名字，则可以拿到其中所有的实体类

if (databasename != null &&!databasename.equals("")) {

// 获取所有实体表名字

tablenames = new ArrayList<String>()

getAllEntityTable(conn, tablenames)

System.out.println(tablenames)

// 为每个实体表生成实体类

genEntity(tablenames, conn)

} else {

// 为指定实体表生成实体类

genEntity(tablename, conn)

}

// 关闭数据库连接

if (conn != null) {

DB.close(conn)

}

}

}

}

可以根据规律来编写一些程序来生成这些代码，这个生成代码的程序就是代码生成器。

现阶段代码生成器有很多，其中我个人认为CodeSmith的功能最为强大。基本上你想要生成什么样的代码都可以根据模版来生成，模版有自带的，有别人编写的，当然，你觉得不够，也可以自己编写模版。

至于如何根据数据库生成实体类。

他的原理是数据库中的字段就是将来生成实体类中的私有变量和属性。

所以我们可以编写模版来读取数据库中的字段，然后来根据数据库中的字段来生成你所需要的变量和属性。

至于Codesmith的具体使用，比较简单，可以到网上搜索一下，有很多的介绍。

---