jdbc 心得

时间类型

数据库类型与java中类型的对应关系：

varchar-->String

char--->String

DATE --》java.sql.Date

TIME--》java.sql.Time

TIMESTAMP --》java.sql.Timestamp

 

l 领域对象（实体对象）（domain）中的所有属性就是，不能出现java.sql包下的东西！即不能使用java.sql.Date；

l ResultSet#getDate()返回的是java.sql.Date()

l PreparedStatement#setDate(int,Date)，其中第二个参数也是java.sql.Date

时间类型的转换：

l java.util.Date à java.sql.Date、Time、Timestamp

Ø 把util的Date转换成毫秒值

Ø 使用毫秒值创建sql的Date、Time、Timestamp

l java.sql.Date、Time、Timestamp à java.util.Date

Ø 这一步不需要处理了：因为java.sql.Date是java.util.Date；

java.util.Datedate = new java.util.Date();

long l =date.getTime();

java.sql.DatesqlDate = new java.sql.Date(l);

 

 

 

 

1　Java中的时间类型

java.sql包下给出三个与数据库相关的日期时间类型，分别是：

l Date：表示日期，只有年月日，没有时分秒。会丢失时间；

l Time：表示时间，只有时分秒，没有年月日。会丢失日期；

l Timestamp：表示时间戳，有年月日时分秒，以及毫秒。

 

这三个类都是java.util.Date的子类。

 

　　

 

2　时间类型相互转换

把数据库的三种时间类型赋给java.util.Date，基本不用转换，因为这是把子类对象给父类的引用，不需要转换。

java.sql.Datedate = …

java.util.Date d= date;

 

java.sql.Timetime = …

java.util.Date d= time;

 

java.sql.Timestamptimestamp = …

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.Datedate = new java.sql.Date(d.getTime());//会丢失时分秒

Time time = newTime(d.getTime());//会丢失年月日

Timestamptimestamp = new Timestamp(d.getTime());

 

3　代码

我们来创建一个dt表：

CREATE TABLE dt(   d DATE,   t TIME,   ts TIMESTAMP )

 

下面是向dt表中插入数据的代码：

@Test     publicvoid fun1() throws SQLException {        Connection con = JdbcUtils.getConnection();        String sql = "insert into dt value(?,?,?)";        PreparedStatement pstmt = con.prepareStatement(sql);               java.util.Date d = new java.util.Date();        pstmt.setDate(1, new java.sql.Date(d.getTime()));        pstmt.setTime(2, new Time(d.getTime()));        pstmt.setTimestamp(3, new Timestamp(d.getTime()));        pstmt.executeUpdate();     }

 

下面是从dt表中查询数据的代码：

@Test     publicvoid fun2() throws SQLException {        Connection con = JdbcUtils.getConnection();        String sql = "select * from dt";        PreparedStatement pstmt = con.prepareStatement(sql);        ResultSet rs = pstmt.executeQuery();               rs.next();        java.util.Date d1 = rs.getDate(1);        java.util.Date d2 = rs.getTime(2);        java.util.Date d3 = rs.getTimestamp(3);               System.out.println(d1);        System.out.println(d2);        System.out.println(d3);     }

 

大数据

目标：把mp3保存到数据库中！

在my.ini中添加如下配置！

max_allowed_packet=10485760

MySQL存储blob数据包太大

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

 

 

1　什么是大数据

所谓大数据，就是大的字节数据，或大的字符数据。标准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	28--1B（256B）
text	216-1B（64K）
mediumtext	224-1B（16M）
longtext	232-1B（4G）

 

首先我们需要创建一张表，表中要有一个mediumblob（16M）类型的字段。

CREATE TABLE tab_bin(        id   INT      PRIMARY KEY AUTO_INCREMENT,        filename    VARCHAR(100),        data     MEDIUMBLOB );

 

　　

