- 浏览: 77004 次
- 性别:
- 来自: 广州
最新评论
-
wayilau:
第24条,是不是有问题呀。。。
教你认人 -
xiaoBaoProgramme:
很好的一篇文章,顶。
html页面嵌套html页面 -
JUnique:
...
SSH -
yihuijie2011:
...
SSH -
linpark:
没事来看看~
SSH
JDBC
第一节课:B/S四层结构的介绍,引入对数据库的分析,为什么要用到JDBC。
表现层:结果展示,数据录入,触发请求
控制层:接收请求,下发数据
业务逻辑:组织业务逻辑,分配任务
数据持久:数据操作
一般数据库的文件只要数据库厂商才知道怎么去操作的,因此开发了数据库服务器,并提供了数据库客户端,用户只需在客户端上操作就直接能操作底层的数据了。但是这一个客户端每个公司的不同,造成了应用的困难,因此需要用一个统一的规范,这就是JDBC的出现。
JDBC规范
所谓规范实际上一套套的接口规定
JDBC只是定义了一套操作数据库的接口,不同数据库公司按照这个接口规范实现了相应的类,因此对于客户来说只要学习JDBC的规范就可以操作不同的数据库了,不同数据库公司实现的JDBC的接口的类库称为该数据库的驱动。
JDBC使用流程
获取数据库连接(一次一般只能连接一个库,对orcale来说只要服务的概念,也就是一个库)
服务器IP,端口(MySQL为3306)
协议(jdbc:mysql)
库或服务名称
执行SQL语句
如果执行的是查询的话,要接收查询结果
断开与数据库的连接
Class.forName(“com.mysql.jdbc.Driver”) //动态引入数据库驱动类 ,而不是直接静态的采用import方法,以此提高程序的可维护性,因为这个名字可以通过xml配置文件读入而得到。
JDBC详细应用
类介绍:
DriverManager 其中的getConnection方法可以得到一个Connection 变量
Connection 其中的createStatement()方法可以得到一个Statement变量
Statement 其中的executeUpdate()可以执行一条SQL语句,该返回值表示影响到了几条记录。executeQuery()进行查询,返回一个ResultSet对象
ResultSet: 其对象一定要关闭,当执行查询完成后,rs指向标题,故在使用时首先要用next方法,移到下一条,并可以通过返回值判断是否结束。之后就可以通过各个get方法得到不同字段的值了。
在引用这些类时,建议使用java.jdbc下面的接口,以提高程序的可移植性,如果用了某个具体数据库的实现类程序可以实现同样的效果但是可移植性不好,要换数据库时需要改动大量的源码!
//这里引用的都是sql的接口类,而不是用mySQL的实现类,主要是为了提高本程序的可移植性,用到了多态!
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JdbcDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Connection conn = null;
Statement stat = null;
ResultSet set = null;
try {
//通过反射机制动态的引入应用的数据库的驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
//先初始化连接参数mysql:jdbc为协议
String url = "jdbc:mysql://127.0.0.1:3306/storagemis";
//所连接的数据库的用户名和密码
String userName = "root";
String passWord = "";
conn = DriverManager.getConnection(url,userName,passWord);
//System.out.println(CreateID.createID());
//利用SQL语句进行数据库操作
//数据插入操作
String sqlStatement = "INSERT INTO storagemis.goods VALUES ('House',"+CreateID.createID()+",560000)";
//上面的sql语句拼接容易出错,因此可以考虑采用其他的方式。下面改进
//创建表
//String sqlStatement = "create table storagemis.test ( ID varchar(5))";
//得到一个jdbc执行语句
stat = conn.createStatement();
//执行该语句
int result = stat.executeUpdate(sqlStatement);
System.out.println("The operation affect "+result+"record");
//数据库查询操作实例
String sqlQuery = "SELECT * FROM storagemis.goods";
//执行查询操作以后返回一个ResultSet的对象
set = stat.executeQuery(sqlQuery);
//遍历查询结果
while(true){
//在最初执行查询后,指针指向标题,为了能够获取数据,一开始应该移动
//指针到第一条记录,其返回结果用来判断是否结束
boolean resultQuery = set.next();
if(resultQuery == false){
break;
}
//通过set的不同方法的表中的值
int ID = set.getInt(2);
//可以通过字段名得到
String goodsName = set.getString("goodsname");
//可以通过字段的编号得到,注意编号从0开始
int goodsPrice = set.getInt(3);
System.out.println("ID:"+ID+"-goodsName is :"+goodsName+" - goodsPrice is: "+goodsPrice);
}
//以下实例是带参数的SQL查询
String sqlParm = "update storagemis.goods set goodsname ='telphone' where goodsID = ?;";
// 通过connection的prepareStatement()方法建立一个PreparedStatement类(这是statement的子类)的对象,这表示预备sql
PreparedStatement pstatement = conn.prepareStatement(sqlParm);
//进行参数传递,下面的语句表示为预备参数的第一个?传递一个“1”参数
//这里用的setlong,如果是传递的字符串的话,就用setString()
pstatement.setLong(1,2);
//执行sql语句,但是千万注意不要再带参数,否则将出现执行错误,因为sal语句中有?,而不带参数的
//的execute则表示对PreparedStatement的对象执行。
pstatement.execute();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//注意一定要关闭ResultSet
try {
set.close();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//关闭数据库连接
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
JDBC 带参数的SQL JDBC元数据
元数据 Meta Data
本身固有的特性称为元数据
元数据的分类:
数据库的元数据:数据库的名称,版本
查询结果的元数据:字段
通过DatabasedMetaData类的方法得到数据库的元数据,该类的变量有connection.getMetaData( )方法
通过ResultSet类的getMtaData()方法得到一个ResultSetMetaData类的实例,再功过该实例的不同方法得到查询结果的元数据。
练习:双击运行,让用户输入有关数据库的信息,数据库驱动,用户名,密码,数据库。对于查询结果能够以表格的方式表现。 并进行程序的实施!
GetMetaDate.java
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
public class GetMetaDate {
/**
*
* 本实例主要是为了演示获的元数据
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//建立链接
String databaseDriver = "com.mysql.jdbc.Driver";
//利用反射机制动态加载驱动
Class.forName(databaseDriver);
String url = "jdbc:mysql://127.0.0.1:3306/storagemis";
String userName ="root";
String passWord = "";
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
ResultSetMetaData rsMetaData = null;
//建立链接
try{
conn = DriverManager.getConnection(url,userName,passWord);
//建立好连接后就可以获得有关数据库本身的元数据信息
DatabaseMetaData dbmd = conn.getMetaData();
//从而可以根据DatabaseMetaDate得到关于数据库的各元个信息
String DatabaseProductName = dbmd.getDatabaseProductName();
String DatabaseProductVersion = dbmd.getDatabaseProductVersion();
String DriverName = dbmd.getDriverName();
System.out.println("DatabaseProductName is :"+DatabaseProductName);
System.out.println("DatabaseProductVersion is :"+DatabaseProductVersion);
System.out.println("DriverName is :"+DriverName);
//建立语句,获得查询结果的个数据元信息
String sql = "SELECT * FROM storagemis.goods";
//利用connection得打一个statement
stat = conn.createStatement();
rs = stat.executeQuery(sql);
//获得查询结果的元数据,比如行数,列数,字段名
rsMetaData = rs.getMetaData();
//再通过rsMetaData得到具体的元数据
//得到该结果集中的列数
int columnCount= rsMetaData.getColumnCount();
//在通过该列数得到每一列的名字和大小
for(int i = 1; i <= columnCount ; i ++){
String columnName = rsMetaData.getColumnName(i);
int columnSize = rsMetaData.getColumnDisplaySize(i);
System.out.println("the size of column "+ columnName+ "is "+ columnSize);
}
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭各个连接
try{
conn.close();
rs.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
DBAnywhere源码:
Main.java
package anyfo.databaseanywhere.src;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
import anyfo.databaseanywhere.util.Channel;
import anyfo.databaseanywhere.util.Param;
import anyfo.databaseanywhere.util.XMLUtil;
public class Main {
private int [] lengthOfField = null;
private List<String []> contentList = new ArrayList<String[]>();
/**
* 解析配置文件,得到数据库链接所需要的参数
* @param filePath
* @return
* @throws Exception
* @author
*/
public Param parseConfig(String filePath) throws Exception{
//根据配置文件路径得到一棵DOM树的根节点
Element root = (Element)XMLUtil.getDOMTree(filePath);
//利用该根节点得到各个子节点的值
String databaseDriver = XMLUtil.getTextValueOfElement(root, "databaseDriver");
String url = XMLUtil.getTextValueOfElement(root, "url");
String userName = XMLUtil.getTextValueOfElement(root, "userName");
String passWord = XMLUtil.getTextValueOfElement(root, "passWord");
Param param = new Param();
param.setDatabaseDriver(databaseDriver);
param.setPassWord(passWord);
param.setUrl(url);
param.setUserName(userName);
return param;
}
/**
* 实现对数据库的链接的建立
* @param param
* @return
* @throws Exception
* @author
*/
public Connection connectDatabase(Param param) throws Exception{
Connection conn = null;
//利用反射机制动态加载数据库的驱动程序
Class.forName(param.getDatabaseDriver());
System.out.println("数据库库正在链接中,请稍等......");
//建立链接
conn = DriverManager.getConnection(param.getUrl(),param.getUserName(), param.getPassWord());
//建立好连接后就可以获得有关数据库本身的元数据信息
System.out.println("您已成功链接到数据库");
DatabaseMetaData dbmd = conn.getMetaData();
//从而可以根据DatabaseMetaDate得到关于数据库的各元个信息
String DatabaseProductName = dbmd.getDatabaseProductName();
String DatabaseProductVersion = dbmd.getDatabaseProductVersion();
String DriverName = dbmd.getDriverName();
System.out.println("您使用的数据库库信息如下:");
//打印所链接的数据库的相关信息
System.out.println("DatabaseProductName is :"+DatabaseProductName);
System.out.println("DatabaseProductVersion is :"+DatabaseProductVersion);
System.out.println("DriverName is :"+DriverName);
return conn;
}
/**
* 实现对更新类操作的处理
* @param conn
* @param cmd
* @throws Exception
* @author
*/
public void update(Connection conn,String cmd)throws Exception {
Statement stat = null;
try{
stat = conn.createStatement();
int result = stat.executeUpdate(cmd);
System.out.println("您的操作已经成功,并且影响到了 "+result+"记录");
}catch(SQLException s){
//打印出失败信息!
System.out.println("您的操作失败"+s.getMessage());
}finally{
stat.close();
}
}
/**
* 数据扫描功能,实现对数据库的内容本地保存
* @param conn 链接
* @param cmd 命令
* @throws Exception
* @author
*/
public void scan(Connection conn,String cmd) throws Exception{
Statement stat = null;
ResultSet rs = null;
ResultSetMetaData rsMetaData = null;
//得到一个jdbc执行语句
stat = conn.createStatement();
//获得查询结果集
rs = stat.executeQuery(cmd);
//获得查询结果的元数据,比如行数,列数,字段名
rsMetaData = rs.getMetaData();
//再通过rsMetaData得到具体的元数据
//得到该结果集中的列数
int columnCount= rsMetaData.getColumnCount();
//创建数组
this.lengthOfField = new int[columnCount];
String [] contentArray = new String[columnCount];
//初始化该长度数组,用各表的字段名字的长度作为初始值,同时把各字段值保留到字符数组中
for(int i = 1 ; i <= columnCount ; i++){
String contentValue = rsMetaData.getColumnName(i);
int size = contentValue.length();
this.lengthOfField[i -1 ] = size;
contentArray[i -1 ] = contentValue;
}
this.contentList.add(contentArray);
//更新长度数组,把具体值中较大的长度放入到长度数组中,并同时把值保留到列表中。
//遍历查询结果
while(true){
//在最初执行查询后,指针指向标题,为了能够获取数据,一开始应该移动
//指针到第一条记录,其返回结果用来判断是否结束
boolean resultQuery = rs.next();
if(resultQuery == false){
break;
}
String [] dataArray = new String[columnCount];
for(int i = 1 ; i <= columnCount ; i++){
String contentValue = rs.getString(i);
int size = contentValue.length();
int max = Math.max( size, this.lengthOfField[ i - 1 ] );
this.lengthOfField[ i - 1 ] = max;
dataArray[i -1 ] = contentValue;
}
this.contentList.add(dataArray);
}
}
/**
* 主要实现格式化显示数据的功能
* @author
*/
public void displayData( ){
int columnCount = this.lengthOfField.length;
for(String [] content:this.contentList){
//该循环打印表头的横线
for(int i = 0 ; i < columnCount ; i ++){
//columnCount决定打印多少个表格框
System.out.print("|");
for(int j = 0 ; j < this.lengthOfField[i];j++){
//这层循环决定打印每个框中的东西
System.out.print("-");
}
}
System.out.print("|\n");
//目前状态已经换行,可以开始打印数据库的内容,需要从contentList取出一个数组来进行打印
int index = 0;
for ( String columnValue: content ) {
System.out.print( "|" );
System.out.print( columnValue );
int size = this.lengthOfField[ index ];
for ( int i = 0 ; i < size - columnValue.length() ; i ++ ) {
//打印剩余的空格
System.out.print( " " );
}
index ++;
}
System.out.print( "|\n" );
}
//打印表尾的横线
for(int i = 0 ; i < columnCount ; i ++){
//columnCount决定打印多少个表格框
System.out.print("|");
for(int j = 0 ; j < this.lengthOfField[i];j++){
//这层循环决定打印每个框中的横线
System.out.print("-");
}
}
System.out.print("|\n");
}
/**
* 查询处理函数,主要完成逻辑流程管理,即:扫描数据库、格式化显示数据
* @param conn
* @param cmd
* @throws Exception
* @author
*/
public void queryPrcocess(Connection conn,String cmd)throws Exception {
//查询操作处理的关键是打印表格
//为了实现这个目的先把所有的数据保存下来,这是一个非常好的思路,把数据库的东西保留到内存中去
//以后处理的时候只需要从内存中读取数据就可以了
//扫描数据,并保留数据,其格式是长度数组保留没列中最大的长度,而内容列表中保留一条记录(其中记录
//用String数组保存
//扫描查询结果,并保留到类的成员变量
this.scan(conn,cmd);
//下面的代码开始按格式显示数据
this.displayData();
//一次查询完成后要清空list中的数据;
this.contentList.clear();
}
/**
* DBanywher的启动方法,主要是实现对输入命令的判断,从而选择不同的执行方法
* @param param
* @throws Exception
* @author
*/
public void start(Param param) throws Exception{
//根据各个参数建立链接,并返回链接建立链接
Connection conn = null;
Channel chan = null;
try{
conn = this.connectDatabase(param);
//等待用户读入数据并进行处理
chan = Channel.getChannel();
//一直等待用户的输入
while(true){
System.out.println("请输入你要对该数据库表进行操作的指令(Exit退出)");
String cmd = chan.readData();
//判断用户是否输入exit以便退出,故要求进行判断,为此先把它转换为小写
cmd.toLowerCase();
if(cmd.equals("exit")==true){
break;
//表示退出系统,否则进行下面的处理
}
//下面要根据输入的命令类型进行不同处理,主要是分为两类,查询和更新操作(包括修改,删除,增加)
//为此要对命令进行区分,可以判断命令的前几个字符来判断
if(cmd.startsWith("select")){
//表示进行查询操作
this.queryPrcocess(conn, cmd);
}else{
//表示进行更新操作
this.update(conn, cmd);
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
chan.closeChannel();
conn.close();
}
}
/**
* 主函数,启动程序
* @param args
* @throws Exception
*
*/
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
// 读取配置文件,保存各个参数
Main m = new Main();
//运行此带参数的程序需要选用open run dialog,并输入参数
Param param = m.parseConfig(args[0]);
//开始进行处理
m.start(param);
}
}
Channel.java
package anyfo.databaseanywhere.util;
/**
* 本类主要是实现对数据从显示器上读取的管道的建立
*
*/
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Channel {
private InputStream is;
private InputStreamReader isr;
private BufferedReader br;
//做成一个单利模式
private static Channel chan;
//为实现单例,其构造函数必须是私有的
/**
* 私有化构造器,以实现单例模式
* @author
*/
private Channel(){
this.buildChannel();
}
/**
* 由于构造函数是私有的,因此需要为客户提供一个构建该实例的方法
* @return
* @author
*/
public static Channel getChannel(){
if(Channel.chan == null){
Channel.chan = new Channel();
}
return Channel.chan;
}
/**
* 建立管道,不过这是一个私有方法
* @author
*/
private void buildChannel(){
is = System.in;
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
}
/**
* 关闭管道
* @throws Exception
* @author
*/
public void closeChannel() throws Exception{
is.close();
isr.close();
br.close();
}
/**
* 读数据,这是一个柱塞是方法
* @return
* @throws Exception
* @author
*/
public String readData() throws Exception{
//这里的readLine方法是一个柱塞是方法,一直等到独到数据为止
String msg = br.readLine();
return msg;
}
}
Param.java
package anyfo.databaseanywhere.util;
/**
* 本类主要是封装了数据库链接需要的数据
* @author
*
*/
public class Param {
private String databaseDriver;
private String url;
private String userName;
private String passWord;
public String getDatabaseDriver() {
return databaseDriver;
}
public void setDatabaseDriver(String databaseDriver) {
this.databaseDriver = databaseDriver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
}
XMLUtil.java
package anyfo.databaseanywhere.util;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
/**
* 本类主要实现对xml文件的解析
* @author hp
*
*/
public class XMLUtil {
/**
* 根据制定的配置文件xml构建一棵DOM数,并返回改树的根节点
* @param filePath
* @return
* @throws Exception
* @author
*/
public static Element getDOMTree(String filePath)throws Exception {
//取得DOM树
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(filePath);
Element root = doc.getDocumentElement();
return root;
}
/**
* 取得已知节点某属性的值
* @param Element
* @param String
* @return
* @author
*/
public static String getAttributeOfElement(Element e,String type){
return e.getAttribute(type);
}
/**
* 本方法只适用于每个标记中只有一个相同类型的子标记的情况,直接读取其文本值
* @param parent 父标记
* @param childType 子标记值
* @return
* @author
*/
public static String getTextValueOfElement(Element parent,String childType){
NodeList childList = parent.getElementsByTagName(childType);
Element curElement = (Element) childList.item(0);
String childValue ;
//这里主要进行处理,保证能够独到数据,如果读不到数据,则赋值为空
try{
childValue = curElement.getFirstChild().getNodeValue().toString();
}catch(NullPointerException n){
childValue = "";
}
return childValue;
}
}
JDBC事务 Blob Clob
一系列操作的集合称为事务(transaction);
事务的特性
原子性
一致性
隔离性
持续性
事务的分类:嵌套事务,平面事务(事务是平行的)
事务的操作(利用Connection的方法):
事务开启Conn.setAutoCommit(fasle).这里是设了一个标志
事务提交:把临时数据区的数据移送到硬盘中 conn.commit( )
回滚事务:清空临时数据区的数据,即把这次操作取消conn.rollback( );
对于JDBC默认是自动提交事务,要想自己控制事务必须把这个改为手动控制事务的方式。Conn.setAutoCommit(fasle).
对JDBC第一次启动增删改的操作的事务开始启动事务,一直到commit为止,一个事务可以包括多个增删改操作。当执行commit后表示事务结束了,然后可以进行第二个事务,这也说明了JDBC是支持平面事务的,而不是嵌套事务。
Transaction.java
package TransactionDemo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Transaction {
public static void main(String[] args) {
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//设定数据库的事务操作为手动模式,JDBC默认为自动模式
conn.setAutoCommit(false);
//开始执行操作,本例子演示的是一个银行转账的功能,为了
//保证钱的安全性,必须要求在这过程中不发生异常,如果发生,则必须
//取消之前的所有增删改操作
//先查询待转账帐户的余额情况
String sqlCmd = "SELECT * FROM zheng.account WHERE name = 'zheng'";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//由于知道满足条件的记录只有一条,因此不用在遍历直接可以去数据
boolean result = rs.next();
//下面的异常是一种主动的程序退出的方法
if (result == false){
throw new Exception("您要转账的帐户不存在!");
}
//如果帐户正常则开始进行处理
//得到当前帐户的余额
int balance = rs.getInt("balance");
balance -= 10000 ;
if(balance<=0){
throw new Exception("您要转账的帐户余额不够!");
}
sqlCmd = "UPDATE account SET balance = "+balance+ " WHERE name = 'zheng'";
stat.executeUpdate(sqlCmd);
//先查询接收帐户的余额情况
sqlCmd = "SELECT * FROM zheng.account WHERE name = 'zhu'";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//由于知道满足条件的记录只有一条,因此不用在遍历直接可以去数据
result = rs.next();
//下面的异常是一种主动的程序退出的方法
if (result == false){
throw new Exception("您要存款的帐户不存在!");
}
//如果帐户正常则开始进行处理
//得到当前帐户的余额
balance = rs.getInt("balance");
balance += 10000 ;
sqlCmd = "UPDATE account SET balance = "+balance+ " WHERE name = 'zhu'";
stat.executeUpdate(sqlCmd);
//如果正常的话则提交事务
conn.commit();
//下面可以写其他的事务了。。。。。
} catch (Exception e) {
// TODO Auto-generated catch block
try {
//如果发生异常的话,则回滚事务,取消之前执行的增删改操作
conn.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
}
}
}
Blob(二进制) Clob(文本文件)(orcale)(在mysql里面叫text类型)大容量数据存取
(图片,压缩文件(二进制),等等)
微软的word是十进制和二进制的结合,而pdf是二进制
这个可以作为文件上传下载工具,目前解决了(硬盘<—> 数据库)上传下载
由于数据是比较大的,不可能一次传完,因此这里利用了输入输出流的概念,由系统自动传送
执行操作逻辑是:
上传:
采用带参数的sql语句
将要上传的文件绑定到一个输出流
用preparedStatement的set某方法(区分文本和二进制)设定这个参数,而这个参数要绑定到上面的建立的输出流
执行excuteupdate()
BlobDemo.java
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BlobDemo {
//把硬盘上的一个文件上传到数据库中
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstat = null;
FileInputStream fis = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//开始上传文件,使用带参数的sql语句
String sqlCmd = "Update zheng.account Set pic = ? Where name = 'zheng' ";
pstat = conn.prepareStatement(sqlCmd);
//因为文件比较大,因此需要用输入流来进行操作,为此先建立一个输出流
File file = new File(".\\BloBCLoBDemo\\t.jpg");
//通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。
fis = new FileInputStream(file);
//设定sql语句中的参数
//但是这里了要注意下面的这个方法的,第一setBinaryStream表示对于的是二进制数据
//第二:其中的第一个参数表示是参数index,第二个参数是输入流,第三个数是要传入的长度
//但是这个长度一定是int类型的,其他类型的目前不支持;
pstat.setBinaryStream(1, fis, (int)file.length());
//开始上传
pstat.executeUpdate();
//
System.out.println("您已经成功上传到数据库!");
}catch(Exception e){
e.getMessage();
}finally{
try {
fis.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
下载
里面conn的执行查询后得到一个resultset对象,
利用该对象的get某方法(区分文本和二进制)可以得到一个输出流
建立一个面向硬盘文件的输入流
实现则两个输入流和输出流之间的数据处理
BlobDownDemo.java
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class BlobDownDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
InputStream is = null;
FileOutputStream fos = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//开始下载数据
//为此先要查询数据
String sqlCmd = "Select pic from zheng.account where name = 'zheng' ";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//将数据库中读取到的结果以输出流的形式输出
boolean result = rs.next();
if (result == false){
throw new Exception("不存在数据");
}
is = rs.getBinaryStream(1);
//建立要输出的文件,
//文件输出流FileOutputStream是用于将数据写入 File 或 FileDescriptor 的输出流。
fos = new FileOutputStream("./zheng.jpg");
//在两个流之间进行数据交换
byte [] buffer = new byte[1024];
while(true){
//读数据
int length = is.read(buffer);
if(length == -1){
break;
}
//写数据
fos.write(buffer, 0, length);
}
System.out.println("数据已经成功下载!");
}catch(Exception e){
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
连接池
功能
1加快程序获取连接的速度
2 控制连接总数
3 连接的循环使用机制
4 获取连接的等待机制
5 连接数量的优化
编写逻辑:
要用创建连接池的方法(要用预建立一定数量连接的实例,以加快程序获得连接的速度,差异比较大)
要用判断能否创建的方法
要用归还的方法(用户能自己归还,也能直接close,实际也是归还)
能够适用多个不同的数据库(用配置文件读入,并加一个外壳)
保证线程安全(使用sychronized)
能够避免用户误操作(自己定义一个实现conntion的子类,用户实际上是获得该子类)
有后台守护线程做线程池的清理工作(实现连接数量的优化,并控制连接池的总数)
第一节课:B/S四层结构的介绍,引入对数据库的分析,为什么要用到JDBC。
表现层:结果展示,数据录入,触发请求
控制层:接收请求,下发数据
业务逻辑:组织业务逻辑,分配任务
数据持久:数据操作
一般数据库的文件只要数据库厂商才知道怎么去操作的,因此开发了数据库服务器,并提供了数据库客户端,用户只需在客户端上操作就直接能操作底层的数据了。但是这一个客户端每个公司的不同,造成了应用的困难,因此需要用一个统一的规范,这就是JDBC的出现。
JDBC规范
所谓规范实际上一套套的接口规定
JDBC只是定义了一套操作数据库的接口,不同数据库公司按照这个接口规范实现了相应的类,因此对于客户来说只要学习JDBC的规范就可以操作不同的数据库了,不同数据库公司实现的JDBC的接口的类库称为该数据库的驱动。
JDBC使用流程
获取数据库连接(一次一般只能连接一个库,对orcale来说只要服务的概念,也就是一个库)
服务器IP,端口(MySQL为3306)
协议(jdbc:mysql)
库或服务名称
执行SQL语句
如果执行的是查询的话,要接收查询结果
断开与数据库的连接
Class.forName(“com.mysql.jdbc.Driver”) //动态引入数据库驱动类 ,而不是直接静态的采用import方法,以此提高程序的可维护性,因为这个名字可以通过xml配置文件读入而得到。
JDBC详细应用
类介绍:
DriverManager 其中的getConnection方法可以得到一个Connection 变量
Connection 其中的createStatement()方法可以得到一个Statement变量
Statement 其中的executeUpdate()可以执行一条SQL语句,该返回值表示影响到了几条记录。executeQuery()进行查询,返回一个ResultSet对象
ResultSet: 其对象一定要关闭,当执行查询完成后,rs指向标题,故在使用时首先要用next方法,移到下一条,并可以通过返回值判断是否结束。之后就可以通过各个get方法得到不同字段的值了。
在引用这些类时,建议使用java.jdbc下面的接口,以提高程序的可移植性,如果用了某个具体数据库的实现类程序可以实现同样的效果但是可移植性不好,要换数据库时需要改动大量的源码!
//这里引用的都是sql的接口类,而不是用mySQL的实现类,主要是为了提高本程序的可移植性,用到了多态!
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JdbcDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Connection conn = null;
Statement stat = null;
ResultSet set = null;
try {
//通过反射机制动态的引入应用的数据库的驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
//先初始化连接参数mysql:jdbc为协议
String url = "jdbc:mysql://127.0.0.1:3306/storagemis";
//所连接的数据库的用户名和密码
String userName = "root";
String passWord = "";
conn = DriverManager.getConnection(url,userName,passWord);
//System.out.println(CreateID.createID());
//利用SQL语句进行数据库操作
//数据插入操作
String sqlStatement = "INSERT INTO storagemis.goods VALUES ('House',"+CreateID.createID()+",560000)";
//上面的sql语句拼接容易出错,因此可以考虑采用其他的方式。下面改进
//创建表
//String sqlStatement = "create table storagemis.test ( ID varchar(5))";
//得到一个jdbc执行语句
stat = conn.createStatement();
//执行该语句
int result = stat.executeUpdate(sqlStatement);
System.out.println("The operation affect "+result+"record");
//数据库查询操作实例
String sqlQuery = "SELECT * FROM storagemis.goods";
//执行查询操作以后返回一个ResultSet的对象
set = stat.executeQuery(sqlQuery);
//遍历查询结果
while(true){
//在最初执行查询后,指针指向标题,为了能够获取数据,一开始应该移动
//指针到第一条记录,其返回结果用来判断是否结束
boolean resultQuery = set.next();
if(resultQuery == false){
break;
}
//通过set的不同方法的表中的值
int ID = set.getInt(2);
//可以通过字段名得到
String goodsName = set.getString("goodsname");
//可以通过字段的编号得到,注意编号从0开始
int goodsPrice = set.getInt(3);
System.out.println("ID:"+ID+"-goodsName is :"+goodsName+" - goodsPrice is: "+goodsPrice);
}
//以下实例是带参数的SQL查询
String sqlParm = "update storagemis.goods set goodsname ='telphone' where goodsID = ?;";
// 通过connection的prepareStatement()方法建立一个PreparedStatement类(这是statement的子类)的对象,这表示预备sql
PreparedStatement pstatement = conn.prepareStatement(sqlParm);
//进行参数传递,下面的语句表示为预备参数的第一个?传递一个“1”参数
//这里用的setlong,如果是传递的字符串的话,就用setString()
pstatement.setLong(1,2);
//执行sql语句,但是千万注意不要再带参数,否则将出现执行错误,因为sal语句中有?,而不带参数的
//的execute则表示对PreparedStatement的对象执行。
pstatement.execute();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//注意一定要关闭ResultSet
try {
set.close();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//关闭数据库连接
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
JDBC 带参数的SQL JDBC元数据
元数据 Meta Data
本身固有的特性称为元数据
元数据的分类:
数据库的元数据:数据库的名称,版本
查询结果的元数据:字段
通过DatabasedMetaData类的方法得到数据库的元数据,该类的变量有connection.getMetaData( )方法
通过ResultSet类的getMtaData()方法得到一个ResultSetMetaData类的实例,再功过该实例的不同方法得到查询结果的元数据。
练习:双击运行,让用户输入有关数据库的信息,数据库驱动,用户名,密码,数据库。对于查询结果能够以表格的方式表现。 并进行程序的实施!
GetMetaDate.java
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.Statement;
public class GetMetaDate {
/**
*
* 本实例主要是为了演示获的元数据
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
//建立链接
String databaseDriver = "com.mysql.jdbc.Driver";
//利用反射机制动态加载驱动
Class.forName(databaseDriver);
String url = "jdbc:mysql://127.0.0.1:3306/storagemis";
String userName ="root";
String passWord = "";
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
ResultSetMetaData rsMetaData = null;
//建立链接
try{
conn = DriverManager.getConnection(url,userName,passWord);
//建立好连接后就可以获得有关数据库本身的元数据信息
DatabaseMetaData dbmd = conn.getMetaData();
//从而可以根据DatabaseMetaDate得到关于数据库的各元个信息
String DatabaseProductName = dbmd.getDatabaseProductName();
String DatabaseProductVersion = dbmd.getDatabaseProductVersion();
String DriverName = dbmd.getDriverName();
System.out.println("DatabaseProductName is :"+DatabaseProductName);
System.out.println("DatabaseProductVersion is :"+DatabaseProductVersion);
System.out.println("DriverName is :"+DriverName);
//建立语句,获得查询结果的个数据元信息
String sql = "SELECT * FROM storagemis.goods";
//利用connection得打一个statement
stat = conn.createStatement();
rs = stat.executeQuery(sql);
//获得查询结果的元数据,比如行数,列数,字段名
rsMetaData = rs.getMetaData();
//再通过rsMetaData得到具体的元数据
//得到该结果集中的列数
int columnCount= rsMetaData.getColumnCount();
//在通过该列数得到每一列的名字和大小
for(int i = 1; i <= columnCount ; i ++){
String columnName = rsMetaData.getColumnName(i);
int columnSize = rsMetaData.getColumnDisplaySize(i);
System.out.println("the size of column "+ columnName+ "is "+ columnSize);
}
}catch(Exception e){
e.printStackTrace();
}finally{
//关闭各个连接
try{
conn.close();
rs.close();
}catch(Exception e){
e.printStackTrace();
}
}
}
}
DBAnywhere源码:
Main.java
package anyfo.databaseanywhere.src;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.w3c.dom.Element;
import anyfo.databaseanywhere.util.Channel;
import anyfo.databaseanywhere.util.Param;
import anyfo.databaseanywhere.util.XMLUtil;
public class Main {
private int [] lengthOfField = null;
private List<String []> contentList = new ArrayList<String[]>();
/**
* 解析配置文件,得到数据库链接所需要的参数
* @param filePath
* @return
* @throws Exception
* @author
*/
public Param parseConfig(String filePath) throws Exception{
//根据配置文件路径得到一棵DOM树的根节点
Element root = (Element)XMLUtil.getDOMTree(filePath);
//利用该根节点得到各个子节点的值
String databaseDriver = XMLUtil.getTextValueOfElement(root, "databaseDriver");
String url = XMLUtil.getTextValueOfElement(root, "url");
String userName = XMLUtil.getTextValueOfElement(root, "userName");
String passWord = XMLUtil.getTextValueOfElement(root, "passWord");
Param param = new Param();
param.setDatabaseDriver(databaseDriver);
param.setPassWord(passWord);
param.setUrl(url);
param.setUserName(userName);
return param;
}
/**
* 实现对数据库的链接的建立
* @param param
* @return
* @throws Exception
* @author
*/
public Connection connectDatabase(Param param) throws Exception{
Connection conn = null;
//利用反射机制动态加载数据库的驱动程序
Class.forName(param.getDatabaseDriver());
System.out.println("数据库库正在链接中,请稍等......");
//建立链接
conn = DriverManager.getConnection(param.getUrl(),param.getUserName(), param.getPassWord());
//建立好连接后就可以获得有关数据库本身的元数据信息
System.out.println("您已成功链接到数据库");
DatabaseMetaData dbmd = conn.getMetaData();
//从而可以根据DatabaseMetaDate得到关于数据库的各元个信息
String DatabaseProductName = dbmd.getDatabaseProductName();
String DatabaseProductVersion = dbmd.getDatabaseProductVersion();
String DriverName = dbmd.getDriverName();
System.out.println("您使用的数据库库信息如下:");
//打印所链接的数据库的相关信息
System.out.println("DatabaseProductName is :"+DatabaseProductName);
System.out.println("DatabaseProductVersion is :"+DatabaseProductVersion);
System.out.println("DriverName is :"+DriverName);
return conn;
}
/**
* 实现对更新类操作的处理
* @param conn
* @param cmd
* @throws Exception
* @author
*/
public void update(Connection conn,String cmd)throws Exception {
Statement stat = null;
try{
stat = conn.createStatement();
int result = stat.executeUpdate(cmd);
System.out.println("您的操作已经成功,并且影响到了 "+result+"记录");
}catch(SQLException s){
//打印出失败信息!
System.out.println("您的操作失败"+s.getMessage());
}finally{
stat.close();
}
}
/**
* 数据扫描功能,实现对数据库的内容本地保存
* @param conn 链接
* @param cmd 命令
* @throws Exception
* @author
*/
public void scan(Connection conn,String cmd) throws Exception{
Statement stat = null;
ResultSet rs = null;
ResultSetMetaData rsMetaData = null;
//得到一个jdbc执行语句
stat = conn.createStatement();
//获得查询结果集
rs = stat.executeQuery(cmd);
//获得查询结果的元数据,比如行数,列数,字段名
rsMetaData = rs.getMetaData();
//再通过rsMetaData得到具体的元数据
//得到该结果集中的列数
int columnCount= rsMetaData.getColumnCount();
//创建数组
this.lengthOfField = new int[columnCount];
String [] contentArray = new String[columnCount];
//初始化该长度数组,用各表的字段名字的长度作为初始值,同时把各字段值保留到字符数组中
for(int i = 1 ; i <= columnCount ; i++){
String contentValue = rsMetaData.getColumnName(i);
int size = contentValue.length();
this.lengthOfField[i -1 ] = size;
contentArray[i -1 ] = contentValue;
}
this.contentList.add(contentArray);
//更新长度数组,把具体值中较大的长度放入到长度数组中,并同时把值保留到列表中。
//遍历查询结果
while(true){
//在最初执行查询后,指针指向标题,为了能够获取数据,一开始应该移动
//指针到第一条记录,其返回结果用来判断是否结束
boolean resultQuery = rs.next();
if(resultQuery == false){
break;
}
String [] dataArray = new String[columnCount];
for(int i = 1 ; i <= columnCount ; i++){
String contentValue = rs.getString(i);
int size = contentValue.length();
int max = Math.max( size, this.lengthOfField[ i - 1 ] );
this.lengthOfField[ i - 1 ] = max;
dataArray[i -1 ] = contentValue;
}
this.contentList.add(dataArray);
}
}
/**
* 主要实现格式化显示数据的功能
* @author
*/
public void displayData( ){
int columnCount = this.lengthOfField.length;
for(String [] content:this.contentList){
//该循环打印表头的横线
for(int i = 0 ; i < columnCount ; i ++){
//columnCount决定打印多少个表格框
System.out.print("|");
for(int j = 0 ; j < this.lengthOfField[i];j++){
//这层循环决定打印每个框中的东西
System.out.print("-");
}
}
System.out.print("|\n");
//目前状态已经换行,可以开始打印数据库的内容,需要从contentList取出一个数组来进行打印
int index = 0;
for ( String columnValue: content ) {
System.out.print( "|" );
System.out.print( columnValue );
int size = this.lengthOfField[ index ];
for ( int i = 0 ; i < size - columnValue.length() ; i ++ ) {
//打印剩余的空格
System.out.print( " " );
}
index ++;
}
System.out.print( "|\n" );
}
//打印表尾的横线
for(int i = 0 ; i < columnCount ; i ++){
//columnCount决定打印多少个表格框
System.out.print("|");
for(int j = 0 ; j < this.lengthOfField[i];j++){
//这层循环决定打印每个框中的横线
System.out.print("-");
}
}
System.out.print("|\n");
}
/**
* 查询处理函数,主要完成逻辑流程管理,即:扫描数据库、格式化显示数据
* @param conn
* @param cmd
* @throws Exception
* @author
*/
public void queryPrcocess(Connection conn,String cmd)throws Exception {
//查询操作处理的关键是打印表格
//为了实现这个目的先把所有的数据保存下来,这是一个非常好的思路,把数据库的东西保留到内存中去
//以后处理的时候只需要从内存中读取数据就可以了
//扫描数据,并保留数据,其格式是长度数组保留没列中最大的长度,而内容列表中保留一条记录(其中记录
//用String数组保存
//扫描查询结果,并保留到类的成员变量
this.scan(conn,cmd);
//下面的代码开始按格式显示数据
this.displayData();
//一次查询完成后要清空list中的数据;
this.contentList.clear();
}
/**
* DBanywher的启动方法,主要是实现对输入命令的判断,从而选择不同的执行方法
* @param param
* @throws Exception
* @author
*/
public void start(Param param) throws Exception{
//根据各个参数建立链接,并返回链接建立链接
Connection conn = null;
Channel chan = null;
try{
conn = this.connectDatabase(param);
//等待用户读入数据并进行处理
chan = Channel.getChannel();
//一直等待用户的输入
while(true){
System.out.println("请输入你要对该数据库表进行操作的指令(Exit退出)");
String cmd = chan.readData();
//判断用户是否输入exit以便退出,故要求进行判断,为此先把它转换为小写
cmd.toLowerCase();
if(cmd.equals("exit")==true){
break;
//表示退出系统,否则进行下面的处理
}
//下面要根据输入的命令类型进行不同处理,主要是分为两类,查询和更新操作(包括修改,删除,增加)
//为此要对命令进行区分,可以判断命令的前几个字符来判断
if(cmd.startsWith("select")){
//表示进行查询操作
this.queryPrcocess(conn, cmd);
}else{
//表示进行更新操作
this.update(conn, cmd);
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
chan.closeChannel();
conn.close();
}
}
/**
* 主函数,启动程序
* @param args
* @throws Exception
*
*/
public static void main(String[] args)throws Exception {
// TODO Auto-generated method stub
// 读取配置文件,保存各个参数
Main m = new Main();
//运行此带参数的程序需要选用open run dialog,并输入参数
Param param = m.parseConfig(args[0]);
//开始进行处理
m.start(param);
}
}
Channel.java
package anyfo.databaseanywhere.util;
/**
* 本类主要是实现对数据从显示器上读取的管道的建立
*
*/
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Channel {
private InputStream is;
private InputStreamReader isr;
private BufferedReader br;
//做成一个单利模式
private static Channel chan;
//为实现单例,其构造函数必须是私有的
/**
* 私有化构造器,以实现单例模式
* @author
*/
private Channel(){
this.buildChannel();
}
/**
* 由于构造函数是私有的,因此需要为客户提供一个构建该实例的方法
* @return
* @author
*/
public static Channel getChannel(){
if(Channel.chan == null){
Channel.chan = new Channel();
}
return Channel.chan;
}
/**
* 建立管道,不过这是一个私有方法
* @author
*/
private void buildChannel(){
is = System.in;
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
}
/**
* 关闭管道
* @throws Exception
* @author
*/
public void closeChannel() throws Exception{
is.close();
isr.close();
br.close();
}
/**
* 读数据,这是一个柱塞是方法
* @return
* @throws Exception
* @author
*/
public String readData() throws Exception{
//这里的readLine方法是一个柱塞是方法,一直等到独到数据为止
String msg = br.readLine();
return msg;
}
}
Param.java
package anyfo.databaseanywhere.util;
/**
* 本类主要是封装了数据库链接需要的数据
* @author
*
*/
public class Param {
private String databaseDriver;
private String url;
private String userName;
private String passWord;
public String getDatabaseDriver() {
return databaseDriver;
}
public void setDatabaseDriver(String databaseDriver) {
this.databaseDriver = databaseDriver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
}
XMLUtil.java
package anyfo.databaseanywhere.util;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
/**
* 本类主要实现对xml文件的解析
* @author hp
*
*/
public class XMLUtil {
/**
* 根据制定的配置文件xml构建一棵DOM数,并返回改树的根节点
* @param filePath
* @return
* @throws Exception
* @author
*/
public static Element getDOMTree(String filePath)throws Exception {
//取得DOM树
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(filePath);
Element root = doc.getDocumentElement();
return root;
}
/**
* 取得已知节点某属性的值
* @param Element
* @param String
* @return
* @author
*/
public static String getAttributeOfElement(Element e,String type){
return e.getAttribute(type);
}
/**
* 本方法只适用于每个标记中只有一个相同类型的子标记的情况,直接读取其文本值
* @param parent 父标记
* @param childType 子标记值
* @return
* @author
*/
public static String getTextValueOfElement(Element parent,String childType){
NodeList childList = parent.getElementsByTagName(childType);
Element curElement = (Element) childList.item(0);
String childValue ;
//这里主要进行处理,保证能够独到数据,如果读不到数据,则赋值为空
try{
childValue = curElement.getFirstChild().getNodeValue().toString();
}catch(NullPointerException n){
childValue = "";
}
return childValue;
}
}
JDBC事务 Blob Clob
一系列操作的集合称为事务(transaction);
事务的特性
原子性
一致性
隔离性
持续性
事务的分类:嵌套事务,平面事务(事务是平行的)
事务的操作(利用Connection的方法):
事务开启Conn.setAutoCommit(fasle).这里是设了一个标志
事务提交:把临时数据区的数据移送到硬盘中 conn.commit( )
回滚事务:清空临时数据区的数据,即把这次操作取消conn.rollback( );
对于JDBC默认是自动提交事务,要想自己控制事务必须把这个改为手动控制事务的方式。Conn.setAutoCommit(fasle).
对JDBC第一次启动增删改的操作的事务开始启动事务,一直到commit为止,一个事务可以包括多个增删改操作。当执行commit后表示事务结束了,然后可以进行第二个事务,这也说明了JDBC是支持平面事务的,而不是嵌套事务。
Transaction.java
package TransactionDemo;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Transaction {
public static void main(String[] args) {
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn= DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//设定数据库的事务操作为手动模式,JDBC默认为自动模式
conn.setAutoCommit(false);
//开始执行操作,本例子演示的是一个银行转账的功能,为了
//保证钱的安全性,必须要求在这过程中不发生异常,如果发生,则必须
//取消之前的所有增删改操作
//先查询待转账帐户的余额情况
String sqlCmd = "SELECT * FROM zheng.account WHERE name = 'zheng'";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//由于知道满足条件的记录只有一条,因此不用在遍历直接可以去数据
boolean result = rs.next();
//下面的异常是一种主动的程序退出的方法
if (result == false){
throw new Exception("您要转账的帐户不存在!");
}
//如果帐户正常则开始进行处理
//得到当前帐户的余额
int balance = rs.getInt("balance");
balance -= 10000 ;
if(balance<=0){
throw new Exception("您要转账的帐户余额不够!");
}
sqlCmd = "UPDATE account SET balance = "+balance+ " WHERE name = 'zheng'";
stat.executeUpdate(sqlCmd);
//先查询接收帐户的余额情况
sqlCmd = "SELECT * FROM zheng.account WHERE name = 'zhu'";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//由于知道满足条件的记录只有一条,因此不用在遍历直接可以去数据
result = rs.next();
//下面的异常是一种主动的程序退出的方法
if (result == false){
throw new Exception("您要存款的帐户不存在!");
}
//如果帐户正常则开始进行处理
//得到当前帐户的余额
balance = rs.getInt("balance");
balance += 10000 ;
sqlCmd = "UPDATE account SET balance = "+balance+ " WHERE name = 'zhu'";
stat.executeUpdate(sqlCmd);
//如果正常的话则提交事务
conn.commit();
//下面可以写其他的事务了。。。。。
} catch (Exception e) {
// TODO Auto-generated catch block
try {
//如果发生异常的话,则回滚事务,取消之前执行的增删改操作
conn.rollback();
} catch (SQLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
e.printStackTrace();
}
}
}
Blob(二进制) Clob(文本文件)(orcale)(在mysql里面叫text类型)大容量数据存取
(图片,压缩文件(二进制),等等)
微软的word是十进制和二进制的结合,而pdf是二进制
这个可以作为文件上传下载工具,目前解决了(硬盘<—> 数据库)上传下载
由于数据是比较大的,不可能一次传完,因此这里利用了输入输出流的概念,由系统自动传送
执行操作逻辑是:
上传:
采用带参数的sql语句
将要上传的文件绑定到一个输出流
用preparedStatement的set某方法(区分文本和二进制)设定这个参数,而这个参数要绑定到上面的建立的输出流
执行excuteupdate()
BlobDemo.java
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class BlobDemo {
//把硬盘上的一个文件上传到数据库中
public static void main(String[] args) {
Connection conn = null;
PreparedStatement pstat = null;
FileInputStream fis = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//开始上传文件,使用带参数的sql语句
String sqlCmd = "Update zheng.account Set pic = ? Where name = 'zheng' ";
pstat = conn.prepareStatement(sqlCmd);
//因为文件比较大,因此需要用输入流来进行操作,为此先建立一个输出流
File file = new File(".\\BloBCLoBDemo\\t.jpg");
//通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。
fis = new FileInputStream(file);
//设定sql语句中的参数
//但是这里了要注意下面的这个方法的,第一setBinaryStream表示对于的是二进制数据
//第二:其中的第一个参数表示是参数index,第二个参数是输入流,第三个数是要传入的长度
//但是这个长度一定是int类型的,其他类型的目前不支持;
pstat.setBinaryStream(1, fis, (int)file.length());
//开始上传
pstat.executeUpdate();
//
System.out.println("您已经成功上传到数据库!");
}catch(Exception e){
e.getMessage();
}finally{
try {
fis.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
下载
里面conn的执行查询后得到一个resultset对象,
利用该对象的get某方法(区分文本和二进制)可以得到一个输出流
建立一个面向硬盘文件的输入流
实现则两个输入流和输出流之间的数据处理
BlobDownDemo.java
import java.io.FileOutputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class BlobDownDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Connection conn = null;
Statement stat = null;
ResultSet rs = null;
InputStream is = null;
FileOutputStream fos = null;
try {
//动态加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//建立连接
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/zheng","root","");
System.out.println("您已经成功连接数据库!");
//开始下载数据
//为此先要查询数据
String sqlCmd = "Select pic from zheng.account where name = 'zheng' ";
stat = conn.createStatement();
rs = stat.executeQuery(sqlCmd);
//将数据库中读取到的结果以输出流的形式输出
boolean result = rs.next();
if (result == false){
throw new Exception("不存在数据");
}
is = rs.getBinaryStream(1);
//建立要输出的文件,
//文件输出流FileOutputStream是用于将数据写入 File 或 FileDescriptor 的输出流。
fos = new FileOutputStream("./zheng.jpg");
//在两个流之间进行数据交换
byte [] buffer = new byte[1024];
while(true){
//读数据
int length = is.read(buffer);
if(length == -1){
break;
}
//写数据
fos.write(buffer, 0, length);
}
System.out.println("数据已经成功下载!");
}catch(Exception e){
e.printStackTrace();
}finally{
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
连接池
功能
1加快程序获取连接的速度
2 控制连接总数
3 连接的循环使用机制
4 获取连接的等待机制
5 连接数量的优化
编写逻辑:
要用创建连接池的方法(要用预建立一定数量连接的实例,以加快程序获得连接的速度,差异比较大)
要用判断能否创建的方法
要用归还的方法(用户能自己归还,也能直接close,实际也是归还)
能够适用多个不同的数据库(用配置文件读入,并加一个外壳)
保证线程安全(使用sychronized)
能够避免用户误操作(自己定义一个实现conntion的子类,用户实际上是获得该子类)
有后台守护线程做线程池的清理工作(实现连接数量的优化,并控制连接池的总数)
发表评论
-
Cookie跨域 cas
2011-10-27 17:30 1732正常的cookie只能在一个应用中共享,即一个cookie只能 ... -
JQuery中$.ajax()方法参数详解
2011-05-25 13:05 1664url: 要求为String类型的参数,(默认为当前页地址)发 ... -
jquery刷新页面
2011-04-27 23:51 969jquery刷新页面 局部刷新: 这个方法就多了去了,常见 ... -
spring MVC
2011-04-27 23:50 1526需要的JAR包有: spring2.jar cglib-nod ... -
Java hascode
2011-04-10 17:47 833java hascode Java中有两类集合(Colle ... -
spring原理
2011-04-10 00:03 8351、spring原理 s ... -
hibernate的缓存
2011-03-31 14:34 861缓存是介于应用程序和� ... -
Spring AOP之Hello World
2011-03-30 11:36 1017我们使用一个简单的例子来演示一下Spring中的AOP,这是一 ... -
数字推理题规律汇总
2011-03-29 16:48 1053□ 等差数列及其变式 【例题1】2,5,8,() A ... -
freemarker的模板标签获取
2011-03-28 13:23 1751In FreeMarker 2.2, Template has ... -
StringUtils函数全集
2011-01-13 16:45 1308StringUtils函数全集 Strin ... -
jquery+json+servlet
2011-01-11 13:54 5357jquery+json小例子 使用jquery发送请求到s ... -
java - 删除文件
2010-12-30 13:32 1121java删除文件 package IO.file; impo ... -
jquery 赋值函数
2010-12-28 11:14 892$("")是一个jquery对象,而不是一 ... -
jQuery的鼠标事件
2010-12-28 11:13 1952鼠标事件是在用户移动鼠标光标或者使用任意鼠标键点击时触发的。 ... -
获取鼠标在图片对象上的位置
2010-12-27 21:40 1206<!DOCTYPE HTML PUBLIC " ... -
window.opener 与 window.parent 的区别
2010-11-21 22:57 1036我们如果要用到iframe的值传到另一框架就要用到 windo ... -
几个常用代码在IE8和火狐下的对比
2010-11-19 14:44 9831、Input 有的浏览� ... -
window.open()运用
2010-11-18 17:24 1045window.open()支持环境: JavaScript1. ... -
java 环境变量
2010-05-06 10:34 2514电脑属性高级 > 环境变量 > 系统变量 > ...
相关推荐
《深入理解JDBC Driver 3.0:聚焦SQL Server JDBC》 在IT行业中,数据库连接是应用程序与数据存储之间的桥梁,而JDBC(Java Database Connectivity)则是Java平台中用于访问数据库的标准API。JDBC Driver 3.0是针对...
SQL Server驱动包是用于Java应用程序通过JDBC(Java Database Connectivity)接口与Microsoft SQL Server数据库进行交互的必备组件。本文将详细介绍这两个重要的驱动文件——sqljdbc.jar和sqljdbc4.jar,以及如何...
SQLJDBC和SQLJDBC4是Microsoft为Java应用程序提供的用于连接SQL Server数据库的驱动程序。这两个版本都是JDBC(Java Database Connectivity)驱动,允许Java开发者在应用程序中与SQL Server进行交互。下面将详细介绍...
Spring Data JDBC与JDBC是两种不同的数据库访问方式,它们在Java开发中有着广泛的应用。JDBC(Java Database Connectivity)是Java平台的标准API,用于与各种数据库进行交互。它提供了低级别的数据库操作,如建立...
mysql jdbc 驱动 适用于5.6版本及以下数据库 mysql jdbc 驱动 适用于5.6版本及以下数据库 mysql jdbc 驱动 适用于5.6版本及以下数据库 mysql jdbc 驱动 适用于5.6版本及以下数据库 mysql jdbc 驱动 适用于5.6版本及...
mysql jdbc 驱动 适用于5.7及以上版本数据库 mysql jdbc 驱动 适用于5.7及以上版本数据库 mysql jdbc 驱动 适用于5.7及以上版本数据库 mysql jdbc 驱动 适用于5.7及以上版本数据库 mysql jdbc 驱动 适用于5.7及以上...
在Java编程语言中,JDBC(Java Database Connectivity)是一个核心的API,用于连接Java应用程序与各种类型的数据库。这里我们关注的是两个特定版本的Microsoft SQL Server的JDBC驱动:sqljdbc41.jar和sqljdbc42.jar...
sqljdbc.jar 类库提供对 JDBC 3.0 的支持。 sqljdbc.jar 类库要求使用 5.0 版的 Java 运行时环境 (JRE)。连接到数据库时,在 JRE 6.0 上使用 sqljdbc.jar 会引发异常。 注意: JDBC Driver 2.0 不支持 JRE 1.4。...
在给定的压缩包文件中,包含了三个不同版本的达梦JDBC驱动,分别是Dm7JdbcDriver16.jar、Dm7JdbcDriver17.jar和Dm7JdbcDriver18.jar。 1. **JDBC驱动介绍**: JDBC是Java中用于与各种数据库进行交互的标准接口,它...
SQL Server 2000 JDBC 是Java编程语言与Microsoft SQL Server 2000数据库进行交互的一种重要方式。JDBC(Java Database Connectivity)是Java API,允许Java应用程序通过Java虚拟机(JVM)与各种数据库建立连接。在...
标题 "Access_JDBC30" 暗示了这是一个与Microsoft Access数据库相关的Java JDBC驱动程序。JDBC(Java Database Connectivity)是Java编程语言中用于连接和操作数据库的标准接口。这个jar包,"Access_JDBC30.jar",...
KingbaseV8 JDBC驱动是连接KingbaseV8数据库的重要组件,允许Java应用程序通过JDBC(Java Database Connectivity)接口与数据库进行交互。JDBC是Java语言中用来规范客户端程序如何访问数据库的应用程序接口,提供了...
在IT行业中,数据库是至关重要的组成部分,而SQL Server作为一款广泛应用的关系型数据库管理系统,它的连接与操作离不开JDBC(Java Database Connectivity)驱动。本篇将详细介绍如何下载和安装sqljdbc4,这是...
Access的JDBC驱动是Java数据库连接(Java Database Connectivity, JDBC)的一种实现,它允许Java程序与Microsoft Access数据库进行交互。在JDK 1.8之后,Oracle公司不再默认提供对ODBC(Open Database Connectivity...
Java JDBC(Java Database Connectivity)是Java编程语言中用于与各种数据库进行交互的一组接口和类。它提供了一种标准化的方法,让程序员可以使用SQL语句访问数据库,而无需关心具体的数据库实现细节。在Java应用...
标题中的"sqljdbc4.jar, sqljdbc41.jar, sqljdbc42.jar"是指Microsoft SQL Server为Java应用程序提供的Java Database Connectivity (JDBC)驱动程序。这些JAR文件是数据库连接的关键,允许Java代码与SQL Server进行...
标题中的"sqljdbc42.jar、sqljdbc41.jar 更新日期2017-12-21"指的是Microsoft SQL Server的Java Database Connectivity (JDBC) 驱动的两个不同版本,它们分别对应于Java SE 7和Java SE 8的兼容性。JDBC驱动是Java...
`sqljdbc`是Microsoft提供的一个驱动程序,使得Java应用程序能够与SQL Server数据库进行交互。在这个场景中,我们关注的是`sqljdbc 3.0`和`4.0`版本,这两个版本都是专门为Java设计的,用于连接SQL Server 2000。 `...