javaBean+tomcat+MySql连接池三步曲(原创)

wiThouTTears

最近学习jsp,现将心得给大家一起分享,水平有限,高手勿见笑.
如题,开始吧
第一步: 创建数据库并在tomcat下配置链接池
1.创建数据库
在mysql下创建名为testdb的数据库,在testdb下创建数据表test_table.字段id,name
2.tomcat配置
我们在C:\Program Files\Tomcat 5.5.7\conf\content.xml文件中添加如下数据库链接池配置,如果没有就新建一个content.xml,注意tomcat版本要5.5以上,5.5以下不支持content.xml。

1. 
   
2. <Context>
   
3.         <Resource name="jdbc/testdb"
   
4.         auth="Container"
   
5.         type="javax.sql.DataSource"
   
6.         driverClassName="com.mysql.jdbc.Driver"
   
7.         url="jdbc:mysql://localhost/mytestdb"
   
8.         username="root"
   
9.         password="******"
   
10.         maxActive="100"
    
11.         maxIdle="30"
    
12.         maxWait="10000"
    
13.         ></Resource>       
    
14. </Context>
    

复制代码

第二步:编写javaBean读取tomcat下的content.xml
javaBean 文件DataBase.java代码

1. 
   
2. package withouttears.bean;
   
3. 
   
4. import java.util.HashMap;
   
5. import java.sql.*;
   
6. //JNDI有两个核心接口Context和DirContext，
   
7. //Context中包含了基本的名字操作，而DirContext则将这些操作扩展到目录服务。
   
8. import javax.naming.Context;
   
9. import javax.naming.InitialContext;
   
10. //数据库资源的连接工厂是javax.sql.DataSource对象，
    
11. //它可以创建java.sql.Connection数据库连接对象。
    
12. import javax.sql.DataSource;
    
13. //目前您可以从Java开发者连接（http://developer.java.sun.com/developer/earlyAccess/crs）
    
14. //下载CachedRowSet的实现。下载并解压缩安装文件后，将"rowset.jar"文件放到您的类目录下。
    
15. //CachedRowSet在sun.jdbc.rowset包中。
    
16. import sun.jdbc.rowset.CachedRowSet;
    
17. 
    
18. /**
    
19. * <b>类</b>： DataBase<br>
    
20. * <b>版本</b>： 1.0.0<br>
    
21. * <b>作者</b>： wiThouTTears<br>
    
22. * <b>时间</b>： 2006-12-18<br>
    
23. * <b>QQ</b>： 314765755<br>
    
24. * <b>Email</b>： wiThouT--Tears@163.com<br>
    
25. * <b>Blog</b>： http://wiThouTTears.cublog.cn<br>
    
26. * <b>功能</b>： 用连接池连接MySql数据库及相关操作<br>
    
27. * */
    
