jndi连接mysql数据库

1. 怎么用druid连接池连接mysql

现在常用的开源数据库连接池主要有c3p0、dbcp、proxool三种，其中：
Spring 推荐使用dbcp；
Hibernate 推荐使用c3p0和proxool；
1、 DBCP：apache
DBCP(DataBase connection pool)数据库连接池。是apache上的一个 java连接池项目，也是 tomcat使用的连接池组件。单独使用dbcp需要3个包：common-dbcp.jar,common-pool.jar,common-collections.jar由于建立数据库连接是一个非常耗时耗资源的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完后再放回去。dbcp没有自动的去回收空闲连接的功能。

2、 C3P0：
C3P0是一个开源的jdbc连接池，它实现了数据源和jndi绑定，支持jdbc3规范和jdbc2的标准扩展。c3p0是异步操作的，缓慢的jdbc操作通过帮助进程完成。扩展这些操作可以有效的提升性能。目前使用它的开源项目有Hibernate，Spring等。c3p0有自动回收空闲连接功能。

3、 Proxool：Sourceforge
Proxool是一种Java数据库连接池技术。是sourceforge下汪桐如的一个开源项目,这个项目提供一个健壮、易用的连接池，最为关键的是这个连接池提供监控的功能，方便易用，便于发现连接泄漏的情况。
对比：
1> 相同时间内同等量的线程数和循环次数下:通过对三个连接池的三个标志性性能测试参数（Average,median,90%Line）进行比较发现：性能困启dbcp<=c3p0<proxool；
2> 不同情况下的轮搏同一数据库连接池测试：通过观察 Average,median,90%Line三个参数发
现三个连接池的稳定性（三种连接池的三个测试参数的变化情况）依次：稳定性dbcp>=c3p0>proxool。
结论：
通过对三种数据库连接池的性能测试发现，proxool和 c3p0能够更好的支持高并发，但是在稳定性方面略逊于 dpcp；

2. 高并发的MySQL数据查询时,会不会选择数据库连接池

好了，基本概念说完了，言归正传进行比较了。
首先说明的一点，为了应用便于移植以及可配置的角度，建议还是使用jndi统一进行连接池的配置。怎么配置其实网上都有很多例子，
这里简单举个例子（使用spring框架）：
首先在应用的上下文定义中配置jndi名称，如一个resource.xml文件，里边的写法
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>jdbc/myapp</value></property>
</bean>
注意dataSource这个bean在层(hibernate或jdbc)的配置文件里需要作为dataSource名称的属性配置到所有bean中
其中“jdbc/myds”这个就是jndi名称了，下一步就是在应用服务器连接池里进行数据库连接以及对应的jndi配置了

3. MyBatis 怎样使用JNDI连接数据库

JNDI是J2EE中一个很重要的标准，通常我们是在J2EE编程中用到，Tomcat中提供了在JSP和Servelt中直接使用JNDI的方法，主要是通过dbcp连接池
重点讲使用：
1.配置context.xml
注意地址是：tomcat安装目录下的conf，该目录下应该有了context.xml文件。貌似以前的版本是在项目目录中的META-INF目录下配置，我刚开始时参考是也是老版本的操作方法，谁知道试了一晚都不行。。。如果不是那里配置的话会可能出现这样的错误提示：javax.naming.NameNotFoundException: Name jdbc is not bound in this Context?
现在开始配置:
<Context path="/Manager" reloadable="true">
<Resource
name="hello"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
username="root"
password="123456"
maxIdle="4"
maxActive="4"

4. linux下怎么配置jndi数据源配置

