JDBC连接oracle数据库
Oracle数据库连接的几种方式
Oracle数据库连接的⼏种⽅式⼀、本地通过JDBC获得Oracle数据库连接通过JDBC获得Oracle数据库连接,有三种⽅式:OCI⽅式、thin⽅式和JdbcOdbc桥⽅式。
OCI⽅式依赖于本地的动态链接库,如果在本地安装了Oracle数据库客户端可以采⽤该⽅式;⽽thin⽅式为纯java的数据库连接⽅式;JdbcOdbc桥⽅式依赖于本地ODBC数据库源的配置,这种⽅式⼀般不太被采⽤。
1、OCI⽅式 先在本地安装Oracle客户端,安装完之后,在安装的路径中可以找到…/jdbc/lib/classes12.zip⽂件,我们在环境变量classpath中设置classes12.zip所在的路径。
然后通过以下的数据库连接类,在本地通过OCI⽅式获得Oracle数据库连接。
/*** 在本地获得数据库连接*/package com.j2ee.db;import java.util.*;import java.sql.*;import javax.sql.*;import java.io.*;import oracle.jdbc.driver.*;import javax.naming.*;/*** 通过OCI⽅式获得Oracle数据库连接*/public class DbConnection{ final static String sDBDriver = "oracle.jdbc.driver.OracleDriver"; final static String sConnStr = "jdbc:oracle:oci8:sr/sr@ora199"; /** * */ public DbConnection() { } /** * 获得Oracle数据库连接 */ public java.sql.Connection connectDbByOci() { java.sql.Connection conn=null; try { Class.forName(sDBDriver); conn = DriverManager.getConnection(sConnStr); } catch (Exception e) { System.out.println("ERROR:"+e.getMessage()); } return conn; }}/*** 在本地获得数据库连接*/package com.j2ee.db;import java.util.*;import java.sql.*;import javax.sql.*;import java.io.*;import oracle.jdbc.driver.*;import javax.naming.*;/*** 通过thin⽅式获得Oracle数据库连接*/public class DbConnection{ private String sConnStr = ""; /** * 缺省构造器 */ public DbConnection() { sConnStr = "jdbc:oracle:thin:@10.1.4.199:1521:ora199"; } /** * @param ip,serviceName */ public DbConnection(String ip,String serviceName) { sConnStr = "jdbc:oracle:thin:@"+ip+":1521:"+serviceName; } /** * 通过thin⽅式获得Oracle数据库的连接. */ public java.sql.Connection connectDbByThin() { java.sql.Connection conn=null; try { Class.forName(sDBDriver); conn = DriverManager.getConnection(sConnStr,"sr","sr"); } catch (Exception e) { System.out.println("ERROR:"+e.getMessage()); } return conn; } /** * 通过thin⽅式获得Oracle数据库的连接. * @param userId,password */ public java.sql.Connection connectByJdbc(String userId,String password) { java.sql.Connection conn=null; try { Class.forName(sDBDriver); conn = DriverManager.getConnection(sConnStr,userId,password); } catch (Exception e) { System.out.println("ERROR:"+e.getMessage()); } return conn; }} 这种⽅式运⽤起来⽐较灵活,简单,具有较强的移植性和适⽤性。
连接oracle数据库的语句
连接oracle数据库的语句连接Oracle数据库是开发人员常常遇到的一个任务,下面我将列举一些连接Oracle数据库的语句,希望能够帮助你。
1. 使用SQL*Plus连接Oracle数据库:```sqlplus username/password@host:port/service_name```其中,`username`是Oracle数据库的用户名,`password`是密码,`host`是主机名,`port`是端口号,`service_name`是服务名。
2. 使用JDBC连接Oracle数据库:```import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class OracleJdbcExample {public static void main(String[] args) {String url = "jdbc:oracle:thin:@host:port:service_name";String username = "username";String password = "password";try {Connection connection = DriverManager.getConnection(url, username, password);System.out.println("Successfully connected to Oracle database!");// 执行其他操作...connection.close();} catch (SQLException e) {System.out.println("Failed to connect to Oracle database!");e.printStackTrace();}}}```其中,`url`是连接Oracle数据库的URL,`username`是用户名,`password`是密码,`host`是主机名,`port`是端口号,`service_name`是服务名。
Java连接oracle数据库方法
Java连接oracle数据库一、普通的连接数据库1、注册驱动Class.forName(“oracle.jdbc.driver.OracleDriver”);2、获取连接Connection conn=null;conn= DriverManager.getConnection(“jdbc:oracle:thin:@127.0.0.1:1521:XE”,user,pa ssword);3、建立statementStatement stat=conn.createStatement();4、执行SQL语句stat.execute(“SQL语句”);5、处理结果集ResultSet rs=null;rs=stat.executeQuery(“SQL语句”);While(rs.next()){System.out.println(“id:”+rs.getInt(“id”)+”last_name”+getString(“l ast_name”));}6、关闭连接Rs.close();Stat.close();Conn.close();二、加载properties文件连接数据库并使用PreparedStatement --------------------首先准备xxx.properties文件---------------------user=xxxxxpassword=xxxxxxdriver=oracle.jdbc.driver.DriverOracleurl=jdbc:oracle:thin:@127.0.0.1:1521:XE--------------------------------------------------------------------------------1、创建properties实例对象Properties prop=new Properties();2、加载xxx.properties文件prop.load(new FileInputStream(“xxx.properties文件路径”));3、获取xxx.properties文件中的属性Class.forName(prop.getString(“driver”));conn=DriverManager.getConnetion(prop.getString(“url”,prop));4、创建PreparedStatement实例对象并执行语句String sql=“select*from table_name where id=?And last_name=?”;PreparedStatement ps=conn.preparedStatement(sql);ps.setInt(1,4);ps.setString(2,”nihao”);ps.execute();5、处理结果集ResultSet rs=null;rs=ps.executeQuery(“SQL语句”);While(rs.next()){System.out.println(“id:”+rs.getInt(“id”)+”last_name”+getString(“l ast_name”));}6、关闭连接rs.close();ps.close();Conn.close();三、DOM解析XML文件连接数据库--------------------首先准备xxx.xml文件---------------------<?xml version="1.0"encoding="UTF-8"?><PEOPLE><PERSON><className>oracle.jdbc.driver.OracleDriver</className><url>jdbc:oracle:thin:@127.0.0.1:1521:XE</url><user>user</user><password>xxx</password></PERSON></PEOPLE>-------------------------------------------------------------------------Connection conn=null;try{1、建立解析工厂,获取实例DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();2、创建文件解析器DocumentBuilder builder=factory.newDocumentBuilder();3、加载xml文件Document doc=builder.parse("xxx.xml文件路径");4、获取根节点NodeList nl=doc.getElementsByTagName("PEOPLE");Element node=(Element)nl.item(0);5、获取驱动StringclassName=node.getElementsByTagName("className").item(0).getFirstChild().get NodeValue();6、获取urlStringurl=node.getElementsByTagName("url").item(0).getFirstChild().getNodeValue();7、获取用户名Stringuser=node.getElementsByTagName("user").item(0).getFirstChild().getNodeValue();8、获取用户密码Stringpwd=node.getElementsByTagName("password").item(0).getFirstChild().getNodeValu e();9、注册驱动Class.forName(className);10、连接数据库conn=DriverManager.getConnection(url,user,pwd);}catch(Exception e){e.printStackTrace();}。
oracle jdbc连接 批量导入参数
主题:使用Oracle JDBC连接实现批量导入参数内容:1. 介绍Oracle JDBC连接Oracle JDBC是一种用于连接Oracle数据库的Java API,它允许Java应用程序与Oracle数据库进行通信和交互。
通过使用Oracle JDBC连接,可以实现对Oracle数据库的数据操作,包括查询、更新、删除、插入等。
2. 批量导入参数的意义在实际开发过程中,有时需要将大量数据一次性导入到Oracle数据库中。
这时,使用批量导入参数的方式可以提高导入效率,减少数据库访问的次数,从而提升系统性能。
3. 使用Oracle JDBC连接实现批量导入参数步骤如下:3.1. 导入Oracle JDBC驱动包在Java应用程序中,首先需要导入Oracle JDBC驱动包,以便能够使用Oracle JDBC连接。
3.2. 建立数据库连接使用Oracle JDBC连接,首先需要建立与Oracle数据库的连接。
可以通过以下代码实现:```javaString url = "jdbc:oracle:thin:192.168.1.1:1521:ORCL";//数据库连接位置区域String user = "username";//用户名String password = "password";//密码Connection conn = DriverManager.getConnection(url, user, password);//建立数据库连接```3.3. 设置批量导入参数在建立数据库连接后,需要设置批量导入参数。
可以通过以下代码实现:```javaString sql = "INSERT INTO table_name (column1, column2) VALUES (?, ?)";//插入语句PreparedStatement pstmt = conn.prepareStatement(sql);//准备插入语句```3.4. 执行批量导入操作在设置好批量导入参数后,可以通过循环方式批量导入数据。
jdbc使用DataSource连接mysql,postgresql,oracle的代码
jdbc使⽤DataSource连接mysql,postgresql,oracle的代码jdbc连接数据库,使⽤DataSource是推荐的⽅式(jdbc驱动是当然要放进classpath⾥的,官⽹⼀般都有下载)1import java.sql.Connection;2import java.sql.ResultSet;3import java.sql.ResultSetMetaData;4import java.sql.SQLException;5import java.sql.Statement;67import org.postgresql.ds.PGSimpleDataSource;89import oracle.jdbc.pool.OracleDataSource;1011import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;1213public class DBConnection {1415/**16 * @param args17 * @throws SQLException18*/19public static void main(String[] args) throws SQLException {20// TODO Auto-generated method stub21 MysqlDataSource mysqlDataSource = new MysqlDataSource();22// mysqlDataSource.setPassword("dev");23// mysqlDataSource.setUser("dev");24 mysqlDataSource25 .setURL("jdbc:mysql://localhost/forJava?user=dev&password=dev");26 Connection conn = mysqlDataSource.getConnection();27 Statement stmt = conn.createStatement();28 stmt.executeUpdate("create table if not exists web\n" + "(\n"29 + " id int not null primary key,\n" + " name varchar(100),\n"30 + " created timestamp,\n" + " content blob\n" + ");\n" + "");31for (int i = 0; i < 1; i++) {32 stmt.executeUpdate("insert into web (name,content) values ('HL','frgertrhrtnthtohioh')");33 }34 showResultSet(stmt.executeQuery("select * from web limit 10"));3536// Driver driver = new com.mysql.jdbc.Driver();37// driver.connect("jdbc:mysql://localhost/forJava?user=dev&password=dev",38// null);3940 PGSimpleDataSource pgSimpleDataSource = new PGSimpleDataSource();41 pgSimpleDataSource.setServerName("localhost");42 pgSimpleDataSource.setDatabaseName("dev");43 pgSimpleDataSource.setUser("dev");44 pgSimpleDataSource.setPassword("dev");45 conn = pgSimpleDataSource.getConnection();46// conn =47// DriverManager.getConnection("jdbc:postgresql://localhost/test",48// "dev", "dev");49 showResultSet(conn.createStatement().executeQuery("select * from cities"));5051 OracleDataSource oraDataSource = new OracleDataSource();52// oraDataSource.setServerName("127.0.0.1");53// oraDataSource.setDatabaseName("HR");54// oraDataSource.setUser("HR");55// oraDataSource.setPassword("HR");56 oraDataSource.setURL("jdbc:oracle:thin:hr/hr@//localhost:1521/XE");57 conn = oraDataSource.getConnection();58 stmt = conn.createStatement();59 stmt.execute("select * from tab");60 showResultSet(stmt.getResultSet());61 stmt.execute("select * from jobs");62 showResultSet(stmt.getResultSet());63 stmt.execute("select * from DEPARTMENTS");64 showResultSet(stmt.getResultSet());65 }6667static void showResultSet(ResultSet resultSet) throws SQLException {68 ResultSetMetaData resultSetMetaData = resultSet.getMetaData();69int num = resultSetMetaData.getColumnCount();70while (resultSet.next()) {71for (int i = 1; i <= num; i++) {72 System.out.print(resultSetMetaData.getCatalogName(i) + " "73 + resultSet.getString(i));74 }75 System.out.println();76 }77 }}78java.sql.ResultSet;importjava.sql.ResultSetMetaD呃,在⾃⼰电脑上同时安装了mysql, postgresql,oracle,db2,sqlite的⼈是不是很蛋疼?ata;importjava.sql.SQLException;importjava.sql.Statement;importorg.postgresql.ds.PGSimpleDataSource;importoracle.jdbc.pool.OracleDataSource;importcom.mysql.jdbc.jdbc2.optional.MysqlDataSource;public classDBConnection {/*** @param args* @throwsSQLException*/public static voidmain(String[] args)throws SQLException {// TODO Auto-generatedmethod stubMysqlDataSourcemysqlDataSource = newMysqlDataSource();//mysqlDataSource.setPassword("dev");//mysqlDataSource.setUser("dev");mysqlDataSource.setURL("jdbc:mysql://localhost/forJava?user=dev&password=dev");Connection conn =mysqlDataSource.getConnection();Statement stmt =conn.createStatement();stmt.executeUpdate("create table if not existsweb\n" + "(\n"+ " id int not nullprimary key,\n" + " name。
java链接Oracle数据库的工具类
java链接Oracle数据库的⼯具类java连接Oracle数据库的⽅式1 特点:oracle.jdbc.OracleDriver是注册oracle驱动类;jdbc:oracle:thin:@localhost:1521:xe:连接oracle的⽅式:⽹络协议+访问⽅式+IP+端⼝号+xe数据库;user:hr数据库⽤户名Password:hr数据库的⽤户密码缺点:statement⽅式连接数据库容易被⿊客注⼊式攻击所有不安全现在企业中很少采⽤这种⽅式的了连接数据库后⼀定的关闭连接,这个最容易忘记调⽤close()⽅法关闭连接public static void main(String[] args) throws Exception {// 1 注册驱动类Class.forName("oracle.jdbc.OracleDriver");// 2 创建连接String url="jdbc:oracle:thin:@localhost:1521:xe";Connection con = DriverManager.getConnection(url,"hr","hr");// 3 创建stmStatement stm = con.createStatement();// 4 执⾏SQLString sql = "select accountNo cardid,accountName name,balance bal from accounts";// executeQuery: 执⾏DQL语句(select),返回ResultSet类型,代表查询到的虚表ResultSet rs = stm.executeQuery(sql);// 5 处理查询结果while (rs.next()){// 获取每个字段的值 rs.getXxx("字段名") rs.getXxx(index)int no = rs.getInt("cardid");double bal = rs.getDouble("bal");String name = rs.getString(2);String pwd = rs.getString("password");System.out.println("卡号:" + no +" , name=" + name +", bal=" + bal+", pwd=" + pwd);}// 6 释放资源if (stm != null)stm.close();if (con != null)con.close();}2 特点:io读取配饰⽂件db.properties的信息配置⽂件⾥为⾃⼰⼿写是mydriver路径myurl连接oracle的⽅式:⽹络协议+访问⽅式+IP+端⼝号+xe数据库 myuser数据库⽤户名称mypasswoed:数据库访问密码把以上信息封装到配置⽂件中可以复⽤减少代码的冗余使⽤⼀次调⽤⼀次关闭连接封装带getRelease()⽅法中需要使⽤时再调⽤ dao层⼀般不关闭连接⼀般在service层关闭连接否则容易造成业务出错private static Properties prop = new Properties();优点:封装成⽅法需要时调⽤减少代码的冗余安全性能提⾼:?占位符赋值⽐第⼀种⽅法安全解决注⼊式攻击等问题缺点:属于单例模式多线程并发访问时容易产⽣线程安全问题例如双⼗⼀秒杀时多⽤户同时访问同⼀资源临界资源对象如果加锁会造成线程等待不加锁⼤量⽤户并发访问会造成线程安全问题// 类加载时,读⼀次配置⽂件static{try {// 获取配置⽂件的输⼊流InputStream is = JdbcUtil2.class.getResourceAsStream("/com/baizhi/day2/db.properties");// 使⽤prop的load⽅法⾃动读⽂件prop.load(is);} catch (IOException e) {e.printStackTrace();} finally {// 关流}}// 获取连接public static Connection getConn(){Connection con = null;try {// 获取配置⽂件的内容String driverClassName = prop.getProperty("mydriverclass");String pwd = prop.getProperty("password");Class.forName(driverClassName);con = DriverManager.getConnection(url, userName, pwd);} catch (Exception e) {e.printStackTrace();throw new RuntimeException(e);}return con;}// 释放资源public static void release(ResultSet rs, Statement stm, Connection con){ if (rs != null){try {rs.close();} catch (Exception e) {e.printStackTrace();throw new RuntimeException(e);}}if (stm != null){try {stm.close();} catch (Exception e) {e.printStackTrace();throw new RuntimeException(e);}}if (con != null){try {con.close();} catch (Exception e) {e.printStackTrace();throw new RuntimeException(e);}3 特点/优点:引⼊线程对象ThreadLocal 针对多⽤户并发访问问题可以⽀持⼤量⽤户同时访问public class JdbcUtil {private static Properties prop = new Properties();// 读配置⽂件static {try {InputStream is = JdbcUtil.class.getResourceAsStream("/com/baizhi/day3/db.properties"); prop.load(is);} catch (IOException e) {e.printStackTrace();throw new RuntimeException(e);} finally {}}// 增加静态的成员变量private static final ThreadLocal<Connection> thl = new ThreadLocal<Connection>();// 获取连接public static Connection getConn() {Connection conn = thl.get(); // 从线程局部变量中取值try {if (conn == null) { // 没有值// 获取配置⽂件中的内容String driverClass = prop.getProperty("mydriverclass");String myurl = prop.getProperty("myurl");String username = prop.getProperty("username");String password = prop.getProperty("password");Class.forName(driverClass);conn = DriverManager.getConnection(myurl, username, password);thl.set(conn); // 把conn存到thl}} catch (Exception e) {// 释放资源public static void release(ResultSet rs, Statement stm, Connection conn) {try {if (rs != null)rs.close();if (stm != null)stm.close();if (conn != null){conn.close();thl.remove(); // 关闭的连接必须从thl删除************}} catch (Exception e) {e.printStackTrace();throw new RuntimeException(e);}}}4:特点/优点:引⼊数据池减少访问数据库的次数提⾼执⾏效率public class JdbcUtilPool {public static final ThreadLocal thl=new ThreadLocal();public static Connection getConn(){Connection conn=(Connection) thl.get();try {if(conn == null){//获取资源所在的根Context ctx = new InitialContext();//根据名称和⽬录获取资源javax.sql.DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/myoracle"); //从连接池获取连接conn=ds.getConnection();}} catch (Exception e) {public static void release(ResultSet rs,PreparedStatement pstm,Connection conn){ try {if (rs!=null) rs.close();} catch (Exception e) {e.printStackTrace();throw new RuntimeException();}try {if (pstm!=null) pstm.close();} catch (Exception e) {e.printStackTrace();throw new RuntimeException();}try {if (conn!=null) {conn.close(); //把连接还给连接池thl.remove();//清除线程连接}} catch (Exception e) {e.printStackTrace();throw new RuntimeException();}}}。
JDBC:加载数据库驱动、连接数据库(详细讲解)
JDBC:加载数据库驱动、连接数据库(详细讲解)1. 加载数据库驱动:1)由于Java是⼀个纯⾯向对象语⾔,任何事物在其中都必须抽象成类或者类对象,数据库也不例外,JDBC同样也把数据库抽象成⾯向对象的结构;2)JDBC将整个数据库驱动器在底层抽象成⼀个对象(即驱动器对象),所有对数据库的操作都可以通过该对象进⾏;3)只不过数据库驱动对象和普通的Java对象有所不同:i. ⾸先⼤多数普通的Java对象都是运⾏该Java程序前不存在的,⽽是运⾏的时候临时创建的,程序退出后这些对象也随之释放;ii. 但数据库不⼀样,数据库往往是不依赖程序运⾏的,数据库通常都是24⼩时持续运⾏,只不过应⽤程序可以访问它⽽已,因此数据库对象不能像普通对象那样从⽆到有地“创建”;iii. 也就是说⼀个在应⽤程序运⾏之前就已经存在并且正常运⾏的数据库实例如何在Java程序中访问呢?4)加载数据库驱动的⽅法:i. 加载数据库驱动其实就是将操作系统中正在运⾏的数据库进程(实例)转化成Java对象供Java程序使⽤(操作数据库);ii. 这⾥⾸先要了解以下类驱动器的概念:a. 其实在Java中任何类(Object、String等)想要正常运⾏,底层都要有相应的驱动器驱动它;b. 但是我们平时看不出来这些类对象需要什么驱动器驱动啊!那是因为这些基础类的驱动器就是JVM虚拟机本⾝,其驱动的加载是在底层伴随着JVM的启动进⾏的,都对⽤户隐藏起来了,所以你看不到;c. ⽽那些不依赖虚拟机驱动的程序(⽐如⾮常典型的就是数据库程序、⼤多数图形程序,基本都是⽤C/C++编写,肯定不能靠JVM驱动)想在Java中访问就必须⾃⼰⼿动编写加载驱动器的代码了!!iii. ⼿动加载类的驱动器——使⽤Class类的forName静态⽅法:static Class<?> Class.forName(String className);a. className就是那个不依赖JVM驱动的外部进程的Java类名,这个类名必须符合Java命名规则,例如“com.xxx.Xxx"之类的;b. 你在Java中访问外部进程(将外部进程抽象成Java类或者对象)还⼀定要有Java类名?那这个类名是不是要事先就准备好咯?c. 是的!并不是任何外部进程都可以被Java访问,想要被Java访问就必须让那个程序⾃⼰准备好被Java调⽤的接⼝,并事先命名好Java类名才⾏,⽽程序准备好的Java接⼝就是该程序的Java驱动器(让JVM控制程序⾏为的东西就是Javad. 因此数据库⼚商必须⾃⾏别写好数据库的Java驱动器(称作数据库Connector,即连接器,⽤于和Java程序连接),并准备好类名,好让Class.forName加载它;iv. forName的加载原理:a. ⾸先任意⼀个提供Java接⼝的程序都会拥有⼀个Java类名(加载到JVM中就是⽤该类名来访问该程序实例的);b. 这样的程序运⾏后,这个Java类名就会被记录到改程序的进程信息中(⽽改程序的Java接⼝(驱动器)的句柄也会被记录到进程信息中);c. forName传⼊该类名以后就会到操作系统的进程表中查找具有该Java类名的线程;d. 找到对应的进程后就会找到该进程对应的Java驱动,然后将该驱动加载进JVM;e. 之后就可以在Java程序中通过这个类名(或者对象)来调⽤该进程的功能,或者访问进程中的数据了;5)数据库⼚商对驱动类名的命名:i. ⼚商之间各不相同,⽽且也没有规律可循,因此必须要查阅相应⼚商的JDBC⼿册才能知道;ii. MySQL的命名:com.sql.jdbc.Driveriii. Oracle的命名:oracle.jdbc.driver.OracleDriveriv. 从命名的包路径来看,各个⼚商驱动的实现差异较⼤;因此MySQL数据库的加载就是:Class.forName("com.sql.jdbc.Driver");6)准备好数据库连接器:i. 必须事先将数据库的JDBC-Connector加⼊到CLASSPATH路径当中,Connector由数据库⼚商提供,⽽MySQL的JDBC-Connector⽂件是mysql-connector-java-版本号-bin.jar;ii. 原因很简单,数据库的JDBC驱动必须要运⾏起来才能起到作⽤,在Java中就是要运⾏该类,⽽运⾏⼀个类⾸先会想到命令"java 要运⾏的类的类名“了,既然要直接执⾏该命令,那就必须得将⽬标类的路径添加到CLASSPATH中去才⾏,因 iii. 在Eclipse中这样设置:window -> preferences -> java -> install jres -> 选中当前采⽤的JRE点击edit -> add external jars -> 选择jar包路径保存即可;2. JDBC如何管理加载后的数据库驱动——⽤DriverManager建⽴连接:1. forName加载完类后如果发现这是⼀个数据库类的驱动那就会做⼀定的特殊处理了;2. JDBC专门(注意!“专门”)⽤DriverManager类来管理数据库驱动!也就是说DriverManager类是专门⽤来管理JDBC驱动的!不要因为类命中没有出现JDBC之类的字眼就认为该类还可以管理其它驱动!不!DriverManager只⽤来管理JDBC驱动!3. 加载后的驱动会被抽象成Java类型的对象保存在DriverManager的静态变量driver中;4. JDBC规定,⼀个Java进程只能同时持有(最多持有)⼀个JDBC驱动,也就是说上述的driver在加载后就有且仅有它⼀个了,也就是说你⼀次只能持有⼀个数据库对象,这就不允许你⼀个Java进程同时连多个数据库了;5. 还有⼀点要强调的是,数据库访问跟HTTP协议的原理⼀样,都是基于连接的,即查询数据库前必须现建⽴连接,连接上了以后可以进⾏多次查询,最后查询完毕后关闭连接才算⼀次完整的数据库操作,⽽这⾥的要素是什么?i. 那就是⼀个进程同时(最多)只能建⽴⼀个连接;ii. 这是很显然的,⼀个进程就代表⼀个⽤户,这和HTTP⼀样,⼀个⽤户不能同时向⼀个服务器建⽴两个连接,即同⼀个⼈要建⽴第⼆个连接除⾮是第⼀个连接已经断开(上⼀次服务已经结束);iii. 因此加载后的驱动器driver是受到同不监视的,即driver是⼀个同步监视器!6. 可以看⼀下DriverManager的getConnection⽅法,它利⽤driver来建⽴和数据库的连接(就跟HTTP中客户端和服务器端建⽴连接⼀样⼀样滴),它是⼀个同步⽅法!public static synchronized Connection DriverManager.getConnection(String url, String user, String passwd);driver是DriverManager的静态对象,该⽅法是同步⽅法,因此driver在该⽅法中就是同步监视器了;可以看到这样的结构就是单例模式,JDBC让⼀个进程最多只能得到⼀个数据库驱动器!7. 看⼀下getConnection的参数和返回值:i. url:要访问的数据库往往都是在远程(处在某个⽹络节点中),因此需要对数据库进⾏定位;a. 这个url的写法有讲究,不同数据库的写法不⼀样,需要参考数据库的JDBC⼿册;b. 但是JDBC标准还是规定了该URL的框架,其格式是:jdbc:数据库品牌:具体定位信息(该部分各数据库有差异)c. MySQL的写法:jdbc:mysql://hostname:port/具体数据库名,例如"jdbc.mysql://192.23.21.9:8889/student_dataii. user和passwd代表⽤户名和登陆密码,这都是数据库管理员分配的;iii. 返回值是⼀个Connection对象,该对象表⽰Java程序和数据库所建⽴的⼀个屋⾥连接会话,之后可以通过Connection对象和数据库进⾏交流(操作数据库);8. 建⽴连接的⽰例:Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/select_test", "root", "1234");3. ⼀个完整的加载驱动建⽴连接的代码:Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/select_test"); // 利⽤conn和数据库交流。
简要说明jdbc连接数据库的步骤
简要说明jdbc连接数据库的步骤一、引入JDBC驱动在使用JDBC连接数据库之前,首先需要引入相应的JDBC驱动。
不同的数据库有不同的驱动,需要根据实际情况选择合适的驱动。
通常情况下,驱动的jar包会提供给开发者使用,需要将其导入到项目中。
二、加载驱动类在使用JDBC连接数据库之前,需要先加载驱动类。
加载驱动类可以通过Class.forName()方法实现,该方法接收一个参数,即驱动类的全限定名。
例如,对于MySQL数据库,加载驱动类的代码如下所示:Class.forName("com.mysql.jdbc.Driver");三、建立数据库连接在加载驱动类之后,可以通过DriverManager的getConnection()方法建立与数据库的连接。
getConnection()方法接收三个参数,分别是数据库的URL、用户名和密码。
其中,URL是连接数据库的地址,用户名和密码用于认证身份。
例如,连接MySQL数据库的代码如下所示:String url = "jdbc:mysql://localhost:3306/test";String username = "root";String password = "123456";Connection connection = DriverManager.getConnection(url, username, password);四、创建Statement对象在建立与数据库的连接之后,需要创建一个Statement对象,用于执行SQL语句。
Statement对象可以通过Connection的createStatement()方法创建。
例如,创建Statement对象的代码如下所示:Statement statement = connection.createStatement();五、执行SQL语句在创建Statement对象之后,可以通过Statement对象的executeQuery()方法执行SQL查询语句,或者通过executeUpdate()方法执行SQL更新语句。
jdbc+代码oracle数据库连接,JDBC连接Oracle数据库代码
jdbc+代码oracle数据库连接,JDBC连接Oracle数据库代码import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class TestOracle {public static void main(String[] args) {Connection conn = null;Statement stmt = null;ResultSet rs = null;try {Class.forName("oracle.jdbc.driver.OracleDriver");//实例化oracle数据库驱动程序(建⽴中间件)String url = "jdbc:oracle:thin:@localhost:1521:oar92";//@localhost为服务器名,sjzwish为数据库实例名conn = DriverManager.getConnection(url, "guchao", "jimmy");//连接数据库,a代表帐户,a代表密码stmt = conn.createStatement();//提交sql语句,创建⼀个Statement对象来将SQL语句发送到数据库//查询数据⽤executeQueryrs = stmt.executeQuery("select * from ruby");//执⾏查询,(ruby)为表名while (rs.next()) {//使当前记录指针定位到记录集的第⼀条记录System.out.println(rs.getString("sid") +" "+ rs.getString("sname"));}//1代表当前记录的第⼀个字段的值,可以写成字段名。
JAVA使用JDBC连接数据库的几种方式
JAVA使用JDBC连接数据库的几种方式JDBC(Java Database Connectivity)是Java编程语言用于连接数据库的一种标准API。
它提供了一种访问和操作不同类型数据库的方法。
在JDBC中,有几种不同的方式可以连接数据库。
下面是常见的几种方式以及它们的详细介绍。
1.使用JDBC驱动程序连接数据库2. DriverManager类连接数据库DriverManager是一个Java类,用于管理JDBC驱动程序。
它提供了一种简单的方法来注册和获取特定驱动程序的连接。
使用DriverManager 连接数据库时,首先需要加载驱动程序,并使用驱动程序的URL、用户名和密码创建连接。
然后可以使用这个连接执行SQL查询和更新操作。
3. DataSource接口连接数据库DataSource是一个接口,用于从数据库连接池获取连接。
连接池是一组预先创建的数据库连接,可以重复使用,从而提高应用程序的性能。
通过使用DataSource接口,可以通过配置连接池的方式来连接和管理数据库连接。
这种方式通常适用于大型应用程序或需要高并发连接的场景。
4. 使用JNDI(Java Naming and Directory Interface)连接数据库JNDI是Java提供的一种用于在Java应用程序中查找和访问命名服务的API。
通过使用JNDI,可以在应用程序中配置数据库连接信息,并使用统一的方式访问数据库。
这种方式通常适用于企业级应用程序,其中数据库连接信息可以统一管理。
5.使用第三方库连接数据库除了使用JDBC标准API连接数据库,还可以使用一些第三方库来简化数据库访问。
例如,Hibernate是一个流行的Java持久化框架,它提供了一种简单的方式来与数据库进行交互。
使用Hibernate,可以通过简单的配置来连接和管理数据库。
总结:上述是几种使用JDBC连接数据库的方式。
每种方式都有自己的优势和适用场景。
数据库连接参数
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);
8、access数据库直连用ODBC的
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
3、Sql Server7.0/2000数据库
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
2、关闭自动提交功能,提高系统性能
在第一次建立与数据库的连接时,在缺省情况下,连接是在自动提交模式下的。为了获得更好的性能,可以通过调用带布尔值false参数的Connection类的setAutoCommit()方法关闭自动提交功能,如下所示:
conn.setAutoCommit(false);
5、Informix数据库
Class.forName("rmix.jdbc.IfxDriver").newInstance();
String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
Statement stmtNew=conn.createStatement() ;
jdbc oracle sql查询表结构
jdbc oracle sql查询表结构JDBC连接Oracle数据库并查询表结构一、引言JDBC(Java Database Connectivity)是Java语言访问数据库的标准接口,它提供了一种通用的方式来连接和操作各种数据库。
Oracle是一种强大的关系型数据库管理系统,本文将针对Oracle 数据库使用JDBC连接,并通过SQL语句查询表结构。
二、准备工作在开始查询表结构之前,我们需要进行一些准备工作。
首先,确保已经正确安装了Java开发环境(JDK)和Oracle数据库,并且配置了正确的JDBC驱动。
其次,在Java代码中导入所需的JDBC类和包,以便能够与Oracle数据库进行交互。
三、建立数据库连接要查询Oracle数据库的表结构,首先需要建立与数据库的连接。
可以通过以下代码实现:```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class OracleJDBCExample {public static void main(String[] args) {// 数据库连接信息String url = "jdbc:oracle:thin:@localhost:1521:xe";String username = "your_username";String password = "your_password";// 建立数据库连接try {Connection conn = DriverManager.getConnection(url, username, password);System.out.println("成功连接到数据库!");// 查询表结构的代码将在这里添加conn.close();} catch (SQLException e) {System.out.println("连接数据库失败!");e.printStackTrace();}}}```在上述代码中,需要将`url`、`username`和`password`分别替换为你的数据库连接信息。
ojdbc14用法
ojdbc14用法一、概述ojdbc14是一款用于连接Oracle数据库的Java数据库连接(JDBC)驱动程序。
它提供了Java应用程序与Oracle数据库进行交互的接口,使得开发者能够轻松地进行数据库操作。
二、安装与配置1.下载ojdbc14驱动程序包,并解压缩。
2.将ojdbc14的jar文件添加到Java类路径中。
3.确保Java环境配置正确。
三、基本用法1.导入相关类:在Java代码中导入ojdbc14相关的类,如OracleDriver、Connection等。
2.建立连接:使用DriverManager类的getConnection方法建立与Oracle数据库的连接。
需要提供数据库URL、用户名和密码。
3.执行查询:使用Statement或PreparedStatement对象执行SQL查询。
4.处理结果:使用ResultSet对象获取查询结果。
5.关闭连接:使用Connection对象的close方法关闭数据库连接。
四、示例代码以下是一个简单的Java程序,用于连接Oracle数据库并执行查询:```javaimportjava.sql.Connection;importjava.sql.DriverManager;importjava.sql.ResultSet;importjava.sql.Statement;publicclassOJDBC14Example{publicstaticvoidmain(String[]args){//配置连接参数Stringurl="jdbc:oracle:thin:@//localhost:1521/orcl";Stringuser="username";Stringpassword="password";try{//建立连接Connectionconnection=DriverManager.getConnection(url,user,password); if(connection!=null){//执行查询Statementstatement=connection.createStatement();ResultSetresultSet=statement.executeQuery("SELECT*FROMtablename"); //处理结果集while(resultSet.next()){System.out.println("Column1:"+resultSet.getString("Column1"));//其他列的处理...}//关闭连接和结果集resultSet.close();statement.close();connection.close();}else{System.out.println("Failedtoconnecttothedatabase.");}}catch(Exceptione){e.printStackTrace();}}}```五、注意事项1.请根据实际情况修改连接参数,包括数据库URL、用户名、密码和表名。
Java连接Oracle数据库常用方法
Java连接Oracle数据库常用方法在Java中连接Oracle数据库有多种方法,下面是几种常用的方法。
1. 使用JDBC连接Oracle数据库```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class OracleConnectionpublic static void main(String[] args)Connection connection = null;try//加载JDBC驱动程序Class.forName("oracle.jdbc.OracleDriver");//创建数据库连接String username = "username";String password = "password";connection = DriverManager.getConnection(url, username, password);//在此处执行SQL语句或其他操作} catch (ClassNotFoundException e) e.printStackTrace(;} catch (SQLException e)e.printStackTrace(;} finally//关闭数据库连接tryif (connection != null) connection.close(;}} catch (SQLException e)e.printStackTrace(;}}}``````javaimport java.sql.Connection;import java.sql.SQLException;import java.util.Properties;public class OracleConnectionPoolpublic static void main(String[] args)BasicDataSource dataSource = null;Connection connection = null;try//创建连接池Properties properties = new Properties(;properties.setProperty("driverClassName", "oracle.jdbc.OracleDriver");properties.setProperty("username", "username");properties.setProperty("password", "password");dataSource =BasicDataSourceFactory.createDataSource(properties);//从连接池中获取连接connection = dataSource.getConnection(;//在此处执行SQL语句或其他操作} catch (Exception e)e.printStackTrace(;} finally//关闭连接tryif (connection != null) connection.close(;}} catch (SQLException e) e.printStackTrace(;}//关闭连接池if (dataSource != null) trydataSource.close(;} catch (SQLException e) e.printStackTrace(;}}}}```3. 使用Spring的JdbcTemplateSpring的JdbcTemplate是一个简化数据库访问的工具类,可以更方便地执行SQL语句。
Java开发Oracle数据库连接JDBCThinDriver的三种方法
Java开发Oracle数据库连接JDBCThinDriver的三种⽅法Oracle的jdbc驱动三种主要分类:1、JDBC OCI: oci是oracle call interface的缩写,此驱动类似于传统的ODBC 驱动。
因为它需要Oracle Call Interface and Net8,所以它需要在运⾏使⽤此驱动的JAVA程序的机器上安装客户端软件,其实主要是⽤到orcale客户端⾥以dll⽅式提供的oci和服务器配置。
2、JDBC Thin: thin是for thin client的意思,这种驱动⼀般⽤在运⾏在WEB浏览器中的JAVA程序。
它不是通过OCI orNet8,⽽是通过Java sockets进⾏通信,是纯java实现的驱动,因此不需要在使⽤JDBC Thin的客户端机器上安装orcale客户端软件,所以有很好的移植性,通常⽤在web开发中。
3、JDBC KPRB:这种驱动由直接存储在数据库中的JAVA程序使⽤,如Java Stored Procedures 、triggers、Database JSP's。
因为是在服务器内部使⽤,他使⽤默认或当前的会话连接来访数据库,不需要⽤户名密码等,也不需要数据库url。
⼀.JDBC 连接Oracle 说明JDBC 的应⽤连接Oracle 遇到问题,错误如下:ORA-12505,TNS:listener does not currently know of SID given in connect descriptor TheConnection descriptor used by the client was。
我在DB 层⾯配置了静态注册,并且GLOBAL_DBNAME和SID_NAME 不⼀样,以往的配置都是⼀样的,所以没有发现这个问题。
(SID_DESC =(GLOBAL_DBNAME = dave)(ORACLE_HOME =D:\app\Administrator\product\11.2.0\dbhome_1)(SID_NAME = NEWCCS))Oracle Listener 动态注册与静态注册在⽹上google 了⼀下,发现JDBC Thin Driver 的formats 有三种格式:格式⼀: Oracle JDBC Thin using a ServiceName:jdbc:oracle:thin:@//<host>:<port>/<service_name>Example: jdbc:oracle:thin:@//192.168.2.1:1521/XE注意这⾥的格式,@后⾯有//, 这是与使⽤SID的主要区别。
JDBC数据库连接的驱动名称及URL
jdbc:oracle:thin:@localhost:1521:testdb
jdbc:oracle:thin:root/secret@localhost:1521:testdb
jdbc:oracle:oci:@hoststring
jdbc:oracle:oci:@localhost:1521:testdb
数据库URL格式:
jdbc:oracle:<drivertype>:@<database>
jdbc:oracle:<drivertype>:<user>/<password>@<database> where drivertype can be thin, oci or kprb.
例子:
jdbc:sqlserver://localhost\\sqlexpress;integratedSecurity=true
jdbc:sqlserver://localhost\\sqlexpress;user=uncletoo;password=123
3. Oracle
驱动程序类名:oracle.jdbc.OracleDriver
1. MySQL
驱动程序类名:com.mysql.jdbc.Driver
数据库URL格式:
jdbc:mysql://[host][,failoverhost...][:port]/[database][?propertyName1][=propertyValue1][&propertyName2][=propertyValue2]...
jdbc:postgresql:database
jdbc连接oracle的基本步骤
一、概述在Java编程中,JDBC(Java Database Connectivity)是一个重要的API,它允许开发者通过使用标准的SQL语句来访问数据库。
对于访问Oracle数据库,JDBC也是常用的技术之一。
本文将介绍JDBC 连接Oracle数据库的基本步骤,以帮助读者快速了解并使用JDBC来实现与Oracle数据库的连接。
二、JDBC连接Oracle的准备工作1. 确认Oracle数据库驱动在使用JDBC连接Oracle数据库之前,首先需要确认已经安装了适当版本的Oracle数据库驱动。
Oracle冠方提供了多个版本的JDBC驱动程序,开发人员应当选择合适的版本,并将其添加到项目的类路径中。
2. 确保已经拥有Oracle数据库的连接信息在进行连接之前,需要确保已经获得了Oracle数据库的连接信息,包括数据库的主机名、端口号、数据库实例名、用户名和密码等。
这些信息将在后续的程序中被用到。
三、创建JDBC连接Oracle的步骤1. 加载JDBC驱动程序连接Oracle数据库之前,首先需要加载JDBC驱动程序。
使用Class.forName()方法,并传入JDBC驱动程序的类名,来加载驱动程序。
例如:```javaClass.forName("oracle.jdbc.driver.OracleDriver");```加载驱动程序后,即可使用JDBC与Oracle数据库进行通信。
2. 建立数据库连接一旦加载了驱动程序,接下来就可以建立与Oracle数据库的连接。
使用DriverManager.getConnection()方法,并传入数据库的连接信息,来建立连接。
例如:```javaString url = "jdbc:oracle:thin:主机名:端口号:数据库实例名";String user = "用户名";String password = "密码";Connection connection = DriverManager.getConnection(url, user, password);```其中,url是Oracle数据库的连接URL,用户名和密码分别是数据库的登入名和密码。
使用JDBC连接数据库(一)
使⽤JDBC连接数据库(⼀)JDBC是由java编程语⾔编写的类及接⼝组成,同时它为程序开发⼈员提供了⼀组⽤于实现对数据库访问的JDBC API,并⽀持SQL语⾔。
利⽤JDBC可以将JAVA代码连接到oracle、DB2、SQLServer、MYSQL等数据库,从⽽实现对数据库中的数据操作的⽬的。
⼀、JDBC简介JDBC全称为:Java Data Base Connectivity (java数据库连接),可以为多种数据库提供填统⼀的访问。
JDBC是sun开发的⼀套数据库访问编程接⼝,是⼀种SQL级的API。
它是由java语⾔编写完成,所以具有很好的跨平台特性,使⽤JDBC编写的数据库应⽤程序可以在任何⽀持java的平台上运⾏,⽽不必在不同的平台上编写不同的应⽤程序。
JDBC的主要功能如下:(1)建⽴与数据库或者其他数据源的链接(2)向数据库发送SQL命令(3)处理数据库的返回结果⼆、JDBC中常⽤类和接⼝连接到数据库(Connection)、建⽴操作指令(Statement)、执⾏查询指令(executeQuery)、获得查询结果(ResultSet)等。
1、驱动程序管理类(DriverManager)DriverManager类是JDBC的管理类,作⽤于⽤户和驱动程序之间。
它跟踪在可⽤的驱动程序,并在数据库和相应驱动程序之间建⽴连接。
另外,DriverManager类也处理诸如驱动程序登陆时间限制及登录和跟踪消息的显⽰事务。
对于简单的应⽤程序,⼀般程序员需要在此类中直接使⽤唯⼀的⽅法时DriverManager.getConnection()。
该⽅法将建⽴与数据库的链接。
JDBC允许⽤户调⽤DriverManager的⽅法getDriver()、getDrivers()和registerDriver()及Driver的⽅法connect().2、声明类(Statement)Statement对象⽤于将SQL语句发送到数据库中。
jdbc调用Oracle数据库存储过程
/blog/1582331 Java jdbc调用Oracle数据库存储过程一、了解CallableStatement接口1.callablestatement接口提供了两种调用形式{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} //包含结果参数的调用形式如:函数(funciton){call <procedure-name>[(<arg1>,<arg2>, ...)]} //不包含结果参数的调用形式如:存储过程(procedure)2.callablestatement接口提供的方法Java代码1.void registerOutParameter(int parameterIndex, int sqlType)2.throws SQLException; //在调用存储过程的时候设置输出参数的类型,用于接收输出结果registerOutParameter接口中有四个该方法的重载实现,具体的可以查看源码了解Java代码1.setXXX(int parameterIndex,XXX x) //主要用于设置过程调用时候需要的输入参数信息其中XXX代表对应类型Java代码1.getXXX(int x) //主要用于获取过程调用后返回的参数的信息3.callablestatement接口产生的异常提示如下源码:Java代码1./*2.* @exception SQLFeatureNotSupportedException if<code>sqlType</code> is3.* a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,4.* <code>DATALINK</code>, <code>JAVA_OBJECT</code>,<code>NCHAR</code>,5.* <code>NCLOB</code>, <code>NVARCHAR</code>,<code>LONGNVARCHAR</code>,6.* <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>7.* or <code>STRUCT</code> data type and the JDBC driver does notsupport8.* this data type9.* @see Types10.*/11.void registerOutParameter(int parameterIndex, int sqlType)12.ows SQLException;当我们使用registerOutParameter方法设置输出参数类型的时候,需要注意对于某一些类型是不能够进行设置的如上中所以提到的类型都会引发SQLFeatureNotSupportedException异常,对于能够支持的类型可以查看java.sql.Types和oracle.jdbc.OracleTypes如下源码:Java代码1./*2.* java.sql.SQLException: 不允许的操作: Ordinal binding and Namedbinding cannot be3.* combined! at4.*oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:112) at5.*oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:146) at6.* oracle7.* .jdbc.driver.OracleCallableStatement.execute(OracleCallableStatement.java8.* :4219) at9.*org.viancent.call.procedure.CallProcedure.main(CallProcedure.ja va:36)10.*/当我们在给过程设置参数信息的时候,不能够同时使用下标和名称来指定对应参数的。
Oracle数据库集群连接_JDBC连接Oracle集群数据库
JAVA查询Oracle数据库集群连接字符串事件:报表接口数据库突然无法连接 ,导致无法正常取数操作。
异常信息: Io 异常: Got minus one from a read call分析:数据库地址及其配置信息都为发生变化 , 经询问后得知数据库调整为集群工作方式 .结果:1. 修改普通 JDBC 连接字符串为集群工作方式。
2. 接口中的 JDBC JAR文件不适合集群工作方式。
思维宽度:1.JDBC JAR文件的选择,Classes12 到底是个啥玩意?第一次听很晕 , 其实就是 oracle 数据库自带的 JDBC ,全名叫classes12.jar 高手都这么忽悠人的!常用JDBC JAR信息常用JDBC驱动包JDK 1.4 JDK 1.5 JDK 1.6 单例数据库集群数据库Class.forName1)OracleJdbcDriver9i.jar 支持支持支持支持不支持oracle.jdbc.OracleDriver2)classes12.jar(oracle 92i)支持支持支持支持不支持oracle.jdbc.OracleDriver3)ojdbc14.jar(oracle 92i)支持支持支持支持不支持oracle.jdbc.OracleDriver4)classes12.jar(oracle 10G)支持支持支持支持支持oracle.jdbc.OracleDriver5)ojdbc14.jar(oracle 10G)支持支持支持支持支持oracle.jdbc.OracleDriver6)ojdbc5.jar 不支持支持支持支持支持无需Class.forName 加载7)ojdbc6.jar 不支持不支持支持支持支持无需Class.forName 加载序号1 : OracleJdbcDriver9i.jar 这就是我常用的 JDBC 驱动,本次肇事者 !出身不明 , 户口本(MANIFEST.MF)内容为空 ,初步分析为oracle92i 时代产物。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
String user = props.getProperty(poolName + ".user");
String password = props.getProperty(poolName + ".password");
String dbip = props.getProperty(poolName + ".db_ip", "192.168.96.1");
*/
public Connection getConnection(String name, long time) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConnection(time);
Enumeration propNames = props.propertyNames();
while (propNames.hasMoreElements()) {
String name = (String) propNames.nextElement();
if (name.endsWith(".url")) {
String dbport = props.getProperty(poolName + ".db_port", "1521");
String dbuid = props.getProperty(poolName + ".db_uid", "ORACLE9I");
String maxconn = props.getProperty(poolName + ".maxconn", "0");
try {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
con = DriverManager.getConnection (“jdbc:oracle:thin:@192.168.96.1:1521:oracle9i”,user,password);
JDBC连接oracle数据库(资料整理)
JSP+JDBC(Thin模式)连接Oracle
在JSP中连接到Oracle一般有2种方式:
1、Oracle JDBC的oci8方式
2、Oracle JDBC的thin方式
我比较喜欢第2种,因为WEB发布服务器与数据库服务器一般都不会放在同一台电脑中,而在使用thin方式连接时,WEB服务器端无须安装oracle的客户端。
}
loadDrivers(dbProps);
createPools(dbProps);
}
/**
*装载和注册所有JDBC驱动程序
*
* @param props属性
*/
private void loadDrivers(Properties props) {
String driverClasses = props.getProperty("driver");
StringTokenizer st = new StringTokenizer(driverClasses);
while (st.hasMoreElements()) {
String driverClassName = st.nextToken().trim();
try {
Driver driver = (Driver)
}
catch (SQLException e) {
log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName());
}
}
}
/**
*根据指定属性创建连接池实例.
*
* @param props连接池属性
*/
private void createPools(Properties props) {
}
/**
*将连接对象返回给由名字指定的连接池
*
* @param name在属性文件中定义的连接池名字
* @param con连接对象
*/
public void freeConnection(String name, Connection con) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
private PrintWriter log;
private Hashtable pools = new Hashtable();
/**
*返回唯一实例.如果是第一次调用此方法,则创建实例
*
* @return DBConnectionManager唯一实例
*/
static synchronized public DBConnectionManager getInstance() {
配置好环境后,我们就开始开始动手写代码了。关于数据库连接的代码,应该写个专门的连接类来调用,没必要想网络上有些文章那样,直接写到JSP的代码中。
关于连接的代码很简单
private Connection newConnection(String user,String password) {
Connection con = null;
}
return null;
}
/**
*关闭所有连接,撤销驱动程序的注册
*/
public synchronized void release() {
//等待直到最后一个客户程序调用
if (--clients != 0) {
return;
}
Enumeration allPools = pools.elements();
public class DBConnectionManager {
static private DBConnectionManager instance; //唯一实例
static private int clients;
private Vector drivers = new Vector();
try {
dbProps.load(is);
}
catch (Exception e) {
System.err.println("不能读取属性文件. " +
"请确保db.properties在CLASSPATH指定的路径中");
return;
}
String logFile = dbProps.getProperty("logfile", "newslog.txt");
*/
public Connection getConnection(String name) {
DBConnectionPool pool = (DBConnectionPool) pools.get(name);
if (pool != null) {
return pool.getConection();}
catch (SQLException e) {
return null;
}
return con;
}
如果帐号密码没有错,那这个函数就应该能返回个可用的连接。但如此简单的连接在一个项目中使用,是远远达不到效果的。我们可以在这个数据库连接类中加入更多的功能,如连接池等等。下面我就把该数据库连接类的代码详细的列出来,大家可以参考参考。
while (allDrivers.hasMoreElements()) {
Driver driver = (Driver) allDrivers.nextElement();
try {
DriverManager.deregisterDriver(driver);
log("撤销JDBC驱动程序" + driver.getClass().getName()+"的注册");
//连接信息
String dbInfo = user + "/" + password + "@" + dbip + ":" + dbport + ":" + dbuid;
int max;
try {
max = Integer.valueOf(maxconn).intValue();
}
catch (NumberFormatException e) {
if (instance == null) {
instance = new DBConnectionManager();
}
clients++;
return instance;
}
/**
*建构函数私有以防止其它对象创建本类实例
*/
private DBConnectionManager() {
init();
if (pool != null) {
pool.freeConnection(con);
}
}
/**
*获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
*限制,则创建并返回新连接