JDBC

import java.security.Provider;
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.Properties;
import java.util.concurrent.ThreadLocalRandom;

import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.RowSetFactory;
import javax.sql.rowset.RowSetProvider;

import com.mysql.jdbc.CallableStatement;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Driver;


/*
	2017-02-22
	JDBC 4.2
		 DriverManger 管理JDBC驱动的服务类
		 程序中使用该类的主要功能是获取Connection对象主要方法
		 Connection 对代表数据库连接对象，每个Connection代表一个物理连接会话
		 	---Statement createStatment   返会一个Statement对象
		 	---PreparedStetement prepareCall  该方法返回预编译的Statement对象，将sql语句提交到数据库进行预编译
		 	---CallableStatement prepareCall 返回一个CallableStetement对象，对象用于调用存储过程  
		 都是返回执行sql 的Statement对象，都是Statement 的子类
		 只有获得Statement 之后才才可执行sql语句
		 
 	Connection  控制事务的方法
 	setSavepoint
 	setTransactionIsolation  事务隔离级别
 	rollback 回滚事务
 	setAutoCommit  关闭自动提交，打开事务
 	commit 提交事务
 	
*/

/*
	2017-02-22
	PreparenStatement 预编译的Statement 对象
	是Statement的子接口，允许数据库预编译sql语句 以后每次只要改变sql命令的参数就可以了
	避免每次都要执行
	PreparStatement 执行sql语句是，无须再传入sql语句，只要传入参数就可以
*/
/*
	2017-02-22
	ResultSet 结果集对象
	该对象包含访问查询结果的方法
	ResulSet可以通过列索引或列名获得列数据
	close
	absolute   移动   负数时倒数
	beforFirst 定位首行之前  初始状态  位于第一行之前
	first   定位到首行
	previous 定位到上一行。移动后的记录指向一条有效记录，返回true
	next  记录指针定位到下一行。移动后指向一条有效记录 返回true
	lash  最后一条1
	afteLast 定位到最后一行之后
	
	
*/
/*
	2017-02-22
*/
public class Jdbcj {
	//1 加载驱动
//		Class.forName(driverClss); 
	
//		Class.forName("com.mysql.jdbc.Driver");    加载mysql 驱动
//		Class.forName("oracle.jdbc.driver.OracleDriver"); 加载Oracle 驱动
	
	/*
	 * 加载驱动不是真正使用数据库的驱动类，只是使用数据库类名的字符串而已
	 */
	
	//2获取数据库连接
//		DriverManager.getConnection(url, user, password)
	/*
	 * url 的写法
	 * jdbc:subprotocol:other stuff
	 * jdbc:指定连接到特定数据库驱动： 各个数据库不同
	 * 
	 * jdbc：mysql：//hostname：port/databasename
	 * 
	 * jdbc:oracle:thin:@hostname:port:databasename
	 */
	
	
	//3 通过connection 对象创建Statement 对象
	/**
	 * createStatement 创建基本的Statement对象
	 * prepareStatement (String sql) 根据传入的sql语句创建预编译的Statement对象
	 * prepareCall(String sql) 根据传入的sql语句创建CallableStatement对象   
	 */
	// 4 使用Statement 执行sql语句
	/**
	 * ---execute 执行任何sql语句
	 * ---executeUpdate 主要执行 DML DDL  
	 * 		执行DML返回受影响的行数
	 * 		执行DDL返回0
	 * ---exeQuery 只能执行查询语句，执行后返回代表查询结果的ResultSet对象
	 */
	//5 操作结果集
	/**
	 * 执行查询语句，则返回一个ResultSet对象
	 * 	ResultSet方法
	 * 		--移动 	next previous first last beforFirst afterLast absolute
	 * 		--获取getXXX获取记录指针指向行、特定列的值，列索引做参数性能好，列名做参数可读性好
//			executeQuery.first()
//			executeQuery.next()
//			executeQuery.previous()
//			executeQuery.beforeFirst();
//			executeQuery.afterLast();
//			executeQuery.last()
	 * ResultSet实质是一个查询结果集
	 */
	
	// 6 回收数据库资源  
	/**
	 * 关闭ResultSet Statement Connection
	 * @throws SQLException 
	 */
	
	
	
