資料庫實體類

❶ 實體類圖中的類和資料庫中的實體有什麼不同

一般最簡單的互聯網應用，因為沒有復雜的邏輯和業務，只是數據的簡單展示，那麼可以認為實體類就和資料庫中的表一致對應。沒有什麼不同，只是在UML之中所在的位置不同而已。也就是展示的視圖不同，一個叫E_R[資料庫設計]。一個叫類圖。類分析設計模型。

❷ 資料庫的實體類需要序列化嗎

傳輸的時候都是字元串所以需要序列化，自己需要用到對象的時候就反序列化
序列化：對象-->字元串
反序列化：字元串->對象 這么理解先。

❸ 如何根據資料庫的欄位動態創建實體類 用java啊～ 最好給點源碼和實例

你這個需求特殊，給你個思路。
先通過資料庫元數據對象DataBaseMetaData和ResultSetMetaData得到表的元數據的信息。
生成類，可以用反射的方式和修改位元組碼的方式。修改位元組碼方式可以使用開源的CGLib這個庫，Hibernate就是使用的這個庫。這個生成是在內存的。
估計，將java代碼寫成.java文件，再調用編譯器編譯形成class也能完成需求。
就是不知道哪個適合你。效率上，肯定是上面兩種好，最後一種差一些。

❹ 資料庫多個表與對應實體類怎麼建

實現的方法和詳細的操作步驟如下：

1、第一步，確保正確啟動與資料庫相關的服務，見下圖，轉到下面的步驟。

❺ netbeans如何通過資料庫創建實體類

使用資料庫類和JPA可以簡化資料庫交互程序設計。使用步驟如下：

1. 在「服務」中建立要連接的資料庫。
2. 新建項目

3. 新建 -》「持久性」-》「通過資料庫生成實體類」

4.選中要生成資料庫中的表，對應生成類。

5.新建-》「持久性」-》「通過實體生成JPA控制器類」

6.選中剛剛建立的資料庫實體類，生成對應JPA. 在此過程中自動生成 persistence.xml

7.在要使用的位置，實例化JPA.

7.1 EntityManagerFactory factory = Persistence.createEntityManagerFactory("XML中的persistence-unit name");

7.2 實例化。 「JPA控制器類名」 JPA控制器變數名 = new JPA控制器類名(factory);

7.3 使用 JPA控制器變數名.方法

tip：可以在控制器類中自由定義方法

❻ 如何根據資料庫中的表自動生成實體類

最好的做法是每張表對應一個實體類bean，如果一張表關聯其他表，把這張表對應的實體類加上就可以了。如果使用了Hibernate，就可以使用配置文件進行映射。

A. 實體類就是屬性類，通常定義在model層裡面。
B. 一般的實體類對應一個數據表，其中的屬性對應數據表中的欄位，這樣做對資料庫操作起來方便。

這樣做的好處：
1.對對象實體的封裝，體現OO思想。
2.屬性可以對欄位定義和狀態進行判斷和過濾
3.把相關信息用一個實體類封裝後，我們在程序中可以把實體類作為參數傳遞，更加方便。
C. 說白了就是為了讓程序員在對資料庫操作的時候不用寫sql語句
D. 就是一個資料庫表生成一個類

❼ 設計資料庫和實體類的一些問題

出道早的程序員往往喜歡第二種，個人比較喜歡第一種。這當然也得看業務需要和個人習慣。

一般來說，對象的持久化我們都會選用成熟的Hibernate框架來完成。現在提倡面對對象編程，既然是面對對象，個人認為是先設計實體。然後由H框架根據所需要的配置來完成資料庫表的創建。

資料庫的結構和工作原理比較復雜，對於程序員來說，不便像DBA那樣去管理操作資料庫。H框架比較成熟，完全可以交給它來創建表，但一定要注意配置，如果配置不當，嚴重的話還會影響項目的運行！

再一個，對於程序員來說，對實體類的設計更為熟悉，得心應手。

當然，並不是所有的項目都適用H框架，比如說項目中各實體間的關系太復雜、數據的查詢量過大或十分頻繁等。

❽ 如何通過java反射將資料庫表生成實體類

首先有幾點聲明：
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 = 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, 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 = 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 ArrayList<String>();
getAllEntityTable(conn, tablenames);
System.out.println(tablenames);
// 為每個實體表生成實體類
genEntity(tablenames, conn);
} else {
// 為指定實體表生成實體類
genEntity(tablename, conn);
}

// 關閉資料庫連接
if (conn != null) {
DB.close(conn);
}
}

}

}

❾ 代碼生成器是什麼如何根據資料庫去產生實體類

我們在編寫代碼的過程中會發現有很多代碼是有規律的，編寫起來無味、繁瑣。
這個時候我們可以根據規律來編寫一些程序來生成這些代碼，這個生成代碼的程序就是代碼生成器。
現階段代碼生成器有很多，其中我個人認為CodeSmith的功能最為強大。基本上你想要生成什麼樣的代碼都可以根據模版來生成，模版有自帶的，有別人編寫的，當然，你覺得不夠，也可以自己編寫模版。

至於如何根據資料庫生成實體類。他的原理是資料庫中的欄位就是將來生成實體類中的私有變數和屬性。
所以我們可以編寫模版來讀取資料庫中的欄位，然後來根據資料庫中的欄位來生成你所需要的變數和屬性。

至於Codesmith的具體使用，比較簡單，可以到網上搜索一下，有很多的介紹。

❿ 資料庫設計的流程中的「實體類」指什麼

就是資料庫表，在java中的class表現形式。