1.JDBC（Java DataBase Connectivity）就是Java数据库连接，说白了就是用Java语言来操作数据库。
2.JDBC原理
最终得出的结论是，由SUN提供一套访问数据库的规范（就是一组接口），并提供连接数据库的协议标准，然后各个数据库厂商会遵循SUN的规范提供一套访问自己公司的数据库服务器的API出现。SUN提供的规范命名为JDBC，而各个厂商提供的，遵循了JDBC规范的，可以访问自己数据库的API被称之为驱动！
3.JDBC核心类（接口）介绍
JDBC中的核心类有：DriverManager、Connection、Statement，和ResultSet
DriverManager（驱动管理器）的作用有两个：
注册驱动：这可以让JDBC知道要使用的是哪个驱动；
获取Connection：如果可以获取到Connection，那么说明已经与数据库连接上了。
Connection对象表示连接，与数据库的通讯都是通过这个对象展开的：
Connection最为重要的一个方法就是用来获取Statement对象；
Statement是用来向数据库发送SQL语句的
voidexecuteUpdate(String sql)：执行更新操作（insert、update、delete等）；
ResultSetexecuteQuery(String sql)：执行查询操作，数据库在执行查询后会把查询结果，查询结果就是ResultSet；
ResultSet对象表示查询结果集，只有在执行查询操作后才会有结果集的产生
booleannext()：使“行光标”移动到下一行，并返回移动后的行是否存在
XXXgetXXX(int col)：众多get方法,获取当前行指定列上的值，参数就是列数，列数从1开始，而不是0。
A:导jar包：驱动！
B:加载驱动类：Class.forName(“类名”);
C:给出ur、username、password，其中url背下来！
D:使用DriverManager类来得到Connection对象！
4.1:mysql数据库的驱动jar包:mysql-connector-java-5.1.13-bin.jar
4.2:获取连接
获取连接需要两步:
一是使用DriverManager来注册驱动
:注册驱动:
就只有一句话：Class.forName(“com.mysql.jdbc.Driver”)
原理:源码中静态代码块中会把com.mysql.jdbc.Driver注册到DriverManager
DriverManager.registerDriver(newcom.mysql.jdbc.Driver());
虽然可以注册驱动,属硬编码,依赖jar包,换数据库需要改代码
二是使用DriverManager来获取Connection对象。
:获取连接:
也只有一句代码：DriverManager.getConnection(url,username,password)
username和password为数据库用户名和密码
url:用来找到要连接数据库“网址”
mysql的url：jdbc:mysql://localhost:3306/mydb1
例:
Connectioncon =DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb1”,”root”,”123”);
4.3:获取Statement
Statementstmt = con.createStatement();
Statement是用来向数据库发送要执行的SQL语句的！
4.4 发送SQL增、删、改语句
Stringsql = “insert into user value(’zhangSan’, ’123’)”;
执行更新操作，即执行insert、update、delete,create table、alter table,drop table
intm = stmt.executeUpdate(sql);//m为影响的行数
4.5 发送SQL查询语句
Stringsql = “select * from user”;
ResultSetrs = stmt.executeQuery(sql);
executeQuery()方法返回的是ResultSet，ResultSet封装了查询结果,称之为结果集。
4.6 读取结果集中的数据
rs.next();//光标移动到第一行
rs.getInt(1);//获取第一行第一列的数据
常用方法:
ObjectgetObject(int col)
StringgetString(int col)
intgetInt(int col)
doublegetDouble(int col)
滚动结果集光标方法
voidbeforeFirst()：把光标放到第一行的前面，这也是光标默认的位置；
voidafterLast()：把光标放到最后一行的后面；
booleanfirst()：把光标放到第一行的位置上，返回值表示调控光标是否成功；
booleanlast()：把光标放到最后一行的位置上；
booleanisBeforeFirst()：当前光标位置是否在第一行前面；
booleanisAfterLast()：当前光标位置是否在最后一行的后面；
booleanisFirst()：当前光标位置是否在第一行上；
booleanisLast()：当前光标位置是否在最后一行上；
booleanprevious()：把光标向上挪一行；
booleannext()：把光标向下挪一行；
booleanrelative(int row)：相对位移，当row为正数时，表示向下移动row行，为负数时表示向上移动row行；
booleanabsolute(int row)：绝对位移，把光标移动到指定的行上；
intgetRow()：返回当前光标所有行。
获取结果集元数据
得到元数据：rs.getMetaData()，
返回值为ResultSetMetaData；
获取结果集列数：int getColumnCount()
获取指定列的列名：String getColumnName(intcolIndex)
4.7 关闭资源
与IO流一样,关闭的顺序是先得到的后关闭，后得到的先关闭。
rs.close();
stmt.close();
con.close();
4.8 代码
public class Demo2 {
/*
* 连接数据库，得到Connection就算成功！
* 对数据库做增、删、改
*/
@Test
public void fun1() throws ClassNotFoundException, SQLException {
/*
* 一、得到Connection
* 1. 准备四大参数
* 2. 加载驱动类
* 3. 得到Connection
*/
// 准备四大参数
String driverClassName = "com.mysql.jdbc.Driver";
// jdbc协议的格式！jdbc:工商的名称:子协议（由工商自己来规定）
// 对mysql而言，它的子协议结构：//主机:端口号/数据库名称
String url = "jdbc:mysql://localhost:3306/mydb3";
String username = "root";
String password = "123";
// 加载驱动类
Class.forName(driverClassName);
// 使用DriverManager，以及省下的3个参数，得到Connection
Connection con = DriverManager.getConnection(url, username, password);
/*
* 二、对数据库做增、删、改
* 1. 通过Connection对象创建Statement
* > Statement语句的发送器，它的功能就是向数据库发送sql语句！
* 2. 调用它的int executeUpdate(String sql)，它可以发送DML、DDL
*/
// 1. 通过Connection得到Statement对象
Statement stmt = con.createStatement();
// 2. 使用Statement发送sql语句！
// String sql = "INSERT INTO stu VALUES('ITCAST_0003', 'wangWu', 88, 'male')";
// String sql = "UPDATE stu SET name='zhaoLiu', age=22, " +
// "gender='female' WHERE number='ITCAST_0003'";
String sql = "DELETE FROM stu";
int r = stmt.executeUpdate(sql);
System.out.println(r);
}
/**
* 执行查询
* @throws ClassNotFoundException
* @throws SQLException
*/
@Test
public void fun2() throws ClassNotFoundException, SQLException {
/*
* 一、得到Connection
* 二、得到Statement，发送select语句
* 三、对查询返回的“表格”进行解析！
*/
/*
* 一、得到连接
* 1. 准备四大连接参数
*/
String driverClassName = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/exam";
String username = "root";
String password = "123";
/*
* 2. 加载驱动类
*/
Class.forName(driverClassName);
/*
* 3. 通过省下的三个参数调用DriverManger的getConnection()，得到连接
*/
Connection con = DriverManager.getConnection(url, username, password);
/*
* 二、得到Statement，执行select语句
* 1. 得到Statement对象：Connection的createStatement()方法
*/
Statement stmt = con.createStatement();
/*
* 2. 调用Statement的ResultSet rs = executeQuery(String querySql)
*/
ResultSet rs = stmt.executeQuery("select * from emp");
/*
* 三、解析ResultSet
* 1. 把行光标移动到第一行，可以调用next()方法完成！
*/
while(rs.next()) {//把光标向下移动一行，并判断下一行是否存在！
int empno = rs.getInt(1);//通过列编号来获取该列的值！
String ename = rs.getString("ename");//通过列名称来获取该列的值
double sal = rs.getDouble("sal");
System.out.println(empno + ", " + ename + ", " + sal);
}
/*
* 四、关闭资源
* 倒关
*/
rs.close();
stmt.close();
con.close();//这个东东，必须要关，不关就死！
}4.9规范化代码
// 规范化
@Test
public void fun3() throws Exception {
Connection con = null;//定义引用
Statement stmt = null;
ResultSet rs = null;
try {
/*
* 一、得到连接
*/
String driverClassName = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost:3306/exam";
String username = "root";
String password = "123";
Class.forName(driverClassName);
con = DriverManager.getConnection(url, username, password);//实例化
/*
* 二、创建Statement
*/
stmt = con.createStatement();
String sql = "select * from emp";
rs = stmt.executeQuery(sql);
rs.last();//把光标移动到最后一行
rs.beforeFirst();
/*
* 三、循环遍历rs，打印其中数据
*
* getString()和getObject()是通用的！
*/
// while(rs.next()) {
// System.out.println(rs.getObject(1) + ", "
// + rs.getString("ename") + ", " + rs.getDouble("sal"));
// }
int count = rs.getMetaData().getColumnCount();
while(rs.next()) {//遍历行
for(int i = 1; i <= count; i++) {//遍历列
System.out.print(rs.getString(i));
if(i < count) {
System.out.print(", ");
}
}
System.out.println();
}
} catch(Exception e) {
throw new RuntimeException(e);
} finally {
// 关闭
if(rs != null) rs.close();
if(stmt != null) stmt.close();
if(con != null) con.close();
}
}
}
它是Statement接口的子接口
优点:防SQL攻击,提高代码的可读性、可维护性,提高效率
使用:
给出SQL模板---所谓SQL模板就是有“?”的SQL语句，其中“?”就是参数
使用Connection的prepareStatement(String sql)：即创建它时就让它与一条SQL模板绑定；
调用PreparedStatement的setXXX()系列方法为问号设置值
调用executeUpdate()或executeQuery()方法，但要注意，调用没有参数的方法；
代码
/* * 一、得到PreparedStatement * 1. 给出sql模板：所有的参数使用?来替代 * 2. 调用Connection方法，得到PreparedStatement */ String sql = "select * from t_user where username=? and password=?"; PreparedStatement pstmt = con.prepareStatement(sql); /* * 二、为参数赋值 */ pstmt.setString(1, username);//给第1个问号赋值，值为username pstmt.setString(2, password);//给第2个问号赋值，值为password ResultSet rs = pstmt.executeQuery();//调用查询方法，向数据库发送查询语句 pstmt.setString(1, "liSi"); pstmt.setString(2, "123"); pstmt.executeQuery();
工具代码v1.0
dbconfig.properties
driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mydb1?useUnicode=true&characterEncoding=UTF8 username=root password=123
public class JdbcUtils {
private static Properties props = null;
// 只在JdbcUtils类被加载时执行一次！
static {
// 给props进行初始化，即加载dbconfig.properties文件到props对象中
try {
InputStream in = JdbcUtils.class.getClassLoader()
.getResourceAsStream("dbconfig.properties");//<span style="font-family: Arial, Helvetica, sans-serif; font-size: 12px;">配置文件路径在src目录下</span>
props = new Properties();
props.load(in);
} catch(IOException e) {
throw new RuntimeException(e);
}
// 加载驱动类
try {
Class.forName(props.getProperty("driverClassName"));
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
// 获取连接!
public static Connection getConnection() throws SQLException {
// 得到Connection
return DriverManager.getConnection(props.getProperty("url"),
props.getProperty("username"),
props.getProperty("password"));
}
}DAO（Data Access Object）模式就是写一个类，把访问数据库的代码封装起来。DAO在数据库与业务逻辑（Service）之间。
实体域，即操作的对象，例如我们操作的表是user表，那么就需要先写一个User类；
DAO模式需要先提供一个DAO接口；
然后再提供一个DAO接口的实现类；
再编写一个DAO工厂，Service通过工厂来获取DAO实现。
修改项目：
1.把UserDao修改为接口，然后把原来的UserDao修改类名为UserDaoImpl
2.修改UserService中对UserDao的实例化：private UserDao userDao =DaoFactory.getUserDao()
3.创建DaoFactory，提供getUserDao()
代码
工厂类
/**
* 通过配置文件得到dao实现类的名称！
* 通过类名称，完成创建类对象！（反射完成的！）
* @author cxf
*
*/
public class DaoFactory {
private static Properties props = null;
static {
// 加载配置文件内容到props对象中
try {
InputStream in = DaoFactory.class
.getClassLoader().getResourceAsStream("dao.properties");
props = new Properties();
props.load(in);
} catch(Exception e) {
throw new RuntimeException(e);
}
}
/**
* 返回一个具体UserDao的实现类对象
* @return
*/
public static UserDao getUserDao() {
/**
* 给出一个配置文件，文件中给出UserDao接口的实现类名称！
* 我们这个方法，获取实现类的类名，通过反射完成创建对象！
*/
/*
* 得到dao实现类的名称
*/
String daoClassName = props.getProperty("cn.itcast.usermng.dao.UserDao");
/*
* 通过反射来创建实现类的对象
*/
try {
Class clazz = Class.forName(daoClassName);
return (UserDao)clazz.newInstance();
} catch(Exception e) {
throw new RuntimeException(e);
}
}
}数据库类型与java中类型的对应关系：
DATE → java.sql.Date
TIME → java.sql.Time
TIMESTAMP → java.sql.Timestamp
领域对象（domain）中的所有属性不能出现java.sql包下的东西！即不能使用java.sql.Date；
ResultSet#getDate()返回的是java.sql.Date()
PreparedStatement#setDate(int, Date)，其中第二个参数也是java.sql.Date
时间类型的转换：
java.util.Date java.sql.Date、Time、Timestamp
把util的Date转换成毫秒值
使用毫秒值创建sql的Date、Time、Timestamp
java.sql.Date、Time、Timestamp java.util.Date
这一步不需要处理了：因为java.sql.Date是java.util.Date；
java.util.Datedate = new java.util.Date();
longl = date.getTime();
java.sql.DatesqlDate = new java.sql.Date(l);
java.sql包下给出三个与数据库相关的日期时间类型，分别是：
Date：表示日期，只有年月日，没有时分秒。会丢失时间；
Time：表示时间，只有时分秒，没有年月日。会丢失日期；
Timestamp：表示时间戳，有年月日时分秒，以及毫秒。
这三个类都是java.util.Date的子类。
把数据库的三种时间类型赋给java.util.Date，基本不用转换，因为这是把子类对象给父类的引用，不需要转换。
java.sql.Date date = …
java.util.Date d = date;
java.sql.Time time = …
java.util.Date d = time;
java.sql.Timestamp timestamp = …
java.util.Date d = timestamp;
当需要把java.util.Date转换成数据库的三种时间类型时，这就不能直接赋值了，这需要使用数据库三种时间类型的构造器。java.sql包下的Date、Time、TimeStamp三个类的构造器都需要一个long类型的参数，表示毫秒值。创建这三个类型的对象，只需要有毫秒值即可。我们知道java.util.Date有getTime()方法可以获取毫秒值，那么这个转换也就不是什么问题了。
java.utl.Date d = new java.util.Date();
java.sql.Date date = newjava.sql.Date(d.getTime());//会丢失时分秒
Time time = new Time(d.getTime());//会丢失年月日
Timestamp timestamp = newTimestamp(d.getTime());
1 什么是大数据
所谓大数据，就是大的字节数据，或大的字符数据。标准SQL中提供了如下类型来保存大数据
标准SQL大数据类型
|
类型 |
长度 |
|
tinyblob |
28--1B（256B） |
|
blob |
216-1B（64K） |
|
mediumblob |
224-1B（16M） |
|
longblob |
232-1B（4G） |
|
tinyclob |
28--1B（256B） |
|
clob |
216-1B（64K） |
|
mediumclob |
224-1B（16M） |
|
longclob |
232-1B（4G） |
在mysql中没有提供tinyclob、clob、mediumclob、longclob四种类型
而是使用tinytext,text,mediumtext,longtext
代码
把mp3保存到数据库中！
com.mysql.jdbc.PacketTooBigException: Packet for query is too large (9802817 > 1048576). You can change this value on the server by setting the max_allowed_packet' variable.
在my.ini中设置，在[mysqld]下添加max_allowed_packet=10M，例如：
[mysqld]
max_allowed_packet=64M
/**
* 大数据
* @author cxf
*
*/
public class Demo4 {
/**
* 把mp3保存到数据库中。
* @throws SQLException
* @throws IOException
* @throws FileNotFoundException
*/
@Test
public void fun1() throws Exception {
/*
* 1. 得到Connection
* 2. 给出sql模板，创建pstmt
* 3. 设置sql模板中的参数
* 4. 调用pstmt的executeUpdate()执行
*/
Connection con = JdbcUtils.getConnection();
String sql = "insert into tab_bin values(?,?,?)";
PreparedStatement pstmt = con.prepareStatement(sql);
pstmt.setInt(1, 1);
pstmt.setString(2, "流光飞舞.mp3");
/**
* 需要得到Blob
* 1. 我们有的是文件，目标是Blob
* 2. 先把文件变成byte[]
* 3. 再使用byte[]创建Blob
*/
// 把文件转换成byte[]
byte[] bytes = IOUtils.toByteArray(new FileInputStream("F:/流光飞舞.mp3"));
// 使用byte[]创建Blob
Blob blob = new SerialBlob(bytes);
// 设置参数
pstmt.setBlob(3, blob);
pstmt.executeUpdate();
}
/**
* 从数据库读取mp3
* @throws SQLException
*/
@Test
public void fun2() throws Exception {
/*
* 1. 创建Connection
*/
Connection con = JdbcUtils.getConnection();
/*
* 2. 给出select语句模板，创建pstmt
*/
String sql = "select * from tab_bin";
PreparedStatement pstmt = con.prepareStatement(sql);
/*
* 3. pstmt执行查询，得到ResultSet
*/
ResultSet rs = pstmt.executeQuery();
/*
* 4. 获取rs中名为data的列数据
*/
if(rs.next()) {
Blob blob = rs.getBlob("data");
/*
* 把Blob变成硬盘上的文件！
*/
/*
* 1. 通过Blob得到输入流对象
* 2. 自己创建输出流对象
* 3. 把输入流的数据写入到输出流中
*/
InputStream in = blob.getBinaryStream();
OutputStream out = new FileOutputStream("c:/lgfw.mp3");
IOUtils.copy(in, out);
}
}
}
MySQL的批处理也需要通过参数来打开：rewriteBatchedStatements=true
批处理就是一批一批的处理，而不是一个一个的处理！
当你有10条SQL语句要执行时，一次向服务器发送一条SQL语句，这么做效率上很差！
处理的方案是使用批处理，即一次向服务器发送多条SQL语句，然后由服务器一次性处理。
批处理只针对更新（增、删、改）语句，批处理没有查询什么事儿！
可以多次调用Statement类的addBatch(Stringsql)方法，
把需要执行的所有SQL语句添加到一个“批”中，
然后调用Statement类的executeBatch()方法来执行当前“批”中的语句。
voidaddBatch(String sql)：添加一条语句到“批”中；
int[]executeBatch()：执行“批”中所有语句。返回值表示每条语句所影响的行数据；
voidclearBatch()：清空“批”中的所有语句。
for(int i = 0; i < 10; i++) {
String number = "S_10" + i;
String name = "stu" + i;
int age = 20 + i;
String gender = i % 2 == 0 ? "male" : "female";
String sql = "insert into stu values('" + number + "', '" + name + "', " + age + ", '" + gender + "')";
stmt[内部有个集合，用来装载sql语句].addBatch(sql);
}
stmt.executeBatch[执行批，即一次把批中的所有sql语句发送给服务器]();当执行了“批”之后，“批”中的SQL语句就会被清空！也就是说，连续两次调用executeBatch()相当于调用一次！因为第二次调用时，“批”中已经没有SQL语句了。
还可以在执行“批”之前，调用Statement的clearBatch()方法来清空“批”！
PreparedStatement的批处理有所不同，因为每个PreparedStatement对象都绑定一条SQL模板。
所以向PreparedStatement中添加的不是SQL语句，而是给“?”赋值。
/**
* 批处理
* @author cxf
*
*/
public class Demo5 {
/**
* pstmt对象内部有集合
* 1. 用循环疯狂向pstmt中添加sql参数，它自己有模板，使用一组参数与模板罚没可以匹配出一条sql语句
* 2. 调用它的执行批方法，完成向数据库发送！
* @throws SQLException
*/
@Test
public void fun5() throws SQLException {
/*
* pstmt：
* > 添加参数到批中
* > 执行批！
*/
Connection con = JdbcUtils.getConnection();
String sql = "INSERT INTO t_stu VALUES(?,?,?,?)";
PreparedStatement pstmt = con.prepareStatement(sql);
// 疯狂的添加参数
for(int i = 0; i < 10000; i++) {
pstmt.setInt(1, i+1);
pstmt.setString(2, "stu_" + i);
pstmt.setInt(3, i);
pstmt.setString(4, i%2==0?"男":"女");
pstmt.addBatch();//添加批！这一组参数就保存到集合中了。
}
long start = System.currentTimeMillis();
pstmt.executeBatch();//执行批！
long end = System.currentTimeMillis();
System.out.println(end - start);//412764, 301
}
}
