JDBC入门学习(更新完结)

什么是JDBC?

概念:Java DataBase Connectivity Java 数据库连接, Java语言操作数据库
JDBC本质:其实是官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口。各个数据库厂商去实现这一套接口,提供数据库驱动jar包。我们可以使用这套接口(JDBC)编程,真正执行代码的是驱动jar包中的实现类。

下面以java代码来操作数据库为案例来演示步骤:

/** * 步骤: 1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar 1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下 2.右键-->Add As Library 2. 注册驱动 3. 获取数据库连接对象 Connection 4. 定义sql 5. 获取执行sql语句的对象 Statement 6. 执行sql,接受返回结果 7. 处理结果 8. 释放资源 */
public class TestMySQL { 
    public static void main(String[] args) throws Exception { 
        //1. 导入驱动jar包
        //2.注册驱动
        Class cls = Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.
                getConnection("jdbc:mysql://localhost:3306/db1", "root", "809080");
        //4.定义sql语句
        String sql = "update account set balance = 1000 where id = 1";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        6.执行sql,rst影响的行数
        int rst = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(rst);
        //8.释放资源
        stmt.close();
        conn.close();
    }
}

详解各个重要对象

  1. DriverManager驱动管理对象
    功能:

    1. 注册驱动:告诉程序应该使用哪一个数据库驱动jar
      static DriverManager.registerDriver(new Driver()):注册给定的驱动程序DriverManager
      写代码使用:Class.forName(“com.mysql.jdbc.Driver”);即可
      通过查看源代码可见,在com.mysql.jdbc.Driver存在静态块
         static { 
        try { 
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) { 
            throw new RuntimeException("Can't register driver!");
        }
        }
    

    注意:mysql5之后,Class.forName(“com.mysql.jdbc.Driver”);可以省略不写,系统自动驱动

    • 获取数据库连接:
      方法:static Connection getConnection(String url,String user, String password)
      参数:

    url:指定连接路径
    jdbc:mysql://ip地址(域名):端口号/数据库名称
    例子:jdbc:mysql://localhost:3306/db3
    细节:如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称
    user:用户名
    password:密码

  2. Connection:数据库连接对象
    功能:

    1. 获取执行sql 的对象
      * Statement createStatement()
      * PreparedStatement prepareStatement(String sql)
    2. 管理事务:
      * 开启事务:setAutoCommit(boolean autoCommit) :调用该方法设置参数为false,即开启事务
      * 提交事务:commit()
      * 回滚事务:rollback()
  3. Statement:执行sql的对象

  • 执行sql
    1. boolean execute(String sql) :可以执行任意的sql 语句了解
    2. int executeUpdate(String sql) :执行DML(insert、update、delete)语句、DDL(create,alter、drop)语句
    返回值:影响的行数,可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功,反之,则失败。
    3. ResultSet executeQuery(String sql) :执行DQL(select)语句
    4. 练习:
1、 account表 添加一条记录
	insert into account value(null,'liuzeyu',3000)
2、 account表 修改记录
	update account set balance = 100000 where id = 3
3、account表 删除一条记录
	delete FROM  account where id  = 3