一 首先要配置Tomcat的server.xml文件，在对应的web应用的<Context>中加入<Resource>元素,比如:
<Context path="/Manager" reloadable="true">
<Resource
name="hello"
type="javax.sql.DataSource"
driverClassName="com.mysql.jdbc.Driver"
username="root"
password="123456"
maxIdle="4"
maxActive="4"
maxWait="5000"
url="jdbc:mysql://127.0.0.1/jspdev"
/>
</Context>
其中：
name：指定悔山Resource的JNDI名字
type：指定Resource所属的Java类名
driverClassName：指定瞎历连接数据库的JDBC驱动程序
username：指定连接数据库的用户名
password：指定连接数据库的口令
maxIdle：指定数据库连接池中的最大空闲连接数目，0表示不受限制
maxActive：指定数据库连接池中的最大活动连接数目，0表示不受限制
maxWait：指定连接池中连接处于空闲状态的最长时间,超过会抛出异常，-1表示无限
url：指定连接数据库的URL

二 在Web应用中使用数据源：
javax.naming.Context提供了查找JNDI Resource的接口，可以通过三个步骤来使用数据源对象：
A．获得对数据源的引用：
Context ctx = new InitalContext();
DataSource ds =
(DataSource)ctx.lookup("java:comp/env/hello");
B．获得数据库连接对象：
Connection con = ds.getConnection();

C．返回数据库连接到连接池：
con.close();
在连接池中使用close()方法和在非连接池中使用close()方法的区别是：前者仅仅是把数据库连接对象返回到数据库连接池中，是连接对象又恢复到空闲状态，而非关闭数据库连接，而后者将直接关闭和数据库的连接。

三 如果通过数据源访问数据库，由于数据源由Servlet容器创建并维磨前搜护，所以必须把JDBC驱动程序拷贝到Tomcat安装目录下的common/lib目录下，确保Servlet容器能够访问驱动程序。

5. 请教linux下mysql数据库使用JNDI访问权限的问题

正如提示所说，你这个ip没权访问mysql。 mysql里面有个mysql库，里面有个user表或乱州告host表哗明，进去有个host项，如果数值%就是开放给任意ip，如果设置了某个ip，则其他计算迹笑机无法访问。

6. JDBC与JNDI这两种连接方式有什么区别

jdbc是数据库中间代理商为了是java连接数据库而定的一个协议 或者说是方法,通过jdbc-odbc的方法进行数据库连接,是连接一次创建一次的做法 1,由数据库驱动和协议组成连接数据的方法,调用中间商提供的类包,进行创建连接 2.再由连接去调用3种状态. 3.由状态来提供对数据库的操作 jndi是一种命名树的方式,把需要的类都列成目录的样式,需要哪个只要根据命名直接去 调用,是一种比较快洁的思想和行为. 当你要操作数据库的用jdbc 操作命名服务用jndi Java Database Connectivity (JDBC)是一个标准的Java API，它由一组类和接口组成，Java应用程序开发人员使用它来访问数据库和执行SQL语句 JNDI(Java Name Directory Interface),可不仅仅是进行数据库定位的， 它是给当前应用服务器所管理的所有资源一个唯一的标识，包括数据库，网页，文件， 连接池等等。

配置 JNDI绑定
此处绑定的数据源是以 DBCP 为实现。首先必须将数据库驱动（这里用了MYSQL数据库）和DBCP所需要的 Jar 包复制到 Jetty 根目录的 lib 目录下。DBCP主要需要以下3个文件：
Commons-dbcp.jar
Commons-pool.jar
Commons-collections.jar
jdbc和jndi区别
Connection conn = null;
try{
Class.forName("com.mysql.jdbc.Driver",true,Thread.currentThread().getContextClassLoader());
conn = DriverManager.getConnection("jdbc:mysql://MyDBServer?user=***&password=****");
.....
conn.close();
}
catch(...){...}finally{
if(conn!=null){
try{
conn.close();
}
catch(...){...}
}
}
存在的问题？
1、数据库服务器名称MyDBServer 用户名和口令可能需要修改，由此引发JDBC URL修要修改；
2、数据库可能该用别的产品；
3、随着实际终端的增加，原配置的连接池参数可能需要调整；
解决办法
程序员不必关心数据库级别的事情，只需要知道如何引用即可
JNDI出现了。
定义数据源，也就是JDBC引用参数，给这个数据源设置一个名称；
在程序中通过数据源名称引用数据源，从而访问数据库；
//jndi连接
Context initCtx = new InitialContext();
Context envCtx = (Context)initCtx.lookup("java:comp/env");
DataSource ds = (DataSource)envCtx.lookup("jdbc/webtest");
conn = ds.getConnection();

