程序博客网 > 五音不全唱歌的软件

【servlet】jdbc开发

来源：互联网 发布：五音不全唱歌的软件 编辑：程序博客网 时间：2024/06/07 10:39

使用数据库连接池优化程序性能

应用程序直接获取链接的缺点

缺点：用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、宕机。


【案例】传统方法连接数据库


  1. 配置文件db.properties
    1. driver=com.mysql.jdbc.Driver  
    2. url=jdbc:mysql://localhost:3306/java  
    3. username=root  
    4. password=123456  

  2. 加载数据库驱动                                                                                                                                                                                                       
  3. 连接数据库java代码 DBConn.java
    1. package com.hbsi.util;  
    2.   
    3. import java.io.IOException;  
    4. import java.io.InputStream;  
    5. import java.sql.Connection;  
    6. import java.sql.DriverManager;  
    7. import java.sql.PreparedStatement;  
    8. import java.sql.ResultSet;  
    9. import java.sql.SQLException;  
    10. import java.util.Properties;  
    11.   
    12. public class DBConn {  
    13.   
    14.     static String driver;  
    15.     static String url;  
    16.     static String username;  
    17.     static String password;  
    18.     static{  
    19.         InputStream in = DBConn.class.getClassLoader().getResourceAsStream("db.properties");  
    20.         Properties pro = new Properties();  
    21.         try {  
    22.             pro.load(in);  
    23.         } catch (IOException e) {  
    24.             // TODO Auto-generated catch block  
    25.             e.printStackTrace();  
    26.         }  
    27.         driver = pro.getProperty("driver");  
    28.         url = pro.getProperty("url");  
    29.         username = pro.getProperty("username");  
    30.         password = pro.getProperty("password");  
    31.     }  
    32.     public static Connection getConnection(){  
    33.         Connection conn = null;  
    34.         try {  
    35.             Class.forName(driver);  
    36.             conn = DriverManager.getConnection(url,username,password);   
    37.         } catch (ClassNotFoundException e) {  
    38.             // TODO Auto-generated catch block  
    39.             e.printStackTrace();  
    40.         }catch (SQLException e) {  
    41.             // TODO Auto-generated catch block  
    42.             e.printStackTrace();  
    43.         }  
    44.           
    45.         return conn;  
    46.           
    47.     }  
    48.       
    49.     public static void close(ResultSet rs, PreparedStatement ps, Connection conn){  
    50.         if(rs != null){  
    51.             try {  
    52.                 rs.close();  
    53.             } catch (SQLException e) {  
    54.                 // TODO Auto-generated catch block  
    55.                 e.printStackTrace();  
    56.             }  
    57.         }  
    58.           
    59.         if(ps != null){  
    60.             try {  
    61.                 ps.close();  
    62.             } catch (SQLException e) {  
    63.                 // TODO Auto-generated catch block  
    64.                 e.printStackTrace();  
    65.             }  
    66.         }  
    67.         if(conn != null){  
    68.             try {  
    69.                 conn.close();  
    70.             } catch (SQLException e) {  
    71.                 // TODO Auto-generated catch block  
    72.                 e.printStackTrace();  
    73.             }  
    74.         }  
    75.     }  
    76.   
    77. }  

  4. 测试  DBConnTest.java
    1. package com.hbsi.test;  
    2.   
    3. import org.junit.Test;  
    4.   
    5. import com.hbsi.util.DBConn;  
    6.   
    7.   
    8. import junit.framework.TestCase;  
    9.   
    10. public class DBConnTest extends TestCase {  
    11.   
    12.     @Test  
    13.     public void testGetConn(){  
    14.         System.out.print(DBConn.getConnection());  
    15.     }  
    16. }  

  5. java应用类
    1. package com.hbsi.demo;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.PreparedStatement;  
    5. import java.sql.ResultSet;  
    6.   
    7. import com.hbsi.util.DBConn;  
    8.   
    9. public class ChuanTong {  
    10.   
    11.     public static void main(String[] args) {  
    12.         Connection conn = null;  
    13.         PreparedStatement ps =null;  
    14.         ResultSet rs = null;  
    15.         try{  
    16.         conn = DBConn.getConnection();            
    17.         //.....  
    18.            System.out.println(conn);  
    19.         //.....  
    20.         }catch(Exception e){  
    21.             e.printStackTrace();  
    22.         }finally{  
    23.             DBConn.close(rs, ps, conn);  
    24.         }  
    25.           
    26.   
    27.     }  
    28. }  