/**
	 * 把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("e:/jjf0001.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);
		}
	}
}

 

 

 

 

 

 

 

批处理

 

1　Statement批处理

批处理就是一批一批的处理，而不是一个一个的处理！

当你有10条SQL语句要执行时，一次向服务器发送一条SQL语句，这么做效率上很差！处理的方案是使用批处理，即一次向服务器发送多条SQL语句，然后由服务器一次性处理。

批处理只针对更新（增、删、改）语句，批处理没有查询什么事儿！

 

可以多次调用Statement类的addBatch(Stringsql)方法，把需要执行的所有SQL语句添加到一个“批”中，然后调用Statement类的executeBatch()方法来执行当前“批”中的语句。

l  void addBatch(String sql)：添加一条语句到“批”中；

l  int[] executeBatch()：执行“批”中所有语句。返回值表示每条语句所影响的行数据；

l  void clearBatch()：清空“批”中的所有语句。

 

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[c1] .addBatch(sql);            }            stmt.executeBatch[c2] ();

 

当执行了“批”之后，“批”中的SQL语句就会被清空！也就是说，连续两次调用executeBatch()相当于调用一次！因为第二次调用时，“批”中已经没有SQL语句了。

还可以在执行“批”之前，调用Statement的clearBatch()方法来清空“批”！

 

2　PreparedStatement批处理

PreparedStatement的批处理有所不同，因为每个PreparedStatement对象都绑定一条SQL模板。所以向PreparedStatement中添加的不是SQL语句，而是给“?”赋值。

con = JdbcUtils.getConnection();            String sql = "insert into stu values(?,?,?,?)";            pstmt = con.prepareStatement(sql);            for(int i = 0; i < 10; i++) {               pstmt.setString(1, "S_10" + i);               pstmt.setString(2, "stu" + i);               pstmt.setInt(3, 20 + i);               pstmt.setString(4, i % 2 == 0 ? "male" : "female");               pstmt.addBatch()[崔3] ;            }            pstmt.executeBatch[崔4] ();

事务的四大特性（ACID）
　　面试！
事务的四大特性是：
  原子性（Atomicity）：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部

执行成功，要么全部执行失败。
   一致性 （Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，

无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。
   隔离性（Isolation）：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发

中的事务不会相互干扰。
   持久性（Durability）：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库

中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

JDBC事务
在jdbc中处理事务，都是通过Connection完成的！
同一事务中所有的操作，都在使用同一个Connection对象！

1　JDBC中的事务
Connection的三个方法与事务相关：
 setAutoCommit(boolean)：设置是否为自动提交事务，如果true（默认值就是true）表示自动提交，也就是每条执行的SQL语句都是一个单独的事务，如果设置false，那么就相当于开启了事务了；con.setAutoCommit(false)表示开启事务！！！
 commit()：提交结束事务；con.commit();表示提交事务
  rollback()：回滚结束事务。con.rollback();表示回滚事务

jdbc处理事务的代码格式：
try {
  con.setAutoCommit(false);//开启事务…
  ….
  …
  con.commit();//try的最后提交事务
} catch() {
  con.rollback();//回滚事务
}


    public void transfer(boolean b) {
        Connection con = null;
        PreparedStatement pstmt = null;
        
        try {
            con = JdbcUtils.getConnection();
            //手动提交
            con.setAutoCommit(false);
            
            String sql = "update account set balance=balance+? where id=?";
            pstmt = con.prepareStatement(sql);
            
            //操作
            pstmt.setDouble(1, -10000);
            pstmt.setInt(2, 1);
            pstmt.executeUpdate();
            
            // 在两个操作中抛出异常
            if(b) {
                throw new Exception();
            }
             
            pstmt.setDouble(1, 10000);
            pstmt.setInt(2, 2);
            pstmt.executeUpdate();
            
            //提交事务
            con.commit();
        } catch(Exception e) {
            //回滚事务
            if(con != null) {
                try {
                    con.rollback();
                } catch(SQLException ex) {}
            }
            throw new RuntimeException(e);
        } finally {
            //关闭
            JdbcUtils.close(con, pstmt);
        }
    }

1　并发事务问题
因为并发事务导致的问题大致有5类，其中两类是更新问题，三类是读问题。

例如：我给你转了100，你看了已经转过去了，你确认了，转过去了，这个时候我右回滚了

脏读

事务1：张三给李四转账100元

事务2：李四查看自己的账户

 

t1：事务1：开始事务

t2：事务1：张三给李四转账100元

t3：事务2：开始事务

t4：事务2：李四查看自己的账户，看到账户多出100元（脏读）

t5：事务2：提交事务

t6：事务1：回滚事务，回到转账之前的状态

不可重复读

事务1：酒店查看两次1048号房间状态

事务2：预订1048号房间

 

t1：事务1：开始事务

t2：事务1：查看1048号房间状态为空闲

t3：事务2：开始事务

t4：事务2：预定1048号房间

t5：事务2：提交事务

t6：事务1：再次查看1048号房间状态为使用

t7：事务1：提交事务

对同一记录的两次查询结果不一致！

 

幻读

教导员统计班级人数：第一次统计50人，这个时候有一个人迟到了，才来，统计51人

事务1：对酒店房间预订记录两次统计

事务2：添加一条预订房间记录

 

t1：事务1：开始事务

t2：事务1：统计预订记录100条

t3：事务2：开始事务

t4：事务2：添加一条预订房间记录

t5：事务2：提交事务

t6：事务1：再次统计预订记录为101记录

t7：事务1：提交

　　对同一表的两次查询不一致！

 

不可重复读和幻读的区别：

不可重复读是读取到了另一事务的更新；

幻读是读取到了另一事务的插入（MySQL中无法测试到幻读）；

4个等级的事务隔离级别，在相同数据环境下，使用相同的输入，执行相同的工作，根据不同的隔离级别，可以导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力是不同的。

 1　SERIALIZABLE（串行化）

不会出现任何并发问题，因为它是对同一数据的访问是串行的，非并发访问的；

性能最差；

 

2　REPEATABLE READ（可重复读）（MySQL）

防止脏读和不可重复读，不能处理幻读问题；

性能比SERIALIZABLE好

 

3　READ COMMITTED（读已提交数据）（Oracle）

防止脏读，没有处理不可重复读，也没有处理幻读；

性能比REPEATABLE READ好

4　READ UNCOMMITTED（读未提交数据）

可能出现任何事务并发问题

性能最好

MySQL的默认隔离级别为REPEATABLE READ，这是一个很不错的选择吧！

 

5　MySQL隔离级别

MySQL的默认隔离级别为Repeatable read，可以通过下面语句查看：

select @@tx_isolation

 

也可以通过下面语句来设置当前连接的隔离级别：

set transaction isolationlevel [4先1]

 

6　JDBC设置隔离级别

con.setTransactionIsolation(int level)

参数可选值如下：

Connection.TRANSACTION_READ_UNCOMMITTED；

Connection.TRANSACTION_READ_COMMITTED；

Connection.TRANSACTION_REPEATABLE_READ；

Connection.TRANSACTION_SERIALIZABLE。

 

事务总结：

事务的特性：ACID；

事务开始边界与结束边界：开始边界（con.setAutoCommit(false)），结束边界（con.commit()或con.rollback()）；

事务的隔离级别： READ_UNCOMMITTED、READ_COMMITTED、REPEATABLE_READ、SERIALIZABLE。多个事务并发执行时才需要考虑并发事务。

 

JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由商用服务器等提供实现，也有一些开源组织提供实现（DBCP、C3P0）。
DataSource通常被称为数据源，它包含连接池和连接池管理两个部分，但习惯上也经常把DataSource称为连接池。

DataSource有三种类型的实现：

• 基本实现——生成标准Connection对象
• 连接池实现——生成自动参与连接池的Connection 对象。此实现与中间层连接池管理器一起使用。
• 分布式事务实现——生成一个Connection 对象，该对象可用于分布式事务，并且几乎始终参与连接池。此实现与中间层事务管理器一起使用，并且几乎始终与连接池管理器一起使用。DataSource对象的属性在需要时可以修改。例如，如果将数据源移动到另一个服务器，则可更改与服务器相关的属性。其优点是，因为可以更改数据源的属性，所以任何访问该数据源的代码都无需更改。

在Spring与Hibernate、Mybatis等ORM框架的整合过程中，DataSource扮演着非常重要的角色。

DBCP数据源

开源系统：common-pool。如果需要使用该连接池实现，则应在系统中增加如下两个jar文件。

• commons-dbcp.jar：连接池的实现
• commons-pool.jar：连接池实现的依赖库

Tomcat的连接池正是采用该连接池实现的。数据库连接池既可以与应用服务器整合使用，也可以由应用程序独立使用。

 

 

dbc 连接池

为什么要使用池的概念，就是因为有一些东西创建和销毁是非常麻烦的问题，比如我们办培训班，我们不知道要招多少人招多了，我还要养着他，辞了吧，害怕这个时候来学生了没有老师教他们，所以现在有一个老师批发市场，就是池

这个池当中有一些属性

初始大小：10

最小空闲连接：3个（最小的时候有三个是没人用的连接）

增量：一次还可以增加连接数最少一次增加5个

最大空闲连接数：20个，

最大的等待时间：1000毫秒（就是现在连接都用着，还有人要用连接，他就得等着，但是他不能一直等着，最大的等待时间是1000毫秒）

连接池也是使用四大连接参数来完成创建连接对象的

现在连接池的种类：

1 dbcp 连接池

为什么我一点就可以看到源码，因为我导入的jar包中已经包含了class 文件

 

对象增强的手段

* 继承

 被增强的对象的增强的部分是固定的

 被增强的对象的增强的内容也是固定的

继承：

缺点：

1. 增强的内容是死的，不能动！

2. 被增强的对象也是死的！

使用继承会使类增多！！！

class咖啡类 {}

class有糖咖啡extends 咖啡类 {}

class加奶咖啡extends 咖啡类 {}

class 加盐咖啡 extends 咖啡类 {}

class 加糖加奶 extends 加奶 {}

* 装饰者模式

1. 被增强的对象的增强的内容是不能修改的！

2. 被增强的对象的增强的对象可以是任意的！

class咖啡类 {}

class有糖咖啡extends 咖啡类 {}

class加奶咖啡extends 咖啡类 {}

class加盐咖啡extends 咖啡类 {}

咖啡 a = new 加糖();

咖啡 b = new 加盐(a);//对a进行装饰，就是给a加盐

咖啡 c = new 加奶(b);

装饰者模式

JavaAPI

IO流！

四大家：

1. 字节：InputStream、OutputStream

2. 字符：Reader、Writer

InputStream

FileInputSteram：它是节点流！就是和一个资源绑定在一起的！文件！

BufferedInputStream：它是装饰流！创建我是一定要给我一个底层对象，然后我不管你给我的是什么流，我都会给它添加缓冲区！

 

newBufferedInputStream(任意的InputStream)

 

FileInputStreamin = new FileInputStream("F:/a.jpg");

BufferedInputStreamb = new BufferedInputStream(in);

ObjectInputStreamo = new ObjectInputStream(b);

 

Connectioncon = ...

装饰：不知道被增强对象的具体类型时，可以使用！

1. 是你还有你，一切拜托你！

is a

has a

use a

classMyConnection implements Connection {//是你也可以采用继承的方式
     // 还有你
     private Connection con;//底层对象，被增强对象 
     public MyConnection(Connection con){//通过构造器传递底层对象！
        this.con = con;
     }

     // 一切拜托你
     public Statement createStatement() {
            return con.createStatement();
     }

     // 增强点
     public void close(){
            把当前连接归还给池！
     }
}

 

Connection con = 通过四大参数创建连接对象！是由mysql提供的！

Connectioncon1 = new MyConnection(con);

 

con1.createStatement()

con.createStatement();

 

con1.close();

con.close();

 

* 动态代理（AOP）

 被增强的对象可以切换：Service

增强的内容也可以切换：事务处理

Jdbc连接池

/**

 * DBCP连接池

 * @author cxf

 *

 */

