gender:
<%
JDBConnection
jdbc
=
new
JDBConnection();
String
sql
=
"select
*
from
gender";
ResultSet
rs
=
null;
rs
=
jdbc.executeQuery(sql);
while
(rs.next())
{
%>
">
<%=rs.getString("gender")%>
<%
}
%>
---------
JDBConnection是我写的一个javabean，封装了数据库的各种操作。
以上有此假设：有一个数据表内gender，里面有个字容段gender，但只有两条记录（M和F）。
子获取值的时候就只获取gender的值就行了。
String
gender
=
request.getParameter("gender");
㈡ JSP对数据库的基本操作
直接将你要的连接封装成一个数据库的连接类，在这个类中值完成数据库的连接和关闭不做任何事情，要用的时候直接调用就是了，你说的<jsp:useBean id="db" class "bean.ConnDB" scope="session"/>....
JavaBean是一种符合特定规范的Java对象，在JavaBean中定义了一系列的属性（也就是成员变量），并提供了访问和设置这些属性的公共方法（也就是getXXX和setXXX方法）。JavaBean可以作为共享数据存放在page、request、session和application范围内。在JSP文件中，可以通过专门的标签来定义或访问JavaBean。例如：<jsp:useBean id="uuwoxin" scopo="page/request/session/application" class="BaiUser">（--使用BaiUser类实例化一个对象uuwoxin，相当于BaiUser uuwoxin=new BaiUser();--）
输出一个JavaBean的某个属性到页面上的时候，可以使用<jsp:getProperty name="uuwoxin" property="password">(--相当于uuwoxin.getPassword();--)
设置一个JavaBean的某个属性，可以使用<jsp:setProperty name="uuwoxin" property="password" value="uuwoxin_password">（--相当于uuwoxin.setPassword("uuwoxin_password");--）
用于实例化JavaBean对象的类是写在后台的，比如Tomcat站点中WEB-INF/classes文件夹下，并且需要编译成字节码文件(.class)。
struts框架中的ActionForm Bean就是一种典型的JavaBean。
深入了解JavaBean可以访问：http://java.sun.com/procts/javabeans。
㈢ JAVA web 与数据库的连接到底是怎样连的啊
JAVA Web开发中与数据库的连接操作，配置：
1、新建数据库。
新建登录角色，在新建数据库的时候把数据库的所有权交给你新建的角色。用用户和密码控制数据库。保证数据库的安全。
2、编写context.xml文件 Xml文件的目的是封装用户和密码，也是封装的一种，方便操作。
以下为context.xml文件样例：
<?xml version="1.0" encoding="utf-8"?>
<Context reloadable = "true">
<Resource
name="jdbc/sampleHS"
type="javax.sql.DataSource"
maxActive="14"
maxIdle="10"
username="hstaoshu"
maxWait="5000"
driverClassName="org.postgresql.Driver"
password="hstaoshu"
url="jdbc:postgresql://localhost:5432/hstaoshu"/>
</Context>
详细说明：
name="jdbc/sampleHS"里面的ssampHS是可改名称，建议根据需要自己命名；
username="hstaoshu"
password="hstaoshu"此两项为你新建的数据库登录角色用户名和密码信息，只有匹配 了才能访问。这里简单为了表示，把用户名和密码弄成了跟数据库名字一样。其实这是很不安全的。
url="jdbc:postgresql://localhost:5432/hstaoshu"/>
这是连接数据库的URl,就像访问网站的地址一样。没有这个是无法访问数据库的。localhost:5432表示本地端口。一般不需要改动，如果你在配置数据库的时候改动过端口，那么你需要把它改回来。/hstaoshu是你的数据库名称。
其他选项请勿擅自改动。
3、编写DAO类。
DAO类的作用是与数据连接后，对数据库的一些操作的封装。封装的作用。为了更好的数据管理。
DAO是真正如何使用数据库的关键步骤，前两步只是部署和配置。
private static InitialContext context = null;
private DataSource dataSource = null;
//一般把跟数据库的连接放在DAO类的构造函数里，只要被实例化，就能和数据库连接。
public BookDAO() {
try {
if (context == null) {
context = new InitialContext();
}
dataSource = (DataSource) context.lookup("java:comp/env/jdbc/sampleHS");
// 连接数据库，前面在context.xml文件配置里的URl
} catch (NamingException e2) {
e2.printStackTrace();
}
}
public Connection getConnection() {
Connection conn = null;
try {
conn = dataSource.getConnection();// 获得数据源的连接对象
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
做完上面的三步操作，开发环境已经完全和数据库连接OK,可以开始数据库的操作了。一般来说，对数据库的操作语句都是提前封装好的。这样修改起来会对下面的代码影响降到最小。
如下：
// ------------------数据库操作语句代码封装------------------
/* 查看所有图书 */
private static final String SELECT_ALL_SQL = "SELECT * FROM book";
那么在使用的时候只要直接调用：
pstmt = conn.prepareStatement(SELECT_ALL_SQL);
㈣ 用javabean怎么样才能显示数据库中的数据，（Java与数据库已通过jdbc在另已在中连接 ）
数据库中有个学生表(STUDENT)，字段有学号、姓名、性别、生日。
1、建立学生对应的JavaBean
publicclassStudent{
privateintno;
privateStringname;
privateintsex;
privateDatebirthday;
//setter、getter方法
}2、从数据库中查询数据封装到JavaBean中
Stringsql="select*fromstudent";
ps=connection.preparestatement(sql);
rs=ps.execeteQuery();
ArrayList<Student>list=newArrayList<Student>();
while(rs.hasNext()){
Students=newStudent();
s.setNo(rs.getInt("NO"));
//...
list.add(s);
}
//然后遍历list就可以拿到Student的数据了。
㈤ 关于javabean和DAO模式
JavaBean是数据的承载体，负责把一组有逻辑的数据从一个层传到另一个层。
DAO的出现是对持久层的变动的一个解决方案。
对于不同的持久介质(RDBMS、XML、ODBMS等)、不同的提供厂商(Oracle、Mysql等)提供的产品，进行持久化操作时，对于业务逻辑层应该是统一的，于是DAO模式就出现了。
对于同一个业务操作，例如添加一个用户，请求到达业务层，只需调用DAO层的addUser()即可。而到底是怎么添加的、以及添加到哪里，是业务层不用关心的，也是不要关心的。
于是，持久层将利用业务层传递来的请求数据，即封装了要添加的用户信息JavaBean，添加到持久层：Oracle就要取序列，Mysql会自动增长，XML就要手动控制了。这些实现细节对业务逻辑层是一样的效果。
但是DAO模式中也会有一些数据承载体，不过它们承载的不是业务数据，而是持久化操作的相关对象，例如DAO对象，DAO工厂，连接对象等。表面上看，这些也承载数据，但它实际是包含了内在的逻辑和操作。例如连接对象的打开和关闭，事务的回滚和提交等。
所以，严格意义上来说，它们不是纯粹的JavaBean。纯粹的JavaBean是只包含属性和这些属性对应的getter和setter。
㈥ jsp中封装数据库操作，例如数据库连接，条件查询等到javabean中，怎么做
封装到bean里面有点麻烦，等于自己实现简易orm了，况且多表查询时还不好操作，把结果集放到List里面还好
㈦ （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();