使用连接池：




编写数据库连接池

  • 编写连接池需实现javax.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：
    1. Connection getConnection() 
    2. Connection getConnection(String username, String password) 
  • 实现DataSource接口，并实现连接池功能的步骤：
    1. 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
    2. 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
    3. 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。
    4. Collection保证将自己返回到LinkedList中是此处编程的难点。 
使用动态代理技术构建连接池中的connection--自己编写
动态代理
  • 明确两个概念：
    1. 代理对象存在的价值：主要用于拦截对真实业务对象的访问。
    2. 代理对象有什么方法
  • Java提供了一个Proxy类，调用它的newInstance方法可以生成某个对象的代理对象，使用该方法生成代理对象时，需要三个参数：
    1. 生成代理对象使用哪个类装载器
    2. 生成哪个对象的代理对象，通过接口指定
    3. 生成的代理对象的方法里干什么事，由开发人员编写handler接口的实现来指定。
  • 初学者必须理解，或不理解必须记住的2件事情：
    1. Proxy类负责创建代理对象时，如果指定了handler（处理器），那么不管用户调用代理对象的什么方法，该方法都是调用处理器的invoke方法。
    2. 由于invoke方法被调用需要三个参数：代理对象、方法、方法的参数，因此不管代理对象哪个方法调用处理器的invoke方法，都必须把自己所在的对象、自己（调用invoke方法的方法）、方法的参数传递进来。

建立了一个代理类,传入代理对象、方法、方法的参数

如果想访问真是对象的方法只能通过invoke访问