publicclass Demo1 {

         @Test

         publicvoid fun1() throwsSQLException {

                   /*

                    * 1. 创建连接池对象

                    * 2. 配置四大参数

                    * 3. 配置池参数

                    * 4. 得到连接对象

                    */

                   BasicDataSource dataSource = new BasicDataSource();//创建的是数据源对象实际上就是连接池

                   dataSource.setDriverClassName("com.mysql.jdbc.Driver");

                   dataSource.setUrl("jdbc:mysql://localhost:3306/mydb3");

                   dataSource.setUsername("root");

                   dataSource.setPassword("123");

                  

                   dataSource.setMaxActive(20);

                   dataSource.setMaxIdle(20);

                   dataSource.setMinIdle(3);

                   dataSource.setMaxWait(1000);

                  

                   Connection con =dataSource.getConnection();

                   Connection con1 = newMyConnection(con);

                   System.out.println(con1.getClass().getName());

                  

                   /**

                    * 连接池内部使用四大参数创建了连接对象！即mysql驱动提供的Connection

                    * 连接池使用mysql的连接对象进行了装饰，只对close()方法进行了增强！

                    * 装饰之后的Connection的close()方法，用来把当前连接归还给池！

                    */

                   con1.close();//把连接归还给池！

         }

}

 

 

 

