JDBC简介及其用Java连接数据库

一、JDBC的主要作用：用Java代码来操作数据库（oracle，mySQL）

1、数据的添加

2、数据的删除

3、数据的更新

4、数据的查询

5、事物

二、编写JDBC的步骤

1、加载驱动——不同的数据库加载不同的驱动。

2、获取数据库连接  connection

3、构建statement 或者preparedstatement 对象   ——执行的SQL

4、执行SQL语句 ——返回结果

5、解析结果

6、关闭statement 或者preparedstatement对象和连接

实现代码如下：

public class last 
{
    public static void main(String[] args)
    {
        Connection conn = null;
        PreparedStatement ptem = null;
        ResultSet resu = null;
        
        try {
            //1、加载驱动——固有写法
            Class.forName("oracle.jdbc.driver.OracleDriver");
            //2、连接数据库——固有写法
            String url = "jdbc:oracle:thin:@localhost:1521:orcl";
            conn = DriverManager.getConnection(url, "scott", "sbc111");
            System.out.println(conn);
            //3、构建preparedstatement对象执行SQL语句
            String sql = "select empno,ename,job,mgr from emp";
            ptem = conn.prepareStatement(sql);
            //4、执行SQL语句
            resu = ptem.executeQuery(sql);
            //5、用while遍历 来解析结果
            while(resu.next())
            {
                int a = resu.getInt("empno");
                String b = resu.getString("ename");
                String c = resu.getString("job");
                String d = resu.getString("mgr");
                //e = resu.getDate("hiredate");
                //resu.getInt("sal");
                //resu.getInt("comm");
                //resu.getString("deptno");
                
                System.out.println(a + " : " + b + " : " + c + " : " + d);
            }
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally //关闭资源
        {
            if(conn !=null)
            {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(ptem !=null)
            {
                try {
                    ptem.cancel();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(resu !=null)
            {
                try {
                    resu.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 JDBC实现oracle分页

1、基于内存：

特点：运行速度快，但是非常占用资源，一般用在小数据

public class JDBCSort 
{
    /**
     * 
     * @param page 当前要显示的页数
     * @param pageSize 每页显示多少行
     * 编写步骤：
     *     1. 判断pageSize是否越界
     *  2. 判断page是否越界
     *  3. 创建一个可以滚动的Statement对象
     *  4. 执行sql语句
     *  5. 让结果集(ResultSet)里面的指针指向当前分页的第一行
     *  6. 往下next pageSize次获取当前分页要显示的所有行
     *  7. 关闭所有的资源
     * 
     * 
     */
    public static void getData(int page,int pageSize)
    {
        String sql = "select * from emp";
        String count = "select count(*) from emp";
        Connection conn = DBUtils.getConnection();
        int maxCount;
        PreparedStatement pstm = null;
        ResultSet set = null;
        Statement st = null;
        ResultSet set1 = null;
        try {
            pstm = conn.prepareStatement(count);
            set = pstm.executeQuery();
            maxCount = 0;
            while(set.next())
            {
                maxCount = set.getInt(1);
            }
            
            //判断每页显示的行数是否越界
            if(pageSize < 10)
            {
                pageSize = 10;
            }else if(pageSize > maxCount)
            {
                pageSize = maxCount;
            }
            
            //计算当前的总条数可以分多少页
            if(maxCount % pageSize == 0)
            {
                maxCount = maxCount/pageSize;
            }else
            {
                maxCount = maxCount/pageSize + 1;
            }
            
            //判断page是否有越界
            if(page < 1)
            {
                page = 1;
            }
            if(page > maxCount)
            {
                page = maxCount; //如果传递过来的页数超过了最大的分页数，那么显示最后一页
            }
            
            /**
             * ResultSet.TYPE_SCROLL_INSENSITIVE 设置得到的结果集可以滚动显示
             * ResultSet.CONCUR_READ_ONLY : 设置结果集数据为只读
             */
            st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            set1 = st.executeQuery(sql);
            
            set1.absolute((page-1)*pageSize + 1);// 定位到当前要显示也的第一行
            
            for(int i = pageSize; i > 0; i--)
            {
                String ename = set1.getString("ename");
                System.out.println(ename);
                
                if(!set1.next())// set1.next()如果没有下一行则返回false，然后在取反，终止循环
                {
                    break;
                }
            }
            
            
            /*//显示第十一行记录的员工名称
            set1.absolute(10); //直接指向结果集里面的某一行记录
            System.out.println(set1.getString("ename"));
            set1.next(); //指向结果集里面的下一行
            System.out.println(set1.getString("ename"));
            set1.previous(); // 指向上一行
            System.out.println(set1.getString("ename"));
            set1.relative(3);//相对于现在的位置移动3个位置
            System.out.println(set1.getString("ename"));*/
            
        } catch (SQLException e) {
            e.printStackTrace();
        }finally
        {
            DBUtils.closeResultSet(set);
            DBUtils.closeResultSet(set1);
            DBUtils.closeStatement(st);
            DBUtils.closePreparedStatement(pstm);
            DBUtils.closeConnection(conn);
        }
        
    }
}

2、基于数据库

特点：占用资源少，但是速度较内存蛮，而且跟数据库交互多，但是可以应对大数据

public class JDBCSort1
{
    /**
     * 编程步骤：
     *     1. 判断pageSize是否越界
     *  2. 判断page是否越界
     *  3. 计算当前页要显示的第一行和最后一行
     *  4. 设置参数，然后执行sql语句
     *  5. 解析结果
     *  6. 关闭资源
     * @param page
     * @param pageSize
     */
    public static void getData(int page,int pageSize)
    {
        String sql = "select r,empno,ename from ( "
                    +    " select rownum r,empno,ename from emp where rownum <= ? "
                    +" ) where r>= ? ";
        String count ="select count(*) from emp";
        int countMax = 0;
        Connection conn = DBUtils.getConnection();
        PreparedStatement pstm = null;
        ResultSet set = null;
        try {
            pstm = conn.prepareStatement(count);
            set = pstm.executeQuery();
            while(set.next())
            {
                countMax = set.getInt(1);//得到总行数
            }
            DBUtils.closeResultSet(set);
            DBUtils.closePreparedStatement(pstm);
            
            if(pageSize < 10)
            {
                pageSize = 10;
            }else if(pageSize > countMax)
            {
                pageSize = countMax;
            }
            
            //获取总分页数
            if(countMax % pageSize == 0)
            {
                countMax = countMax/pageSize;// 得到总分页数
            }else
            {
                countMax = countMax/pageSize + 1;
            }
            
            if(page < 1)
            {
                page = 1;
            }else if(page > countMax)
            {
                page = countMax;
            }
            
            //就算当前页的起始位置和结束位置
            int start = (page-1)*pageSize + 1;
            int end = page*pageSize;
            
            pstm = conn.prepareStatement(sql);
            pstm.setInt(1, end);
            pstm.setInt(2, start);
            
            set = pstm.executeQuery();
            while(set.next())
            {
                System.out.println(set.getString("ename"));
            }
            
        } catch (SQLException e) {
            e.printStackTrace();
        }finally
        {
            DBUtils.closeResultSet(set);
            DBUtils.closePreparedStatement(pstm);
            DBUtils.closeConnection(conn);
        }
    }
}