【案例】自编写连接池

  1. java类
    1. <pre name="code" class="java">package com.hbsi.util;  
    2.   
    3. import java.io.InputStream;  
    4. import java.io.PrintWriter;  
    5. import java.lang.reflect.InvocationHandler;  
    6. import java.lang.reflect.Method;  
    7. import java.lang.reflect.Proxy;  
    8. import java.sql.Connection;  
    9. import java.sql.DriverManager;  
    10. import java.sql.SQLException;  
    11. import java.util.LinkedList;  
    12. import java.util.Properties;  
    13. import javax.sql.DataSource;  
    14.   
    15. public class MyJdbcPool implements DataSource {  
    16.   
    17.     // 创建的连接放在linklist里  
    18.     private static LinkedList<Connection> list = new LinkedList<Connection>();  
    19.     private static String driver;  
    20.     private static String url;  
    21.     private static String username;  
    22.     private static String password;  
    23.     // 通过静态代码块创建连接  
    24.     static {  
    25.         try {  
    26.             // 类加载器  
    27.             InputStream in = MyJdbcPool.class.getClassLoader()  
    28.                     .getResourceAsStream("db.properties");  
    29.             //属性对象  
    30.             Properties prop = new Properties();  
    31.             prop.load(in);  
    32.   
    33.             driver = prop.getProperty("driver");  
    34.             url = prop.getProperty("url");  
    35.             username = prop.getProperty("username");  
    36.             password = prop.getProperty("password");  
    37.   
    38.             //连接数据库,加载驱动  
    39.             Class.forName(driver);  
    40.   
    41.             //创建一批连接  
    42.             for (int i = 0; i < 10; i++) {  
    43.                 Connection conn = DriverManager.getConnection(url, username,  
    44.                         password);  
    45.                 System.out.println("向池中加入了：" + conn);  
    46.                 list.add(conn);  
    47.             }  
    48.   
    49.         } catch (Exception e) {  
    50.             e.printStackTrace();  
    51.         }  
    52.   
    53.     }  
    54.   
    55.     public Connection getConnection() throws SQLException {  
    56.         if (list.size() > 0) {  
    57.             //不用get方法，get方法会出现重复利用  
    58.             final Connection conn = list.removeFirst();  
    59.             System.out.println("用户从池中取走了：" + conn);  
    60.             System.out.println("池的大小为：" + list.size());  
    61.   
    62.             //动态代理,那个类,哪个对象,干什么事  
    63.             return (Connection) Proxy.newProxyInstance(MyJdbcPool.class  
    64.                     .getClassLoader(), new Class[] { Connection.class },  
    65.                     new InvocationHandler() {  
    66.   
    67.                 //做什么事情,放回连接池里  
    68.                         public Object invoke(Object proxy, Method method,  
    69.                                 Object[] args) throws Throwable {  
    70.                             if (!method.getName().equalsIgnoreCase("close")) {  
    71.                                 return method.invoke(conn, args);  
    72.                             }  
    73.                             System.out.println(conn + "被还了");  
    74.                             list.add(conn);  
    75.                             System.out.println("池的大小为：" + list.size());  
    76.                             return null;  
    77.                         }  
    78.                     });  
    79.   
    80.         } else {  
    81.             throw new RuntimeException("对不起，请稍等！");  
    82.   
    83.         }  
    84.     }  
    85.   
    86.     public Connection getConnection(String username, String password)  
    87.             throws SQLException {  
    88.         // TODO Auto-generated method stub  
    89.         return null;  
    90.     }  
    91.   
    92.     public PrintWriter getLogWriter() throws SQLException {  
    93.         // TODO Auto-generated method stub  
    94.         return null;  
    95.     }  
    96.   
    97.     public int getLoginTimeout() throws SQLException {  
    98.         // TODO Auto-generated method stub  
    99.         return 0;  
    100.     }  
    101.   
    102.     public void setLogWriter(PrintWriter out) throws SQLException {  
    103.         // TODO Auto-generated method stub  
    104.   
    105.     }  
    106.   
    107.     public void setLoginTimeout(int seconds) throws SQLException {  
    108.         // TODO Auto-generated method stub  
    109.   
    110.     }  
    111.   
    112.     public boolean isWrapperFor(Class<?> iface) throws SQLException {  
    113.         // TODO Auto-generated method stub  
    114.         return false;  
    115.     }  
    116.   
    117.     public <T> T unwrap(Class<T> iface) throws SQLException {  
    118.         // TODO Auto-generated method stub  
    119.         return null;  
    120.     }  
    121.   
    122. }  
    123. </pre><br>  
    124. <pre></pre>  
    125. <pre></pre>  
    126. <pre></pre>  
    127. <pre></pre>  
    128. <pre></pre>  
    129. <pre></pre>  
  2. 测试java类
    1. package com.hbsi.demo;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.PreparedStatement;  
    5. import java.sql.ResultSet;  
    6.   
    7. import com.hbsi.util.DBConn;  
    8. import com.hbsi.util.MyJdbcPool;  
    9.   
    10. public class MyJdbcPoolDemo {  
    11.     public static void main(String[] args) {  
    12.         Connection conn = null;  
    13.         PreparedStatement ps =null;  
    14.         ResultSet rs = null;  
    15.         try{  
    16.             MyJdbcPool pool = new MyJdbcPool();  
    17.             conn =pool.getConnection();           
    18.         //.....  
    19.            System.out.println(conn);  
    20.         //.....  
    21.         }catch(Exception e){  
    22.             e.printStackTrace();  
    23.         }finally{  
    24.             DBConn.close(rs, ps, conn);  
    25.         }  
    26.     }  
    27.   
    28. }  


开源数据库连接池

  • 现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSource的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
  • 也有一些开源组织提供了数据源的独立实现：
    • DBCP 数据库连接池 
    • C3P0 数据库连接池
  • 实际应用时不需要编写连接数据库代码，直接从数据源获得数据库的连接。程序员编程时也应尽量使用这些数据源的实现，以提升程序的数据库访问性能。
DBCP数据源
  • DBCP 是 Apache 软件基金组织下的开源连接池实现，使用DBCP数据源，应用程序应在系统中增加如下两个 jar 文件：
    1. Commons-dbcp.jar：连接池的实现
    2. Commons-pool.jar：连接池实现的依赖库
  • Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。