数据库连接池

作用：使用池来管理连接的生命周期，节省资源，提高性能。

java提供的连接池接口：javax.sql.DataSource，javax表示的是扩展类，就是在jdk在本版本增加的内容，连接池厂商的连接池类需要实现这一接口。

 

C3P0 连接池

有两种配置方式

1 用代码实现

   /**

    * 代码配置

    * @throwsPropertyVetoException

    * @throwsSQLException

    */

   @Test

   publicvoid fun1() throwsPropertyVetoException, SQLException {

      // 创建连接池对象

      ComboPooledDataSource dataSource = new ComboPooledDataSource();

     

      // 对池进行四大参数的配置

      dataSource.setDriverClass("com.mysql.jdbc.Driver");

      dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mydb3");

      dataSource.setUser("root");

      dataSource.setPassword("123");

     

      // 池配置

      dataSource.setAcquireIncrement(5);

      dataSource.setInitialPoolSize(20);

      dataSource.setMinPoolSize(2);

      dataSource.setMaxPoolSize(50);

     

      Connection con =dataSource.getConnection();

      System.out.println(con);

      con.close();

  }

 

2 用配置方式实现 

 配置文件必须叫这个名字，必须在src下面

配置文件代码：

<?xml version="1.0" encoding="UTF-8"?>