28. public class Database {
    
29.     /**
    
30.      * 数据库JNDI名称，默认：jdbc/testdb
    
31.      * */
    
32.     private String jndiName="jdbc/testdb";
    
33.     /**
    
34.      * 建立连接池
    
35.      * @param null
    
36.      * @return  DataSource
    
37.      * */
    
38.     private DataSource localhost(){
    
39.         DataSource ds=null;
    
40.         //在HashMap中通过get()来获取value，通过put()来插入value，
    
41.         //ContainsKey()则用来检验对象是否已经存在
    
42.         HashMap<Object,Object>  cachedDs=new HashMap<Object,Object> ();
    
43.         if(cachedDs.containsKey("ds"))//取出空闲状态的数据库连接
    
44.             {
    
45.                 /* 在DataSource中事先建立了多个数据库连接，
    
46.                  * 这些数据库连接保存在连接池(Connect Pool)中。
    
47.                  * Java程序访问数据库时，只需要从连接池中取出空闲状态的数据库连接；
    
48.                  * 当程序访问数据库结束，再将数据库连接放回连接池。
    
49.                  * */
    
50.                 ds = (DataSource)cachedDs.get("ds");
    
51.             }
    
52.         else
    
53.             try
    
54.             {
    
55.                     /*在javax.naming包中提供了Context接口，
    
56.                      * 该接口提供了将对象和名字绑定，以及通过名字检索对象的方法。
    
57.                      * */
    
58.                 Context initCtx = new InitialContext();
    
59.                 //lookup(String name)：返回与指定的名字绑定的对象,获得数据库连接工厂
    
60.                 ds = (DataSource)initCtx.lookup("java:comp/env/"+getjndiName());
    
61.                 cachedDs.put("ds", ds);
    
62.             }
    
63.             catch(Exception e)
    
64.             {
    
65.                 e.printStackTrace();
    
66.             }
    
67.                 return ds;
    
68.         }
    
69.     /**
    
70.      * 库的连接
    
71.      * @param null
    
72.      * @return  Connection
    
73.      * */
    
74.     public Connection getConnection(){
    
75.         Connection conn = null;
    
76.         try{
    
77.             DataSource ds = localhost();
    
78.             conn = ds.getConnection();
    
79.             }
    
80.         catch(Exception e){
    
81.             e.printStackTrace();
    
82.             }
    
83.         return conn;
    
84.         }
    
85.     /**
    
86.      * 关闭连接
    
87.      * @param null
    
88.      * @return  null
    
89.      * @since 1.2
    
90.      * */
    
91.     public static void close(Connection conn){
    
92.         try{
    
93.             if(conn != null)
    
94.                 conn.close();
    
95.             }
    
96.         catch(SQLException e){
    
97.             e.printStackTrace();
    
98.             }
    
99.         }
    
100.     /**
     
101.      * 执行查询操作
     
102.      * @param sql
     
103.      * @return ResultSet
     
104.      * */
     
105.     public  CachedRowSet executeQuery(String sql)
     
106.     {  
     
107.         Connection conn=null;
     
108.         CachedRowSet rs=null;
     
109.         try{
     
110.             rs=new CachedRowSet();
     
111.             conn=getConnection();
     
112.             Statement stmt=conn.createStatement();
     
113.             ResultSet rs1=stmt.executeQuery(sql);
     
114.             rs.populate(rs1);
     
115.             }
     
116.         catch(Exception e) {
     
117.             System.out.println(e.toString());  
     
118.             }
     
119.         finally{
     
120.             try{
     
121.                 conn.close();
     
122.                 }
     
123.             catch(Exception ex){}
     
124.             }
     
125.         return rs;
     
126.         }
     
127.     /**
     
128.      * 执行数据的插入、删除、修改操作
     
129.      * @param sql
     
130.      * @return boolean
     
131.      * */
     
132.     public  boolean executeUpdate(String sql){
     
133.         boolean bl;
     
134.         bl = false;
     
135.         Connection conn = getConnection();
     
136.         try{
     
137.             Statement stmt = conn.createStatement();
     
138.             if(stmt.executeUpdate(sql) > 0)
     
139.                 stmt.close();
     
140.             bl = true;
     
141.             }
     
142.         catch(SQLException e){}
     
143.         finally{
     
144.             close(conn);
     
145.             }
     
146.         return bl;
     
147.         }
     
148.     /**
     
149.      * 获得数据库JNDI名称
     
150.      * @param null
     
151.      * @return String
     
152.      * */
     
153.     public String getjndiName(){
     
154.         return this.jndiName;
     
155.     }
     
156.     /**
     
157.      * 设置数据库JNDI名称
     
158.      * @param jndiName
     
159.      * @return true|false
     
160.      * */
     
161.     public boolean setjndiName(String jndiName){
     
162.         this.jndiName = jndiName;
     
163.         return true;
     
164.         }
     
165. }
     

复制代码

第三步: 编写test.jsp测试

1. <%@ page language="java" contentType="text/html; charset=gbk"
   
2.     pageEncoding="gbk"%>
   
3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   
4. "http://www.w3.org/TR/html4/loose.dtd">
   
5. <%@page import="withouttears.bean.Database"%>
   
6. <%@page import="java.sql.*"%>
   
7. <html>
   
8. <head>
   
9. <meta http-equiv="Content-Type" content="text/html; charset=gbk">
   
10. <title>Insert title here</title>
    
11. </head>
    
12. <body>
    
13. <%
    
14. Database db=new Database();
    
15. db.setjndiName("jdbc/testdb");//初始化JNDI名称
    
16. ResultSet rs=db.executeQuery("select * from test_table");
    
17. while(rs.next()){
    
18.         out.println("id:"+rs.getInt("id")+"<br>");
    
19. }
    
20. rs.close();
    
21. %>
    
22. </body>
    
23. </html>
    

复制代码

好了,打开浏览器输入:http://localhost:8080/test.jsp

[ 本帖最后由 wiThouTTears 于 2006-12-19 15:56 编辑 ]