#使用JDBC操作数据库
#1、JDBC基础
#JDBC简介:JDBC(Java Database Connectivity)是一种可以执行SQL的Java API,通过它可以用一种API操作不同的数据库.
#JDBC驱动:不同数据库间,标准的SQL语句可以移植,而数据库实际通信协议及某些数据库特征不可移植,因此,JDBC和数据库之间须还有一层,用于将JDBC调用映射成特定的数据库调用,此特殊层就是JDBC驱动程序.
常见的JDBC驱动有四种:
》JDBC-ODBC桥,是最早实现的JDBC驱动程序,目的为了快速推广JDBC,非多线程,能力有限,此驱动程序将JDBC API映射成ODBC API
》直接将JDBC API映射成数据库特定的客户端API,这种驱动程序包含特定数据库的本地代码,可用于特定数据库的客户端
》支持三层结构的JDBC访问方式,主要用于Applet阶段,通过Applet访问数据库
》纯java的,直接与数据库实例交互,智能型的,知道数据库使用的底层协议,是目前最流行的JDBC 驱动
#JDBC常用接口和类简介
DriverManager:用于管理JDBC驱动的服务类,主要方法是获得Connection对象
public static synchronized Connection getConnection(String url,String user,String pass) throws SQLException
Connection:代表一个数据库连接物理会话,若放我数据库,须先获得数据库连接.常用方法
》Statement createStatement() throws SQLException 返回Statement对象
》PreparedStatement prepareStatement(Strin sql) throws SQLException 返回编译的Statement 对象
》CallableStatement preparedCall(Strin sql) throws SQLException 返回的CallableStatement 对象用于存储过程调度
Statement:执行DML SQL的工具接口,常用方法:
》ResultSet executeQuery(String sql) throws SQLException 执行查询,返回结果集对应的ResultSet对象
》int executeUpdate(String sql) throws SQLException 执行DML并返回受影响的行数
》boolean execute(String sql) throws SQLException 返回boolean表式执行成功与否
PreparedStatement :是Statement的子接口,允许数据库预编译SQL,避免数据库每次重新编译,以后每次只改变SQL的参数,性能较好,常用方法
》ResultSet executeQuery() throws SQLException 执行查询,返回结果集对应的ResultSet对象
》int executeUpdate() throws SQLException 执行DML并返回受影响的行数
》boolean execute() throws SQLException 返回boolean表式执行成功与否
注:上述方法因SQL预编译,无须接手SQL字符串,只是需要接收参数,故有如下方法 void
setXxx(int paramIndex,Xxx value)
ResultSet:包含访问结果集的方法,可通过列索引或列名获得列数据,常用方法
》boolean next() throws SQLException,将ResultSet定位到下一行,结果集的起始位在第一行之前
》void close()throws SQLException 释放ResultSet对象
》boolean absolute(int row)throws SQLException 将结果集移到指定行,若row是负值,则倒数移动
注:默认方法创建的ResultSet不支持absolute方法因为结果集不支持后移,若想支持,需要如此创建
:Statement
stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
:ResultSet rs=stmt.executeQuery(sql);
#传统JDBC访问数据库步骤
》通过Class.forName(String driverClass)注册数据库驱动
》通过DriverManager.getConnection(String url,String user,String password)获得数据库连接对象
》通过Connnection.createStatement()或者Connection.createPreparedStatement(String sql)创建相应的Statement对象
》通过Statement.execute(String sql)或者PreparedStatement.execute()执行相应的SQL,并返回ResultSet对象
》操作ResultSet
#2、数据库连接池
》数据库连接的建立及关闭极其耗资源,对系统性能影响尤为明显.
》传统数据库连接方式:一个数据库连接均对应一个物理连接,每次操作都要打开、关闭该物理操作,这种频繁性,会造成系统性能下降,此时,考虑数据库连接池.
》数据库连接池解决方案:当应用程序启动时,系统主动建立足够的连接(按指定的初始化数据),并将这些连接组成一个池.每次应用程序请求数据库连接时,无需重新打开连接,而是从池中取出已有的连接,使用完后,不再关闭,而是直接将该连接归还池,使用连接池,可大大提高系统运行效率.
》数据库连接池介绍
》对于共享资源的情况,有一个通用的设计模式--资源池(Resource Pool),用于解决资源的频繁请求、释放所造成的性能下降.为解决数据库连接的这种频繁性,JDBC2.0规范引入了数据库连接池技术,实际上,数据库连接池是Connection对象的工厂,常用参数有:
@数据库的初始连接数 @连接池的最大连接数 @连接池每次增加的连接数
》连接池的工作示意图 {JDBC标准的API并没有提供连接池的实现,仅仅提供了DataSource接口具体的实现有一些厂商提供}
》连接池的分配与释放
@程序启动,分配初始化数目的连接,按需分配,用过归还、超时归还,当申请时无或者达到指定的最小值,按增量参数值分配新的连接
@为确保连接池中最小的连接数,通常有如下策略:
:动态--定时检查连接池,一旦发现数量小于最小连接数,则补充相应的新连接,保证连接池正常运转
:静态--空闲连接不足时,系统才检测是否达到最小连接
》连接池的实现
连接池通常包括连接池类(DBConnectionPool)和连接池管理类(DBConnectionPoolManager):
》连接池类是某一数据库所有连接的缓冲池,主要实现功能:@从连接池获取或者创建可用连接,@使用完毕,归还给池连接,@系统关闭前,断开所有连接并释放连接占用的资源,@处理无效连接,@限制池中连接的数节目,介于最小值和最大值之间
》连接池管理类是连接池类的包装类,该类采用单态模式设计,保证系统中只有一个实例,主要用于管理多个连接池对象,主要实现以下功能:@注册数据库驱动程序,@根据配置文件,创建连接池对象,@命名、管理连接池,@跟踪连接池的使用,需要时关闭并释放资源
:数据库连接池的管理是个难点,管理不当,造成系统开销过大,将成为性能瓶颈.对于高并发的WEB 应用,采用连接池技术效率和稳定性比传统的连接方式要好的多
:并发问题--数据库必须考虑此问题,对于并发,Java语言提供管理并发的支持,使用synchronized 关键字可确保方法线程的安全.故,DataSource的getConnection方法必须以该该关键字修饰
public synchronized Connection getConnection(); //保证线程安全
:事务处理--JDBC的Connection本身通过设置Connection的AutoCommit属性为false,提供对事务的支持,然后,显式地调用commit或rollback方法提交或回滚事务.
连接池需要复用connection,因此,必须提供相应的事务支持机制.考虑采用每个事务独占一个连接,此法可降低事务管理复杂性.
:多数据库服务器和多用户--JDBC规范中,DataSource具备同时连接不同数据库的能力,如同时连oracle和sql server.此时,考虑使用xml配置文件来配置连接所需的相关信息.然后,提供一个Singleton 模式的连接池管理类,该管理类每次启动时读取配置文件信息,创建多个连接池类的实例,每个实例对应一
个数据库连接池.连接池管理类实例命名每个连接池实例,通过不同的名称管理不同的连接池.
对于多个用户访问同一个数据库的情况,也可考虑使用xml配置文件.
》常见的数据库连接池
通常,没有必要自己实现连接池.商用应用服务器都有自己的连接池实现,如WebLogic和WebSphere,其性能和稳定性绝佳,即使没有商用应用服务器,也可使用开源的连接池.目前流行的有2个:@DBCP连接
池 @C3P0连接池
》DBCP连接池
Appache提供的开源实现,依赖于两个jar文件
@commons-dbcp-1.2.1.jar:连接池的实现
@commons-pool.jar:连接池实现的依赖库
Tomcat的连接池正是采用该连接池实现的.连接该连接池,既允许与应用服务器整合使用,又可由应用程序独立使用.下面的代码DBConn类通过DBCP获得数据库连接:
public class DBConn
{
private static DBConn dc;
private Connection conn = null; private Statement stmt = null; private DBConn()
{
}
public static DBConn instance() {
if (dc == null)
{
dc = new DBConn();
}
return dc;
}
public Statement openStmt()
{
if (stmt == null)
{
conn = getConn();
try
{
stmt = conn.createStatement(); }
catch (Exception e)
System.err.println("创建Statement异常: " + e.getMessage()); }
}
return stmt;
}
public void closeStmt()
{
if (stmt != null)
{
try
{
stmt.close();
}
catch (Exception e)
{
System.err.println("Statement关闭异常");
}
}
if (conn != null)
{
try
{
conn.close();
catch (Exception e)
{
System.err.println("数据库关闭异常");
}
}
}
private Connection getConn()
{
if (conn == null)
{
try
{
BasicDataSource ds = new BasicDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver"); ds.setUrl("jdbc:mysql://localhost:3306/j2ee"); ds.setUsername("root");
ds.setPassword("123456");
conn = ds.getConnection();
}
catch (Exception e)
{
e.printStackTrace();
}
return conn;
}
}
》C3P0连接池
Hibernate推荐使用该优秀的连接池,它实现了JDBC3.0规范的部分功能,故其性能更加突出,该池不仅可自动清理不再使用的Connection,还可以自动清理Statement和ResultSet.C3P0连接池需要jre1.3以上,推荐jre1.4
若需使用C3P0连接池,应将包c3p0-0.8.5.jar文件复制进系统.下面代码是通过C3P0连接池获得数据库连接:
public class DBConn
{
private static DBConn dc;
private Connection conn = null;
private Statement stmt = null;
private DBConn()
{
}
public static DBConn instance()
{
if (dc == null)
{
dc = new DBConn();
}
return dc;
public Statement openStmt()
{
if (stmt == null)
{
conn = getConn();
try
{
stmt = conn.createStatement();
}
catch (Exception e)
{
System.err.println("创建Statement异常: " + e.getMessage()); }
}
return stmt;
}
public void closeStmt()
{
if (stmt != null)
{
try
{
stmt.close();
catch (Exception e)
{
System.err.println("Statement关闭异常"); }
}
if (conn != null)
{
try
{
conn.close();
}
catch (Exception e)
{
System.err.println("数据库关闭异常"); }
}
}
public Connection getConn()
{
if (conn == null)
{
try
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("32147");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
conn = ds.getConnection();
}
catch (Exception e)
{
e.printStackTrace();
}
}
return conn;
}
}
#3、Spring的JDBC体系
》Spring提供的JDBC抽象框架由core、datasource、object和support4个包组成.
core包含Spring JDBC抽象的核心类,包含各种SQLExceptionTranslator,用于将SQLException转化成spring的异常继承体系,还有DataFileMaxValueIncrementer实现,以及JdbcTemplate,持久层访问模板类.
datasource包含简化数据源连接的工具类,以及各种数据源的简单实现.通过这些实现,spring可以在j2ee之外测试jdbc代码.通过该工具类,可以从JNDI获得连接,并可关闭连接.
object包里的工具类,可将数据库的查询、更新等过程封装成类.这种方式模拟JDO的访问方式,纵横四海查询返回的"值对象"不与数据库关联.support包含了JdbcDaoSupport等工具类.
底层数据库异常被包装成org.springframework.dao中的异常,是运行时异常,故,通过JDBC抽象进行的持久操作,无需处理jdbc访问特定的异常.Spring允许将包装后的异常传播到特定的层.
》Spring的JDBC封装核心是JdbcTemplate,简化了JDBC的使用,可以处理数据库的连接和释放,故,可避免没有数据库关闭造成的连接泄露.
使用构造器JdbcTemplate(DataSource dataSource),可通过数据源引用创建JdbcTemplate实例,实际应用中,可以通过JdbcDaoSupport取得,JdbcDaoSupport的getJdbcTemplate()方法会创建JdbcTemplate实例,所需的数据源有JdbcDaoSupport提供.
JdbcTemplate提供系列方法简化数据库访问,主要常用有:
》void execute(String sql) 主要用于执行DDL语句
》List query(String sql,Object[] args,RowMapper) 执行SQL查询,并将每条记录映射成bean 实例,返回bean的实例集合
》List queryForList(String sql,Object[] args)
》Object queryForObject(String sql,RowMapper rowMapper)
》int update(String sql)
》int update(String sql,Object[] args)
》JDBC封装的回调接口
这些回调接口允许在spring的JDBC抽象体系内,使用原生JDBC查询,避免spring对JDBC封装后的灵活性不足缺点.Spring JDBC抽象体系内的回调接口有:
》CallableStatementCallback:通过该接口,可使用原生的JDBC命令调用存储过程和函数
》CallableStatementCreator:是JdbcTemplate使用的两个核心回调接口之一,通过该接口可以获得CallableStatement对象
》PreparedStatementCallback:通过该接口,可以使用原生的JDBC命令访问数据库
》PreparedStatementCreator:是JdbcTemplate使用的两个核心回调接口之一,通过该接口可以获得PreparedStatement对象
》StatementCallback:作用类似PreparedStatementCallback,只是不具备预编译功能
》Spring JDBC与传统JDBC对比
》简化连接获取方式--无须每次采用DriverManager获得连接,也不需使用JNDI查找获得连
接.Spring的JDBC连接依赖IOC容器注入
》模板化操作方式--无需繁琐的getConnection,createStatement等操作
》优秀的面向对象操作方式--结果直接转化成JavaBean传出
》一致的异常继承体系--无需捕获JDBC特定的数据库异常,JDBC的checked异常被包装成了Runtime异常,不再要求强制捕捉
#4、JdbcTemplate访问数据库
》执行简单的查询 {API详见Spring API 2.0}
int queryForXxx(String sql):静态SQL命令执行查询,Xxx可以是int或long,返回一个标量值,而且只能返回一行记录
int queryForXxx(String sql,Object[] args):同上,带参数而已
Object queryForObject(String sql,Class requiredType):返回执行单行单列的查询,将返回结果转换成requiredType类型的对象
注:只支持特定类型的转换,比如,varchar只能转成String
List queryForList(String sql):
List queryForList(String sql,Object[] args):
List queryForList(String sql,Class requiredType):
List queryForList(String sql, Object[] args, Class elementType):
/*
*示例
*/
public class JdbcTemplateQuery
{
public static void main(String[] args)throws Exception
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("32147");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
//创建一个JdbcTemplate
JdbcTemplate jt = new JdbcTemplate();
//为JdbcTemplate指定DataSource
jt.setDataSource(ds);
//如果只需返回一个特定值,可直接查询
int count = jt.queryForInt("select count(*) from mytable");
System.out.println(count);
//此处的转换实际非常简单:只支持Varchar->String的转换.
String nametmp = (String)jt.queryForObject("select name from mytable where name='wawa2'",String.class);
System.out.println(nametmp);
List namelist = jt.queryForList("select name from mytable");
for (Iterator it = namelist.iterator();it.hasNext(); )
{
System.out.println(it.next().getClass());
}
//返回系列值
List list = jt.queryForList("select * from mytable");
for (Iterator it = list.iterator();it.hasNext(); )
{
System.out.println(it.next().getClass());
System.out.println((Map)it.next());
}
}
}
》执行更新的
int update(String sql)
int update(String sql,Object[] args)
int update(String sql,Object[] args,int[] argTypes):使用PreparedStatement执行更新,args 用于传入参数,argTypes指定参数的SQL类型
/*
*示例
*/
public class JdbcTemplateUpdate
{
public static void main(String[] args)throws Exception
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("32147");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
//创建一个JdbcTemplate
JdbcTemplate jt = new JdbcTemplate();
//为JdbcTemplate指定DataSource
jt.setDataSource(ds);
jt.update("update mytable set name = 'china' where name='aaa'");
String[] values = {"American"} ;
jt.update("update mytable set name = ? where name='china'" , values); }
}
》执行简单DDL的
void execute(String sql)
/*
*示例
*/
public class JdbcTemplateDdl
{
public static void main(String[] args)throws Exception
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("123456");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
//创建一个JdbcTemplate
JdbcTemplate jt = new JdbcTemplate();
//为JdbcTemplate指定DataSource
jt.setDataSource(ds);
jt.execute("drop table if exists wawa");
jt.execute("create table xxx(name varchar(100))");
System.out.println("正常结束");
}
}
#5、StatementCallback访问数据库
JdbcTemplate对数据库访问包装,持久化操作更简单,但降低了访问的灵活性,而通过回调接口的使用,可弥补此损失.
通过StatementCallback接口,可获得JdbcTemplate的Statement回调,使用原生的SQL命令,此时,同样可利用JdbcTemplate提供的系列优点,如一致的异常体系.
StatementCallback回调接口只有一个方法需实现:
Object doInStatement(Statement stmt)throws SQLException,DataAccessException
在该方法的执行体内,可获得Statement的引用,从而完成数据库的访问.
/*
*示例
public class ExecuteStatementCallback
{
public static void main(String[] args)throws Exception
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("32147");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
//创建一个JdbcTemplate
JdbcTemplate jt = new JdbcTemplate();
//为JdbcTemplate指定DataSource
jt.setDataSource(ds);
jt.execute(new StatementCallback()
{
public Object doInStatement(Statement stmt)throws SQLException
{
stmt.execute("update mytable set name = 'xx' where name ='American' "); return null;
}
}
}
程序中,通常使用StatementCallback的匿名内部类创建StatementCallback实例,实现该接口,则要求实现doInStatement(Statement stmt)方法,其方法体就是实际要执行的SQL操作
#6、PreparedStatementCallback访问数据库
作用类似于StatementCallback接口,只是使用了PreparedStatement对象
/*
*示例
*/
public class ExecutePreparedStatementCallback
{
public static void main(String[] args)throws Exception
{
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/j2ee");
ds.setUser("root");
ds.setPassword("32147");
ds.setMaxPoolSize(40);
ds.setMinPoolSize(2);
ds.setMaxStatements(180);
//创建一个JdbcTemplate
JdbcTemplate jt = new JdbcTemplate();
//为JdbcTemplate指定DataSource
jt.setDataSource(ds);
jt.execute("update mytable set name=? where name = 'xx'", new PreparedStatementCallback()
{
public Object doInPreparedStatement(PreparedStatement pstmt)throws SQLException
{
pstmt.setString(1,"-----");
pstmt.execute();
return null;
}
}
);
}
}
#7、连接数据库的辅助类
》DataSourceUtils工具类:通过DataSource获取连接,支持线程的绑定,如用于DataSourceTransactionManager.含有很多静态方法,主要有2个:
》static Connection getConnection(DataSource dataSource)
》static voic releaseConnection(Connection con,DataSource dataSource)
通常情况下建议使用spring的IOC容器管理DataSource.
/*
*示例
*/
public class BeanTest
package com.jdbc.myConnection; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ConnectionFactory { //获取Oracle连接 public static Connection getOracleConnection() { Connection con = null; try { Class.forName("oracle.jdbc.OracleDriver"); String url = "jdbc:oracle:thin:@localhost:1521:orcl"; con = DriverManager.getConnection(url, "scott", "tiger"); } catch (Exception e) { e.printStackTrace(); } return con; } //获取SQLServer的test数据库连接 public static Connection getSQLServerConnection() { return getMySQLConnection("test"); } //获取SQLServer 连接 public static Connection getSQLServerConnection(String databaseName) { Connection con = null; try { Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver"); String url = "jdbc:microsoft:sqlServer://localhost:1433;databaseName=" + databaseName; con = DriverManager.getConnection(url, "sa", "sa"); } catch (Exception e) { e.printStackTrace(); } return con; } //获取MySQL连接 public static Connection getMySQLConnection() { return getMySQLConnection("test");
Java数据库连接大全 注：newInstance()可要可不要。 通用JDBC-ODBC直连方式（无需额外的驱动包）： Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); Connection conn=DriverManager.getConnection("jdbc:odbc:Driver={SQL Server};Server=localhost;uid=sa;pwd=1111;Database=db"); 以下方式中Class.forName中的都是需要添加的驱动包。 1Java连接Oralce Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); String url="jdbc:oracle:thin:@localhost:1521:orcl"; Connection conn=DriverManager.getConnection(url,user,password); 2Java连接MySQL Class.forName("org.gjt.mm.mysql.Driver").newInstance(); //Class.forName("com.mysql.jdbc.Driver"); String URL="jdbc:mysql://localhost/test"; Connection conn=DriverManager.getConnection(url,user,password); 3Java连接SQLServer 连接mssql2000 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance(); String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db"; Connection conn=DriverManager.getConnection(url,user,password); 连接mssql2005+ Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver").newInstance(); String URL="jdbc:sqlserver://localhost:1433;DatabaseName=db"; Connection conn=DriverManager.getConnection(url,user,password); 通用方式： Class.forName("net.sourceforge.jtds.jdbc.Driver").newInstance(); String url="jdbc:jtds:sqlserver://localhost:1433;DatabaseName=db"; Connection conn=DriverManager.getConnection(url,user,password); 4Java连接DB2 Class.forName(“com.ibm.db2.jdbc.app.DB2Driver").newInstance(); String URL=”jdbc:db2://localhost:5000/db"; Connection conn=DriverManager.getConnection(url,user,password); 5Java连接Infomix Class.forName("https://www.doczj.com/doc/1418775296.html,rmix.jdbc.IfxDriver").newInstance(); String URL＝"jdbc:informix-sqli://123.45.67.89:1533/db:INFORMIXSERVER=myserver"; Connection conn=DriverManager.getConnection(url,user,password); 6Java连接SyBase Class.forName("com.sybase.jdbc.SybDriver").newInstance(); Properties sysProps=System.getProperties(); SysProps.put("user","userid"); SysProps.put("password","user_password"); Connection conn=DriverManager.getConnection(url,SysProps);
1.C#连接连接Access 程序代码: using System.Data; using System.Data.OleDb; .. string strConnection="Provider=Microsoft.Jet.OleDb.4.0;"; strConnection+=@"Data Source=C:BegASPNETNorthwind.mdb"; OleDbConnection objConnection=new OleDbConnection(strConnection); .. objConnection.Open(); objConnection.Close(); 解释: 连接Access数据库需要导入额外的命名空间,所以有了最前面的两条using命令,这是必不可少的! strConnection这个变量里存放的是连接数据库所需要的连接字符串,他指定了要使用的数据提供者和要使用的数据源. "Provider=Microsoft.Jet.OleDb.4.0;"是指数据提供者,这里使用的是Microsoft Jet引擎,也就是Access中的数据引擎,https://www.doczj.com/doc/1418775296.html,就是靠这个和Access的数据库连接的. "Data Source=C:\BegASPNET\Northwind.mdb"是指明数据源的位置,他的标准形式是"Data
Source=MyDrive:MyPath\MyFile.MDB". PS: 1."+="后面的"@"符号是防止将后面字符串中的"\"解析为转义字符. 2.如果要连接的数据库文件和当前文件在同一个目录下,还可以使用如下的方法连接: strConnection+="Data Source="; strConnection+=MapPath("Northwind.mdb"); 这样就可以省得你写一大堆东西了! 3.要注意连接字符串中的参数之间要用分号来分隔. "OleDbConnection objConnection=new OleDbConnection(strConnection);"这一句是利用定义好的连接字符串来建立了一个链接对象,以后对数据库的操作我们都要和这个对象打交道. "objConnection.Open();"这用来打开连接.至此,与Access数据库的连接完成. 2.C#连接SQL Server 程序代码: using System.Data; using System.Data.SqlClient; .. string strConnection="user id=sa;password=;"; strConnection+="initial catalog=Northwind;Server=YourSQLServer;";
Java连接mysql数据库源代码 /** *@author mervyn *@Development_time 2011.3.12 *welcome to https://www.doczj.com/doc/1418775296.html,/mervyn_hb */ package src; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.sql.*; import java.util.*; public class MysqlConnectSystem { /** * @param args * @throws IOException */ public static void main(String[] args) throws SQLException, IOException { String Usename,KeyID,UrlString; //String DriverConnect; char MenuExitValue; String driver="com.mysql.jdbc.Driver"; Scanner EntryValue=new Scanner(System.in); System.out.println("欢迎使用MysqlConnectSystem信息管理系统！"); MysqlConnectSystem mysqlconnect=new MysqlConnectSystem(); MysqlConnectSystem mysqlinsert=new MysqlConnectSystem(); MysqlConnectSystem mysqlupdate=new MysqlConnectSystem(); MysqlConnectSystem mysqldelete=new MysqlConnectSystem(); System.out.println("请输入要登录的用户名："); Usename=EntryValue.next(); System.out.println("请输入要登录的数据库的密码："); KeyID=EntryValue.next(); System.out.println("请输入需要登录的数据库："); UrlString="jdbc:mysql://127.0.0.1:3306/"+EntryValue.next(); do{ try { Class.forName(driver); Connection conn=DriverManager.getConnection(UrlString, Usename,
随笔- 6 文章- 0 评论- 1 Java连接各种数据库写法 # 示例配置参考，涵盖几乎所有的主流数据库 ############# Oracle数据库######################## # 数据库驱动名 driver=oracle.jdbc.driver.OracleDriver # 数据库URL(包括端口） dburl=jdbc:oracle:thin:@127.0.0.1:1521:zvfdb # 数据库用户名 user=root # 用户密码
password=zvfims ############# DB2数据库######################## # 数据库驱动名 driver=com.ibm.db2.jcc.DB2Driver # 数据库URL(包括端口） dburl=jdbc:db2://127.0.0.1:50000/zvfdb # 数据库用户名 user=root # 用户密码 password=zvfims ############# MySQL数据库######################## # 数据库驱动名
driver=com.mysql.jdbc.Driver # 数据库URL(包括端口） dburl=jdbc:mysql://127.0.0.1:3306/zvfdb # 数据库用户名 user=root # 用户密码 password=zvfims ############# PostgreSQL数据库数据库######################## # 数据库驱动名 driver=org.postgresql.Driver # 数据库URL(包括端口） dburl=jdbcostgresql://127.0.0.1/zvfdb
/* * 1.配置数据源 * 2.在程序中连接数据源 * */ package jdbc_odbc; import java.sql.*; public class jdbc_odbc_SQL2000 { public static void main(String[] args) { Connection ct=null; Statement sm=null; try { //1.加载驱动 Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); //2.得到连接(锁定连接到哪个数据源) //如果配置数据源时选择windows nt验证，则不需要“用户名”，“密码”（"sa","sa"） ct=DriverManager.getConnection("jdbc:odbc:mytest","sa","sa"); //3.创建Statement或者PrepareStatement（区别） //Statement主要用于发送SQL语句会返回一个int如果int=n则修改了n条记录 sm=ct.createStatement(); //4.执行（CRUD）增删改查 //executeUpdate可以实现添加删除修改 int i=sm.executeUpdate("insert into emp values('一切有为法，如梦幻泡影')"); //查看是否修改成功 if(i==0) { System.out.println("修改出错"); } else { System.out.println(i+"条记录已修改"); }
} catch (Exception e) { //显示异常信息 e.printStackTrace(); } finally{ //关闭资源!!!(这个一定要记得哦) //关闭顺序是，谁后创建则先关闭 try { //为了程序健壮 if (sm!=null) {sm.close();} if(ct!=null) {ct .close();} } catch (Exception e) { e.printStackTrace(); } } } }
今天总结了java平时最常用的7种数据库连接方式，现在分享给大家 MySQL： String Driver="com.mysql.jdbc.Driver"; //驱动程序 String URL="jdbc:mysql://localhost:3306/db_name"; //连接的URL,db_name 为数据库名 String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).new Instance(); Connection con=DriverManager.getConnection(URL,Username,Password); Microsoft SQL Server: 1) String Driver="com.microsoft.jdbc.sqlserver.SQLServerDriver"; //连接SQL数据库的方法 String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name"; //db_name为数据库名 String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).new Instance(); //加载数据可驱动 Connection con=DriverManager.getConnection(URL,UserName,Password); // 2) String Driver="com.microsoft.sqlserver.jdbc.SQLServerDriver"; //连接SQL数据库的方法 String URL="jdbc:sqlserver://localhost:1433;DatabaseName=db_name"; //db_name为数据库名 String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).new Instance(); //加载数据可驱动 Connection con=DriverManager.getConnection(URL,UserName,Password); Sysbase: String Driver="com.sybase.jdbc.SybDriver"; //驱动程序 String URL="jdbc:Sysbase://localhost:5007/db_name"; //db_name为数据可名 String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).newInstance(); Connection con=DriverManager.getConnection(URL,Username,Password); Oracle(用thin模式): String Driver="oracle.jdbc.driver.OracleDriver"; //连接数据库的方法String URL="jdbc:oracle:thin:@loaclhost:1521:orcl"; //orcl为数据库的SID String Username="username"; //用户名 String Password="password"; //密码 Class.forName(Driver).newInstance(); //加载数据库驱动
JDBC连接sql server数据库的详细步骤和代码JDBC连接sql server数据库的步骤如下： [java] view plaincopy 1.1、加载JDBC驱动程序： 2.在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机）， 3.这通过https://www.doczj.com/doc/1418775296.html,ng.Class类的静态方法forName(String className)实现。 4.成功加载后，会将Driver类的实例注册到DriverManager类中。 5.2、提供JDBC连接的URL 6.?连接URL定义了连接数据库时的协议、子协议、数据源标识。 7.?书写形式：协议：子协议：数据源标识 8.协议：在JDBC中总是以jdbc开始 9.子协议：是桥连接的驱动程序或是数据库管理系统名称。 10.数据源标识：标记找到数据库来源的地址与连接端口。 11.3、创建数据库的连接 12.?要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象， 13.该对象就代表一个数据库的连接。 14.?使用DriverManager的getConnectin(String url , String username , 15. String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和 16.密码来获得。 17.4、创建一个Statement 18.?要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3 19.种类型： 20.1、执行静态SQL语句。通常通过Statement实例实现。 21.2、执行动态SQL语句。通常通过PreparedStatement实例实现。 22.3、执行数据库存储过程。通常通过CallableStatement实例实现。 23.具体的实现方式： 24. Statement stmt = con.createStatement() ; 25. PreparedStatement pstmt = con.prepareStatement(sql) ; 26. CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}") ; 27.5、执行SQL语句 28. Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate 29.和execute 30.1、ResultSet executeQuery()：执行查询数据库的SQL语句 31.，返回一个结果集（ResultSet）对象。 32.2、int executeUpdate()：用于执行INSERT、UPDATE或 33. DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等 34.3、execute():用于执行返回多个结果集、多个更新计数或二者组合的 35.语句。 36.具体实现的代码： 37. ResultSet rs = pstmt.executeQuery() ;
通过ADO连接各种数据库的字符串 在网络编程过程中，ADO（Activex Data Object）编程往往是不可少的工作，特别是开发电子商务网站。既然讲到ADO数据对象，那么就顺便简单地介绍一下ADO数据对象及其功能。ADO数据对象共有七种独立的对象，他们分别是连接对象（Connection）、记录集对象（RecordSet）、域对象（Field）、命令对象（Command）、参数对象（Parameter）、属性对象（Property）和错误对象（Error）。功能请参见附录1。 ADO数据对象用来连接数据库的方式有两种，分别是ODBC和OLE DB方式，下面就分别介绍用这两种方式连接数据库的例子。 第一种：ODBC DSN-Less Connections ODBC Driver for Access ODBC Driver for dBASE ODBC Driver for Excel ODBC Driver for MySQL ODBC Driver for Oracle ODBC Driver for Paradox ODBC Driver for SQL Server ODBC Driver for Sybase ODBC Driver for Sybase SQL Anywhere ODBC Driver for Text ODBC Driver for Teradata ODBC Driver for Visual FoxPro 第二种：OLE DB Data Provider Connections OLE DB Provider for Active Directory Service OLE DB Provider for DB2 OLD DB Provider for Internet Publishing OLE DB Provider for Index Server OLE DB Provider for Microsoft Jet OLE DB Provider for ODBC Databases OLE DB Provider for Oracle (From Microsoft) OLE DB Provider for Oracle (From Oracle)
连接数据库的方法小结 1.ODBC API ODBC(Open Database Connectivity，开放数据库互连)是微软公司开放服务结构(WOSA，Windows Open Services Architecture)中有关数据库的一个组成部分，它建立了一组规范，并提供了一组对数据库访问的标准API（应用程序编程接口）。这些API利用SQL来完成其大部分任务。ODBC本身也提供了对SQL语言的支持，用户可以直接将SQL语句送给ODBC。 一个基于ODBC的应用程序对数据库的操作不依赖任何DBMS，不直接与DBMS打交道，所有的数据库操作由对应的DBMS的ODBC驱动程序完成。也就是说，不论是FoxPro、Access , MYSQL还是Oracle数据库，均可用ODBC API 进行访问。由此可见，ODBC的最大优点是能以统一的方式处理所有的数据库。 2．MFC ODBC 由于直接使用ODBC API编写应用程序要编制大量代码，开发者往往需要花费很多的精力在非核心代码的维护上，而Visual C++提供了MFC ODBC类，封装了ODBC API，这使得利用MFC ODBC来创建ODBC应用程序非常简便。 3．DAO（Data Access Object） DAO提供了一种通过程序代码创建和操纵数据库的机制，多个DAO构成一个体系结构，在这个体系结构中，各个DAO对象协同工作。MFC DAO是Microsoft提供的用于访问Microsoft jet数据库文件的强有力的数据库开发工具，它通过封装DAO，向程序员提供了DAO操作数据库的手段。 4．OLE DB OLE DB(Object Linking and Embedding, Database, 又称为OLE DB或OLE-DB),一个基于COM的数据存储对象,能提供对所有类型的数据的操作,甚至能在离线的情况下存取数据(比方说,你使用的是你的便携机,你可以毫不费力地看到最后一次数据同步时的数据映像). OLEDB位于ODBC层与应用程序之间. 在你的ASP页面里,ADO是位于OLEDB之上的应用程序. 你的ADO调用先被送到OLEDB,然后再交由ODBC 处理. 你可以直接连接到OLEDB层,如果你这么做了,你将看到服务器端游标(recordset的缺省的游标,也是最常用的游标)性能的提升.
一实验目的 (1)理解JDBC的工作原理，熟悉java.sql包中与数据库访问相关的类及其用法，如DriverManager、 Connection、Statement、ResultSet。 (2)熟悉利用JDBC进行数据库访问的步骤： —加载JDBC驱动程序(Class.forName() —建立数据库连接(DriverManager.getConnection()) —发布ＳＱＬ命令 (stmt=Con.createStatement(),stmt.executeQuery()) —取结果集并处理(ResultSet的next()方法和.get＊＊＊()方法) —关闭连接，释放对象（close()） (3)掌握建立ODBC数据源的方法，会使用JDBC-ODBC Bridge进行数据库访问。 二实验内容 编写图形界面程序，利用JDBC实现图书／同学通讯录／校园卡／团员／教师／学生管理系统。(任选1题，也可自拟题目，但需指导教师同意！) 三实验要求 (1) 进行规范的数据库设计，正确地定义关系数据表的结构及表间联系(包括：字段的数据类型、宽度、精度、主键、外键、缺省值)。 (2)要求界面布局紧凑、流畅、美观，实现的功能较为完善 (3)本实验分两次完成，第一次可以先做一些准备测试，旨在熟悉ＪＤＢＣＡＰＩ编程接口中相关类的使用方法，测试中可以先基于字符界面实现功能，再逐步过渡到图形界面。 四实验步骤 (1)在Access或SQL Server中建立数据库及基础表。在控制面板中正确配置ＯＤＢＣ数据源，并测试成功。 (2)编写图形界面的Application，利用JDBC-ODBC Bridge进行数据库访问，实现要求的功能。 五实验主要代码
Private Sub CommandButton1_Click() Dim i As Integer, j As Integer, sht As Worksheet 'i,j为整数变量；sht 为excel工作表对象变量，指向某一工作表 Dim cn As Object '定义数据链接对象，保存连接数据库信息 Dim rs As Object '定义记录集对象，保存数据表 Set cn = CreateObject("ADODB.Connection") '创建数据链接对象 Set rs = CreateObject("ADODB.RecordSet") '创建记录集对象 Dim strCn As String, strSQL As String '字符串变量 strCn = "Provider=sqloledb;Server=GuilinHu-PC\HuglSQLSEVER;Database=Hugl;U id=sa;Pwd=HGL102643lch;" '定义数据库链接字符串 ’Sever =服务器名称；Database =数据库名称,Uid =sa ； Pwd = 以sa身份登录数据库的密码 '下面的语句将读取数据表数据，并将它保存到excel工作表中：画两张表想像一下，工作表为一张两维表，记录集也是一张两维表 strSQL = "select 姓名,性别,年龄 from 个人信息" '定义SQL查询命令字符串cn.Open strCn '与数据库建立连接，如果成功，返回连接对象cn rs.Open strSQL, cn '执行strSQL所含的SQL命令，结果保存在rs记录集对象中 i = 1 Set sht = ThisWorkbook.Worksheets("sheet1") '把sht指向当前工作簿的sheet1工作表 Do While Not rs.EOF '当数据指针未移到记录集末尾时，循环下列操作 sht.Cells(i, 1) = rs("姓名") '把当前记录的字段1的值保存到sheet1工作表的第i行第1列 sht.Cells(i, 2) = rs("性别") '把当前字段2的值保存到sheet1工作表的第i行第2列 sht.Cells(i, 3) = rs("年龄") '把当前字段2的值保存到sheet1工作表的第i行第2列 rs.MoveNext '把指针移向下一条记录 i = i + 1 'i加1，准备把下一记录相关字段的值保存到工作表的下一行 Loop '循环 rs.Close '关闭记录集，至此，程序将把某数据表的字段1和字段2保存在excel工作表sheet1的第1、2列，行数等于数据表的记录数 End Sub
1 package com.kyo.connection; 2 3 import java.sql.Connection; 4 import java.sql.DatabaseMetaData; 5 import java.sql.Driver; 6 import java.sql.DriverManager; 7 import java.sql.SQLException; 8 import java.sql.Statement; 9 import java.util.Enumeration; 10 import java.util.Vector; 11 12 public class ConnectionPool { 13 14 private ConnectionParam param; 15 16 private String testTable = ""; // 测试连接是否可用的测试表名，默认没 有测试表 17 18 private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 19 // null,它中存放的对象为PooledConnection 型 20 21 public void setParam(ConnectionParam param { 22 this.param = param; 23 } 24 25 public ConnectionParam getParam( { 26 return param;
27 } 28 29 /** 30 * 构造函数 31 * 32 * @param param 33 */ 34 public ConnectionPool(ConnectionParam param { 35 this.param = param; 36 } 37 38 /** 39 * 40 * 获取测试数据库表的名字 41 * 42 * @return 测试数据库表的名字 43 */ 44 45 public String getTestTable( { 46 return this.testTable; 47 } 48 49 /** 50 * 51 * 设置测试表的名字 52 * 53 * @param testTable
连接数据库： 命名空间：using System.Data.SqlClient;
"+"userid:" + sr.GetInt32(0)); } sr.NextResult(); while (sr.Read()) { Response.Write("
" + "userName:" + sr.GetString(0)); } sr.Close(); conn.Dispose(); conn.Close(); } 在原数据表中新增一条数据：
分享Java连接各种数据库的实例 Java数据库连接（JDBC）由一组用 Java 编程语言编写的类和接口组成。本文为你介绍了几种java链接数据库的实例，希望对你有帮助，一起来看。 Java数据库连接（JDBC）由一组用 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的 API，使他们能够用纯Java API 来编写数据库应用程序。然而各个开发商的接口并不完全相同，所以开发环境的变化会带来一定的配置变化。本文主要集合了不同数据库的连接方式。 1、Oracle8/8i/9i数据库（thin模式） 1.Class.forName（“oracle.jdbc.driver.OracleDriver”）。newInstance（）； 2.String url=“jdbc:oracle:thin:@localhost:1521:orcl”; 3.//orcl为数据库的SID 4.String user=“test”; 5.String password=“test”; 6.Connection conn= DriverManager.getConnection（url,user,password）； 2、DB2数据库 1.Class.forName（“com.ibm.db 2.jdbc.app.DB2Driver”）。newInstance（）； 2.String url=“jdbc:db2://localhost:5000/sample”; 3.//sample为你的数据库名 4.String user=“admin”; 5.String password=“”; 6.Connection conn= DriverManager.getConnection（url,user,password）； 3、Sql Server7.0/2000数据库 1.Class.forName（“com.microsoft.jdbc.sqlserver.SQLServerDriver”）。 newInstance（）； 2.String url=“jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=m ydb”; 3.//mydb为数据库 4.String user=“sa”; 5.String password=“”; 6.Connection conn= DriverManager.getConnection（url,user,password）； 4、Sybase数据库 1.Class.forName（“com.sybase.jdbc.SybDriver”）。newInstance（）； 2.String url =“ jdbc:sybase:Tds:localhost:5007/myDB”;
用JDBC-ODBC桥连接Access实例（1） import java.sql.*; public class JDBCDemo{ public static void main(String args[]){ JDBCDemo obj = new JDBCDemo(); obj.AccessDB(); } Connection theConnection; //声明数据库连接对象 Statement theStatement; //声明发送到数据库执行的SQL命令的对象 ResultSet theResult; //读取的数据的结果集对象 ResultSetMetaData theMetaData; //此对象用于数据库命令执行后,返回结果信息 String theDataSource; //被访问数据库或者数据源的名称 String theUser; //数据库的用户名 String thePassword; //数据库的密码 public void AccessDB(){ openConnection(); //调用打开数据库连接的方法 execSQLCommand(“select * from Student”); //调用执行SQL语句的方法，从数据库中读取内容closeConnection(); //调用关闭已经打开的数据库的方法 } public void openConnection(){ theDataSource=“jdbc:odbc:TeachingAccess”; //使用TeachingAccess数据源 theUser=""; thePassword=""; try{ Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); //装载JDBC-ODBC驱动程序 theConnection=DriverManager.getConnection(theDataSource,theUser,thePassword); System.out.println("Connect:OK"); }catch (Exception e){ handleException(e); } } public void execSQLCommand(String command){ try{ theStatement=theConnection.createStatement(); theResult=theStatement.executeQuery(command); theMetaData=theResult.getMetaData (); int columnCount=theMetaData.getColumnCount(); System.out.println("Column Count:"+columnCount); while(theResult.next()){ for(int i =1;i<=columnCount;i++){ String colValue=theResult.getString(i); if(colValue==null) colValue=""; System.out.print(colValue+";"); }