引用：http://blog.csdn.net/itblog/article/details/981136
到目前为目,JDBC2的连结池只是一个接口,没有真正的实现,JDBC3正在开发中,据报已经支持连结池,但..........
JDBC3用了JNDI技术,连结池的配置可以让一个高手都烦死.
目前第三方已经实现的连结池当然是poolman,1.0版对一般用户来说已经足够用了.配置也简单,2.0版虽然增加了一些功能,但配置也是采用JNDI,对RMI和EJB不懂的朋友可能很烦.建议用1.0的了.
如果有兴趣,自己也可以实现连结池,最关键的技术也就是把连结作为参数传给一个BEAN,用完后返回这个参数连结而不是关闭.
下面是一个简单的实现:
DBConnectionManager.java程序清单如下：
001 import java.io.*;
002 import java.sql.*;
003 import java.util.*;
004 import java.util.Date;
005
006 /**
007 * 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接
008 * 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例.
009 */
010 public class DBConnectionManager {
011 static private DBConnectionManager instance; // 唯一实例
012 static private int clients;
013
014 private Vector drivers = new Vector();
015 private PrintWriter log;
016 private Hashtable pools = new Hashtable();
017
018 /**
019 * 返回唯一实例.如果是第一次调用此方法,则创建实例
020 *
021 * @return DBConnectionManager 唯一实例
022 */
023 static synchronized public DBConnectionManager getInstance() {
024 if (instance == null) {
025 instance = new DBConnectionManager();
026 }
027 clients++;
028 return instance;
029 }
030
031 /**
032 * 建构函数私有以防止其它对象创建本类实例
033 */
034 private DBConnectionManager() {
035 init();
036 }
037
038 /**
039 * 将连接对象返回给由名字指定的连接池
040 *
041 * @param name 在属性文件中定义的连接池名字
042 * @param con 连接对象/
043 */
044 public void freeConnection(String name, Connection con) {
045 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
046 if (pool != null) {
047 pool.freeConnection(con);
048 }
049 }
050
051 /**
052 * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
053 * 限制,则创建并返回新连接
054 *
055 * @param name 在属性文件中定义的连接池名字
056 * @return Connection 可用连接或null
057 */
058 public Connection getConnection(String name) {
059 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
060 if (pool != null) {
061 return pool.getConnection();
062 }
063 return null;
064 }
065
066 /**
067 * 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制,
068 * 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接.
069 *
070 * @param name 连接池名字
071 * @param time 以毫秒计的等待时间/
072 * @return Connection 可用连接或null
073 */
074 public Connection getConnection(String name, long time) {
075 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
076 if (pool != null) {
077 return pool.getConnection(time);
078 }
079 return null;
080 }
081
082 /**
083 * 关闭所有连接,撤销驱动程序的注册/
084 */
085 public synchronized void release() {
086 // 等待直到最后一个客户程序调用
087 if (--clients != 0) {
088 return;
089 }
090
091 Enumeration allPools = pools.elements();
092 while (allPools.hasMoreElements()) {
093 DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
094 pool.release();
095 }
096 Enumeration allDrivers = drivers.elements();
097 while (allDrivers.hasMoreElements()) {
098 Driver driver = (Driver) allDrivers.nextElement();
099 try {
100 DriverManager.deregisterDriver(driver);
101 log("撤销JDBC驱动程序 " + driver.getClass().getName()+"的注册///");
102 }
103 catch (SQLException e) {
104 log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());
105 }
106 }
107 }
108
109 /**
110 * 根据指定属性创建连接池实例.
111 *
112 * @param props 连接池属性
113 */
114 private void createPools(Properties props) {
115 Enumeration propNames = props.propertyNames();
116 while (propNames.hasMoreElements()) {
117 String name = (String) propNames.nextElement();
118 if (name.endsWith(".url")) {
119 String poolName = name.substring(0, name.lastIndexOf("."));
120 String url = props.getProperty(poolName + ".url");
121 if (url == null) {
122 log("没有为连接池" + poolName + "指定URL");
123 continue;
124 }
125 String user = props.getProperty(poolName + ".user");
126 String password = props.getProperty(poolName + ".password");
127 String maxconn = props.getProperty(poolName + ".maxconn", "0");
128 int max;
129 try {
130 max = Integer.valueOf(maxconn).intValue();
131 }
132 catch (NumberFormatException e) {
133 log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName);
134 max = 0;
135 }
136 DBConnectionPool pool =
137 new DBConnectionPool(poolName, url, user, password, max);
138 pools.put(poolName, pool);
139 log("成功创建连接池" + poolName);
140 }
141 }
142 }
143
144 /**
145 * 读取属性完成初始化
146 */
147 private void init() {
148 InputStream is = getClass().getResourceAsStream("/db.properties");
149 Properties dbProps = new Properties();
150 try {
151 dbProps.load(is);
152 }
153 catch (Exception e) {
154 System.err.println("不能读取属性文件. " +
155 "请确保db.properties在CLASSPATH指定的路径中");
156 return;
157 }
158 String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log");
159 try {
160 log = new PrintWriter(new FileWriter(logFile, true), true);
161 }
162 catch (IOException e) {
163 System.err.println("无法打开日志文件: " + logFile);
164 log = new PrintWriter(System.err);
165 }
166 loadDrivers(dbProps);
167 createPools(dbProps);
168 }
169
170 /**
171 * 装载和注册所有JDBC驱动程序/
172 *
173 * @param props 属性
174 */
175 private void loadDrivers(Properties props) {
176 String driverClasses = props.getProperty("drivers");
177 StringTokenizer st = new StringTokenizer(driverClasses);
178 while (st.hasMoreElements()) {
179 String driverClassName = st.nextToken().trim();
180 try {
181 Driver driver = (Driver)
182 Class.forName(driverClassName).newInstance();
183 DriverManager.registerDriver(driver);
184 drivers.addElement(driver);
185 log("成功注册JDBC驱动程序///" + driverClassName);
186 }
187 catch (Exception e) {
188 log("无法注册JDBC驱动程序: " +
189 driverClassName + ", 错误: " + e);
190 }
191 }
192 }
193
194 /**
195 * 将文本信息写入日志文件
196 */
197 private void log(String msg) {
198 log.println(new Date() + ": " + msg);
199 }
200
201 /**
202 * 将文本信息与异常写入日志文件
203 */
204 private void log(Throwable e, String msg) {
205 log.println(new Date() + ": " + msg);
206 e.printStackTrace(log);
207 }
208
209 /**
210 * 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最/
211 * 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.
212 */
213 class DBConnectionPool {
214 private int checkedOut;
215 private Vector freeConnections = new Vector();
216 private int maxConn;
217 private String name;
218 private String password;
219 private String URL;
220 private String user;
221
222 /**
223 * 创建新的连接池
224 *
225 * @param name 连接池名字
226 * @param URL 数据库的JDBC URL
227 * @param user 数据库帐号,或 null
228 * @param password 密码,或 null
229 * @param maxConn 此连接池允许建立的最大连接数
230 */
231 public DBConnectionPool(String name, String URL, String user, String password,
232 int maxConn) {
233 this.name = name;
234 this.URL = URL;
235 this.user = user;
236 this.password = password;
237 this.maxConn = maxConn;
238 }
239
240 /**
241 * 将不再使用的连接返回给连接池
242 *
243 * @param con 客户程序释放的连接
244 */
245 public synchronized void freeConnection(Connection con) {
246 // 将指定连接加入到向量末尾
247 freeConnections.addElement(con);
248 checkedOut--;
249 notifyAll();
250 }
251
252 /**
253 * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
254 * 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
255 * 然后递归调用自己以尝试新的可用连接.
256 */
257 public synchronized Connection getConnection() {
258 Connection con = null;
259 if (freeConnections.size() > 0) {
260 // 获取向量中第一个可用连接
261 con = (Connection) freeConnections.firstElement();
262 freeConnections.removeElementAt(0);
263 try {
264 if (con.isClosed()) {
265 log("从连接池" + name+"删除一个无效连接");
266 // 递归调用自己,尝试再次获取可用连接
267 con = getConnection();
268 }
269 }
270 catch (SQLException e) {
271 log("从连接池" + name+"删除一个无效连接");
272 // 递归调用自己,尝试再次获取可用连接
273 con = getConnection();
274 }
275 }
276 else if (maxConn == 0 || checkedOut < maxConn) {
277 con = newConnection();
278 }
279 if (con != null) {
280 checkedOut++;
281 }
282 return con;
283 }
284
285 /**
286 * 从连接池获取可用连接.可以指定客户程序能够等待的最长时间/
287 * 参见前一个getConnection()方法.
288 *
289 * @param timeout 以毫秒计的等待时间限制
290 */
291 public synchronized Connection getConnection(long timeout) {
292 long startTime = new Date().getTime();
293 Connection con;
294 while ((con = getConnection()) == null) {
295 try {
296 wait(timeout);
297 }
298 catch (InterruptedException e) {}
299 if ((new Date().getTime() - startTime) >= timeout) {
300 // wait()返回的原因是超时
301 return null;
302 }
303 }
304 return con;
305 }
306
307 /**
308 * 关闭所有连接
309 */
310 public synchronized void release() {
311 Enumeration allConnections = freeConnections.elements();
312 while (allConnections.hasMoreElements()) {
313 Connection con = (Connection) allConnections.nextElement();
314 try {
315 con.close();
316 log("关闭连接池" + name+"中的一个连接");
317 }
318 catch (SQLException e) {
319 log(e, "无法关闭连接池" + name+"中的连接");
320 }
321 }
322 freeConnections.removeAllElements();
323 }
324
325 /**
326 * 创建新的连接
327 */
328 private Connection newConnection() {
329 Connection con = null;
330 try {
331 if (user == null) {
332 con = DriverManager.getConnection(URL);
333 }
334 else {
335 con = DriverManager.getConnection(URL, user, password);
336 }
337 log("连接池" + name+"创建一个新的连接");
338 }
339 catch (SQLException e) {
340 log(e, "无法创建下列URL的连接: " + URL);
341 return null;
342 }
343 return con;
344 }
345 }
346 }
三、类DBConnectionPool说明/
该 类在209至345行实现，它表示指向某个数据库的连接池。数据库由JDBC URL标识。一个JDBC URL由三部分组成：协议标识（总是 jdbc），驱动程序标识（如 odbc、idb、oracle等），数据库标识（其格式依赖于驱动程序）。例如，jdbc:odbc:demo，即是一 个指向demo数据库的JDBC URL，而且访问该数据库要使用JDBC-ODBC驱动程序。每个连接池都有一个供客户程序使用的名字以及可选的用户帐 号、密码、最大连接数限制。如果Web应用程序所支持的某些数据库操作可以被所有用户执行，而其它一些操作应由特别许可的用户执行，则可以为两类操作分别 定义连接池，两个连接池使用相同的JDBC URL，但使用不同的帐号和密码。
类DBConnectionPool的建构函数需要上述所有数据作为其参数。如222至238行所示，这些数据被保存为它的实例变量：
如 252至283行、285至305行所示， 客户程序可以使用DBConnectionPool类提供的两个方法获取可用连接。两者的共同之处在于：如连 接池中存在可用连接，则直接返回，否则创建新的连接并返回。如果没有可用连接且已有连接总数等于最大限制数，第一个方法将直接返回null，而第二个方法 将等待直到有可用连接为止。
所有的可用连接对象均登记在名为freeConnections的向量（Vector）中。如果向量中有多于 一个的连接，getConnection()总是选取第一个。同时，由于新的可用连接总是从尾部加入向量，从而使得数据库连接由于长时间闲置而被关闭的风 险减低到最小程度。
第一个getConnection()在返回可用连接给客户程序之前，调用了isClosed()方法验证连接仍旧有 效。如果该连接被关闭或触发异常，getConnection()递归地调用自己以尝试获取另外的可用连接。如果在向量freeConnections中 不存在任何可用连接，getConnection()方法检查是否已经指定最大连接数限制。如已经指定，则检查当前连接数是否已经到达极限。此处 maxConn为0表示没有限制。如果没有指定最大连接数限制或当前连接数小于该值，该方法尝试创建新的连接。如创建成功，则增加已使用连接的计数并返 回，否则返回空值。
如325至345行所示，创建新连接由newConnection()方法实现。创建过程与是否已经指定数据库帐号、密码有关。
JDBC的DriverManager类提供多个getConnection()方法，这些方法要用到JDBC URL与其它一些参数，如用户帐号和密码等。DriverManager将使用指定的JDBC URL确定适合于目标数据库的驱动程序及建立连接。
在285至305行实现的第二个getConnection()方法需要一个以毫秒为单位的时间参数，该参数表示客户程序能够等待的最长时间。建立连接的具体操作仍旧由第一个getConnection()方法实现。
该 方法执行时先将startTime初始化为当前时间。在while循环中尝试获得一个连接。如果失败，则以给定的时间值为参数调用wait()。 wait()的返回可能是由于其它线程调用notify()或notifyAll()，也可能是由于预定时间已到。为找出wait()返回的真正原因，程 序用当前时间减开始时间（startTime），如差值大于预定时间则返回空值，否则再次调用getConnection()。
把空闲的 连接登记到连接池由240至250行的freeConnection()方法实现，它的参数为返回给连接池的连接对象。该对象被加入到 freeConnections向量的末尾，然后减少已使用连接计数。调用notifyAll()是为了通知其它正在等待可用连接的线程。
许 多Servlet引擎为实现安全关闭提供多种方法。数据库连接池需要知道该事件以保证所有连接能够正常关闭。DBConnectionManager类负 协调整个关闭过程，但关闭连接池中所有连接的任务则由DBConnectionPool类负责。在307至323行实现的release()方法供 DBConnectionManager调用。该方法遍历freeConnections向量并关闭所有连接，然后从向量中删除这些连接。
四、类DBConnectionManager 说明/
该类只能创建一个实例，其它对象能够调用其静态方法（也称为类方法）获得该唯一实例的引用。如031至036行所示，DBConnectionManager类的建构函数是私有的，这是为了避免其它对象创建该类的实例。
DBConnectionManager 类的客户程序可以调用getInstance()方法获得对该类唯一实例的引用。如018至029行所示，类的唯一实例在getInstance()方法 第一次被调用期间创建，此后其引用就一直保存在静态变量instance中。每次调用getInstance()都增加一个 DBConnectionManager的客户程序计数。即，该计数代表引用DBConnectionManager唯一实例的客户程序总数，它将被用于 控制连接池的关闭操作。
该类实例的初始化工作由146至168行之间的私有方法init()完成。其 中 getResourceAsStream()方法用于定位并打开外部文件。外部文件的定位方法依赖于类装载器的实现。标准的本地类装载器查找操作总是 开始于类文件所在路径，也能够搜索CLASSPATH中声明的路径。db.properties是一个属性文件，它包含定义连接池的键-值对。可供定义的 公用属性如下：
drivers 以空格分隔的JDBC驱动程序类列表/
logfile 日志文件的绝对路径
其它的属性和特定连接池相关，其属性名字前应加上连接池名字：
< poolname>.url 数据库的 JDBC URL
< poolname>.maxconn 允许建立的最大连接数，0表示没有限制
< poolname>.user 用于该连接池的数据库帐号
< poolname>.password 相应的密码/
其中url属性是必需的，而其它属性则是可选的。数据库帐号和密码必须合法。用于Windows平台的db.properties文件示例如下：
drivers=sun.jdbc.odbc.JdbcOdbcDriver jdbc.idbDriver
logfile=D://user//src//java//DBConnectionManager//log.txt
idb.url=jdbc:idb:c://local//javawebserver1.1//db//db.prp
idb.maxconn=2
access.url=jdbc:odbc:demo
access.user=demo
access.password=demopw
注意在Windows路径中的反斜杠必须输入2个，这是由于属性文件中的反斜杠同时也是一个转义字符。
init() 方法在创建属性对象并读取db.properties文件之后，就开始检查logfile属性。如果属性文件中没有指定日志文件，则默认为当前目录下的 DBConnectionManager.log文件。如日志文件无法使用，则向System.err输出日志记录。
装载和注册所有在 drivers属性中指定的JDBC驱动程序由170至192行之间的loadDrivers()方法实现。该方法先用StringTokenizer将 drivers属性值分割为对应于驱动程序名称的字符串，然后依次装载这些类并创建其实例，最后在 DriverManager中注册该实例并把它加入到 一个私有的向量drivers。向量drivers将用于关闭服务时从DriverManager取消所有JDBC 驱动程序的注册。
init() 方法的最后一个任务是调用私有方法createPools()创建连接池对象。如109至142行所示，createPools()方法先创建所有属性名 字的枚举对象（即Enumeration对象，该对象可以想象为一个元素系列，逐次调用其nextElement()方法将顺序返回各元素），然后在其中 搜索名字以“.url”结尾的属性。对于每一个符合条件的属性，先提取其连接池名字部分，进而读取所有属于该连接池的属性，最后创建连接池对象并把它保存 在实例变量pools中。散列表（Hashtable类 ）pools实现连接池名字到连接池对象之间的映射，此处以连接池名字为键，连接池对象为值。
为 便于客户程序从指定连接池获得可用连接或将连接返回给连接池，类DBConnectionManager提供了方法getConnection()和 freeConnection()。所有这些方法都要求在参数中指定连接池名字，具体的连接获取或返回操作则调用对应的连接池对象完成。它们的实现分别在 051至064行、066至080行、038至049行。
如082至107行所示，为实现连接池的安全关 闭，DBConnectionManager提供了方法release()。在上面我们已经提到，所有DBConnectionManager的客户程序 都应该调用静态方法getInstance()以获得该管理器的引用，此调用将增加客户程序计数。客户程序在关闭时调用release()可以递减该计 数。当最后一个客户程序调用release()，递减后的引用计数为0，就可以调用各个连接池的release()方法关闭所有连接了。管理类 release()方法最后的任务是撤销所有JDBC驱动程序的注册。
五、Servlet使用连接池示例
Servlet API所定义的Servlet生命周期类如：
1) 创建并初始化Servlet（init()方法）。
2) 响应客户程序的服务请求（service()方法）。
3) Servlet终止运行，释放所有资源（destroy()方法）。
本例演示连接池应用，上述关键步骤中的相关操作为：
1) 在init()，用实例变量connMgr 保存调用DBConnectionManager.getInstance()所返回的引用。
2) 在service()，调用getConnection()，执行数据库操作，用freeConnection()将连接返回给连接池。
3) 在destroy()，调用release()关闭所有连接，释放所有资源。
示例程序清单如下：
CODE:
import java.io.*;
import java.sql.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet {
private DBConnectionManager connMgr;
public void init(ServletConfig conf) throws ServletException {
super.init(conf);
connMgr = DBConnectionManager.getInstance();
}
public void service(HttpServletRequest req, HttpServletResponse res)
throws IOException {
res.setContentType("text/html");
PrintWriter out = res.getWriter();
Connection con = connMgr.getConnection("idb");
if (con == null) {
out.println("不能获取数据库连接.");
return;
}
ResultSet rs = null;
ResultSetMetaData md = null;
Statement stmt = null;
try {
stmt = con.createStatement();
rs = stmt.executeQuery("SELECT * FROM EMPLOYEE");
md = rs.getMetaData();
out.println("< H1>职工数据< /H1>");
while (rs.next()) {
out.println("< BR>");
for (int i = 1; i < md.getColumnCount(); i++) {
out.print(rs.getString(i) + ", ");
}
}
stmt.close();
rs.close();
} catch (SQLException e) {
e.printStackTrace(out);
}
connMgr.freeConnection("idb", con);
}
public void destroy() {
connMgr.release();
super.destroy();
}
}
发表于 @ 2006年03月17日 11:29 PM | 评论 (0)
从数据库中读出图片并显示的示例代码
< !-- -- -- -- -- -- -- -- -- -- -- -- -- --servlet-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -->
package Photo;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;
import java.lang.*;
import java.sql.*;
/**
* <p>Title: </p>
* <p>Description: </p>
* <p>Copyright: Copyright (c) 2002</p>
* <p>Company: </p>
* @author unascribed
* @version 1.0
*/
public class ShowImage extends HttpServlet {
private static final String CONTENT_TYPE = "image/*";
/**
* 定义数据库连接字符串，jdbc.odbc桥
*/
private String driver_class = "oracle.jdbc.driver.OracleDriver";
private String connect_string =
"jdbc:oracle:thin:xxw/xxw@192.168.1.50:1521:ORCL";
Connection conn = null;
ResultSet rs = null;
Statement stmt = null;
/********************************************
* 定义应用变量
******************************************/
private String SQLString = ""; //定义查询语句
public String M_EorrMenage = ""; //定义错误信息变量
private InputStream in = null; //定义输入流
private int len = 10 * 1024 * 1024; //定义字符数组长度
//Initialize global variables
public void init() throws ServletException {
/**
* 连接数据库
*/
try {
Class.forName(driver_class);
} catch (java.lang.ClassNotFoundException e) {
//异常
System.err.println("databean():" + e.getMessage());
}
}
//Process the HTTP Get request
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType(CONTENT_TYPE);
PrintWriter out = response.getWriter();
//在数据库中的照片的ID
int PHOTOID = 0;
/*********************************************
* 接受上文传递的图片ID号
* 上文传输文件名称为photoid
*********************************************/
try {
PHOTOID = Integer.parseInt(request.getParameter("photoid"));
SQLString = "select * from xxw_photo where p_id=" + PHOTOID;
} catch (Exception e) {
e.printStackTrace();
response.setContentType("text/html; charset=gb2312");
M_EorrMenage = "请输入图片ID号";
M_EorrMenage =
new String(M_EorrMenage.getBytes("ISO8859_1"), "GBK");
out.println("<%@ page contentType='text/html; charset=gb2312' %>");
out.println("<html>");
out.println("<head><title>id</title></head>");
out.println("<body>");
out.println("<p>" + M_EorrMenage + "</p>");
out.println("</body></html>");
}
/*****************************************************
* 执行查询语句
*****************************************************/
try {
conn = DriverManager.getConnection(connect_string);
stmt = conn.createStatement();
rs = stmt.executeQuery(SQLString);
} //try
catch (SQLException ex) {
System.err.println("aq.executeUpdate:" + ex.getMessage());
M_EorrMenage = "对不起，数据库无法完成此操作！";
M_EorrMenage =
new String(M_EorrMenage.getBytes("ISO8859_1"), "GBK");
response.setContentType("text/html; charset=gb2312");
out.println("<html>");
out.println("<head><title>no_database</title></head>");
out.println("<body>");
out.println("<p>" + M_EorrMenage + "</p>");
out.println("</body></html>");
}
/*********************************************
* 将图片流读入字符数组中，并显示到客户端
********************************************/
try {
if (rs.next()) {
in = rs.getBinaryStream("photo");
response.reset(); //返回在流中被标记过的位置
response.setContentType("image/jpg"); //或gif等
// int len=in.available();//得到文件大小
OutputStream toClient = response.getOutputStream();
byte[] P_Buf = new byte[len];
int i;
while ((i = in.read(P_Buf)) != -1) {
toClient.write(P_Buf, 0, i);
}
in.close();
toClient.flush(); //强制清出缓冲区
toClient.close();
} else {
M_EorrMenage = "无此图片！";
M_EorrMenage =
new String(M_EorrMenage.getBytes("ISO8859_1"), "GBK");
response.setContentType("text/html; charset=gb2312");
out.println("<html>");
out.println(
"<head><title>this photo isn't have</title></head>");
out.println("<body>");
out.println("<p>" + M_EorrMenage + "</p>");
out.println("</body></html>");
}
rs.close();
} catch (Exception e) {
e.printStackTrace();
M_EorrMenage = "无法读取图片！";
M_EorrMenage =
new String(M_EorrMenage.getBytes("ISO8859_1"), "GBK");
response.setContentType("text/html; charset=gb2312");
out.println("<%@ page contentType='text/html; charset=gb2312' %>");
out.println("<html>");
out.println("<head><title>no photo</title></head>");
out.println("<body>");
out.println("<p>" + M_EorrMenage + "</p>");
out.println("</body></html>");
}
}
//Clean up resources
public void destroy() {
try {
conn.close();
} catch (SQLException e) {
System.err.println("aq.executeUpdate:" + e.getMessage());
M_EorrMenage = "对不起，数据库无法完成此操作！";
}
}
}
<!---------------------------显示---------------------------------------------->
<html>
<head>
<title>Untitled Document</title>
</head>
<body bgcolor="#FFFFFF" text="#000000">
<table>
<%
int i=1;
while(i<3){
%>
<tr>
<td colspan="3"> <img border="1" src="http://192.168.1.50:8100/ShowImage?photoid=<%=i%>"></td>
</tr>
<%
i++;
}
%>
</table>
</body>
</html>
注：此程序对于从数据库读取图片后写入文件请参考代码者留意
发表于 @ 2006年03月17日 11:26 PM | 评论 (0)
消除JDBC的瓶颈
摘要大部分的 J2EE（Java 2 Platform, Enterprise Edition）和其它类型的Java应用都需要与数据库进行交互。与数据库进行交 互需要反复地调用SQL语句、连接管理、事务生命周期、结果处理和异常处理。这些操作都是很常见的；不过这个重复的使用并不是必定需要的。在这篇文章中， 我们将介绍一个灵活的架构，它可以解决与一个兼容JDBC的数据库的重复交互问题。
最近在为公司开发一个小的J2EE应用时，我 对执行和处理SQL调用的过程感到很麻烦。我认为在Java开发者中一定有人已经开发了一个架构来消除这个流程。不过，搜索诸如 /"Java SQL framework" 或者 "JDBC [Java Database Connectivity] framework"等都 没有得到满意的结果。
问题的提出？
在讲述一个解决方法之前，我们先将问题描述一下。如果你要通过一个JDBC数据源执行SQL指令时，你通常需要做些什么呢？
1、建立一个SQL字符串
2、得到一个连接
3、得到一个预处理语句（prepared statement）
4、将值组合到预处理语句中
5、执行语句
6、遍历结果集并且形成结果对象
还有，你必须考虑那些不断产生的SQLExceptions；如果这些步骤出现不同的地方，SQLExecptions的开销就会复合在一起，因为你必须使用多个try/catch块。
不 过，如果我们仔细地观察一下这些步骤，就可以发现这个过程中有几个部分在执行期间是不变的：你通常都使用同一个方式来得到一个连接和一个预处理语句。组合 预处理语句的方式通常也是一样的，而执行和处理查询则是特定的。你可以在六个步骤中提取中其中三个。即使在有点不同的步骤中，我们也可以在其中提取出公共 的功能。但是我们应该怎样自动化及简化这个过程呢？
查询架构
我们首先定义一些方法的签名，这些方法是我们将要用来执行一个SQL语句的。要注意让它保持简单，只传送需要的变量，我们可以编写一些类似下面签名的方法：
CODE:
public Object[] executeQuery(String sql, Object[] pStmntValues,
ResultProcessor processor);
我们知道在执行期间有 所不同的方面是SQL语句、预处理语句的值和结果集是如何分析的。很明显，sql参数指的是SQL语句。pStmntValues对象数据包含有必须插入 到预处理语句中的值，而processor参数则是处理结果集并且返回结果对象的一个对象；我将在后面更详细地讨论这个对象。
在这样一个方法签名中，我们就已经将每个JDBC数据库交互中三个不变的部分隔离开来。现在让我们讨论exeuteQuery()及其它支持的方法，它们都是SQLProcessor类的一部分：
CODE:
public class SQLProcessor {
public Object[] executeQuery(String sql, Object[] pStmntValues,
ResultProcessor processor) {
//Get a connection (assume it's part of a ConnectionManager class)
Connection conn = ConnectionManager.getConnection();
//Hand off our connection to the method that will actually execute
//the call
Object[] results = handleQuery(sql, pStmntValues, processor, conn);
//Close the connection
closeConn(conn);
//And return its results
return results;
}
protected Object[] handleQuery(String sql, Object[] pStmntValues,
ResultProcessor processor, Connection conn) {
//Get a prepared statement to use
PreparedStatement stmnt = null;
try {
//Get an actual prepared statement
stmnt = conn.prepareStatement(sql);
//Attempt to stuff this statement with the given values. If
//no values were given, then we can skip this step.
if(pStmntValues != null) {
PreparedStatementFactory.buildStatement(stmnt, pStmntValues);
}
//Attempt to execute the statement
ResultSet rs = stmnt.executeQuery();
//Get the results from this query
Object[] results = processor.process(rs);
//Close out the statement only. The connection will be closed by the
//caller.
closeStmnt(stmnt);
//Return the results
return results;
//Any SQL exceptions that occur should be recast to our runtime query
//exception and thrown from here
} catch(SQLException e) {
String message = "Could not perform the query for " + sql;
//Close out all resources on an exception
closeConn(conn);
closeStmnt(stmnt);
//And rethrow as our runtime exception
throw new DatabaseQueryException(message);
}
}
}
...
}
在这些方法中，有两个 部分是不清楚 的：PreparedStatementFactory.buildStatement() 和 handleQuery()'s processor.process() 方法调用。buildStatement()只是将参数对象数组中的每个对象放入到预处理语句中的相应位置。例如：
CODE:
...
//Loop through all objects of the values array, and set the value
//of the prepared statement using the value array index
for(int i = 0; i < values.length; i++) {
//If the object is our representation of a null value, then handle it separately
if(value instanceof NullSQLType) {
stmnt.setNull(i + 1, ((NullSQLType) value).getFieldType());
} else {
stmnt.setObject(i + 1, value);
}
}
由于 stmnt.setObject(int index, Object value)方法不可以接受一个null对象值，因此我们必须使用自己特殊的构 造：NullSQLType类。NullSQLType表示一个null语句的占位符，并且包含有该字段的JDBC类型。当一个NullSQLType对 象实例化时，它获得它将要代替的字段的SQL类型。如上所示，当预处理语句通过一个NullSQLType组合时，你可以使用NullSQLType的字 段类型来告诉预处理语句该字段的JDBC类型。这就是说，你使用NullSQLType来表明正在使用一个null值来组合一个预处理语句，并且通过它存 放该字段的JDBC类型。
现在我已经解释了 PreparedStatementFactory.buildStatement()的逻辑，我将解释另一个缺少的部 分：processor.process()。processor是ResultProcessor类型，这是一个接口，它表示由查询结果集建立域对象的 类。ResultProcessor包含有一个简单的方法，它返回结果对象的一个数组：
CODE:
public interface ResultProcessor {
public Object[] process(ResultSet rs) throws SQLException;
}
一个典型的结果处理器遍历给出的结果集，并且由结果集合的行中形成域对象/对象结构。现在我将通过一个现实世界中的例子来综合讲述一下。
查询例子
你经常都需要利用一个用户的信息表由数据库中得到一个用户的对象，假设我们使用以下的USERS表：
CODE:
USERS table
Column Name Data Type
ID NUMBER
USERNAME VARCHAR
F_NAME VARCHAR
L_NAME VARCHAR
EMAIL VARCHAR
并且假设我们拥有一个User对象，它的构造器是：
public User(int id, String userName, String firstName,
String lastName, String email)
如果我们没有使用这篇文章讲述的架构，我们将需要一个颇大的方法来处理由数据库中接收用户信息并且形成User对象。那么我们应该怎样利用我们的架构呢？
首先，我们构造SQL语句：
CODE:
private static final String SQL_GET_USER = "SELECT * FROM USERS WHERE ID = ?";
接着，我们形成ResultProcessor，我们将使用它来接受结果集并且形成一个User对象：
CODE:
public class UserResultProcessor implements ResultProcessor {
//Column definitions here (i.e., COLUMN_USERNAME, etc...)
..
public Object[] process(ResultSet rs) throws SQLException {
//Where we will collect all returned users
List users = new ArrayList();
User user = null;
//If there were results returned, then process them
while(rs.next()) {
user = new User(rs.getInt(COLUMN_ID), rs.getString(COLUMN_USERNAME),
rs.getString(COLUMN_FIRST_NAME), rs.getString(COLUMN_LAST_NAME),
rs.getString(COLUMN_EMAIL));
users.add(user);
}
return users.toArray(new User[users.size()]);
最后，我们将写一个方法来执行查询并且返回User对象：
CODE:
public User getUser(int userId) {
//Get a SQL processor and execute the query
SQLProcessor processor = new SQLProcessor();
Object[] users = processor.executeQuery(SQL_GET_USER_BY_ID,
new Object[] {new Integer(userId)},
new UserResultProcessor());
//And just return the first User object
return (User) users[0];
}
这就是全部。我们只需 要一个处理类和一个简单的方法，我们就可以无需进行直接的连接维护、语句和异常处理。此外，如果我们拥有另外一个查询由用户表中得到一行，例如通过用户名 或者密码，我们可以重新使用UserResultProcessor。我们只需要插入一个不同的SQL语句，并且可以重新使用以前方法的用户处理器。由于 返回行的元数据并不依赖查询，所以我们可以重新使用结果处理器。
更新的架构
那么数据库更新又如何呢？我 们可以用类似的方法处理，只需要进行一些修改就可以了。首先，我们必须增加两个新的方法到SQLProcessor类。它们类似 executeQuery()和handleQuery()方法，除了你无需处理结果集，你只需要将更新的行数作为调用的结果：
CODE:
public void executeUpdate(String sql, Object[] pStmntValues,
UpdateProcessor processor) {
//Get a connection
Connection conn = ConnectionManager.getConnection();
//Send it off to be executed
handleUpdate(sql, pStmntValues, processor, conn);
//Close the connection
closeConn(conn);
}
protected void handleUpdate(String sql, Object[] pStmntValues,
UpdateProcessor processor, Connection conn) {
//Get a prepared statement to use
PreparedStatement stmnt = null;
try {
//Get an actual prepared statement
stmnt = conn.prepareStatement(sql);
//Attempt to stuff this statement with the given values. If
//no values were given, then we can skip this step.
if(pStmntValues != null) {
PreparedStatementFactory.buildStatement(stmnt, pStmntValues);
}
//Attempt to execute the statement
int rows = stmnt.executeUpdate();
//Now hand off the number of rows updated to the processor
processor.process(rows);
//Close out the statement only. The connection will be closed by the
//caller.
closeStmnt(stmnt);
//Any SQL exceptions that occur should be recast to our runtime query
//exception and thrown from here
} catch(SQLException e) {
String message = "Could not perform the update for " + sql;
//Close out all resources on an exception
closeConn(conn);
closeStmnt(stmnt);
//And rethrow as our exception
throw new DatabaseUpdateException(message);
}
}
这些方法和查询处理方 法的区别仅在于它们是如何处理调用的结果：由于一个更新的操作只返回更新的行数，因此我们无需结果处理器。我们也可以忽略更新的行数，不过有时我们可能需 要确认一个更新的产生。UpdateProcessor获得更新行的数据，并且可以对行的数目进行任何类型的确认或者记录：
CODE:
public interface UpdateProcessor {
public void process(int rows);
}
如果一个更新的调用必 须至少更新一行，这样实现UpdateProcessor的对象可以检查更新的行数，并且可以在没有行被更新的时候抛出一个特定的异常。或者，我们可能需 要记录下更新的行数，初始化一个结果处理或者触发一个更新的事件。你可以将这些需求的代码放在你定义的UpdateProcessor中。你应该知道：各 种可能的处理都是存在的，并没有任何的限制，可以很容易得集成到架构中。
更新的例子
我将继续使用上面解释的User模型来讲述如何更新一个用户的信息：
首先，构造SQL语句：
CODE:
private static final String SQL_UPDATE_USER = "UPDATE USERS SET USERNAME = ?, " +
"F_NAME = ?, " +
"L_NAME = ?, " +
"EMAIL = ? " +
"WHERE ID = ?";
接着，构造UpdateProcessor，我们将用它来检验更新的行数，并且在没有行被更新的时候抛出一个异常：
CODE:
public class MandatoryUpdateProcessor implements UpdateProcessor {
public void process(int rows) {
if(rows < 1) {
String message = "There were no rows updated as a result of this operation.";
throw new IllegalStateException(message);
}
}
}
最后就写编写执行更新的方法：
CODE:
public static void updateUser(User user) {
SQLProcessor sqlProcessor = new SQLProcessor();
//Use our get user SQL statement
sqlProcessor.executeUpdate(SQL_UPDATE_USER,
new Object[] {user.getUserName(),
user.getFirstName(),
user.getLastName(),
user.getEmail(),
new Integer(user.getId())},
new MandatoryUpdateProcessor());
如前面的例子一样，我们无需直接处理SQLExceptions和Connections就执行了一个更新的操作。
事务
前 面已经说过，我对其它的SQL架构实现都不满意，因为它们并不拥有预定义语句、独立的结果集处理或者可处理事务。我们已经通过 buildStatement() 的方法解决了预处理语句的问题，还有不同的处理器（processors）已经将结果集的处理分离出来。不过还有一个 问题，我们的架构如何处理事务呢？
一个事务和一个独立SQL调用的区别只是在于在它的生命周期内，它都使用同一个连接，还有，自 动提交标志也必须设置为off。因为我们必须有一个方法来指定一个事务已经开始，并且在何时结束。在整个事务的周期内，它都使用同一个连接，并且在事务结 束的时候进行提交。
要处理事务，我们可以重用SQLProcessor的很多方面。为什么将该类的 executeUpdate() 和handleUpdate()独立开来呢，将它们结合为一个方法也很简单的。我这样做是为了将真正的SQL执行和连接 管理独立开来。在建立事务系统时，我们必须在几个SQL执行期间对连接进行控制，这样做就方便多了。
为了令事务工作，我们必须保持状态，特别是连接的状态。直到现在，SQLProcessor还是一个无状态的类。它缺乏成员变量。为了重用SQLProcessor，我们创建了一个事务封装类，它接收一个SQLProcessor并且透明地处理事务的生命周期。
具体的代码是：
CODE:
public class SQLTransaction {
private SQLProcessor sqlProcessor;
private Connection conn;
//Assume constructor that initializes the connection and sets auto commit to false
...
public void executeUpdate(String sql, Object[] pStmntValues,
UpdateProcessor processor) {
//Try and get the results. If an update fails, then rollback
//the transaction and rethrow the exception.
try {
sqlProcessor.handleUpdate(sql, pStmntValues, processor, conn);
} catch(DatabaseUpdateException e) {
rollbackTransaction();
throw e;
}
}
public void commitTransaction() {
//Try to commit and release all resources
try {
conn.commit();
sqlProcessor.closeConn(conn);
//If something happens, then attempt a rollback and release resources
} catch(Exception e) {
rollbackTransaction();
throw new DatabaseUpdateException("Could not commit the current transaction.");
}
}
private void rollbackTransaction() {
//Try to rollback and release all resources
try {
conn.rollback();
conn.setAutoCommit(true);
sqlProcessor.closeConn(conn);
//If something happens, then just swallow it
} catch(SQLException e) {
sqlProcessor.closeConn(conn);
}
}
}
SQLTransaction 拥有许多新的方法，但是其中的大部分都是很简单的，并且只处理连接或者事务处理。在整个事务周期内，这个事务封装类只是在SQLProcessor中增加 了一个简单的连接管理。当一个事务开始时，它接收一个新的连接，并且将其自动提交属性设置为false。其后的每个执行都是使用同一个连接（传送到 SQLProcessor的handleUpdate()方法中），因此事务保持完整。
只有当我们的持久性对象或者方法调用commitTransaction()时，事务才被提交，并且关闭连接。如果在执行期间发生了异常，SQLTransaction可以捕捉该异常，自动进行回滚，并且抛出异常。
事务例子
让我们来看一个简单的事务
CODE:
//Reuse the SQL_UPDATE_USER statement defined above
public static void updateUsers(User[] users) {
//Get our transaction
SQLTransaction trans = sqlProcessor.startTransaction();
//For each user, update it
User user = null;
for(int i = 0; i < users.length; i++) {
user = users[i];
trans.executeUpdate(SQL_UPDATE_USER,
new Object[] {user.getUserName(),
user.getFirstName(),
user.getLastName(),
user.getEmail(),
new Integer(user.getId())},
new MandatoryUpdateProcessor());
}
//Now commit the transaction
trans.commitTransaction();
}
上面为我们展示了一个 事务处理的例子，虽然简单，但我们可以看出它是如何工作的。如果在执行executeUpdate()方法调用时失败，这时将会回滚事务，并且抛出一个异 常。调用这个方法的开发者从不需要担心事务的回滚或者连接是否已经关闭。这些都是在后台处理的。开发者只需要关心商业的逻辑。
事务也可以很轻松地处理一个查询，不过这里我没有提及，因为事务通常都是由一系列的更新组成的。
问题
在我写这篇文章的时候，对于这个架构，我提出了一些疑问。这里我将这些问题提出来，因为你们可能也会碰到同样的问题。
自定义连接
如 果每个事务使用的连接不一样时会如何？如果ConnectionManager需要一些变量来告诉它从哪个连接池得到连接？你可以很容易就将这些特性集合 到这个架构中。executeQuery() 和 executeUpdate()方法（属于SQLProcessor和SQLTransaction 类）将需要接收这些自定义的连接参数，并且将他们传送到ConnectionManager。要记得所有的连接管理都将在执行的方法中发生。
此外，如果更面向对象化一点，连接制造者可以在初始化时传送到SQLProcessor中。然后，对于每个不同的连接制造者类型，你将需要一个SQLProcessor实例。根据你连接的可变性，这或许不是理想的做法。
ResultProcessor返回类型
为 什么ResultProcessor接口指定了process()方法应该返回一个对象的数组？为什么不使用一个List？在我使用这个架构来开发的大部 分应用中，SQL查询只返回一个对象。如果构造一个List，然后将一个对象加入其中，这样的开销较大，而返回一个对象的一个数组是比较简单的。不过，如 果在你的应用中需要使用对象collections，那么返回一个List更好。
SQLProcessor初始管理
在这篇文章的例子中，对于必须执行一个SQL调用的每个方法，初始化一个SQLProcessor。由于SQLProcessors完全是没有状态的，所以在调用的方法中将processor独立出来是很有意义的。
而对于SQLTransaction类，则是缺少状态的，因此它不能独立使用。我建议你为SQLProcessor类增加一个简单的方法，而不是学习如何初始化一个SQLTransaction，如下所示：
public SQLTransaction startTransaction() {
return new SQLTransaction(this);
}
这样就会令全部的事务功能都在SQLProcessor类中访问到，并且限制了你必须知道的方法调用。
数据库异常
我 使用了几种不同类型的数据库异常将全部可能在运行时发生的SQLExceptions封装起来。在我使用该架构的应用中，我发现将这些异常变成 runtime exceptions更为方便，所以我使用了一个异常处理器。你可能认为这些异常应该声明，这样它们可以尽量在错误的发生点被处理。不 过，这样就会令SQL异常处理的流程和以前的SQLExceptions一样，这种情况我们是尽量避免的。
省心的JDBC programming
这篇文章提出的架构可以令查询、更新和事务执行的操作更加简单。在类似的SQL调用中，你只需要关注可重用的支持类中的一个方法。我的希望是该架构可以提高你进行JDBC编程的效率。
发表于 @ 2006年03月17日 11:08 PM | 评论 (0)
JDBC初级应用实例(二)[动态访问数据库]
上面有一位朋友问了,如果在已经连结的情况下,知道当前连结的库的表的情况呢?
其实只你已经连结了,你就能知道这个库中所以情况而不仅仅上表的情况:
有时(我到目前只见到过一次),我们对一种新的数据库根本不知道它的结构或者是
其中的内容,好坏么我们如何来获取数据库的情况呢?
真实的例子是这样的,我的朋友的公司接到了一个单子,对方使用的数据库是叫什么
/"titanium/"的,说实话由于本人的孤陋寡闻,在此之前从来不知道还有这种数据库,更别说如何
访问了,现在朋友要看里面有什么/"东西/",当然是一筹莫展.所以只好找我.
接到电话后,我先问他是什么平台上跑的,如果连结的,他说是在windows下可以建立
ODBC数据源,哈哈,就是说可以用java建立Connection了,OK
只能建立一下Connection,那么就可以得到这个数据库的所有元信息:
DatabaseMetadata dbmd = conn.getMetadata();然后你可以从这个对象获取以下信
息:
getUrl(); //返回与这个数据库的连结的URL,当然是已知的,要不你怎么连上去
getUserName(); //返回与这个数据库的连结的用户,同上
isReadOnly();数据库是否为只读
getDatabaseProduceName();//数据库产品名称
getDatabaseProduceVersion();//版本号
getDriverName();//驱动程序
getDriverVersion();//驱动程序版本
以上内容没有什么意义
ResultSet getTables(String catalog,
String schemaPattern,
String tableNamePattern,
String[] types)
可以得到该库中/"表/"的所有情况,这里的表包括表,视图,系统表,临时空间,别名,同义词
对于各参数:
String catalog,表的目录,可能为null,/"null/"匹配所有
String schemaPattern,表的大纲,同上
String tableNamePattern,表名,同上
String[] types,表的类型,/"null/"匹配所有,可用的类型为:
TABLE,VIEW,SYSEM TABLE,GLOBAL TEMPORARY,LOCAL TEMPORARY,ALIAS,SYNONYM
例如:
DatabaseMetaData dbmd = conn.getMetaData();
ResultSet rs = dbmd.getTables(null,null,null,null);
ResultSetMetaData rsmd = rs.getMetaData();
int j = rsmd.getColumnCount();
for(int i=1;i<=j;i++){
out.print(rsmd.getColumnLabel(i)+/"//t/");
}
out.println();
while(rs.next()){
for(int i=1;i<=j;i++){
out.print(rs.getString(i)+/"//t/");
}
out.println();
}
对于更详细的表中的列的信息,可以用dbmd(不是rsmd).getColumns(
String catalog,
String schemaPattern,
String tableNamePattern,
String columnNamePattern
)
不仅可以获得rsmd中的信息,还可以获得列的大小,小数位数,精度,缺省值,列在表中
的位置等相关信息.
还有两个方法,调用和获取表信息一样,可以获得存储过程和索引的信息:
ResultSet getProcedures(
String catalog,
String schemaPattern,
String procedurePattern
);
ResultSet getIndexINFO(
String catalog,
String schemaPattern,
String table,
boolean unique,boolean approximate
);
发表于 @ 2006年03月17日 11:06 PM | 评论 (0)
JDBC初级应用实例(一)
JDBC初级应用实例(一)在了解JDBC基础知识以后,我们先来写一个数据库操作的类(Bean)以后我们会
在这个类的基础上,随着介绍的深入不断提供优化的方案.
要把一个数据库操作独立到一个类(Bean)中,至少要考虑以下几个方面:
1.对于不同层次的应用,应该有不同的得到连结的方法,如果得到连结的方法要随
着应用层次的不同而改变,我们就应该把他独立成一个专门的类中,而把在任何应用层次
中都通用的处理方法封装到一个(类)Bean中.
2.既然考虑到既作为javaBean使用又可以用为一个普通类调用,要考虑到javaBean
的规范和普通类的灵活性.
3.对于特定的数据库操作不应封装到共性的(类)Bean中,而应该成为它的扩展类.
以上几点是充分考虑JAVA的面象对象的思想,经过深入的抽象形成的层次,下面我
们就按这个思想来设计:
一:定义一个用于连结的Bean,以后如果要在不同的应用中,如可以在J2EE中从
DataSource中得到连结,或从普通的连结池中得到连结,以及直接从DriverManager中得到
连结,只需修改本类中的得到连结的实现方法.
package com.imnamg.axman.beans;
import java.sql.*;
import ..................
public class ConnectionFactory{
protected Connection conn;
ConnectionFactory() throws SQLException
{ //构造方法中生成连结
//无论是从DataSource还是直接从DriverManager中取得连结.
//先初始化环境,然后取得连结,本例作为初级应用,从
//DriverManager中取得连结,因为是封装类,所以要把异常抛
//给调用它的程序处理而不要用try{}catch(){}块自选处理了.
//因为要给业务方法的类继承,而又不能给调用都访问,所以
//conn声明为protected
conn = DriverManager.getConnection(url,user,passwd);
}
/**
在多线程编程中,很多时候有可能在多个线程体中得到同一连
结的引用,但如果在一个线程中关闭了连结,则另一个得到相同
引用的线程就无法操作了,所以我们应该加一个重新建立连结
的辅助方法,有人问为什么既然有这个辅助方法不直接调用这个
辅助而要在构造方法中生成连结?因为这样可以增加效率,如果
在构造时不能生成连结则就不能生成这个对象了,没有必要在
对象生成后再测试能不能生成连结.
*/
public void makeConnection(){
//此处的代码同构造方法,无论以后如果实现连结,都将构造方
//法的代码复制到此处.
conn = DriverManager.getConnection(url,user,passwd);
}
}
这个类就封装到这里,当然你可以在这儿增加业务方法,但如果要修改连结的实现,
整个类都要重新编译,因为业务方法和应用层次无关,代码一经生成不易变动,所以独立封装.
以下我们实现业务方法:
package com.imnamg.axman.beans;
import java.sql.*;
import ..................
public class DBOperater extends ConnectionFactory{
//private Statement stmt;
//private ResultSet rs;
//为什么要注释成员变量stmt和rs,基础部分已经说过,如果声明为成员变量,
//在关闭conn时可以显示地先关闭rs和stmt,别的没有任何好处,而显示关
//闭只是说明你编程风格好,但综合考虑,我们要生成多个stmt或不是类型的
//stmt就不能声明为成员方法,否则引用同一对象,所以我们要业务方法中生
//成stmt对象.不仅可以同时处理多个结果集,还可以提高性能和灵活性.
public ResultSet executeQuery(String sql) throws SQLException{
if(conn==null || conn.isClosed())
makeConnection();
Statement stmt = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
//对于一般的查询操作,我们只要生成一个可流动的结果集就行了.
//而对于在查询时要更新记录,我们用另一个业务方法来处理,这样,
//这样可以在普通查询时节省回滚空间.
ResultSet rs = stmt.executeQuery(sql);
return rs;
}
public ResultSet executeUpdatabledQuery(String sql) throws SQLException{
if (con == null || con.isClosed())
makeConnection();
Statement stmt = con.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLED);
//可更新的结果结要更大的回滚空间,普通查询时不要调用这个方法
ResultSet rs = stmt.executeQuery(sql);
return rs;
}
/**
基于同上的原因,在执行更新操作是我们根本不要任何回滚空间,所以建立
一个基本类型的stmt,实现如下
*/
public int executeUpdate(String sql) throws SQLException{
if (con == null || con.isClosed())
makeConnection();
Statement stmt = con.createStatement();
//这个stmt在执行更新操作时更加节省内存,永远记住,能节省的时候要节省
//每一个字节的内存,虽然硬件设备可能会有很大的物理内存,但内存是给用
//户用的而不是给程序员用的(!!!!!!!!!!!!!!!!!!)
int s = stmt.executeUpdate(sql);
return s;
}
//以上实现了常用功能,还有两个通用的功能也是/"共性/"的,我们一起在这个封装类
//中实现:
public PreparedStatement getPreparedStmt(String sql) throws SQLException{
if (con == null || con.isClosed())
makeConnection();
PreparedStatement ps = con.prepareStatement(sql);
return ps;
}
public CallableStatement getCallableStmt(String sql) throws SQLException{
if (con == null || con.isClosed())
makeConnection();
PreparedStatement ps = con.prepareCall(sql);
return ps;
}
//记住:对于封装类而言预编译语句和存储过程调用应该从连结中返PreparedStatement
//和CallableStatement供调用者处理而不是返回它们的处理结果.也就是说封装类只封
//装了它们的连结过程.最后再次声明,一定要有一个close()方法供调用者调用,而且告
//诉调用者无论如果要调用这个方法:
public void close() throws SQLException{
if(conn != null && !conn.isClosed())
conn.close();
}
//这个方法最好放在ConnectionFactory中,这样可以直接调用来只测试连结.而不用再
调用子类来关闭
}
OK,我们已经实现了数据库常用操作的封装,注意这些业务方法都是把异常抛给调用者而没有用
try...catch来处理,你如果在这里处理了那么调用者则无法调试了.对于特定的数据库的特殊操作,不要封
装到此类中,可以再从这个类继承,或直接从ConnectionFactory类继承,当然最好是从这个业务类中继承,
这样不仅可以调用特殊方法也可以调用共性的业务方法,兴一个例子,我在应用Oracle时要把XML文件直接
存到数据数和把数据直接读取为XML文件,那么这两个方法只对Oracle才用到,所以:
package com.inmsg.axman.beans;
import java.sql.*;
import oracle.xml.sql.query.OracleXMLQuery;
import oracle.xml.sql.dml.OracleXMLSave;
public class OracleDBOperater extends DBOperater{
public OracleXMLQuery getOXQuery(String sql,String table) throws Exception
{
OracleXMLQuery qry = new OracleXMLQuery(con,sql);
qry.setRowsetTag(table);
qry.setRowTag(/"RECORD/");
return qry;
}
public int insertXML(String path,String table) throws Exception
{
OracleXMLSave sav = new OracleXMLSave(con,table);
URL url = sav.createURL(path);
sav.setRowTag(/"RECORD/");
int x = sav.insertXML(url);
sav.close();
return x;
}
}
现在,有了这样的几个/"东西/"在手里,你还有什么觉得不方便的呢?
虽然本处作为初级应用,但设计思想已经是JAVA高手的套路了,是不是有些自吹自擂了啊?
好的,休息一下吧.
发表于 @ 2006年03月17日 11:05 PM | 评论 (0)
JDBC基础(二)
因为是基础篇,所以还是对每一步骤简单说明一下吧:前面说是,注册驱动程序有多方法,Class.forName();是一种显式地加载.当一个驱
动程序类被Classloader装载后,在溶解的过程中,DriverManager会注册这个驱动类的实例.
这个调用是自动发生的,也就是说DriverManager.registerDriver()方法被自动调用了,当然
我们也可以直接调用DriverManager.registerDriver()来注册驱动程序,但是,以我的经验.
MS的浏览中APPLET在调用这个方法时不能成功,也就是说MS在浏览器中内置的JVM对该方法的
实现是无效的.
另外我们还可以利用系统属性jdbc.drivers来加载多个驱动程序:
System.setProperty(/"jdbc.drivers/",/"driver1:driver2:.....:drivern/");多个驱动程序之
间用/":/"隔开,这样在连结时JDBC会按顺序搜索,直到找到第一个能成功连结指定的URL的驱动
程序.
在基础篇里我们先不介绍DataSource这些高级特性.
在成功注册驱动程序后,我们就可以用DriverManager的静态方法getConnection来得
到和数据库连结的引用:
Connection conn = DriverManager.getConnection(url);
如果连结是成功的,则返回Connection对象conn,如果为null或抛出异常,则说明没有
和数据库建立连结.
对于getConnection()方法有三个重载的方法,一种是最简单的只给出数据源即:
getConnection(url),另一种是同时给出一些数据源信息即getConnection(url,Properties),
另外一种就是给出数据源,用户名和密码:getConnection(url,user,passwod),对于数据源信息.
如果我们想在连结时给出更多的信息可以把这些信息压入到一个Properties,当然可以直接压
入用户名密码,别外还可以压入指定字符集,编码方式或默认操作等一些其它信息.
在得到一个连结后,也就是有了和数据库找交道的通道.我们就可以做我们想要的操
作了.
还是先来介绍一些一般性的操作:
如果我们要对数据库中的表进行操作,要先缘故绑定一个语句:
Statement stmt = conn.createStatement();
然后利用这个语句来执行操作.根本操作目的,可以有两种结果返回,如果执行的查询
操作,返回为结果集ResultSet,如果执行更新操作,则返回操作的记录数int.
注意,SQL操作严格区分只有两个,一种就是读操作(查询操作),另一种就是写操作(更
新操作),所以,create,insert,update,drop,delete等对数据有改写行为的操作都是更新操作.
ResultSet rs = stmt.executeQuery(/"select * from table where xxxxx/");
int x = stmt.executeUpdate(/"delete from table where ....../");
如果你硬要用executeQuery执行一个更新操作是可以的,但不要把它赋给一个句柄,
当然稍微有些经验的程序员是不会这么做的.
至于对结果集的处理,我们放在下一节讨论,因为它是可操作的可选项,只有查询操作
才返回结果集,对于一次操作过程的完成,一个非常必要的步骤是关闭数据库连结,在你没有了
解更多的JDBC知识这前,你先把这一步骤作为JDBC操作中最最重要的一步,在以后的介绍中我会
不断地提醒你去关闭数据库连结!!!!!!!!!!!
按上面介绍的步骤,一个完成的例子是这样的:(注意,为了按上面的步骤介绍,这个例
子不是最好的)
try{
Class.forName(/"org.gjt.mm.mysql.Driver/");
}catch(Exception e){
System.out.println(/"没有成功加载驱动程序:/"+e.toString());
return;
}//对于象我这样的经验,可以直接从e.toString()的简单的几个字判断出异常原因,
//如果你是一个新手应该选捕获它的子类,如何知道要捕获哪几个异常呢?一个简单
//的方法就是先不加try{},直接Class.forName(/"org.gjt.mm.mysql.Driver/");,编
//译器就会告诉你要你捕获哪几个异常了,当然这是偷机取巧的方法,最好还是自己
//去看JDK文档,它会告诉你每个方法有哪些异常要你捕获.
Connection conn = null;
try{
conn = DriverManager.getConnection(
/"jdbc:mysql://host:3306/mysql/",
/"user/",
/"passwd/");
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(/"select * from table/");
//rs 处理
[rs.close();]
[stmt.close();]
}
catch(Exception e){
System.out.println(/"数据库操作出现异常:/"+e.toString());
}
finally{
try{conn.close();}catch(Exception){}
}//不管你以前是学习到的关于数据库流程是如何操作的,如果你相信我,从现在开始,
//请你一定要把数据库关闭的代码写到finally块中,切切!
发表于 @ 2006年03月17日 11:04 PM | 评论 (0)
JDBC基础(一)
本来不想写这部份入门级的内容,但既然栏目定为JDBC专栏,还是简单写一些吧.JDBC基础(一)
来,我们认识一下!
JDBC,JAVA平台的DATABASE的连通性.白话一句,什么意思啊?
就是JAVA平台上和数据库进行连结的/"工具/".
还是先一起来回顾一下接口吧:从下向上,接口是对/"案例/"的抽象,由一个案例抽象出一些规则.
反过来,从上向下,被抽象出来的接口是对案例的一种承诺和约束.
也就是说,只要你实现我规定的接口,你的类就已经具有了接口对外承诺的方法,只要/"客户/"会
操作接口,不需要重新学习就会操作实现了该接口的新类!
好了,用行话来说:
1.通过接口可以实现不相关的类的相同行为.
2.通过接口可以指明多个类需要实现的方法.
3.通过接口可以了解对象的交互方法而不需要了解对象所对应的类蓝本.
这几句话很明白吧?好象有一本什么模式的书把这段话用了30多页写出来,结果别人看了还不如
我这几句话明白,不过我明白了为什么有些人要写书了.
搞懂了以上这东西,JDBC就好明白了.
为了通用,JAVA中要求有一种机制,在操作不同厂商数据库时有相同的方法去操作,而不是每接
触一种数据库就要学习新的方法.完成这种机制的/"东西/"就叫/"JDBC/"了.
简单地分,JDBC有两部分组成,JDBC API和JDBC Driver Interface.
JDBC API就是提供给/"客户/"(就是象你我这种菜鸟级程序员来用的,如果是高手都自己写JDBC了,
哈哈)的一组独立于数据库的API,对任何数据库的操作,都可以用这组API来进行.那么要把这些通用的API
翻译成特定数据库能懂的/"指令/",就要由JDBC Driver Interface来实现了,所以这部份是面向JDBC驱动程
序开发商的编程接口,它会把我们通过JDBC API发给数据库的通用指令翻译给他们自己的数据库.
还是通过实际操作来看看JDBC如何工作的吧.
因为JDBC API是通用接口,那么程序是如何知道我要连结的是哪种数据库呢?所以在和数据库连
结时先要加载(或注册可用的Driver),其实就是JDBC签名.加载驱动程序和好多方法,最常用的就是先把驱
动程序类溶解到内存中,作为/"当前/"驱动程序.注意/"当前/"是说内存中可以有多个驱动程序,但只有现在加
载的这个作为首选连结的驱动程序.
Class.forName(/"org.gjt.mm.mysql.Driver/");
Class.forName方法是先在内存中溶解签名为/"org.gjt.mm.mysql.Driver/"的Driver类,Driver类
就会把相应的实现类对应到JDBC API的接口中.比如把org.gjt.mm.mysql.Connection的实例对象赋给
java.sql.Connection接口句柄,以便/"客户/"能通过操作java.sql.Connection句柄来调用实际的
org.gjt.mm.mysql.Connection中的方法.之于它们是如果映射的,这是厂商编程的,/"客户/"只要调用
Class.forName(/"org.gjt.mm.mysql.Driver/");方法就可以顺利地操作JDBC API了.
一个普通数据库的连结过程为:
1.加载驱动程序.
2.通过DriverManager到得一个与数据库连结的句柄.
3.通过连结句柄绑定要执行的语句.
4.接收执行结果.
5.可选的对结果的处理.
6.必要的关闭和数据库的连结.
发表于 @ 2006年03月17日 11:00 PM | 评论 (0)
如何使用javaBean操作数据库？高效Bean封装
你平时是如何使用JSP操作数据库呢？对于jsp+javaBean模式，想必大家都已经很熟悉了，我们可以将获取数据库连接，查询，更新甚至将其它的功能都封装进javaBean----
好了--下面让我们来好好弄清楚一个问题：**你如何在JSP页中取得DB中的数据？从javaBean中返回ResultSet，然后在JSP中枚举吗？如果是这样的话，那我强烈建议你把这篇文章读完。*^_^*
用 javaBean封装数据库操作谁不会？--对啊，大家都会，但是--如果构建一个高扩展性的“结构”？这就要用到java的相关知识了。废话少说，我们 先在Tomcat中创建一个DataSource- jdbc/Panabia，然后再创建一个java“基类”，这个类封装了数据库连接和连接的释放： [程式中有相应的注解]
CODE:
--------------------------------------------------------------------------------
package Panabia.db;
import javax.sql.DataSource;
import javax.naming.*;
import java.sql.*;
public class SQLFactory
{
private static DataSource ds=null;
private static Object Lock=new Object();
//生成DataSource**
public static DataSource gainDataSource(){
try{
if(ds==null){
synchronized(Lock){
if(ds==null){
Context ctx=new InitialContext();
ds=(DataSource)ctx.lookup(/"java:comp/env/jdbc/Panabia/");
}
}
}
}
catch(NamingException e){e.printStackTrace();}
return ds;
}
//生成SQL连接**
public static synchronized Connection gainConnection(){
Connection con=null;
try{
if(ds==null){
gainDataSource();
}
con=ds.getConnection();
}
catch(SQLException e){e.printStackTrace();}
return con;
}
//释放SQL连接**
public static void releaseConnection(ResultSet rs,PreparedStatement ps,Statement sql,Connection con){
try{
if(rs!=null)
rs.close();
}
catch(SQLException e){e.printStackTrace();}
try{
if(ps!=null)
ps.close();
}
catch(SQLException e){e.printStackTrace();}
try{
if(sql!=null)
sql.close();
}
catch(SQLException e){e.printStackTrace();}
try{
if(con!=null&&!con.isClosed())
con.close();
}
catch(SQLException e){e.printStackTrace();}
}
}
--------------------------------------------------------------------------------
大家都应该注意到了，这个类的所有的方法全部是static的，之所以这样，主要是为了方便其它“扩展类”的调用，当然，还有其它好处--- ：）
好了，这个类就封装完毕了，现在我们就可以针对不同的应用要求单独写javaBean了，比如一个简单的：在JSP中列出verify表中的所有用户名与密码列表-
该 怎么做？--使用SQLFactory生成Connection，再生成Statement，再生成ResultSet--然后枚举吗？好象不错，哦，等 等......这样做你难道没有一种“非常亲切”的感觉吗？---对了，ASP，PHP中就是如此-Faint~我们怎么又回到“原始社会”了....
有没有更好的方式？答案是肯定的，JAVA的能力是“通天”的强大，只要你能想得到，仔细看看它的API Document，就不难找出解决办法。
答案出来了：
我们在查询类中返回Iterator到JSP枚举，而不是ResultSet。
好了，我们的UserQuery类就产生了：
CODE:
--------------------------------------------------------------------------------
package Panabia.operate;
import Panabia.db.SQLFactory;
import java.util.*;
import java.sql.*;
public class UserQuery{
private ArrayList list=null;
private Connection con=null;
private Statement sql=null;
private ResultSet rs=null;
public Iterator getResult(){
try{
con=SQLFactory.gainConnection();
sql=con.createStatement();
rs=sql.executeQuery(/"select * from verify/");
//verify表只有两个字段：username,password;
list=new ArrayList();
while(rs.next()){
list.add(rs.getString(1));
list.add(rs.getString(2));
}
}
catch(SQLException e){e.printStackTrace();}
finally{SQLFactory.releaseConnection(rs,null,sql,con);}
return list.iterator();
}
}
--------------------------------------------------------------------------------
然后，就是在JSP页中进行数据的枚举：因为发现cnjbb不支持html标签的显示，所以，只贴出了JSP中的全部java代码片--
........
Iterator it=UserQuery.getResult();
while(it.hasNext()){
out.print((String)it.next());
}
..........
就是这么简单，一个循环就搞定了。
![自定义JSP[if，foreach，数据，select]标签](https://ucc.alicdn.com/images/user-upload-01/71c4c6ea885447a2ae4a5c8e0c1c09a0.png?x-oss-process=image/resize,h_160,m_lfit)