【案例】dbcp连接数据库

  1. 考jar包                                                                                                                                                                                                                                 
  2. 写配置文件
    1. #Á¬½ÓÉèÖà 
    2. driverClassName=com.mysql.jdbc.Driver  
    3. url=jdbc\:mysql\://localhost\:3306/java  
    4. username=root  
    5. password=123456  
    6.   
    7. #<!-- ³õʼ»¯Á¬½Ó -->  
    8. initialSize=10  
    9.   
    10. #×î´óÁ¬½ÓÊýÁ¿  
    11. maxActive=50  
    12.   
    13. #<!-- ×î´ó¿ÕÏÐÁ¬½Ó -->  
    14. maxIdle=20  
    15.   
    16. #<!-- ×îС¿ÕÏÐÁ¬½Ó -->  
    17. minIdle=5  
    18.   
    19. #<!-- ³¬Ê±µÈ´ýʱ¼äÒÔºÁÃëΪµ¥Î» 6000ºÁÃë/1000µÈÓÚ60Ãë -->  
    20. maxWait=60000  
    21.   
    22.   
    23. #JDBCÇý¶¯½¨Á¢Á¬½Óʱ¸½´øµÄÁ¬½ÓÊôÐÔÊôÐԵĸñʽ±ØÐëΪÕâÑù£º[ÊôÐÔÃû=property;]   
    24. #×¢Ò⣺"user" Óë "password" Á½¸öÊôÐԻᱻÃ÷È·µØ´«µÝ£¬Òò´ËÕâÀï²»ÐèÒª°üº¬ËûÃÇ¡£  
    25. connectionProperties=useUnicode=true;characterEncoding=gbk  
    26.   
    27. #Ö¸¶¨ÓÉÁ¬½Ó³ØËù´´½¨µÄÁ¬½ÓµÄ×Ô¶¯Ìá½»£¨auto-commit£©×´Ì¬¡£  
    28. defaultAutoCommit=true  
    29.   
    30. #driver default Ö¸¶¨ÓÉÁ¬½Ó³ØËù´´½¨µÄÁ¬½ÓµÄÖ»¶Á£¨read-only£©×´Ì¬¡£  
    31. #Èç¹ûûÓÐÉèÖøÃÖµ£¬Ôò¡°setReadOnly¡±·½·¨½«²»±»µ÷Óᣣ¨Ä³Ð©Çý¶¯²¢²»Ö§³ÖÖ»¶Áģʽ£¬È磺Informix£©  
    32. defaultReadOnly=  
    33.   
    34. #driver default Ö¸¶¨ÓÉÁ¬½Ó³ØËù´´½¨µÄÁ¬½ÓµÄÊÂÎñ¼¶±ð£¨TransactionIsolation£©¡£  
    35. #¿ÉÓÃֵΪÏÂÁÐÖ®Ò»£º£¨ÏêÇé¿É¼ûjavadoc¡££©NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE  
    36. defaultTransactionIsolation=READ_UNCOMMITTED  
    修改乱码：      
      1. #连接设置  
      2. driverClassName=com.mysql.jdbc.Driver  
      3. url=jdbc\:mysql\://localhost\:3306/java  
      4. username=root  
      5. password=123456  
      6.   
      7. #<!-- 初始化连接 -->  
      8. initialSize=10  
      9.   
      10. #最大连接数量  
      11. maxActive=50  
      12.   
      13. #<!-- 最大空闲连接 -->  
      14. maxIdle=20  
      15.   
      16. #<!-- 最小空闲连接 -->  
      17. minIdle=5  
      18.   
      19. #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->  
      20. maxWait=60000  
      21.   
      22.   
      23. #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]   
      24. #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。  
      25. connectionProperties=useUnicode=true;characterEncoding=gbk  
      26.   
      27. #指定由连接池所创建的连接的自动提交（auto-commit）状态。  
      28. defaultAutoCommit=true  
      29.   
      30. #driver default 指定由连接池所创建的连接的只读（read-only）状态。  
      31. #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）  
      32. defaultReadOnly=  
      33.   
      34. #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。  
      35. #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE  
      36. defaultTransactionIsolation=READ_UNCOMMITTED  
  3. 编写java工具类  DBManger_dbcp.java
    1. package com.hbsi.util;  
    2.   
    3. import java.io.InputStream;  
    4. import java.sql.Connection;  
    5. import java.sql.SQLException;  
    6. import java.util.Properties;  
    7.   
    8. import javax.sql.DataSource;  
    9.   
    10. import org.apache.commons.dbcp.BasicDataSourceFactory;  
    11.   
    12. public class DBManger_dbcp {  
    13.     private static DataSource ds ;  
    14.       
    15.     static{  
    16.         try{  
    17.             InputStream in = DBManger_dbcp.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");  
    18.             Properties prop = new Properties();  
    19.             prop.load(in);  
    20.               
    21.             ds = BasicDataSourceFactory.createDataSource(prop);  
    22.               
    23.               
    24.         }catch(Exception e){  
    25.             e.printStackTrace();  
    26.         }  
    27.     }  
    28.       
    29.      public static Connection getConnction() throws SQLException{  
    30.           
    31.         return ds.getConnection();  
    32.           
    33.      }  
    34.   
    35. }  

  4. 提供一个方法，从池里去连接 DBManger_dbcpDemo.java
    1. package com.hbsi.demo;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.PreparedStatement;  
    5. import java.sql.ResultSet;  
    6.   
    7. import com.hbsi.util.DBConn;  
    8. import com.hbsi.util.DBManger_dbcp;  
    9.   
    10. public class DBManger_dbcpDemo {  
    11.   
    12.     public static void main(String[] args) {  
    13.         Connection conn = null;  
    14.         PreparedStatement ps =null;  
    15.         ResultSet rs = null;  
    16.         try{  
    17.             conn = DBManger_dbcp.getConnction();  
    18.         //.....  
    19.            System.out.println(conn);  
    20.         //.....  
    21.         }catch(Exception e){  
    22.             e.printStackTrace();  
    23.         }finally{  
    24.             DBConn.close(rs, ps, conn);  
    25.         }  
    26.     }  
    27. }  