	/**
	 * 执行sql语句的方式
	 * executeLargeUpdate 执行DDL DML
	 * 
	 */

	
	/**2017-02-22 14:22
	 * PreparedStatement执行sql语句
	 * 可以在sql中用  ? 占位符  来代替参数
	 * 预编译的sql语句在PreparedStatement 
	 * 用于防止sql注入
	 * 
	 */
	
	
	/**2017-02-22 15:31
	 * CallableStatement 
	 * Connection 创建prepareCall 来调用CallableStatement 对象， 
	 */
	
	
	/**2017-02-22 15:50
	 * 管理结果集
	 *  默认的ResultSet是不可更新的需要在创建时传入 
	 *  resultSetType
	 *  
	 *  resultSetConcurrency 控制ResultSet的并发类型
	 *  
	 *  
	 *  可更新的结果集需要满足
	 *  所有的数据都应该来自一个表
	 *  选出的数据必须包含主键列
	 */
	/**2017-02-22 16:25
	 * 处理Blob类型数据
	 * 
	 *  Binary Long Object  二进制长对象的意思
	 *  通常用于存储大文件
	 *  Blob数据插入数据库需要使用PreparedStatement
	 *  setBinaryStream 指定参数传入二进制输入流
	 *  mediumblob 该类型数据列可以存储16MB内容
	 *  
	 */
	/**2017-02-22 16:28
	 *  ResultSetMetaData 分析结果集
	 *  MetaData的意思是元数据
	 *  DatabaseMetaData 封装了描述Database 的数据
	 *  ResultSetMetaData对象的方法
	 *  getColumnCount   返回 ResultSet列数量
	 *  getColumnName 返回指定索引的列名
	 *  getColumnType 返回指定索引的列类型
	 *  
	 *  
	 */
	/**2017-02-22 18:02
	 *  
	 */
	public static void main(String[] args) throws ClassNotFoundException, SQLException {
//			c1();
//			c2();
//			c3();
//			c4();
//			c5();
//			c6();
		
		
		
		
		/**
		 * RowSet接口继承了ResultSet接口
		 * 	RowSet
		 * 		--JdbcRowSet  也继承了Joinable
		 * 		--CacheRowSet 及其子接口都代表离线RowSet，不需要底层数据库连接
		 * 			-WebRowSet
		 * 				--JoinRowSet
		 * 				--FilteredRowSet
		 * 
		 * 	rowset
		 * 	-----JdbcRowSetImpl  这是一个还没有公开的api 不能使用
		 * 	-----CachedRowSetImpl
		 * 	-----WebRowSetImpl
		 * 	-----FilteredRowSetImpl
		 * 	-----JoinRowSetImpl
		 * 
		 * 
		 * 
		 */
		Class.forName("com.mysql.jdbc.Driver");
		java.sql.Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shopping","root","root");
//		JdbcRowSet jdbcRowSet = new JdbcRowSetImpl(connection); 这是一个没有公布的api
		/**
		 * 离线RowSet
		 * 
		 * ResultSet 的两种处理方式
		 * 使用迭代访问ResultSet里的记录，将这些记录转换成Java Bean，在将多个JavaBean 转成一个list集合
		 * 再将list集合传到视图显示层， 可以显示查询得到的数据
		 * 
		 * 直接将ResultSet传到视图显示层，底层一直处于打开状态，否则Result 无法读取记录
		 * 
		 * 
		 * 离线RowSet 将底层数据读入内存中，封装成RowSet对象，RowSet对象完全可以当成JavaBean 使用
		 * 所有的离线RowSet的父接口CachedRowSet
		 * 
		 */
			Statement statement = connection.createStatement();
			ResultSet executeQuery = statement.executeQuery("select * from users");
			CachedRowSet cachedRowSet = RowSetProvider.newFactory().createCachedRowSet();// 包装一个离线的cachedRowSet
			cachedRowSet.populate(executeQuery);
//			cachedRowSet.acceptChanges();将对rowset做出的修改同步到底层数据库
			/**
			 * 离线rowset 分页查询
			 * 
			 */
//			cachedRowSet.populate(ResultSet);  填充
//			cachedRowSet.setPageSize(size); 设置每次返回多少条记录
//			cachedRowSet.previousPage(); 读取上一页记录
//			cachedRowSet.nextPage(); 读取下一页记录
			
//			cachedRowSet.populate(executeQuery,(page - 1)*(page + ));
			
			
			/*
			 * 事务的概念和mysql 事务支持
			 * 原子性 Atomicity
			 * 一致性Consistency
			 * 隔离型Isolation
			 * 持续性Durability
			 * 
			 * 
			 * 事务组成 
			 * 一组DML+一条DDL+一条DCL
			 * DDL  DCL 的提交都会导致事务立即提交
			 * 
			 * 显示提交commit
			 * 自动提交执行 DDL  DML   或者程序正常退出
			 * 
			 * 操作失败后应该回滚rollback
			 * 显示回滚rollback
			 * 自动回滚系统错误，强行退出
			 * 
			 * set autocommit =  0 关闭自动提交  ，开启事务
			 * 
			 * 一个mysql命令行窗口代表一次连接Session    设置一次就对当前窗口有效，不会影响其他连接
			 * 
			 * 
			 */
			
			
			/**
			 *jdbc 事务支持
			 *connection 默认打开自动提交，关闭事务，每条sql一旦执行，便会立即提交到数据库，无法rollback 
//			connection.setAutoCommit(autoCommit);
//			connection.commit(); 提交事务
//			connection.rollback(); 回滚事务
//			connection.setSavepoint(); 设置保存点
			 */
//			ThreadLocalRandom
			
			/**
			 * java 8 批量更新
			 * 多条sql语句将被作为一批操作被同时手机，并同时提交
			 * 批量更新必须得到底层数据库的支持，可以通过调用DatabaseMetaData 的suppoportsBatchUpdates方法来查看底层数据库是否支持批量更新
			 * 
			 * 创建一个statement对象，用addBatch 方法收集多条sql语句
			 * executeLargeBatch方法同时执行sql语句
			 * 当记录条数超过int 最大值是 使用
			 * executeLargeBatch 返回一个long数组
			 * statement执行DDL DML语句都将返回一个long值
			 * 
			 * 为了提高批量操作的处理错误
			 * 需要把批量操作视为单个事务，
			 * 如果失败，就回滚到批量操作开始之前
			 * 需要在批量更新之前 先关闭自动提交
			 * */
			
			/**
			 * 分析数据库信息
			 * 插入C 
			 * 查询S
			 * 修改U
			 * 删除D
			 * DatabaseMetaData封装数据库连接对应数据库的信息
//			connection.getMetaData();
			 *获取数据库对应的DatabaseMetaData对象
			 *该接口通常由驱动程序供应商提供实现，
			 *目的是让用户了解底层数据库的相关信息
			 *发现如何处理底层数据库
			 *当程序使用多个数据库时
			 *supportsCorrelatedSubquerise 方法来查看是否可有使用关联子查询 
			 * 
			 */
			DatabaseMetaData metaData = connection.getMetaData();
			ResultSet tableTypes = metaData.getTableTypes();
			ResultSetMetaData resultSetMetaData = tableTypes.getMetaData();
			
			/**
			 * 
			 * 使用系统表分析数据库信息
			 * 
			 * 系统表有称为数据字典
			 * 通常由数据库系统负责维护
			 * 用户只能查询数据库字典
			 * 而不能修改数据字段内容
			 * 
			 * DatabsaseMetaData  分析数据可以不用考虑底层
			 */
			
			/**
			 * 连接池管理
			 * 一个数据库连接对象均对应一个物理数据库连接，每次操作都打开一个物理连接，使用完，立即关闭
			 * 
			 * 资源池 Resource Pool
			 * 数据库连接池是Connection工厂
			 * 
			 * 数据库的初始连接数
			 * 连接池的最大，最小连接数
			 * 连接池每次增加的容量
			 * javax.sqlDataSource表示数据库连接池
			 * DataSource 只是一个接口
			 * 该接口通常由商用服务器等提供实现
			 * 
			 * DataSource通常被称为数据源
			 * 包含连接池和连接池管理两个部分
			 * 
			 */
			/**
			 * 
			 * DBCP 数据源是Apache 软件基金会的开源连接池实现
			 * 依赖  common-pool
			 * 		--commons-dbcp.jar
			 * 		--commons-pool.jar
			 */
			/**
			 * C3P0   Hibernate 推荐使用该连接池
			 * 自动清理不在使用的Connection
			 * 自动清理Statement ResultSet
			 * 
			 * C3p0.jar
			 * 
			 */
			
	}

