1.应用步骤：
- 导包
- 加载驱动类class.forName(....)
- DriverManager获取sql对象
- 写sql语句
- Statement与prepareStatement不一样的执行sql语句，前者是间接sql对象 . 执行语句，而后者是预处理，即在创立sql对象时，就用sql语句，最初在用对象执行操作。
2.JDBCUtils工具类：
就是把应用步骤的共性，提出来，放在一个类中，这样当前就能间接调用创立sql对象的办法就行了。
值得一提的是，如果咱们应用配置文件，扩展性更好，在应用其余数据库时，咱们只须要更改配置文件properties。获取配置文件能够应用properties对象。获取jar包的绝对路径能够应用classLoader类加载器。这样咱们就不必本人增加门路了。
public class JDBCUtils { private static String url; private static String user; private static String password; private static String driver; /** * 文件的读取，只须要读取一次即可拿到这些值。应用动态代码块 */ static{ //读取资源文件，获取值。 try { //1. 创立Properties汇合类。 Properties pro = new Properties(); //获取src门路下的文件的形式--->ClassLoader 类加载器 ClassLoader classLoader = JDBCUtils.class.getClassLoader(); URL res = classLoader.getResource("jdbc.properties"); String path = res.getPath(); //2. 加载文件 pro.load(new FileReader(path)); //3. 获取数据，赋值 url = pro.getProperty("url"); user = pro.getProperty("user"); password = pro.getProperty("password"); driver = pro.getProperty("driver"); //4. 注册驱动 Class.forName(driver); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } /** * 获取连贯 * @return 连贯对象 */ public static Connection getConnection() throws SQLException { return DriverManager.getConnection(url, user, password); } /** * 开释资源 * @param stmt * @param conn */ public static void close(Statement stmt,Connection conn){ if( stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } /** * 开释资源 * @param stmt * @param conn */ public static void close(ResultSet rs,Statement stmt, Connection conn){ if( rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if( stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if( conn != null){ try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } }3.DBC管制事务：
在执行sql语句时，如果程序执行过程中，产生了异样。比方有两个sql语句，一个是转账操作，一个人存转的这笔钱，如果第一个操作完结后产生了异样。那么这笔钱就会不胫而走，所以为了防止这样的状况，能够应用事务。
(1)具体操作
- 开启事务：setAutoCommit( boolean autoCommit ) ：调用该办法设置参数为false，即开启事务。
- 提交事务：commit( )当所有sql都执行完提交事务。
- 回滚事务：rollback( ) 在catch中回滚事务。
public static void main(String[] args) { PreparedStatement pstmt1 = null; PreparedStatement pstmt2 = null; Connection con = null; try { con = JDBCUtils.getConnection(); //开启事务 con.setAutoCommit(false); //2.1 张三 - 500 String sql1 = "update account set balance = balance - ? where id = ?"; //2.2 李四 + 500 String sql2 = "update account set balance = balance + ? where id = ?"; pstmt1 = con.prepareStatement(sql1); pstmt2 = con.prepareStatement(sql2); //4. 设置参数,sql语句里的问号 pstmt1.setDouble(1,500);//填第一个数据 pstmt1.setInt(2,1);//填第二个数据 pstmt2.setDouble(1,500); pstmt2.setInt(2,2); //5.执行sql pstmt1.executeUpdate(); // 手动制作异样 int i = 3/0; pstmt2.executeUpdate(); //提交事务 con.commit(); } catch (SQLException e) { e.printStackTrace(); } catch (Exception e){ try { con.rollback(); } catch (SQLException ex) { ex.printStackTrace(); } } finally{ JDBCUtils.close(con,pstmt1); JDBCUtils.close(con,pstmt2); }}4.JDBC连接池
连接池，就是先创立好一些连贯对象，要用的的时候，间接应用，进步了效率，用完之后，归还给连接池，以便其余的应用。
- c3p0连接池：
步骤： - 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ，还须要导入数据库驱动jar包
定义配置文件：
- 名称： c3p0.properties 或者 c3p0-config.xml。
- 门路：间接将文件放在src目录下即可。
- 创立外围对象 数据库连接池对象 ComboPooledDataSource
- 获取连贯： getConnection
代码：
//1.创立数据库连接池对象 DataSource ds = new ComboPooledDataSource(); //2. 获取连贯对象 Connection conn = ds.getConnection();- druid：
这个是阿里的，性能更好，效率更高。
步骤：
- 导入jar包 druid-1.0.9.jar
定义配置文件：
- 是properties模式的
- 能够叫任意名称，能够放在任意目录下
- 加载配置文件。Properties
- 获取数据库连接池对象：通过工厂类来获取 DruidDataSourceFactory
- 获取连贯：getConnection
代码：
//3.加载配置文件Properties pro = new Properties();InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");pro.load(is);//4.获取连接池对象DataSource ds = DruidDataSourceFactory.createDataSource(pro);//5.获取连贯Connection conn = ds.getConnection();因为代码还是简短，反复率高，所以能够自定义个工具类：
public class JDBCUtils { //1.定义成员变量 DataSource private static DataSource ds ; static{ try { //1.加载配置文件 Properties pro = new Properties(); pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties")); //2.获取DataSource ds = DruidDataSourceFactory.createDataSource(pro); } catch (IOException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } } /** * 获取连贯 */ public static Connection getConnection() throws SQLException { return ds.getConnection(); } /** * 开释资源 */ public static void close(Statement stmt,Connection conn){ /* if(stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null){ try { conn.close();//偿还连贯 } catch (SQLException e) { e.printStackTrace(); } }*/ close(null,stmt,conn); } public static void close(ResultSet rs , Statement stmt, Connection conn){ if(rs != null){ try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if(stmt != null){ try { stmt.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null){ try { conn.close();//偿还连贯 } catch (SQLException e) { e.printStackTrace(); } } } /** * 获取连接池办法 */ public static DataSource getDataSource(){ return ds; } }- Spring JDBC
Spring框架对JDBC的简略封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤：
- 导入jar包
创立JdbcTemplate对象。依赖于数据源DataSource
- JdbcTemplate template = new JdbcTemplate(ds);
调用JdbcTemplate的办法来实现CRUD的操作
- update():执行DML语句。增、删、改语句
queryForMap():查问后果将后果集封装为map汇合，将列名作为key，将值作为value 将这条记录封装为一个map汇合
- 留神：这个办法查问的后果集长度只能是1
queryForList():查问后果将后果集封装为list汇合
- 留神：将每一条记录封装为一个Map汇合，再将Map汇合装载到List汇合中
query():查问后果，将后果封装为JavaBean对象
query的参数：RowMapper
- 个别咱们应用BeanPropertyRowMapper实现类。能够实现数据到JavaBean的主动封装
- new BeanPropertyRowMapper<类型>(类型.class)
queryForObject：查问后果，将后果封装为对象
- 个别用于聚合函数的查问
//2. 定义sql //1. 获取JDBCTemplate对象private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());String sql = "update emp set salary = 10000 where id = 1001";//3. 执行sqlint count = template.update(sql);System.out.println(count);这大大简化了咱们curd的代码量。