C3P0 数据源
【案例】c3p0连接数据库
  • 加jar包                                                                                                                                                                                                 
  • 编写工具类DBManager_c3p0.java
    1. package com.hbsi.util;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.SQLException;  
    5.   
    6. import com.mchange.v2.c3p0.ComboPooledDataSource;  
    7.   
    8. public class DBManager_c3p0 {  
    9.       
    10.     private static ComboPooledDataSource ds = null;  
    11.       
    12.     static{  
    13.         try{  
    14.             //创建连接池           
    15.             ds = new ComboPooledDataSource("mysql");  
    16.         }catch(Exception e){  
    17.             e.printStackTrace();  
    18.         }  
    19.     }  
    20.       
    21.     public static Connection getConnection() throws SQLException{  
    22.         return ds.getConnection();  
    23.     }  
    24.   
    25. }  

  • 编写连接配置文件 c3p0-config.xml
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2.   
    3.   
    4. <c3p0-config>  
    5.     <default-config>  
    6.         <property name="driverClass">com.mysql.jdbc.Driver</property>  
    7.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/java</property>  
    8.         <property name="user">root</property>  
    9.         <property name="password">123456</property>  
    10.           
    11.         <property name="acquireIncrement">5</property>  
    12.         <property name="initialPoolSize">10</property>  
    13.         <property name="minPoolSize">5</property>  
    14.         <property name="maxPoolSize">20</property>  
    15.           
    16.           
    17.     </default-config>  
    18.   
    19.     <named-config name="mysql">  
    20.         <property name="driverClass">com.mysql.jdbc.Driver</property>  
    21.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/java</property>  
    22.         <property name="user">root</property>  
    23.         <property name="password">123456</property>  
    24.         <property name="acquireIncrement">5</property>  
    25.         <property name="initialPoolSize">10</property>  
    26.         <property name="minPoolSize">5</property>  
    27.         <property name="maxPoolSize">20</property>  
    28.     </named-config>  
    29.   
    30. </c3p0-config>  

  • 相应实现DBManager_c3p0Demo.java
    1. package com.hbsi.demo;  
    2.   
    3. import java.sql.Connection;  
    4. import java.sql.PreparedStatement;  
    5. import java.sql.ResultSet;  
    6.   
    7. import com.hbsi.util.DBConn;  
    8. import com.hbsi.util.DBManager_c3p0;  
    9.   
    10. public class DBManager_c3p0Demo {  
    11.     public static void main(String[] args) {  
    12.         Connection conn = null;  
    13.         PreparedStatement ps =null;  
    14.         ResultSet rs = null;  
    15.         try{  
    16.             conn = DBManager_c3p0.getConnection();            
    17.         //.....  
    18.            System.out.println(conn);  
    19.         //.....  
    20.         }catch(Exception e){  
    21.             e.printStackTrace();  
    22.         }finally{  
    23.             DBConn.close(rs, ps, conn);  
    24.         }  
    25.     }  
    26.   
    27. }  

配置Tomcat数据源