	/**2017-02-22 16:54
	 *  
	 */
	private static java.sql.Connection c6() throws ClassNotFoundException, SQLException {
		Class.forName("com.mysql.jdbc.Driver");
		java.sql.Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shopping","root","root");
		System.out.println(connection);
		Statement statement = connection.createStatement();
		ResultSet resultSet = statement.executeQuery("select * from users");
		ResultSetMetaData metaData = resultSet.getMetaData();
	
		
		for (int i = 1; i < metaData.getColumnCount()+1; i++) {  
			
			System.out.println(metaData.getColumnName(i) + "-" + metaData.getColumnType(i));
			
		}
		return connection;
	}

	/**2017-02-22 16:25
	 *  
	 */
	private static void c5() throws SQLException {
		Properties info = new Properties();
		info.setProperty("driver", "com.mysql.jdbc.Driver");
		info.setProperty("url", "jdbc:mysql://127.0.0.1:3306/shopping");
		info.setProperty("user", "root");
		info.setProperty("password", "root");
		java.sql.Connection connection = DriverManager.getConnection(info.getProperty("url"),info);
//			String sql = null;
//			connection.prepareStatement(sql,ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
		// ResultSet 可滚动，可更新
		System.out.println(connection);
	}

	/**2017-02-22 15:49
	 * CallableStatement 调用存储过程  
	 */
	private static void c4() throws ClassNotFoundException, SQLException {
		Properties info = new Properties();
		info.setProperty("driver", "com.mysql.jdbc.Driver");
		info.setProperty("url", "jdbc:mysql://127.0.0.1:3306/shopping");
		info.setProperty("user", "root");
		info.setProperty("password", "root");
		
		Class.forName(info.getProperty("driver"));
//		java.sql.Connection connection = DriverManager.getConnection(info.getProperty("url"), "root","root");
		java.sql.Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/shopping", "root", "root");
		System.out.println(connection);
//		java.sql.CallableStatement callableStatement = connection.prepareCall("");
//		callableStatement.setInt(parameterIndex, x); 
//		callableStatement.registerOutParameter(parameterIndex, sqlType);
//		callableStatement.execute();
//		callableStatement.getInt(parameterIndex)
	}