//jdbc连接
Class.forName("com.mysql.jdbc.Driver",true,Thread.currentThread().getContextClassLoader());
conn = DriverManager.getConnection("jdbc:mysql://localhost/mismain?user=root&autoReconnect=true");
程序员开发时，知道要开发访问MySQL数据库的应用，于是将一个对 MySQL JDBC 驱动程序类的引用进行了编码，并通过使用适当的 JDBC URL 连接到数据库。
就像以下代码这样：
Connection conn=null;
try ...{
Class.forName("com.mysql.jdbc.Driver", true, Thread.currentThread().getContextClassLoader());
conn=DriverManager.getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");
......
conn.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{}
}
}

这是传统的做法，也是以前非Java程序员（如Delphi、VB等）常见的做法。这种做法一般在小规模的开发过程中不会产生问题，只要程序员熟悉Java语言、了解JDBC技术和MySQL，可以很快开发出相应的应用程序。
没有JNDI的做法存在的问题：1、数据库服务器名称MyDBServer 、用户名和口令都可能需要改变，由此引发JDBC URL需要修改；2、数据库可能改用别的产品，如改用DB2或者Oracle，引发JDBC驱动程序包和类名需要修改；3、随着实际使用终端的增加，原配 置的连接池参数可能需要调整；4、……
解决办法：程序员应该不需要关心“具体的数据库后台是什么？JDBC驱动程序是什么？JDBC URL格式是什么？访问数据库的用户名和口令是什么？”等等这些问题，程序员编写的程序应该没有对 JDBC 驱动程序的引用，没有服务器名称，没有用户名称或口令 —— 甚至没有数据库池或连接管理。而是把这些问题交给J2EE容器来配置和管理，程序员只需要对这些配置和管理进行引用即可。
由此，就有了JNDI.
用了JNDI之后的做法：首先，在在J2EE容器中配置JNDI参数，定义一个数据源，也就是JDBC引用参数，给这个数据源设置一个名称；然后，在程序中，通过数据源名称引用数据源从而访问后台数据库。
具体操作如下（以JBoss为例）：
1、配置数据源
在JBoss 的 D:\jboss420GA\docs\examples\jca 文件夹下面，有很多不同数据库引用的数据源定义模板。将其中的 mysql-ds.xml 文件Copy到你使用的服务器下，如 D:\jboss420GA\server\default\deploy。
修改 mysql-ds.xml 文件的内容，使之能通过JDBC正确访问你的MySQL数据库，
如下：
Connection conn=null;
try ...{
Class.forName("com.mysql.jdbc.Driver", true, Thread.currentThread().getContextClassLoader());
conn=DriverManager.getConnection("jdbc:mysql://MyDBServer?user=qingfeng&password=mingyue");
......
conn.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{}
}
}
<?xml version="1.0" encoding="UTF-8"?>
<datasources>
<local-tx-datasource>
<jndi-name>MySqlDS</jndi-name>
<connection-url>jdbc:mysql://localhost:3306/lw</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>root</user-name>
<password>rootpassword</password>
<exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter</exception-sorter-class-name>
<metadata>
<type-mapping>mySQL</type-mapping>
</metadata>
</local-tx-datasource>
</datasources>
这里，定义了一个名为MySqlDS的数据源，其参数包括JDBC的URL，驱动类名，用户名及密码等。
2、在程序中引用数据源：
Connection conn=null;try ...{
Context ctx=new InitialContext();
Object datasourceRef=ctx.lookup("java:MySqlDS"); //引用数据源 DataSource ds=(Datasource)datasourceRef; conn=ds.getConnection();
......
c.close();
} catch(Exception e) ...{
e.printStackTrace();
} finally ...{
if(conn!=null) ...{
try ...{
conn.close();
} catch(SQLException e) ...{ }
}
}
直接使用JDBC或者通过JNDI引用数据源的编程代码量相差无几，但是现在的程序可以不用关心具体JDBC参数了。
在系统部署后，如果数据库的相关参数变更，只需要重新配置 mysql-ds.xml 修改其中的JDBC参数，只要保证数据源的名称不变，那么程序源代码就无需修改。
由此可见，JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置、易于部署。