//替换上述对应的sql执行相应的DML操作
public class JDBCDemo1 {
    public static void main(String[] args) {

        Connection conn = null;
        Statement statement = null;
        //0.导入jar包

        try {
            //1.注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql = "insert into account value(null,'liuzeyu',3000);";
            //4.获取数据库连接对象
                conn = DriverManager.
                        getConnection("jdbc:mysql:///db1","root","809080");

            //5.获取执行sql
            statement = conn.createStatement();
            //6.执行sql,返回影响行数结果
            int rst = statement.executeUpdate(sql);
            //7.处理结果
            if(rst > 0 )
                System.out.println("数据添加成功!");
            else
                System.out.println("数据添加失败!");

        } catch (SQLException e) {
                e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            //释放资源
            if(conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(statement != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  1. ResultSet:结果集对象,封装查询结果
    1. boolean next(): 游标向下移动一行,判断当前行是否是最后一行末尾(是否有数据),如果是,则返回false,如果不是则返回true

    2. getXxx(参数):获取数据,Xxx:代表数据类型 如: int getInt() , String getString()

      1. 参数:
        1. int:代表列的编号,从1开始 如: getString(1)
        2. String:代表列名称。 如: getDouble(“balance”)
      • 注意:
        • 使用步骤:
          1. 游标向下移动一行
          2. 判断是否有数据
          3. 获取数据
/** * 实现:打印表中数据 */
public class JDBCDemo4 {
    public static void main(String[] args) {
        Connection conn = null;
        Statement statement = null;
        //0.注册jar
        try {
            //1、注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2.获取连接对象
            conn = DriverManager.
                    getConnection("jdbc:mysql:///db1", "root", "809080");
            //3.定义sql
            String sql = "select * FROM account";
            //4.获取sql执行对象
            statement = conn.createStatement();
            //5.执行sql返回结果
            ResultSet resultSet = statement.executeQuery(sql);
            //6.处理结果
            //6.1获取结果集
            //6.2游标下移
            while (resultSet.next()){  //结果集是否有下一个
                int id = resultSet.getInt(1);
                String name = resultSet.getString("name");
                double balance = resultSet.getDouble("balance");
                System.out.println("id = " + id +  "---name = " + name +"---工资 = " + balance);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            if(conn!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(statement!=null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

案例1:封装JDBCUtiles工具类 ==> 打印表格
配置文件:

driver=com.mysql.jdbc.Driver
user=root
password=809080
url=jdbc:mysql:///db1
## 注意配置文件最好不要加分号和""表示字符串

工具类实现:

public class JDBCUtils { 
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    
    //静态代码块,在工具类加载的时候jdbc.properties只会被加载一次
    static{ 
        try { 
            //1. 创建Properties集合类。
            Properties pro = new Properties();
            //2.获取src路径下的文件的方式--->ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            //3.获取url
            URL resource = classLoader.getResource("jdbc.properties");
            //4.URL转换成字符串路径
            String path = resource.getPath();
            //5.加载文件
            pro.load(new FileReader(path));
            //6.获取数据,赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");
            //10.注册驱动
            Class.forName(driver);
        } catch (ClassNotFoundException e) { 
            e.printStackTrace();
        } catch (FileNotFoundException e) { 
            e.printStackTrace();
        } catch (IOException e) { 
            e.printStackTrace();
        }
    };

    /** * 获取数据库连接对象 * @return */
    public static  Connection getConnection(){ 
        //1.注册驱动
        try { 
            //2.获取连接
            return  DriverManager.
                    getConnection(url, user, password);
        } catch (SQLException e) { 
            e.printStackTrace();
        }
        return  null;
    }
    /** * 释放资源 * @param resultSet * @param conn * @param statement */
    public  static void close(ResultSet resultSet,Connection conn, Statement statement){ 
        if(conn != null) { 
            try { 
                conn.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
        if(statement != null) { 
            try { 
                statement.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
        if(resultSet != null) { 
            try { 
                resultSet.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
    }
}

emp表:

CREATE TABLE emp (
  id INT PRIMARY KEY, -- 员工id
  ename VARCHAR(50), -- 员工姓名
  job_id INT, -- 职务id
  mgr INT , -- 上级领导
  joindate DATE, -- 入职日期
  salary DECIMAL(7,2), -- 工资
  bonus DECIMAL(7,2), -- 奖金
  dept_id INT -- 所在部门编号
);

-- 添加员工
INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES 
(1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
(1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
(1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
(1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
(1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
(1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
(1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
(1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
(1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
(1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
(1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
(1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
(1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
(1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);

SELECT * FROM emp;

Emp员工类:

public class Emp { 
    private int id;
    private String ename;
    private int job_id;
    private Date joindate;
    private double salary;
    private double bonus;
    private int dept_id;

    @Override
    public String toString() { 
        return "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}' + "\n";
    }

    public int getId() { 
        return id;
    }

    public void setId(int id) { 
        this.id = id;
    }

    public String getEname() { 
        return ename;
    }

    public void setEname(String ename) { 
        this.ename = ename;
    }

    public int getJob_id() { 
        return job_id;
    }

    public void setJob_id(int job_id) { 
        this.job_id = job_id;
    }

    public Date getJoindate() { 
        return joindate;
    }

    public void setJoindate(Date joindate) { 
        this.joindate = joindate;
    }

    public double getSalary() { 
        return salary;
    }

    public void setSalary(double salary) { 
        this.salary = salary;
    }

    public double getBonus() { 
        return bonus;
    }

    public void setBonus(double bonus) { 
        this.bonus = bonus;
    }

    public int getDept_id() { 
        return dept_id;
    }

    public void setDept_id(int dept_id) { 
        this.dept_id = dept_id;
    }
}

测试类:

public class JDBCDemo6 { 
    public static void main(String[] args) { 
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        //0.准备集合
        List<Emp>  emps = new ArrayList<Emp>();
        Emp emp = null;
        //1.导入jar包
        try { 
            //2.定义sql
            String sql = "select * from emp";
            //3.获取数据库连接
            connection = JDBCUtils.getConnection();
            //4.获取执行sql对象
            statement = connection.createStatement();
            //5.执行sql
            resultSet = statement.executeQuery(sql);
            //6.处理结果
            while(resultSet.next()){ 
                 int id = resultSet.getInt("id");
                 String ename = resultSet.getString("ename");
                 int job_id = resultSet.getInt("job_id");
                 Date joindate = resultSet.getDate("joindate");
                 double salary = resultSet.getDouble("salary");
                 double bonus = resultSet.getDouble("bonus");
                 int dept_id = resultSet.getInt("dept_id");

                 //赋值
                emp = new Emp();
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);
                //装载集合
                emps.add(emp);
            }
            System.out.println(emps);
        }catch (SQLException e) { 
            e.printStackTrace();
        }finally { 
            JDBCUtils.close(resultSet,connection,statement);
        }
    }
}

案例2:模拟登录

/** * 实现:模拟控制台输入账号+密码连接数据库登录 */
public class JDBCDemo7 { 
    public static void main(String[] args) { 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入账号:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();
        boolean login = new JDBCDemo7().login(username, password);
        if(login)
            System.out.println("登录成功!");
        else
            System.out.println("账号或密码错误");

    }

    public boolean login(String username,String password){ 
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
            if(username == null && password == null)
                return false;
        try { 
            connection = JDBCUtils.getConnection();
            statement = connection.createStatement();
            String sql = "select *from user where username = '"+username+"' and password = '"+password+"';";
            resultSet = statement.executeQuery(sql);

            return resultSet.next();  //结果集不为空表示查找到了

        }catch (SQLException e) { 
            e.printStackTrace();
        }finally { 
            JDBCUtils.close(resultSet,connection,statement);
        }
            return false;
    }
}
  1. PreparedStatement:执行sql的对象
    引入SQL注入:SQL注入的本质就是利用SQL语法本身的漏洞,绕过系统的检测,入侵后台数据库的操作。
    例如上述案例2,可以利用非法密码:a’ or ‘a’ = ‘a
    构成的SQL语句是:select * from user where username = ‘fhdsjkf’ and password = ‘a’ or ‘a’ = ‘a’
    解决sql注入问题:使用PreparedStatement对象来解决,本质是利用 预编译的SQL:参数使用?作为占位符,然后通过赋值?的方式进行动态的赋值。

步骤:
1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
2. 注册驱动
3. 获取数据库连接对象 Connection
4. 定义sql
* 注意:sql的参数使用?作为占位符。 如:select * from user where username = ? and password = ?;
5. 获取执行sql语句的对象 PreparedStatement Connection.prepareStatement(String sql)
6. 给?赋值:
* 方法: setXxx(参数1,参数2)
* 参数1:?的位置编号 从1 开始
* 参数2:?的值
7. 执行sql,接受返回结果,不需要传递sql语句
8. 处理结果
9. 释放资源

修改上述案例2,解决SQ存在的注入问题

/** * 实现:模拟控制台输入账号+密码连接数据库登录 */
public class JDBCDemo7 { 
    public static void main(String[] args) { 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入账号:");
        String username = sc.nextLine();
        System.out.println("请输入密码:");
        String password = sc.nextLine();
        boolean login = new JDBCDemo7().login2(username, password);
        if(login)
            System.out.println("登录成功!");
        else
            System.out.println("账号或密码错误");

    }
    /** * 使用了PreparedStatement对象解决了SQL注入问题 * @param username * @param password * @return */
    public boolean login2(String username,String password){ 
        Connection connection = null;
        PreparedStatement psmt = null;
        ResultSet resultSet = null;
        if(username == null && password == null)
            return false;
        try { 
            connection = JDBCUtils.getConnection();
            //赋值语句使用?替换
            String sql = "select *from user where username = ? and password = ?;";
            psmt = connection.prepareStatement(sql);
            //为?赋值
            psmt.setString(1,username);
            psmt.setString(2,password);
            resultSet = psmt.executeQuery();

            return resultSet.next();  //结果集不为空表示查找到了

        }catch (SQLException e) { 
            e.printStackTrace();
        }finally { 
            JDBCUtils.close(resultSet,connection,psmt);
        }
        return false;
    }
}

注意:后期都会使用PreparedStatement来完成增删改查的所有操作
1. 可以防止SQL注入
2. 效率更高

JDBC控制事务

  1. 事务:一个包含多个步骤的业务操作。如果这个业务操作被事务管理,则这多个步骤要么同时成功,要么同时失败。
  2. 操作:
    1. 开启事务
    2. 提交事务
    3. 回滚事务
  3. 使用Connection对象来管理事务
    • 开启事务:setAutoCommit(boolean autoCommit) :调用该方法设置参数为false,即开启事务
      • 在执行sql之前开启事务(获取数据库连接之后)
    • 提交事务:commit()
      • 当所有sql都执行完提交事务
    • 回滚事务:rollback()
      • 在catch中回滚事务
/** 使用db1中的account表 * JDBC控制事务,如果出现异常情况,通过回滚事务达到数据的安全性 */
public class JDBCDemo8 { 
    public static void main(String[] args) { 

        Connection connection = null;
        PreparedStatement psmt1 = null;
        PreparedStatement psmt2 = null;
        try { 
            //获取连接
            connection = JDBCUtils.getConnection();
            //开启事务
            connection.setAutoCommit(false);

            //定义sql
            String sql_1 = "update account set balance = balance -? where id = ?;";
            String sql_2 = "update account set balance = balance +? where id = ?;";
            //获取
            psmt1 = connection.prepareStatement(sql_1);
            int i = 3/0 ;  //制造异常
            psmt2 = connection.prepareStatement(sql_2);

            //给?赋值
            psmt1.setDouble(1,500);
            psmt1.setInt(2,1);
            psmt2.setDouble(1,500);
            psmt2.setInt(2,2);

            psmt1.executeUpdate();
            psmt2.executeUpdate();

            //提交事务
            connection.commit();
            

        } catch (SQLException e) { 
            e.printStackTrace();
        }finally { 
            try { 
                if(connection != null)
                connection.rollback();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
            JDBCUtils.close(null,connection,psmt1);
            JDBCUtils.close(null,connection,psmt2);
        }
    }
}

数据库连接池

1、概念:其实就是一个集合,存放数据库连接的容器。
当系统初始化好后,容器会被创建成功,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象返回给容器。
2、好处:

  1. 节约资源
  2. 用户访问高效

3、实现:

  • 标准接口::DataSource javax.sql包下的
    1. 方法:
    * 获取连接:getConnection()
    * 归还连接:Connection.close()。如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接
  • 一般不去实现它,由数据库厂商来实现它
  1. C3P0:数据库连接池技术
    • 步骤:
      1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ,

        • 不要忘记导入数据库驱动jar包
      2. 定义配置文件:

        • 名称: c3p0.properties 或者 c3p0-config.xml
        • 路径:直接将文件放在src目录下即可。
      3. 创建核心对象 数据库连接池对象 ComboPooledDataSource

      4. 获取连接: getConnection

  • 代码:
public class C3P0Demo1 { 
   public static void main(String[] args) throws SQLException { 
       //1.创建数据数据库连接池对象
       DataSource ds = new ComboPooledDataSource();
       for(int i = 0;i < 11;i++) { 
           //2.获取连接对象
           Connection conn = ds.getConnection();
           System.out.println(i + ":"+conn);
       }
   }
}
  1. Druid:数据库连接池实现技术,由阿里巴巴提供的
    1. 步骤:
      1. 导入jar包 druid-1.0.9.jar
      2. 定义配置文件:
        • 是properties形式的
        • 可以叫任意名称,可以放在任意目录下
      3. 加载配置文件。Properties
      4. 获取数据库连接池对象:通过工厂来来获取 DruidDataSourceFactory
      5. 获取连接:getConnection
	/* 测试Demo: */
public class DruidDemo1 { 
    public static void main(String[] args) throws Exception { 

        //1.导入jar包
        //2.加载配置文件
        Properties pro = new Properties();
        ClassLoader cls = DruidDemo1.class.getClassLoader();
        InputStream is = cls.getResourceAsStream("druid.properties");
        pro.load(is);
        //3.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //4.获取连接对象
        for(int i = 0;i<10;i++){ 
            Connection conn = ds.getConnection();
            System.out.println(i + ":"+conn);
        }
    }
}

案例:封装DruidUtils并测试数据库

public class DruidUtils { 
    private static DataSource ds;
    static{ 
        try { 
            //加载jar包
            //加载配置文件
            Properties pro = new Properties();
            ClassLoader classLoader = DruidUtils.class.getClassLoader();
            InputStream is = classLoader.getResourceAsStream("druid.properties");
            pro.load(is);
            //获取DateSourse
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) { 
            e.printStackTrace();
        } catch (Exception e) { 
            e.printStackTrace();
        }
        //
    };
    /** * 释放资源 * @param statement * @param conn * @param resultSet */
    public  static void close(Statement statement, Connection conn, ResultSet resultSet){ 
        if(conn != null) { 
            try { 
                conn.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
        if(statement != null) { 
            try { 
                statement.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
        if(resultSet != null) { 
            try { 
                resultSet.close();
            } catch (SQLException e) { 
                e.printStackTrace();
            }
        }
    }
    /** * 获取连接 * @return */
    public static Connection getConnection(){ 
        try { 
            return ds.getConnection();
        } catch (SQLException e) { 
            e.printStackTrace();
        }
        return null;
    }
}

测试插入account表一条记录

public class DruidDemo2 { 
    public static void main(String[] args) { 
        PreparedStatement preparedStatement = null;
        Connection conn = null;
        try { 
            //1.获取连接
            conn = DruidUtils.getConnection();
            //2.定义sql
            String sql = "insert into account value(null,?,?)";
            preparedStatement = conn.prepareStatement(sql);
            //3.为?赋值
            preparedStatement.setString(1,"jaychou");
            preparedStatement.setDouble(2,999999);
            //4.执行
            preparedStatement.executeUpdate();
        } catch (SQLException e) { 
            e.printStackTrace();
        }finally { 
        	//5.释放资源
            DruidUtils.close(preparedStatement,conn,null);
        }
    }
}

Spring JDBC

  • Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
  • 步骤:
    1. 导入jar包(5个)

    2. 创建JdbcTemplate对象。依赖于数据源DataSource(可以从DruidUtiles获取)

      • 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:查询结果,将结果封装为对象
        • 一般用于聚合函数的查询
    4. 练习:

      • 需求:
        1. 修改1号数据的 salary 为 10000
        2. 添加一条记录
        3. 删除刚才添加的记录
        4. 查询id为1的记录,将其封装为Map集合
        5. 查询所有记录,将其封装为List
        6. 查询所有记录,将其封装为Emp对象的List集合
        7. 查询总记录数
package jdbctemplate;

import druid.DruidUtils;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import utils.JDBCUtils;

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

/** * * 需求: 1. 修改1号数据的 salary 为 10000 2. 添加一条记录 3. 删除刚才添加的记录 4. 查询id为1的记录,将其封装为Map集合 5. 查询所有记录,将其封装为List 6. 查询所有记录,将其封装为Emp对象的List集合 7. 查询总记录数 */
public class TemplateDemo2 { 

    private JdbcTemplate jdbcTemplate = new JdbcTemplate(DruidUtils.getDataSource());

    //1.修改1号数据的 salary 为 10000
    @Test
    public void test01(){ 
        String sql = "update emp set salary = 10000 where id =?";
        int rst = jdbcTemplate.update(sql, 1001);
        System.out.println(rst);
    }

    //2.添加一条记录
    @Test
    public void test02(){ 
        String sql = "insert into emp (id,ename,dept_id)VALUE (?,?,?)";
        int rst = jdbcTemplate.update(sql, 100100,"liuzeyu",4545);
        System.out.println(rst);
    }

    //3.删除刚才添加的记录
    @Test
    public void test03(){ 
        String sql = "DELETE from emp where id = ?";
        int rst = jdbcTemplate.update(sql, 100100);
        System.out.println(rst);
    }
    /** * 4.查询id为1001的记录,将其封装为Map集合 * 注意:这个方法查询的结果集长度只能是1 */
    @Test
    public void test04(){ 
        String sql = "select * from emp where id = ? ";
        Map<String, Object> rst = jdbcTemplate.queryForMap(sql, 1001);
        System.out.println(rst);
    }
    /** * 5.查询所有记录,将其封装为List */
    @Test
    public void test05(){ 
        String sql = "select * from emp";
        /** * List里面装载多个Map */
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);
        for (Map<String, Object> stringObjectMap : list) { 
            System.out.println(stringObjectMap);
        }
    }
    /** * 6. 查询所有记录,将其封装为Emp对象的List集合 */
    @Test
    public void test06(){ 
        String sql = "select * from emp";
        List<Emp> empList = jdbcTemplate.query(sql, new RowMapper<Emp>() { 
            @Override
            public Emp mapRow(ResultSet rs, int i) throws SQLException { 
                Emp emp = new Emp();
                int id = rs.getInt("id");
                String ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                //赋值个Emp
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);
                return emp;
            }
        });
        for (Emp list : empList) { 
            System.out.println(list);
        }
    }

    /** * 6. 查询所有记录,将其封装为Emp对象的List集合 * 这里要注意类型转换==>要统一将基本类型转换成包装类型 */
    @Test
    public void test06_2(){ 
        String sql = "select * from emp";
        List<Emp> empList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
        for (Emp emp : empList) { 
            System.out.println(emp);
        }
    }

    /** * 7. 查询总记录数 */
    @Test
    public void test07(){ 
        String sql = "select count(id) from emp";
        long t = jdbcTemplate.queryForObject(sql, Long.class);
        System.out.println(t);
    }
}

本教程只适合快速入门学习,如有错误欢迎指正。

页面下部广告