JavaWeb Day1

本节内容

  1.JDBC

 

 

 

 一、JDBC

   Jdbc是一种Java连接数据库技术(Java database connectity), 它是 Java 提供的一些接口,这些接口大部分是数据库厂商提供的(jar包),我们要做的,是连接数据库以后,如何使用Java代码从数据库中存取数据!

  做JDBC操作的准备工作： 数据库、数据库厂商提供的jar包、Java运行环境、

  做JDBC操作的步骤：

   1.加载驱动

    引入数据库驱动jar包

    

      加载驱动

      

//加载驱动  以Oracle为例
        
        try {
            Class.forName("oracle.jdbc.OracleDriver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.out.println("驱动加载失败");
        }

 

   2.获取数据库连接

       获取数据库连接：数据库访问地址   、  数据库登录的用户名   密码

      

        // 数据库访问的url
        /**
         * 根据不同的数据库产品不同连接的URL不同 Oracle11g：jdbc:oracle:thin:@主机名:端口:数据库SID
         * MySQL5：jdbc:mysql://主机名:端口/数据库名
         * SQLServer2005：jdbc:sqlserver://主机名:端口:DatabaseName=库名
         */
        String url = "jdbc:oracle:thin:@127.0.0.1:1521:ORCL";
        String user = "hr";
        String password = "hr";
        Connection conn = null;
        try {
            // 获取数据库连接
            conn = DriverManager.getConnection(url, user, password);
        } catch (SQLException e) {
             
            e.printStackTrace();
            System.out.println("获取数据库连接失败");
        }

 

 

 

 

   3.获取封装sql语句的对象

    获得数据库连接后,要想执行sql语句,必须获得java.sql.Statement实例,Statement实例分为三种

• 执行静态的sql语句.通过Statement实例实现
• 执行动态的sql语句.通过PreparedStatement实例实现
• 执行数据库存储过程.通常通过CallableStatement实例实现

 

    

        try {
            //获取封装sql的对象 封装静态sql
            Statement stem = conn.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

 

 //动态sql
         String  sql="select * from employees where employee_id=?"; 
        try {
            PreparedStatement ps =conn.prepareStatement(sql);
            //设置动态sql的参数
            ps.setInt(1, 101);
            
            
                
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

 

 

 

   4.发送sql语句到数据库服务器去执行

      Statement提供了三种执行查询

• ResultSet executeQuery(String sql);   执行查询数据库的sql语句,返回一个结果集(ResultSet)对象
• int executeUpdate(String sql);  执行INSERT,UPDATE或者DELETE语句以及SQL DDL语句,返回受影响行数
• execute(String sql); 用于返回多个结果集,多个更新计数或者二者组合的语句

       

    try {
            String sql1 = "select * from employees";
            //获取封装sql的对象 封装静态sql
            Statement stem = conn.createStatement();
            //执行静态sql,得到返回的结果  执行查询   执行增 删 改  使用executeUpdate(sql);返回int值：受影响的行数
            ResultSet rs=stem.executeQuery(sql1);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
          //动态sql
         String  sql="select * from employees where employee_id=?"; 
        try {
            PreparedStatement ps =conn.prepareStatement(sql);
            //设置动态sql的参数
            ps.setInt(1, 101);
            //执行动态sql并返回结果  执行查询
            ResultSet rs= ps.executeQuery();
                
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

 

 

   5.处理结果

       处理结果有两种情况

• 返回本次操作的记录数 在执行executeUpdate();方法的时候会返回受影响的行数
• 返回ResultSet对象  在执行executeQuery();方法的时候会返回对象

ResultSet对象中包含SQL查询中出的所有行,通过get方法可以获取每行的数据

 

 String  sql="select * from employees where employee_id=?"; 
        try {
            PreparedStatement ps =conn.prepareStatement(sql);
            //设置动态sql的参数
            ps.setInt(1, 101);
            //执行动态sql并返回结果  执行查询
            ResultSet rs= ps.executeQuery();
            //rs.next()判断有没有下一条数据
            while (rs.next()) {
                //取值
                rs.getString("employee_id");//通过列名取值
                rs.getString(2);//根据列在表中的位置类取值
            }
                
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

 

 

 

   6.关闭数据库连接

 

    在使用完毕后需要关闭三个对象,关闭结果集(resultSet),关闭声明(Statement),关闭数据库连接(Connection)

 

if (resultSet != null) { // 关闭记录集
                resultSet.close();
            }
            if (statement != null) { // 关闭声明
                statement.close();
            }
            if (connection != null) { // 关闭连接对象
                connection.close();
            }

 

 工具DBUtils的使用

    Dbutils：主要是封装了JDBC的代码，简化dao层的操作。

     作用：帮助java程序员，开发Dao层代码的简单框架。

          框架的作用：帮助程序员，提高程序的开发效率。

     出生：Dbutils是由Apache公司提供。

 

DBUtils核心：

    QueryRunner中提供对sql语句操作的API.
     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
     ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
     DbUtils类，它就是一个工具类,定义了关闭资源与事务处理的方法

2. QueryRunner类的update方法介绍

     a: 方法介绍

     update(Connection conn, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
     使用QueryRunner类,实现对数据表的insert delete update
     调用QueryRunner类的方法 update (Connection con,String sql,Object...param)
     Object...param 可变参数,Object类型,SQL语句会出现?占位符
     数据库连接对象,自定义的工具类传递

3. DBUtils工具类结果集处理的方式

   a: QueryRunner实现查询操作
     query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作
   b: ResultSetHandler结果集处理类
    ArrayHandler 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
    ArrayListHandler 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中。
    BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中。
    BeanListHandler 将结果集中每一条记录封装到指定的javaBean中，将这些javaBean在封装到List集合中
    ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中
    ScalarHandler 它是用于单数据。例如select count(*) from 表操作。
    MapHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据
    MapListHandler 将结果集第一行封装到Map集合中,Key 列名, Value 该列数据,Map集合存储到List集合

4. QueryRunner类的方法query
  a: QueryRunner类的方法query数据查询操作
    调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
    ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
    Object..params SQL语句中的?占位符
    注意: query方法返回值,返回的是T 泛型, 具体返回值类型,跟随结果集处理方式变化

 

 

db.properties

url=jdbc:oracle:thin:@127.0.0.1:1521:ORCL
username=hr
password=hr
driver=oracle.jdbc.OracleDriver

package com.util.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ResourceBundle;

public class DBUtils {
    // 数据库连接的url
    public static String URL;
    // 数据库用户名
    public static String USERNAME;
    // 数据库密码
    public static String PASSWORD;
    // 数据库驱动
    public static String DRIVER;


    private static ResourceBundle resourceBundle = ResourceBundle.getBundle("db");

    private DBUtils() {

    }

    // 使用静态代码块加载驱动
    static {
        URL = resourceBundle.getString("url");

        USERNAME = resourceBundle.getString("username");

        PASSWORD = resourceBundle.getString("password");

        DRIVER = resourceBundle.getString("driver");
      System.out.println(URL);
      System.out.println(USERNAME);
      System.out.println(PASSWORD);
      System.out.println(DRIVER);
        try {
            Class.forName(DRIVER);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    // 定义一个方法来获取数据库连接

    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
        } catch (SQLException e) {
            System.out.println("获取连接失败");
        }

        return conn;

    }

    // 关闭数据库连接

    public static void close(ResultSet rs, Statement stem, Connection conn) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (stem != null) {
                stem.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
     
            
        }

    }

}

package com.bean;

public class Dept {
    
    private int department_id;
    
    private String department_name;
    
    private int manager_id;
    
    private int location_id;

    public int getDepartment_id() {
        return department_id;
    }

    public void setDepartment_id(int department_id) {
        this.department_id = department_id;
    }

    public String getDepartment_name() {
        return department_name;
    }

    public void setDepartment_name(String department_name) {
        this.department_name = department_name;
    }

    public int getManager_id() {
        return manager_id;
    }

    public void setManager_id(int manager_id) {
        this.manager_id = manager_id;
    }

    public int getLocation_id() {
        return location_id;
    }

    public void setLocation_id(int location_id) {
        this.location_id = location_id;
    }

    @Override
    public String toString() {
        return "Dept [department_id=" + department_id + ", department_name=" + department_name + ", manager_id="
                + manager_id + ", location_id=" + location_id + "]";
    }

    public Dept(int department_id, String department_name, int manager_id, int location_id) {
        super();
        this.department_id = department_id;
        this.department_name = department_name;
        this.manager_id = manager_id;
        this.location_id = location_id;
    }

    public Dept() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    

}

package com.dao;

import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.DbUtils;

import com.bean.Dept;

public interface DeptDao {
    
    
    //添加
    public int add(Dept dept)throws SQLException;
    
    //修改
    
    public int update(Dept dept) throws SQLException;
    
    
    //删除
    
    public int delete(int dept_id) throws SQLException;
    
    //查询 根据ID查询
    public Dept findById(int dept_id) throws SQLException;
    
    //查询所有
    public List<Dept> findAll() throws SQLException;
    
    //查询有多少条数据
    public long deptCount() throws SQLException;
    
    //查询数据返回Map集合的封装
    public Map<String,Object> findDept() throws SQLException;
   
    
    //查询数据返回员工姓名
    
    public List<String> findLast_name()throws SQLException;
}

package com.dao.impl;

import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import com.bean.Dept;
import com.dao.DeptDao;
import com.util.db.DBUtils;

public class DeptDaoImpl implements DeptDao {
    private QueryRunner run = null;

    public DeptDaoImpl() {
        run = new QueryRunner();

    }

    /**
     * 添加数据
     */
    @Override
    public int add(Dept dept) throws SQLException {
        String sql = "insert into departments values(departments_seq.nextval,?,?,?)";
        return run.update(DBUtils.getConnection(), sql, dept.getDepartment_name(), dept.getManager_id(),
                dept.getLocation_id());
    }

    /**
     * 修改数据
     */
    @Override
    public int update(Dept dept) throws SQLException {
        String sql = "update departments set manager_id=? where department_id=?";
        return run.update(DBUtils.getConnection(), sql, dept.getManager_id(), dept.getDepartment_id());
    }

    /**
     * 删除数据
     */
    @Override
    public int delete(int dept_id) throws SQLException {
        String sql = "delete from departments where department_id=?";

        return run.update(DBUtils.getConnection(), sql, dept_id);
    }

    /**
     * 结果集处理的第三种方式BeanHandler 将结果集中的第一条数据封装到JavaBean对象中
     * 注意：被封装成数据到JavaBean对象，Sort类中必须有空参构造
     * 
     * @throws SQLException
     */

    @Override
    public Dept findById(int dept_id) throws SQLException {
        // TODO Auto-generated method stub
        String sql = "select * from departments where department_id=?";
        return run.query(DBUtils.getConnection(), sql, new BeanHandler<Dept>(Dept.class), dept_id);
    }

    /**
     * 结果集处理的方式BeanListHandler 将结果集中每一条数据封装到JavaBean对象中 将这些JavaBean对象放到list集合中
     * 
     * @throws SQLException
     */

    @Override
    public List<Dept> findAll() throws SQLException {
        String sql = "select * from departments";
        return run.query(DBUtils.getConnection(), sql, new BeanListHandler<Dept>(Dept.class));
    }

    /**
     * 结果集处理的 方式ScalarHandler 它用于单数据，对于查询后只有一个结果
     * 
     * @throws SQLException
     */

    @Override
    public long deptCount() throws SQLException {
        String sql = "select count(department_id) from departments";
        return run.query(DBUtils.getConnection(), sql, new ScalarHandler<BigDecimal>()).longValue();
    }

    /**
     * 结果集处理 方式MapHandler 将结果集的第一行数据封装到Map集合中 Key 列名 Value 该列数据
     * 
     * @throws SQLException
     */

    @Override
    public Map<String, Object> findDept() throws SQLException {
        String sql = "select * from employees";

        return run.query(DBUtils.getConnection(), sql, new MapHandler());
    }

    /**
     * 结果集处理的方式ColumnListHandler 将结果集中指定列的字段值封装到list集合中
     */
    @Override
    public List<String> findLast_name() throws SQLException {
        String sql = "select * from employees";
        return run.query(DBUtils.getConnection(), sql, new ColumnListHandler<String>("last_name"));
    }

}