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