java資料庫封裝
⑴ java中如何實現對數據的封裝文字說明一下。
你可以創建一個VO對象類，把你需要封裝的數據創建成VO對象的屬性，並設置相對應的get、set方法，如果是多條數據的話，你可以創建LIST,list的每個元素為VO對象。
你得問題說的不是很明白，因為對不同的數據封裝，採取的方式不同。
⑵ （JAVA）怎樣將對資料庫的增刪查改方法封裝起來便於以後調用
public class DBRecordSet {
static private Logger log = Logger.getLogger(DBRecordSet.class.getName());
ResultSetMetaData md = null;
Connection conInner = null;
private int firstElementOfThisList = 0; //當前緩沖池中保存的記錄在整個結果集中的位置
private int countOfElementsInthisList = 0; //緩沖池中記錄的數目
private List resultList = null; //保存結果的緩沖池
private Vector columnMap = null;
private int cacheSize = -1; //保存結果的緩沖池大小
private int maxRecords = 10; //執行結果集的時候得到的最多的記錄數
private String strSQLStmt = null; //打開結果集的時候執行的SQL語句
private boolean isClosed = true; //結果集是否已經open
private int columnCount = -1; //結果集欄位數目
private int columnTypeInt[] = null;
private String columnTypeString[] = null;
private int curRow = 0; // 當前游標所在行，基數為 1
private int maxRow = -1; // 執行查詢語句得到的記錄數，基數為 1
private int curPage = -1; // 分頁顯示時當前所在頁，基數為 1
private int pageSize = -1; // 分頁顯示時每頁記錄數，基數為 1
private int pageCount = -1; // 分頁顯示時總頁數，基數為 1
private int updateCount = -1;
private boolean cursorDir = true;
DBConnectionManager connMgr = null;
private DBConnectionManager getConnectionManager() {
if (connMgr == null) {
connMgr = DBConnectionManager.getInstance();
}
return connMgr;
}
private int getCacheSize() {
if (this.cacheSize == -1) {
cacheSize = getConnectionManager().getCacheSize();
if (cacheSize <= 0)
cacheSize = 50;
}
return this.cacheSize;
}
public void setCacheSize(int size) {
this.cacheSize = size;
}
/**
* 構造函數
*/
public DBRecordSet() {
close();
}
public int execute(Connection con, String sql) {
if (con == null || sql == null || sql.length() <= 0) {
return -1;
}
Statement stmt = null;
try {
if (con.isClosed()) return -1;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 設置 ResultSet 對象可包含的最多行數
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//執行語句，判斷語句類型
log.debug("開始執行SQL語句: " + sql);
int resultCount = stmt.executeUpdate(sql);
log.debug("執行SQL語句成功: " + sql + "; 返回結果數目為" + resultCount);
return resultCount;
} catch (Exception e) {
log.error("執行SQL語句失敗:" + e.getMessage());
} finally {
try {
if (stmt != null)
stmt.close();
} catch (Exception e) {
log.error("關閉Statement失敗:" + e.getMessage());
return -1;
}
}
return -1;
}
public boolean openSelect(Connection con, String sql) {
Statement stmt = null;
ResultSet rs = null;
int n = 0, i = 0;
if (con == null) return false;
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
try {
if (con.isClosed()) return false;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 設置 ResultSet 對象可包含的最多行數
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//執行語句，判斷語句類型
log.debug("開始執行SQL語句: " + sql);
if (stmt.execute(sql)) {
log.debug("執行查詢語句成功");
rs = stmt.getResultSet();
md = rs.getMetaData();
columnCount = md.getColumnCount();
updateCount = -1;
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
if (columnMap != null) {
columnMap = null;
}
columnMap = new Vector(columnCount);
for (n = 1; n <= columnCount; ++n) {
String columnName = md.getColumnName(n).trim();
columnName = columnName.toLowerCase();
if (columnName == null || columnName.length() <= 0) {
columnName = "vcolumn_" + String.valueOf(n);
}
if (columnMap.contains(columnName)) {
columnName += "_" + String.valueOf(n);
}
columnMap.add(columnName);
}
/*
for (n = 1; n <= columnCount; ++n){
log.debug("查詢語句結果集的列" + n + ":" + String.valueOf(columnMap.get(n - 1)));
}
*/
PropertyContainer property = null;
while (rs.next() && i < getCacheSize()) {
property = new PropertyContainerImpl();
for (n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
i++;
}
if (property != null)
log.debug("Open查詢的最後一條記錄是：" + property.valueToString());
if (i > 0) { //如果有記錄取出
firstElementOfThisList = 1;
countOfElementsInthisList = resultList.size();
maxRow = i;
if (i >= getCacheSize()) { //記錄沒有取完
//注意：為了兼容以前代碼，這里需要將結果集滾動到最後，用來獲得記錄數目
while (rs.next()) maxRow++;
maxRow++;
}
curRow = 0;
} else {//如果沒有記錄
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
curRow = -1;
maxRow = 0;
log.debug("沒有記錄返回：" + sql);
}
log.debug("open: 讀取從第0條記錄開始的" + getCacheSize() + "條記錄, 返回記錄" + countOfElementsInthisList + "條。總記錄數為" + maxRow + "條");
} else {
// 執行更新語句後將查詢結果集關閉並清除各項信息
int updatecount = stmt.getUpdateCount();
close();
updateCount = updatecount;
log.debug("成功執行更新語句");
} //保存執行的SQL語句
strSQLStmt = sql;
} catch (SQLException e) {
log.error(e.toString() + " : 執行SQL語句時出錯：" + sql);
return false;
} catch (Exception e) {
log.error(e.toString() + " : 執行SQL語句時出錯：" + sql);
return false;
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
//getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 結果集不能正確關閉");
//getConnectionManager().freeConnectionInner(con);
return false;
}
}
isClosed = false;
return true;
}
/**
* 執行SQL語句，可以為查詢或更新語句。
* 執行更新語句後調用 getUpdateCount() 取得所更新的記錄數
*
* @param sql 執行的SQL語句
*/
public boolean open(String sql) {
Statement stmt = null;
ResultSet rs = null;
int n = 0, i = 0;
Connection con = getConnectionManager().getConnectionInner();
if (con == null) return false;
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
try {
if (con.isClosed()) return false;
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
// 設置 ResultSet 對象可包含的最多行數
if (maxRecords > 1) stmt.setMaxRows(maxRecords);
//執行語句，判斷語句類型
log.debug("開始執行SQL語句: " + sql);
if (stmt.execute(sql)) {
log.debug("執行查詢語句成功");
rs = stmt.getResultSet();
md = rs.getMetaData();
columnCount = md.getColumnCount();
updateCount = -1;
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
if (columnMap != null) {
columnMap = null;
}
columnMap = new Vector(columnCount);
for (n = 1; n <= columnCount; ++n) {
String columnName = md.getColumnName(n).trim();
columnName = columnName.toLowerCase();
if (columnName == null || columnName.length() <= 0) {
columnName = "vcolumn_" + String.valueOf(n);
}
if (columnMap.contains(columnName)) {
columnName += "_" + String.valueOf(n);
}
columnMap.add(columnName);
}
/*
for (n = 1; n <= columnCount; ++n){
log.debug("查詢語句結果集的列" + n + ":" + String.valueOf(columnMap.get(n - 1)));
}
*/
PropertyContainer property = null;
while (rs.next() && i < getCacheSize()) {
property = new PropertyContainerImpl();
for (n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
i++;
}
if (property != null)
log.debug("Open查詢的最後一條記錄是：" + property.valueToString());
if (i > 0) { //如果有記錄取出
firstElementOfThisList = 1;
countOfElementsInthisList = resultList.size();
maxRow = i;
if (i >= getCacheSize()) { //記錄沒有取完
//注意：為了兼容以前代碼，這里需要將結果集滾動到最後，用來獲得記錄數目
while (rs.next()) maxRow++;
maxRow++;
}
curRow = 0;
} else {//如果沒有記錄
firstElementOfThisList = 0;
countOfElementsInthisList = 0;
curRow = -1;
maxRow = 0;
log.debug("沒有記錄返回：" + sql);
}
log.debug("open: 讀取從第0條記錄開始的" + getCacheSize() + "條記錄, 返回記錄" + countOfElementsInthisList + "條。總記錄數為" + maxRow + "條");
} else {
// 執行更新語句後將查詢結果集關閉並清除各項信息
int updatecount = stmt.getUpdateCount();
close();
updateCount = updatecount;
log.debug("成功執行更新語句");
} //保存執行的SQL語句
strSQLStmt = sql;
} catch (SQLException e) {
log.error(e.toString() + " : 執行SQL語句時出錯：" + sql);
return false;
} catch (Exception e) {
log.error(e.toString() + " : 執行SQL語句時出錯：" + sql);
return false;
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 結果集不能正確關閉");
getConnectionManager().freeConnectionInner(con);
return false;
}
}
isClosed = false;
return true;
}
/**
* 根據語句，得到從startIndex開始的count條記錄
*/
private void getResultAt(int start, int count) throws Exception {
if (isClosed) {
throw new Exception("還沒有打開結果集");
}
Statement stmt = null;
ResultSet rs = null;
Connection con = getConnectionManager().getConnectionInner();
int readStart = start;
int readCount = count;
if (con == null) {
log.error("無法獲得有效連接");
throw new Exception("getResultAt: 無法獲得有效連接");
}
try {
stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
rs = stmt.executeQuery(strSQLStmt);
if (resultList != null) {
resultList.clear();
resultList = null;
}
resultList = new ArrayList();
// skip initial rows as specified by the start parameter.
while (start-- > 1 && rs.next()) ;
//分別對每一個欄位，取出數值，放到BaseBusinessObject的PropertyContainer中
while (count-- > 0 && rs.next()) {
PropertyContainer property = new PropertyContainerImpl();
for (int n = 1; n <= columnCount; ++n) {
try {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getObject(n));
} catch (Exception e) {
property.addPropertyBy(String.valueOf(columnMap.get(n - 1)), rs.getString(n));
}
}
resultList.add(property);
}
log.debug("getResultAt: 讀取從第" + readStart + "條記錄開始的" + readCount + "條記錄, 返回記錄" + resultList.size() + "條");
} catch (SQLException e) {
throw new Exception(e.toString());
} finally {
try {
if (rs != null) {
rs.close();
rs = null;
}
if (stmt != null) {
stmt.close();
stmt = null;
}
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
log.error(e.toString() + " : 結果集不能正確關閉");
getConnectionManager().freeConnectionInner(con);
}
}
}
/**
* 執行SQL語句，可以為查詢或更新語句。
* 執行更新語句後調用 getUpdateCount() 取得所更新的記錄數
*
* @param sql 執行的SQL語句
*/
public boolean openGBK(String sql) {
return open(Convert.toGBK(sql));
}
/**
* 返回執行查詢語句後表的列數
*/
public int getColumnCount() {
return columnCount;
}
/**
* 返回每列的類型，基數為 1
*
* @param schema 表模式名
* @param table 表名
*/
public int[] getColumnType(String schema, String table) {
Connection con = null;
ResultSet results = null;
List list = new ArrayList();
if (columnTypeInt == null) {
log.debug("getColumnType: getConnection");
con = getConnectionManager().getConnectionInner();
if (con == null) return null;
try {
DatabaseMetaData dmd;
dmd = con.getMetaData();
results = dmd.getColumns(null, null, table.toUpperCase(), null);
//
while (results.next()){
list.add(new Integer(results.getInt("DATA_TYPE")));
}
columnTypeInt = new int[list.size()];
for(int i = 0; i < list.size(); i++){
Integer type = (Integer)list.get(i);
columnTypeInt[i] = type.intValue();
}
} catch (Exception e) {
return null;
} finally {
try {
results.close();
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
getConnectionManager().freeConnectionInner(con);
log.error(e.toString() + " : 結果集不能正確關閉");
return null;
}
}
}
return columnTypeInt;
}
/**
* 返回每列的名稱，基數為 1
*
* @param schema 表模式名
* @param table 表名
*/
public String[] getColumnName(String schema, String table) {
Connection con = null;
ResultSet results = null;
if (columnTypeString == null) {
log.debug("getColumnName: getConnection");
con = getConnectionManager().getConnectionInner();
if (con == null) return null;
try {
DatabaseMetaData dmd;
dmd = con.getMetaData();
results = dmd.getColumns(null, null, table.toUpperCase(), null);
//
int i = 1;
while (results.next()) i++;
columnTypeString = new String[i];
i = 1;
results.beforeFirst();
while (results.next()) columnTypeString[i++] = results.getString("COLUMN_NAME").trim();
} catch (Exception e) {
return null;
} finally {
try {
results.close();
getConnectionManager().freeConnectionInner(con);
} catch (Exception e) {
getConnectionManager().freeConnectionInner(con);
log.error(e.toString() + " : 結果集不能正確關閉");
return null;
}
}
}
return columnTypeString;
}
/**
* 返回執行更新語句後實際更新的記錄數
*/
public int getUpdateCount() {
return updateCount;
}
/**
* 設置查詢語句執行完後取得的最大記錄數
*
* @param maxrec 最大記錄數
*/
public void setMaxRecords(int maxrec) {
maxRecords = maxrec;
}
/**
* 返回查詢語句執行完後取得的最大記錄數
*/
public int getMaxRecords() {
return maxRecords;
}
/**
* 關閉查詢結果集並清除各項信息
*/
public void close() {
md = null;
firstElementOfThisList = 0; //當前緩沖池中保存的記錄在整個結果集中的位置
countOfElementsInthisList = 0; //緩沖池中記錄的數目
if (resultList != null) {
int size = resultList.size();
⑶ java與資料庫打包
其實不用
如果已經打包好exe文件
在做程序之前
你就應該把資料庫連接的伺服器ip地址改為你需要連接的主機上
比如我以前是loaclhost
或者127.0.0.1
我現在打包了
要到別的機器上運行
只需要改成我的ip
就可以了
這樣即使對方在其他機器上運行
也不用考慮到對方機器上有沒資料庫的問題了
⑷ 在java中將資料庫裡面的數據r如何封裝到一個集合裡面，菜鳥求大神指點迷津（集合的元素是對象 ）
while(rs.next()){
Subjectsubject=newSubject();
subject.setSubjectID(rs.getString("subjectID"));
subject.setSubjectTitle(rs.getString("subjectTitle"));
subject.setSubjectOptionA(rs.getString("subjectOptionA"));
subject.setSubjectOptionB(rs.getString("subjectOptionB"));
subject.setSubjectOptionC(rs.getString("subjectOptionC"));
subject.setSubjectOptionD(rs.getString("subjectOptionD"));
subject.setSubjectAnswer(rs.getString("subjectAnswer"));
subject.setSubjectParse(rs.getString("subjectParse"));
subjectList.add(subject);
}這樣就可以了。你應該能明白吧。要每回new一個新的。
⑸ Java資料庫連接封裝類
try{
class.forName(driver);
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
錯了，應該寫在方法裡面。。。
public Connection getConnection()
{
try{
class.forName(driver);
connection = DriverManager.getConnection(URL,username,password);
}
catch (SQLException e1)
{
e1.printStackTrace();
}
catch (ClassNotFoundException e)
{
e.printStackTrace();
}
return connection;
}
或者把他放在構造方法里。
當然是：
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
編譯肯定不對。
⑹ java 如何實現封裝
c#中類的封裝、繼承和多態,在C#中可使用類來達到數據封裝的效果，這樣就可以使數據與方法封裝成單一元素，以便於通過方法存取數據。除此之外，還可以控制數據的存取方式。面向封裝
在C#中可使用類來達到數據封裝的效果，這樣就可以使數據與方法封裝成單一元素，以便於通過方法存取數據。除此之外，還可以控制數據的存取方式。
面向對象程序設計中一般以類作為數據封裝的基本單位。類將數據和操作數據的方法結合成一個單位。在設計類時，不希望直接存取類中的數據，而是希望通過方法來存取數據。如此就可以達到封裝數據的目的，方便以後維護、升級，也可以在操作數據時多一層判斷，提高安全性。
封裝還可以解決數據存取許可權問題，使用封裝可以將數據隱藏起來，形成一個封閉的空間，用戶可以設置哪些數據只能在這個空間中使用，哪些數據可以在空間外部使用。如果一個類中包含敏感數據，則有些用戶可以訪問，有些用戶卻不能訪問。如果不對這些數據的訪問加以限制，那麼後果是很嚴重的。所以，在編寫程序時，要對類的成員使用不同的訪問修飾符，從而定義它們的訪問級別。
繼承
繼承是OOP最重要的特性之一。任何類都可以從另外一個類繼承，即這個類擁有它所繼承類的所有成員。在OOP中，被繼承的類稱為父類或基類。C#
提供了類的繼承機制，但C# 只支持單繼承，不支持多重繼承，即在C# 中一次只允許繼承一個類，不能同時繼承多個類。
利用繼承機制，用戶可以通過增加、修改或替換類中方法對這個類進行擴充，以適應不同的應用要求。利用繼承，程序開發人員可以在已有類的基礎上構造新類。繼承使得類支持分類的概念。在日常生活中很多東西比較有條理，那是因為它們有著很好的層次分類。如果不用層次分類，則要對每個對象定義其所有的性質。使用繼承後，每個對象就可以只定義自己的特殊性質。每一層的對象只需定義本身的性質，其他性質可以從上一層繼承下來。
在C# 中，介面允許多繼承，可以通過繼承多個介面來實現類似於C++中的多重繼承。
在繼承一個基類時，成員的可訪問性是一個重要的問題。子類不能訪問基類的私有成員，但是可以訪問其公共成員。子類和外部代碼都可以訪問公共成員。這就是說，只使用這兩個可訪問性，就可以讓一個成員被基類和子類訪問，同時也可以被外部的代碼訪問。
為了解決這個問題，C#
還提供了第3種可訪問性：protected。只有派生類才能訪問protected成員，基類和外部代碼都不能訪問protected成員。
除了成員的保護級別外，用戶還可以為成員定義其繼承行為。基類的成員可以是虛擬的，成員可以由繼承它的類重寫。子類可以提供成員的其他執行代碼。這種執行代碼不會刪除原來的代碼，仍可以在類中訪問原來的代碼，但外部代碼不能訪問它們。如果沒有提供其他執行方式，外部代碼就訪問基類中成員的執行代碼。
虛擬成員不能是私有成員，因為成員不能同時由子類重寫，也不能訪問它。基類還可以定義為抽象類。抽象類不能直接實例化，要使用抽象類就必須繼承這個類，然後再實例化。
多態
繼承使得派生與基類的類在方法上有一定的重疊，因此可以使用相同的語法處理從同一個基類實例化的對象。
多態使得子類的實例可以直接賦予基類的變數，不需要進行強制類型轉換，直接就可以通過這個變數調用基類的方法。
在派生於同一個類的不同對象上執行任務時，多態是一種極為有效的技巧，使用的代碼最少。可以把一組對象放到一個數組中，然後調用它們的方法，這些對象不必是相同類型的對象，在這種情況下多態的作用就體現出來了。當然如果它們都繼承自某個類，可以把這些派生類都放到一個數組中。如果這些對象都有同名方法，可以調用每個對象的同名方法。
⑺ java對資料庫操作的封裝是怎麼樣的
java本身對資料庫沒有封裝,對資料庫封裝好的有hibernate,ibatis(mybatis),hibernate封裝的比較徹底,基本操作不用自己寫SQL語句,ibatis的話還是要自己寫SQL語句,比較靈活.
⑻ java 資料庫查詢數據的封裝和提取
mkhjmbx