<c3p0-config>

   <!-- 这是默认配置信息 -->

   <default-config>

      <!-- 连接四大参数配置 -->

      <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb3</property>

      <property name="driverClass">com.mysql.jdbc.Driver</property>

      <property name="user">root</property>

      <property name="password">123</property>

      <!-- 池参数配置 -->

      <property name="acquireIncrement">3</property>

      <property name="initialPoolSize">10</property>

      <property name="minPoolSize">2</property>

      <property name="maxPoolSize">10</property>

   </default-config>

  

   <!-- 专门为oracle提供的配置信息 -->

   <named-config name="oracle-config">

      <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb1</property>

      <property name="driverClass">com.mysql.jdbc.Driver</property>

      <property name="user">root</property>

      <property name="password">123</property>

      <property name="acquireIncrement">3</property>

      <property name="initialPoolSize">10</property>

      <property name="minPoolSize">2</property>

      <property name="maxPoolSize">10</property>

   </named-config>

 

</c3p0-config>

java 代码

 /**

    * 配置文件的默认配置

    * @throwsSQLException

    */

   @Test

   publicvoid fun2() throwsSQLException{

      /**

       * 在创建连接池对象时，这个对象就会自动加载配置文件！不用我们来指定

       */

      ComboPooledDataSource dataSource  = newComboPooledDataSource();

     

      Connection con =dataSource.getConnection();

      System.out.println(con);

      con.close();

  }

其他数据库配置

 

/**

    * 使用命名配置信息

    * @throwsSQLException

    */

   @Test

   publicvoid fun3() throwsSQLException{

      /**

       * 构造器的参数指定命名配置元素的名称！

       *<named-config name="oracle-config">

       */

      ComboPooledDataSource dataSource  = newComboPooledDataSource("oracle-config");

     

      Connection con =dataSource.getConnection();

      System.out.println(con);

      con.close();

  }