特别提醒：此种配置下，驱动jar文件需放置在tomcat的lib下


JNDI技术简介

  • JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，
  • 这套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需通过名称检索即可。
  • 其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。
【实例】利用Tomcat实现数据库连接
在META-INF下新建context.xml

context.xml

  1. <Context>  
  2.     <Resourse name="jdbc/javaDB"  
  3.         auth="Container"  
  4.         type="javax.sql.DataSource"  
  5.         username="root"  
  6.         password="123456"  
  7.         driverClassName="com.mysql.jdbc.Driver"  
  8.         url="jdbc:mysql://localhost:3306/java"  
  9.         maxActive="8"  
  10.         maxIdle="4"/>  
  11. </Context>  

做一个servlet,读取xml文件
  1. package com.hbsi.util;  
  2.   
  3. import java.io.IOException;  
  4. import java.sql.Connection;  
  5. import java.sql.SQLException;  
  6.   
  7. import javax.naming.Context;  
  8. import javax.naming.InitialContext;  
  9. import javax.naming.NamingException;  
  10. import javax.servlet.ServletException;  
  11. import javax.servlet.http.HttpServlet;  
  12. import javax.servlet.http.HttpServletRequest;  
  13. import javax.servlet.http.HttpServletResponse;  
  14. import javax.sql.DataSource;  
  15.   
  16. public class TomcatPool extends HttpServlet {  
  17.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
  18.             throws ServletException, IOException {  
  19.         try {  
  20.             //初始化jndi容器  
  21.             Context initCxt = new InitialContext();  
  22.             //获取容器，检索出web服务器中的jndi容器  
  23.             Context envCxt = (Context)initCxt.lookup("java:comp/env");  
  24.             //从jndi容器中检索出连接池  
  25.             DataSource ds = (DataSource)envCxt.lookup("jdbc/javaDB");  
  26.             //获取连接  
  27.             Connection conn = ds.getConnection();  
  28.             System.out.println(conn);  
  29.         } catch (NamingException e1) {  
  30.             // TODO Auto-generated catch block  
  31.             e1.printStackTrace();  
  32.         } catch (SQLException e) {  
  33.             // TODO Auto-generated catch block  
  34.             e.printStackTrace();  
  35.         }  
  36.     }  
  37.     public void doPost(HttpServletRequest request, HttpServletResponse response)  
  38.             throws ServletException, IOException {  
  39.         doGet(request, response);  
  40.     }  
  41.   
  42. }  

把jar包考到Tomcat的lib文件夹下

结果：

五音不全唱歌的软件 五音不全唱歌的软件
原创粉丝点击
热门IT博客
nodejs 书籍 知乎nodejs 书籍 知乎
网络翻唱歌曲网络翻唱歌曲
明朝灭亡的原因 知乎
汽车估价软件
淘宝助理旧版本下载
linux samba 用户
南方全站仪到数据驱动
如何学好英语 知乎
淘宝卖家怎么增加客服
淘宝店铺怎么注销重开
照片打印机推荐 知乎
gephi数据集下载
淘宝买av种子要搜什么
phaser.js类似
甲骨文软件多少钱
怎么解析一级域名
mac重装系统失败
手机网站编程工具
java调用void方法
电信网络诈骗案例
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 会计专硕就是个坑 专硕可以考博吗 会计专硕学校排名 学硕和专硕区别 学硕好还是专硕好 专硕考试科目 会计专硕考到230有多难 专硕考公务员不被承认 教育学专硕就是个坑 专硕可以当大学老师吗 会计专硕学费 金融专硕考试科目 专硕可以评国奖吗 审计专硕学校排名 学硕调剂专硕 学硕与专硕哪个容易考 会计专硕学校难度排名 会计专硕分数线 英语专硕就是个坑 专硕读三年后悔 专硕是全日制吗 深大专硕后悔 专硕考英语几 专硕可以考博士吗 会计专硕排名 专硕能考博吗 专硕有奖学金吗 专硕可以调剂吗 专硕可以读博吗 金融专硕排名 学硕和专硕哪个好 学硕专硕的具体区别 专硕和学硕的学费 学硕与专硕的区别 研究生专硕与学硕的区别 专硕和学硕的区别 学硕和专硕的社会认可度 医学学硕与专硕的区别 专硕是什么意思 专硕与学硕哪个难考 会计学专硕考试科目

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里