JDBC

小鱼儿 2021-09-11 07:46 278阅读 0赞

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));  // 表示的是哪个列 
    		}
    	}
    }