7. java如何访问数据库

Java可以使用JDBC访问数据库，也可以使用各类ORM框架访问数据库，但这些框架最终还是通过JDBC访问数据库，它们只是封装了数据库操作，而使得开发者可以减少这部分消耗。因此，本文只讲解JDBC访问方式。
JDBC访问一般分为如下流程：
1、加载JDBC驱动程序：
在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），
这通过java.lang.Class类的静态方法forName(String className)实现。
例如：
try{
//加载MySql的驱动类
Class.forName("com.mysql.jdbc.Driver") ;
}catch(ClassNotFoundException e){
System.out.println("找不到驱动程序类 ，加载驱动失败！");
e.printStackTrace() ;
}
成功加载后，会将Driver类的实例注册到DriverManager类中。
2、提供JDBC连接的URL
•连接URL定义了连接数据库时的协议、子协议、数据源标识。
•书写形式：协议：子协议：数据源标识
协议：在JDBC中总是以jdbc开始
子协议：是桥连接的驱动程序或是数据库管理系统名称。
数据源标识：标记找到数据库来源的地址与连接端口。
例如：（MySql的连接URL）
jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gbk ;
useUnicode=true：表示使用Unicode字符集。如果characterEncoding设置为
gb2312或GBK，本参数必须设置为true 。characterEncoding=gbk：字符编码方式。
3、创建数据库的连接
•要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，该对象就代表一个数据库的连接。
•使用DriverManager的getConnectin(String url,String username,String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和密码来获得。
例如：
//连接MySql数据库，用户名和密码都是root
String url = "jdbc:mysql://localhost:3306/test" ;
String username = "root" ;
String password = "root" ;
try{
Connection con =
DriverManager.getConnection(url , username , password ) ;
}catch(SQLException se){
System.out.println("数据库连接失败！");
se.printStackTrace() ;
}
4、创建一个Statement
•要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3种类型：
1、执行静态SQL语句。通常通过Statement实例实现。
2、执行动态SQL语句。通常通过PreparedStatement实例实现。
3、执行数据库存储过程。通常通过CallableStatement实例实现。
具体的实现方式：
Statement stmt = con.createStatement() ;
PreparedStatement pstmt = con.prepareStatement(sql) ;
CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}") ;
5、执行SQL语句
Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate和execute
1、ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句，返回一个结果集（ResultSet）对象。
2、int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等
3、execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的语句。
具体实现的代码：
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;
int rows = stmt.executeUpdate("INSERT INTO ...") ;
boolean flag = stmt.execute(String sql) ;
6、处理结果
两种情况：
1、执行更新返回的是本次操作影响到的记录数。
2、执行查询返回的结果是一个ResultSet对象。
•ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些行中数据的访问。
•使用结果集（ResultSet）对象的访问方法获取数据：
while(rs.next()){
String name = rs.getString("name") ;
String pass = rs.getString(1); // 此方法比较高效（列是从左到右编号的，并且从列1开始）
}
7、关闭JDBC对象
操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声明顺序相反：
1、关闭记录集
2、关闭声明
3、关闭连接对象
if(rs != null){ // 关闭记录集
try{
rs.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(stmt != null){ // 关闭声明
try{
stmt.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}
if(conn != null){ // 关闭连接对象
try{
conn.close() ;
}catch(SQLException e){
e.printStackTrace() ;
}
}

8. java连接数据库的详细步骤

JDBC:
java database connective

主要作用:
连接程序使用的数据库

使用步骤:
1. 引入外部jar包(mysql提供的Java使用者的连接器)
工程上右键-->build path --> config buildpath --> liberies
-->add external jars
-->选择对应的mysql-connectorXXXXXX.jar
看到工程上有jar文件则证明引入成功

2. 编程:
(1):注册数据库驱动
Class.forName("com.mysql.jdbc.Driver");
(2):创建连接
String url = "jdbc:mysql://192.168.0.243:3306/test";
String userName = "root";
String password = "root";
Connection conn = DriverManager.getConnection(url, userName, password);

(3):创建SQL信使
Statement stmt = conn.createStatement();

(4):执行SQL语句
int i = stmt.executeUpdate("insert into employee values ('10070004', '张三丰', 1, '2005-05-23', 0, 1001, '2007-02-02', 200)");
(5):异常捕获、关闭资源

9. 怎样配置tomcat的jndi数据库连接

是JDBC数据库旦陪闹连接吧？
先建立ODBC
一、jsp连接Oracle8/8i/9i数据库（用thin模式）
testoracle.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<乱脊html>
<body>
<%Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为你的数据库的SID
String user="scott";
String password="tiger";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
二、jsp连接Sql Server7.0/2000数据库
testsqlserver.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";
//pubs为你的数据库的
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一模罩个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
三、jsp连接DB2数据库
testdb2.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample";
//sample为你的数据库名
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
四、jsp连接Informix数据库
testinformix.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
五、jsp连接Sybase数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/tsdata";
//tsdata为你的数据库名
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
六、jsp连接MySQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
七、jsp连接PostgreSQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/soft"
//soft为你的数据库名
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>

10. tomcat怎么连接mysql

msql数据库连接:
一、传统方法:
1、本人使用JDBC驱动mysql-connector-java-5.1.6-bin.jar,将此驱动包放到%Tomcat_Home%\common\lib\下，
2、在应用程序中加载此包,右键项目属性->java build path->libraries->external libraries
3、在应用程序中加载驱动，Class.forName("com.mysql.jdbc.Driver").newInstance()
4、 用java.sql.DriverManager类取得一连conn=DriverManager.getConnection(url);
5、用java.sql.Statement接口创建stmt 对象,stmt=conn.createStatement();
或java.sql.PreraredStatement接口 pstmt;
6、 用java.sql.ResultSet接口创建rst对象,rst = stmt.executeQuery(sql语句);
7、 处理结果集，断开数据库连接。
二、数据池连接技术
1、 将mysql-connector-java-5.1.6-bin.jar,也在%Tomcat_Home%\common\lib\下,
2、 在tomcat中manager中配置数据源名,配置完后内容自动放在conf\server.xml中。
3、 在conf\catalina\localhost\下建你应用程序的xml文件，例wei2.xml中,内容为<Context docBase="wei2" path="/wei2">
<ResourceLink global="jdbc/mysql" name="jdbc/mysql" type="javax.sql.DataSource"/>
</Context>
其中jdbc/mysql为配置的JNDI;
下面说下JNDI与DataSource
JNDI java naming directory interface命名和目录接口命名服务来使组件定位到其它组件和资源（数据库资源）,JNDI所有名应该以字符串java:comp/env开始；
要定位JDBC资源中，这时就可以编写代码使用JNDI的lookup()方法来定位到这个资源了。
JNDI命名服务有一组将名称与对象联系在一起的绑定。JNDI中的lookup()方法传递一个JNDI参数（java:comp/env/myjdbc,前面java:comp/env是必要的。），返回相应的对象(返回类型为DataSource,若为数据库，则可用DataSource中的getConnection()方法获取数据库连接).

DataSoure 是javax.sql.DataSource类型。
数据库连接池分三步：
1、 指定数据库连接的逻辑名，起名java:comp/env/myjdbc
2、 获取与逻辑名相当的DataSource对象，代码为:
InitialContext ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup(“java:comp/env/myjdbc”);
3、 由DataSource对象获取Connection对象
Connection con=ds.getConnection();
综上所有步骤：
Connection con;
Private void init(){
Try{
InitialContext ctx = new InitialContext();
DataSource ds = (DataSource)ctx.lookup(“java:comp/env/jdbc/mysql”);
Conn = ds.getConnection();
}
Catch(Exception e){
e.printStackTrace();
}
}
这段代码使用连接池技术返回一个Connection对象.