	/**2017-02-22 15:38
	 *  
	 */
	private static void c3() throws ClassNotFoundException, SQLException {
		Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/shopping";   // 这个格式一定要准确
//			String url = "jdbc:mysql://127.0.0.1:3306/shopping";
			
			Properties info = new Properties();
			info.setProperty("user", "root");
			info.setProperty("password", "root");
			java.sql.Connection connection = DriverManager.getConnection(url , info );
			
			
			Statement s = connection.createStatement();
			System.out.println(connection);
			
//			java.sql.CallableStatement statement = connection.prepareCall(sql);
//			statement.registerOutParameter(parameterIndex, sqlType);   //传入存储过程的参数
			
			/**
			 * 调用存储过程
			 */
	}

	/**2017-02-22 14:28
	 *  
	 */
	private static void c2() throws ClassNotFoundException, SQLException {
		Properties info = new Properties();
		//在程序移植的时候可以创建一个配置文件来保存连接信息
		//然后再加载
		info.setProperty("driver", "com.mysql.jdbc.Driver");
		info.setProperty("url", "jdbc:mysql://localhost:3306/shopping");
		info.setProperty("name", "root");
		info.setProperty("password", "root");
		
		
		Class.forName(info.getProperty("dirver"));
		java.sql.Connection connection = DriverManager.getConnection(info.getProperty("url"), info);
		Statement statement = connection.createStatement();
		
		 String uptesql = "";
		int i = statement.executeUpdate(uptesql );
		
//			connection.prepareStatement(sql);  可以是带参数占位符的sql 语句
		/**
		 * 然后再set方法传入这些用占位符的参数
		 */
	}

	/**2017-02-22下午1:20:03
	 *  
	 */
	private static void c1() throws ClassNotFoundException, SQLException {
		Class.forName("com.mysql.jdbc.Driver"); // 1  利用反射
		String url = "jdbc:mysql://127.0.0.1:3306/shopping";
		Properties info = new Properties();
		info.setProperty("user", "root");
		info.setProperty("password", "root");
		java.sql.Connection connection = DriverManager.getConnection(url,info);
//		connection  =DriverManager.getConnection(url, user, password)
		Statement statement = connection.createStatement();
//			statement.execute(sql) 所有sql
//			statement.executeQuery(select)   ResultSet
//			statement.executeUpdate()  返回 条数
  
		String selcet = "select * from hehe";
		ResultSet rs = statement.executeQuery(selcet);

		while (rs.next()) {
				System.out.println( "id = " + rs.getString(1) + ",name = "+ rs.getString(2));  // 表示的是哪个列 
		}
	}
}