如何通過java反射將數據庫表生成實體類

首先有幾點聲明：

成都創新互聯公司是一家以成都網站建設、網頁設計、品牌設計、軟件運維、成都網站推廣、小程序App開發等移動開發為一體互聯網公司。已累計為房屋鑒定等眾行業中小客戶提供優質的互聯網建站和軟件開發服務。

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 ListString tablenames;// 拿到對應數據庫中所有的實體類（實體類需要與其他表明做區分）

private ListString colnames; // 列名集合

private ListString 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(ListString 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 ArrayListString();

colTypes = new ArrayListString();

for (int i = 0; i size; i++) {

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, ListString 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 = 0; i 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 = 0; i 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 ArrayListString();

getAllEntityTable(conn, tablenames);

System.out.println(tablenames);

// 為每個實體表生成實體類

genEntity(tablenames, conn);

} else {

// 為指定實體表生成實體類

genEntity(tablename, conn);

}

// 關閉數據庫連接

if (conn != null) {

DB.close(conn);

}

}

}

}

JAVA如何設計實體類？

實體類，只要里面包含屬性跟方法就可以了，例如public class demo{

private int age;

private String name;

}。這就是一個標準的實體類

java比較實體類

這種情況你可以使用反射去寫一個通用的方法，不過前提是你的那些實體類都是簡單的包裝類，稍后奉上代碼。代碼如下：

package?pojo;

/**

*?Created?by?liaokai?on?2017/11/17?0017.

*/

public?class?Person?{

private?String?name;

private?int?age;

public?Person(String?name,?int?age)?{

this.name?=?name;

this.age?=?age;

}

public?String?getName()?{

return?name;

}

public?void?setName(String?name)?{

this.name?=?name;

}

public?int?getAge()?{

return?age;

}

public?void?setAge(int?age)?{

this.age?=?age;

}

@Override

public?boolean?equals(Object?o)?{

if?(this?==?o)?return?true;

if?(o?==?null?||?getClass()?!=?o.getClass())?return?false;

Person?person?=?(Person)?o;

if?(age?!=?person.age)?return?false;

return?name?!=?null???name.equals(person.name)?:?person.name?==?null;

}

@Override

public?int?hashCode()?{

int?result?=?name?!=?null???name.hashCode()?:?0;

result?=?31?*?result?+?age;

return?result;

}

@Override

public?String?toString()?{

return?"Person{"?+

"name='"?+?name?+?'\''?+

",?age="?+?age?+

'}';

}

}

package?util;

import?pojo.Person;

import?java.lang.reflect.Field;

import?java.util.ArrayList;

import?java.util.HashMap;

import?java.util.List;

import?java.util.Map;

/**

*?Created?by?liaokai?on?2017/11/17?0017.

*/

public?class?CompareUtilT?{

public?ListMap?compareT(T?t1,T?t2,String?className){

ListMap?list?=?new?ArrayListMap();

//內容沒改變直接返回

if(t1.equals(t2)){

return?list;

}

try?{

Class?c?=?Class.forName(className);

//讀取t1和t2中的所有屬性

Field[]?fields?=?c.getDeclaredFields();

for?(int?i?=?0;?i??fields.length;?i++)?{

Field?field?=fields[i];

field.setAccessible(true);

Object?value1=field.get(t1);

Object?value2=field.get(t2);

//判斷這兩個值是否相等

if(!isValueEquals(value1,value2)){

Map?map?=?new?HashMap();

map.put("name",field.getName());

map.put("before",value1);

map.put("after",value2);

list.add(map);

}

}

}?catch?(ClassNotFoundException?e)?{

e.printStackTrace();

}?catch?(IllegalAccessException?e)?{

e.printStackTrace();

}

return?list;

}

private?boolean?isValueEquals(Object?value1,?Object?value2)?{

if(value1==nullvalue2==null){

return?true;

}

if(value1==nullvalue2!=null){

return?false;

}

if(value1.equals(value2)){

return?true;

}

return?false;

}

}

package?pojo;

import?util.CompareUtil;

/**

*?Created?by?liaokai?on?2017/11/17?0017.

*/

public?class?Test?{

public?static?void?main(String[]?args)?{

Person?p1?=?new?Person("張三",14);

Person?p2?=?new?Person("張三",15);

Person?p3?=?new?Person("李四",15);

CompareUtilPerson?compareUtil?=?new?CompareUtilPerson();

System.out.println(compareUtil.compareT(p1,p1,Person.class.getName()));

System.out.println(compareUtil.compareT(p1,p2,Person.class.getName()));

System.out.println(compareUtil.compareT(p1,p3,Person.class.getName()));

System.out.println(compareUtil.compareT(p2,p3,Person.class.getName()));

}

}

