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的开发
- 步骤：
  1. 导入jar包
  2. 创立JdbcTemplate对象。依赖于数据源DataSource
    - JdbcTemplate template = new JdbcTemplate(ds);
  3. 调用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. 执行sql
int count = template.update(sql);
System.out.println(count);

这大大简化了咱们curd的代码量。

关于jdbc:JDBC的基本使用

1.应用步骤：

2.JDBCUtils工具类：

3.DBC管制事务：

4.JDBC连接池

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于jdbc:JDBC的基本使用

1.应用步骤：

2.JDBCUtils工具类：

3.DBC管制事务：

4.JDBC连接池

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复