//運行結果

[]

[{before=14,?name=age,?after=15}]

[{before=張三,?name=name,?after=李四},?{before=14,?name=age,?after=15}]

[{before=張三,?name=name,?after=李四}]

java里面實體類和dao類 有一段實例，希望各位高手給注釋一下 要詳細的注釋，字數有限 就不想實體類了

package s2jsp.bysj.dao; //此類所在包的名稱

import java.sql.Connection; //導入Connection類

import java.sql.PreparedStatement; //導入PreparedStatement類

import java.sql.ResultSet; //導入ResultSet類

import java.util.ArrayList; //導入ArrayList類

import java.util.List; //導入List類

import s2jsp.bysj.entity.Users; //導入Users實體類

public class UserDao extends BaseDao { //UserDao類繼承了BaseDao類

private Connection conn; //聲明私有變量：Connection對象

private PreparedStatement pstmt; //聲明私有變量：PreparedStatement對象

private ResultSet rs; //聲明私有變量：ResultSet數據集對象

/**

* 根據用戶名和密碼，查找相關用戶信息

* @return Users類的對象：用戶對象

*@userName 用戶名

*@password 用戶密碼

*/

public Users findUsers(String userName, String password) {

Users user = null; //聲明實體類Users對象

String sql = "select * from users where userName=? and password=? "; //定義sql變量，此變量用來代替執行的SQL語句

try { //將會發生異常的代碼放在了try{}catch{}塊中

conn = this.getConn(); //初始化了Connection對象：conn，getConn()方法是繼承自BaseDao的方法

pstmt = conn.prepareStatement(sql); //初始化PreparedStatement對象：pstmt

pstmt.setString(1, userName); //為SQL語句中的參數1設置值

pstmt.setString(2, password); //為SQL語句中的參數2設置值

rs = pstmt.executeQuery(); //用PreparedStatement的對象的executeQuery()方法初始化ResultSet對象：rs

if (rs.next()) { //如果ResultSet的next()方法返回true，則說明目標數據庫中的下一行有數據

user = new Users(); //初始化Users實體類，此類準備用來初始化其域

user.setUserID(rs.getInt("userID")); //用數據庫中的值初始化Users實體類中的UserID字段

user.setUserName(userName); //用數據庫中的值初始化Users實體類中的UserName字段

user.setPassword(password); //用數據庫中的值初始化Users實體類中的Password字段

user.setStatus(rs.getInt("status")); //用數據庫中的值初始化Users實體類中的Status字段

}

} catch (Exception e) { //catch內使用了Exception異常根類的printStackTrace()方法：表示將錯誤信息打印在堆棧上

e.printStackTrace();

} finally { //finally塊中的語句表示始終要執行的語句，并且在try語句塊后執行

this.closeAll(conn, pstmt, rs); //try語句塊中執行完畢或發生異常則使用closeAll()關閉所有使用到的數據庫連接對象，此處省略this也可以，conn是Connection對象，pstmt是PreparedStatement對象，rs是ResultSet對象

}

return user; //此方法最后返回Users實體類的對象，注：如果方法定義有返回值則一定要加此關鍵字

}

/**

* 判斷數據庫中當前用戶名是否存在

* @param userName 用戶名

* @return 存在返回true,否則返回false

*/

public boolean findUsers(String userName){ //此方法用來查找傳入的用戶是否存在，返回一個布爾類型的值，true表示存在，false表示不存在

String sql = "select * from users where userName=? "; //定義SQL語句并放入sql變量中，這樣的好處是簡化了代碼的長度和復用的便利

try {

conn = this.getConn(); //用BaseDao類的getConn()方法初始化Connection對象：conn

pstmt = conn.prepareStatement(sql); //用Connection對象的prepareStatement()方法初始化PreparedStatement對象：pstmt

pstmt.setString(1, userName); //設置SQL語句參數1的值：userName

rs = pstmt.executeQuery(); //使用PreparedStatement對象的executeQuery()方法初始化ResultSet對象：rs

if (rs.next()) { //如果數據庫中有記錄則返回true，此時方法停止

return true;

}

} catch (Exception e) {

e.printStackTrace(); //將錯誤信息打印到控制臺

} finally {

this.closeAll(conn, pstmt, rs); //關閉所有使用到的數據庫連接對象，此處可省略this關鍵字

}

return false; //最后的返回值可以是任意布爾類型的值

}

/**

* 添加用戶信息

* @param userName

* @param password

* @return 操作數據庫影響行數

*/

public int insertUser(String userName, String password,int status) { //插入一個用戶的方法，此方法類的參數跟數據庫中強制不為空的列是一一對應的

String sql = "insert into users values(?,?,?) "; //定義SQL語句

String[] params = new String[] { userName, password ,status+""}; //定義字符串數組用來存放傳入的參數，因為傳入的參數可能不止一個所以定義一個字符串數組來存放，困了余下的代碼都差不多所以我簡單寫了

return this.executeSQL(sql, params);

}

/**

* 查找所有的注冊用戶信息

* @return 用戶列表

*/

public List selectAllUser(){

List list=new ArrayList(); //實例化一個ArrayList對象，因為ArrayList是List對象的子類

String sql = "select * from users ";

try {

conn = this.getConn();

pstmt = conn.prepareStatement(sql);

rs = pstmt.executeQuery();

while(rs.next()) {

Users user = new Users();

user.setUserID(rs.getInt("userID"));

user.setUserName(rs.getString("userName"));

user.setPassword(rs.getString("password"));

user.setStatus(rs.getInt("status"));

list.add(user);

}

} catch (Exception e) {

e.printStackTrace();

} finally {

this.closeAll(conn, pstmt, rs);

}

return list; //此方法返回一個List對象

}

/**

* 根據用戶ID,進行刪除操作

* @param userID

* @return 執行SQL語句所影響的數據庫行數

*/

public int deleteUserByID(String userID){

String sql="delete from users where userID = ? "; //?號表示占位符號此處要用一個變量表示

String[] param = new String[]{ userID };

return this.executeSQL(sql, param);

}

}

//PreaparedStatement和Statement比較而言，PreparedStatement更適合于做修改插入的操作，應為此類是預編譯的類，他的執行效率要高于Statement類。而普通的查詢則使用Statement就可以了。

//ResultSet是結果集的意思，他用來存放從數據庫中讀取到的所有數據，他用next()方法來確定下一行是否還有數據，用返回的布爾類型值類表示。使用ResultSet對象的getXX(index)方法獲取程序從數據庫中讀取到的值，index為參數位置，從1開始，1對應數據中第一個字段。

//Connection是連接的意思，他的PreparedStatement和createStatement分別用來初始化PreaparedStatement對象和Statement對象。為SQL語句中的參數賦值用PreparedStatement對象的setXX(index,值)方法，參數位置從1開始遞增。

//List是一個接口，ArrayList是實現了List接口的類，也可以其為List的子類，所以List lst=new ArrayList();是一種編譯時多態的表現，是完全允許的。其返回的是ArrayList子類的對象。ArrayList一般用來對數據的遍歷查詢，而LinkedList則比較擅長于增刪改，他們都是集合，在此處用來存放實體類的對象。

//try{}catch{}finally{}就不用我多說了吧！用來捕捉容易發生異常的代碼段，一些拋出異常的類是要求強制捕捉的，如果不捕捉編輯器會報告一個錯誤。finally{}塊中的代碼是無論代碼執行正確與否則都會執行，此處用來對數據庫連接對象執行關閉操作。

//其實我也是一個初學者，說了這么多也許還有很多沒說到的地方，當然這段代碼如果要解釋完全是要牽扯到很多Java知識，應為篇幅和個人精力和知識量有限，先說到這兒了，各位也請多多包涵，多多指正吧！

誰能幫我寫下java實體類

@Entity

@Table(name = "t_book")

public class Book implements Serializable{

private static final long serialVersionUID = -2738902322135434977L;

@GenericGenerator(name = "generator", strategy = "uuid")

@Id

@GeneratedValue(generator = "generator")

@Column(name = "uuid", unique = true, nullable = false, length = 32)

private String uuid;

@Column(name = "t_type)

private int type;

@Column(name = "t_Name", length =30)

private String name;

@Column(name = "t_Author", length = 30)

private String naAuthor;

自己生成get set 方法

java的實體類應該怎么寫，給個例子。謝謝。

public class Test{

private String a;

public Test(){}

public static void main(String[] args){}

}

這是最常見的。

還有很多種。

文章題目：java實體類代碼,java實體類轉實體類
當前URL：http://vcdvsql.cn/article42/hecohc.html

成都網站建設公司_創新互聯，為您提供云服務器、響應式網站、服務器托管、品牌網站建設、定制網站、企業網站制作

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