后端开发——JDBC的学习（三）

news2024/11/20 15:20:29

本篇继续对JDBC进行总结：

①通过Service层与Dao层实现转账的练习；

②重点：由于每次使用连接就手动创建连接，用完后就销毁，这样会导致资源浪费，因此引入连接池，练习连接池的使用；

③实现一个工具类，不用每次都手写获取连接以及配置数据库要素等，并且对工具类进行优化；然后使用连接池以及工具类对前部分转账部分的练习进行优化；

④对于工具类只封装好了1.注册驱动2.创建连接8.回收资源，因此3.4.5.6.7.这五步没有完成；因此需要用高级应用层封装对这五步进行封装；基本每一个数据表都有一个对应的DAO接口以及其实现类，对其进行增删改查，但是这些操作重复性很高，所以可以抽取出公共的代码，然后给这些DAO的实现类可以抽取一个公共的父类，称为BaseDao； 对于查询操作需要用executeQuery,增删改操作需要用executeUpdate，所以增删改一体，查询一体；

后面会继续更新Mybatis简化JDBC的操作；

以下代码可以直接复制到idea中运行，整体的位置如下：（注意导入druid以及jdbc jar包）

代码一：转账的练习

包含两部分代码，一部分是Service层一部分是Dao层；

package data_test7;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

//TODO 此类是对bank表的一些操作；
public class BankDao {
    //account 加钱的账号，money:加钱的金额；这里需要设计jdbc因为是对数据库中的表中数据进行操作：
    public  void add(String account,int money,Connection connection)throws Exception{
        //此处就不需要再创建链接了，为了保证同一个事务，需要使用一样的连接才行；
        //Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_test", "root", "dir99");
        String sql="update t_bank set money=money+? where account=?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,account);
        int i = preparedStatement.executeUpdate();
        preparedStatement.close();
        //connection.close();
        System.out.println("加钱成功！");
    }
    public  void sub(String account,int money,Connection connection)throws Exception{
        //此处就不需要再创建链接了，为了保证同一个事务，需要使用一样的连接才行；
        //Class.forName("com.mysql.cj.jdbc.Driver");
        //Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_test", "root", "dir99");
        String sql="update t_bank set money=money-? where account=?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,account);
        int i = preparedStatement.executeUpdate();
        preparedStatement.close();
        //connection.close();
        System.out.println("扣钱成功！");

    }
}

package data_test7;

import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;

//TODO 转账测试：
//TODO 银行卡业务方法，调用Dao中的方法；
public class BankService {
    @Test
    public void start() throws Exception {
        //hello给hi转账500块：
        transfer("hi","hello",500);
    }

    public void transfer(String addAccount,String subAccount,int money) throws Exception {
        BankDao bankDao=new BankDao();
        //注意这种方法不准确，因为当一个账户money为零的时候，再运行加钱还是成功，扣钱会报错。
        // 因此需要统一为一个事务，这个事务包括加钱和扣钱；注意一个事务最基本的要求就是必须是同一个连接对象，connection；
        //TODO 需要加上注册驱动和创建连接以及try-catch并且需要关闭自动提交事务，这样加钱和扣钱就是同一个事务；
        Class.forName("com.mysql.cj.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_test", "root", "dir99");
        try{
            //设置不自动提交事务
            connection.setAutoCommit(false);
            bankDao.add(addAccount,money,connection);//此处需要再传入connection连接；
            bankDao.sub(subAccount,money,connection);
            //事务提交：
            connection.commit();
        }catch(Exception e){
            //事务回滚：
            connection.rollback();
            //抛出异常：
            throw e;
        }finally {
            connection.close();
        }
        //TODO 正常就提交事务，出现异常就回滚到原来的那样，防止扣钱失败，但是加钱成功类似的错误；
        //TODO 总结：事务是添加到业务方法中的；利用try-catch代码块，开始事务和提交事务以及事务回滚；将connection传入dao层即可，dao只负责使用，不用close；


    }
}

代码二：连接池的使用：

package data_test8;//TODO 数据库连接池：每次使用连接就创建然后销毁的话，会比较浪费资源，因此使用的时候可以在连接池中直接获取，使用完后再放回到连接池中：
// Druid连接池的使用：

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

public class DruidUsepart {
    //硬编码方式：
    //直接使用代码设置连接池连接参数方式！
    //1.创建一个druid连接池对象
    //2.设置连接池参数：【必须|非必须】
    //3.获取连接[通用方法，所有连接都一样]
    //4.回收连接
    public void testHard() throws Exception {
        //连接池对象：
        DruidDataSource dataSource=new DruidDataSource();
        //设置参数：
        //必须设置的参数：
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/jdbc_test");
        dataSource.setUsername("root");
        dataSource.setPassword("dir99");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");//帮助注册驱动和创建连接；
        //非必须的参数：
        dataSource.setInitialSize(5);//初始化连接的数量；
        dataSource.setMaxActive(10);//最大数量
        //获取链接：
        Connection connection=dataSource.getConnection();
        //数据库操作
        connection.close();
    }
    public void testSoft() throws Exception {
        //软编码方式：
        //通过读取外部的配置文件的方法实例化druid连接池对象；
        //1.读取配置文件 Properties
        Properties properties=new Properties();
        InputStream resourceAsStream = DruidUsepart.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(resourceAsStream);
        //2.使用连接池工具类的工厂模式创建连接池；
        DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
        Connection connection=dataSource.getConnection();
        //数据库操作
        connection.close();
    }
}
//TODO 每次使用连接都这样重新设置比较麻烦，因此想将他们封装到工具类中，每次想使用调用那个类即可；

代码三：工具类的实现以及优化：

普通版：

package data_test8;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

//TODO 工具类1.0版本，内部包含一个连接池对象，并且对外提供获取连接和回收连接的方法；
//TODO 工具类中的方法一般设置为静态的，方便外部调用；
/*实现内容：
属性：连接池对象只能实例化一次 实现方法：单例模式或者static代码块（全局只调用一次）
方法：对外提供链接的方法，回收外部传入连接方法
 */
public class jdbc_utils1 {
    private static DataSource dataSource=null;
    static{
        Properties properties=new Properties();
        InputStream resourceAsStream = jdbc_utils1.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataSource= DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //对外提供获取连接方法：
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
    //回收方法：
    public static void freeConnection(Connection connection) throws SQLException {
        connection.close();
    }


}

优化后：

package data_test8;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
//TODO 对于第一个版本的工具类有缺陷，就是在不同方法中调用getconnection方法，返回的是新的连接，并不是一样的连接；
//TODO 利用线程本地变量存储连接信息，确保一个线程的多个方法获取同一个连接connection；
// 优点：实务操作的时候，service和dao 属于同一个线程，不用再传递参数了，大家都可以调用getConnection方法自动获取的是同一个连接；

public class jdbc_util2 {
    private static DataSource dataSource=null;
    private static ThreadLocal<Connection>tl=new ThreadLocal<>();

    static{
        Properties properties=new Properties();
        InputStream resourceAsStream = jdbc_utils1.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataSource= DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //对外提供获取连接方法：
    public static Connection getConnection() throws SQLException {
        //先查看线程本地变量中是否存在
        Connection connection = tl.get();
        if(connection==null){
            //线程本地变量中没有，连接池获取
            connection=dataSource.getConnection();
            //存入线程本地变量
            tl.set(connection);
        }
        return connection;
    }
    //回收方法：
    public static void freeConnection() throws SQLException {
        Connection connection=tl.get();
        if(connection!=null){
            //清空线程本地变量
            tl.remove();
            connection.setAutoCommit(true);//要回归到初始状态，当开启事务的时候是false；
            connection.close();//回收到连接池；
        }
        connection.close();
    }
}

代码四：对转账练习的优化（使用连接池以及工具类）

package data_test8.daoANDservice;

import data_test8.jdbc_util2;

import java.sql.Connection;
import java.sql.PreparedStatement;

//TODO 此类是对bank表的一些操作；
public class BankDao {
    //account 加钱的账号，money:加钱的金额；这里需要设计jdbc因为是对数据库中的表中数据进行操作：
    public  void add(String account,int money)throws Exception{
        //TODO 可以直接从连接池中获取：
        Connection connection = jdbc_util2.getConnection();
        String sql="update t_bank set money=money+? where account=?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,account);
        int i = preparedStatement.executeUpdate();
        preparedStatement.close();
        //connection.close();
        System.out.println("加钱成功！");
    }
    public  void sub(String account,int money)throws Exception{
//TODO 直接从连接池中获取
        Connection connection = jdbc_util2.getConnection();
        String sql="update t_bank set money=money-? where account=?;";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,account);
        int i = preparedStatement.executeUpdate();
        preparedStatement.close();
        //connection.close();
        System.out.println("扣钱成功！");

    }
}

package data_test8.daoANDservice;

import data_test8.jdbc_util2;
import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;

//TODO 转账测试：
//TODO 银行卡业务方法，调用Dao中的方法；
public class BankService {
    @Test
    public void start() throws Exception {
        //hello给hi转账500块：
        transfer("hi","hello",500);
    }

    public void transfer(String addAccount,String subAccount,int money) throws Exception {
        BankDao bankDao=new BankDao();

//TODO 直接从连接池中获取
        Connection connection = jdbc_util2.getConnection();
        try{
            //设置不自动提交事务,开启事务：
            connection.setAutoCommit(false);
            bankDao.add(addAccount,money);
            bankDao.sub(subAccount,money);
            //事务提交：
            connection.commit();
        }catch(Exception e){
            //事务回滚：
            connection.rollback();
            //抛出异常：
            throw e;
        }finally {
            jdbc_util2.freeConnection();
        }
    }
}

代码五：对sql语句进行封装，结合工具类以及连接池对增删改查操作的优化；

package data_test9;//TODO 首先jdbc中一共有八步：1.注册驱动2.创建连接3.编写sql语句4创建statement5.占位符赋值6.发送sql语句7.结果解析8.回收资源；

import data_test8.jdbc_util2;

import java.lang.reflect.Field;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

// TODO 对于test8中的工具类只封装好了1.注册驱动2.创建连接8.回收资源，因此3.4.5.6.7.这五步没有完成；因此需要用高级应用层封装对这五步进行封装；
// TODO 基本每一个数据表都有一个对应的DAO接口以及其实现类，对其进行增删改查，但是这些操作重复性很高，所以可以抽取出公共的代码，然后给这些DAO的实现类可以抽取一个公共的父类，称为BaseDao；
//TODO 对于查询操作需要用executeQuery,增删改操作需要用executeUpdate，所以增删改一体，查询一体；
public class BaseDao {

    public int executeUpdate(String sql,Object...params) throws SQLException {
        //TODO 此处是对非查询语句方法的封装：sql是传入的带占位符的sql语句；params是占位符的值，此处用了可变参数(注意，可变参数可以直接当作数组使用)；

        Connection connection = jdbc_util2.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        for(int i=0;i<params.length;i++){//TODO 注意此处
            preparedStatement.setObject(i+1,params[i]);
        }
        int rows = preparedStatement.executeUpdate();
        //是否回收连接，需要考虑是否是事务,如果将setAutoCommit设置为false代表事务开始，不自动提交，这一系列的操作，要么全部执行成功，要么全部都不成功；如果开启事务了，就不用管，业务层去处理；
        if(connection.getAutoCommit()){//可以通过这个方法来获取是否是false还是true也就是事务是否开启
            //如果为true代表没有开启事务，此时就需要回收；
            jdbc_util2.freeConnection();

        }
        return rows;
    }
    /*
    对于非查询语句的方法返回值是int类型，代表了影响的行数；但是对于查询语句方法返回的是什么类型呢，确实是一个集合，但并不是list<Map>，map没有数据校验机制，并且不支持反射操作；
    其实数据库数据-》对应java的实体类，有一个表：user表，里面有id，name，account，password属性，此时这个表对应一个java类：User类，有id，name，account，password属性，那么表中的一行数据，代表java类的一个对象，——》多行——》List<java实体类>list；
    java实体类可以校验并且支持反射操作；
    那么返回值的类型就是某一个实体类的集合
    <T>声明一个泛型，不确定类型；第一个<T>表示这个方法是一个泛型方法，可以用于指定查询结果的类型；List<T>表示该方法返回的是一个包含T类型的对象的集合，下方的Class<T>由外面传入，确定这个泛型的类型，例如传入一个User类，那么这个泛型就是User类型，还有一个好处就是可以使用这个类的反射机制给属性赋值
    public <T> List<T> executeQuery(Class<T>cla,String sql,Object...params)
    具体实现如下：
     */
    public <T> List<T> executeQuery(Class<T> cla, String sql, Object...params) throws Exception {
        //获取连接：
        Connection connection = jdbc_util2.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //占位符赋值：
        if(params!=null&&params.length!=0){
            for(int i=0;i<params.length;i++){
                preparedStatement.setObject(i+1,params[i]);
            }
        }
        //执行sql语句：
        ResultSet resultSet = preparedStatement.executeQuery();
        //结果解析：
        List<T>list=new ArrayList<>();
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取列的数量，也就是属性的数量；
        int columnCount = metaData.getColumnCount();
        while(resultSet.next()){
            T t=cla.newInstance();//利用反射调用类的无参构造函数实例化对象！
            for(int i=1;i<=columnCount;i++){
                //得到本行i列属性的值
                Object object=resultSet.getObject(i);
                //得到本行i列的属性名：
                String columnLabel = metaData.getColumnLabel(i);
                //此时得到了这一列属性名和属性值，也就是给这个类的实例化对象的属性赋值，可以利用反射实现：
                Field field = cla.getDeclaredField(columnLabel);
                field.setAccessible(true);//属性可能是私用的，这样就可以打破private修饰限制，属性可以被设置；
                //给对象的属性赋值：第一个参数是想要赋值的对象，如果属性为静态的，可以为null；第二个参数是属性值：
                field.set(t,object);

            }
            list.add(t);
        }
        //关闭资源：
        resultSet.close();
        preparedStatement.close();
        if(connection.getAutoCommit()){
            //没有事务可以关闭:
            jdbc_util2.freeConnection();
        }
        return list;
    }


}

package data_test9;

import org.junit.Test;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
//TODO 利用新封装的BaseDao类，对增删改查进行优化：
public class better extends BaseDao {//TODO 此处需要继承一下BaseDao这样就有了其中的Update方法；
    public static void main(String[] args) {

    }
    @Test
    public void testInsert() throws Exception {
//        //对于job_grades表：添加A 1500 3000这条数据
//        //1.创建驱动：
//        Class.forName("com.mysql.jdbc.Driver");
//        //2.创建连接：
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb","root","dir99");
//        //3.编写sql语句以及创建prepareStatement
//        String sql="insert into job_grades values(?,?,?)";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,"A");
//        preparedStatement.setObject(2,1500);
//        preparedStatement.setObject(3,3000);
//        //发送sql语句：
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("数据插入成功！");
//        }else{
//            System.out.println("数据插入失败！");
//        }
//        preparedStatement.close();
//        connection.close();
        String sql="insert into job_grades values(?,?,?)";
        int a = executeUpdate(sql, "A", 88888, 66666);//返回影响行数；


    }
    @Test
    public void testDelete()throws Exception{
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="delete from job_grades where grade_level=?";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,"F");
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("删除成功！");
//        }else{
//            System.out.println("删除失败！");
//        }
//        preparedStatement.close();
//
        String sql="delete from job_grades where grade_level=? and lowest_sal=?";
        executeUpdate(sql,"A",88888);

    }
    @Test
    public void testUpdate()throws Exception{
        //对于job_grades表：将刚添加的A 1500 3000这条数据中3000改为9999；
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="update job_grades set highest_sal=? where lowest_sal=?";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,9999);
//        preparedStatement.setObject(2,1500);
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("更新成功！");
//        }else{
//            System.out.println("更新失败！");
//        }
//        preparedStatement.close();
//        connection.close();
        String sql="update job_grades set highest_sal=? where lowest_sal=?";
        int i = executeUpdate(sql,99999,66666);


    }
    @Test
    //注意此处查询想查询所有数据，然后将数据放入到List<Map>list集合中：
    //可知查询结果是一行一行的，返回的是resultSet,然后将一行存入到map中，map(key=列名，value=列的内容)-》List<Map> list;
    //实现思路：遍历每一行数据，一行对应一个map，获取一行的列名和对应的列的属性，装配即可；然后将map装到一个集合当中就完成了；
    public void testSearch()throws Exception{
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="select * from job_grades";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        ResultSet resultSet = preparedStatement.executeQuery();
//        //TODO 获取列的信息对象:避免手动获取每一个列的数据,metaData装的是当前结果集中列的信息对象（它可以根据下角标获取列的名称，也可以获取列的数量）；
//        ResultSetMetaData metaData = resultSet.getMetaData();
//        //列的数量：有了它以后就可以水平遍历列：
//        int columnCount = metaData.getColumnCount();
//        List<Map> list=new ArrayList<>();
//        while(resultSet.next()){
//            //一行对应一个map；
//            Map map=new HashMap();
//            //下面这种方式纯手动提取，如果列的个数更多会非常麻烦并且换一个表就得重新写，效率很低；
            map.put("gradelevel",resultSet.getString(1));
            map.put("lowestsal",resultSet.getInt(2));
            map.put("highestsal",resultSet.getInt(3));
//            //新的方法读取每一个属性的数据，自动遍历列，注意要从一开始，和数据区分开
//            for(int i=1;i<=columnCount;i++){
//                //获取对应列的属性值：
//                Object value = resultSet.getObject(i);
//                //要是想加入map中，需要传入key和value，value已经有了，但是key：列名还没有：获取列的名称：这个方法可以获取列的别名，getcolumnname方法会获取列的名称，万一要是起了别名，就找不到了；
//                String columnLabel = metaData.getColumnLabel(i);
//                map.put(columnLabel,value);
//            }
//            list.add(map);
//        }
//        System.out.println(list);
//        for(Object data:list){
//            System.out.println(data);
//        }
//        resultSet.close();
//        preparedStatement.close();
//        connection.close();
        String sql="select * from job_grades";
        Class<Job_grades> clas = Job_grades.class;
        List<Job_grades> a = executeQuery(clas, sql);
        for (Object o:a){
            System.out.println(o);
        }
    }
}
class Job_grades{
    private String grade_level;
    private int lowest_sal;
    private int highest_sal;
    public String toString(){
        return grade_level+" "+lowest_sal+" "+highest_sal;
    }


}

package data_test9;

import org.junit.Test;

import java.sql.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
//TODO 利用新封装的BaseDao类，对增删改查进行优化：
public class better extends BaseDao {//TODO 此处需要继承一下BaseDao这样就有了其中的Update方法；
    public static void main(String[] args) {

    }
    @Test
    public void testInsert() throws Exception {
//        //对于job_grades表：添加A 1500 3000这条数据
//        //1.创建驱动：
//        Class.forName("com.mysql.jdbc.Driver");
//        //2.创建连接：
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb","root","dir99");
//        //3.编写sql语句以及创建prepareStatement
//        String sql="insert into job_grades values(?,?,?)";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,"A");
//        preparedStatement.setObject(2,1500);
//        preparedStatement.setObject(3,3000);
//        //发送sql语句：
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("数据插入成功！");
//        }else{
//            System.out.println("数据插入失败！");
//        }
//        preparedStatement.close();
//        connection.close();
        String sql="insert into job_grades values(?,?,?)";
        int a = executeUpdate(sql, "A", 88888, 66666);//返回影响行数；


    }
    @Test
    public void testDelete()throws Exception{
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="delete from job_grades where grade_level=?";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,"F");
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("删除成功！");
//        }else{
//            System.out.println("删除失败！");
//        }
//        preparedStatement.close();
//
        String sql="delete from job_grades where grade_level=? and lowest_sal=?";
        executeUpdate(sql,"A",88888);

    }
    @Test
    public void testUpdate()throws Exception{
        //对于job_grades表：将刚添加的A 1500 3000这条数据中3000改为9999；
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="update job_grades set highest_sal=? where lowest_sal=?";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        preparedStatement.setObject(1,9999);
//        preparedStatement.setObject(2,1500);
//        int i = preparedStatement.executeUpdate();
//        if(i>0){
//            System.out.println("更新成功！");
//        }else{
//            System.out.println("更新失败！");
//        }
//        preparedStatement.close();
//        connection.close();
        String sql="update job_grades set highest_sal=? where lowest_sal=?";
        int i = executeUpdate(sql,99999,66666);


    }
    @Test
    //注意此处查询想查询所有数据，然后将数据放入到List<Map>list集合中：
    //可知查询结果是一行一行的，返回的是resultSet,然后将一行存入到map中，map(key=列名，value=列的内容)-》List<Map> list;
    //实现思路：遍历每一行数据，一行对应一个map，获取一行的列名和对应的列的属性，装配即可；然后将map装到一个集合当中就完成了；
    public void testSearch()throws Exception{
//        Class.forName("com.mysql.jdbc.Driver");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/atguigudb", "root", "dir99");
//        String sql="select * from job_grades";
//        PreparedStatement preparedStatement = connection.prepareStatement(sql);
//        ResultSet resultSet = preparedStatement.executeQuery();
//        //TODO 获取列的信息对象:避免手动获取每一个列的数据,metaData装的是当前结果集中列的信息对象（它可以根据下角标获取列的名称，也可以获取列的数量）；
//        ResultSetMetaData metaData = resultSet.getMetaData();
//        //列的数量：有了它以后就可以水平遍历列：
//        int columnCount = metaData.getColumnCount();
//        List<Map> list=new ArrayList<>();
//        while(resultSet.next()){
//            //一行对应一个map；
//            Map map=new HashMap();
//            //下面这种方式纯手动提取，如果列的个数更多会非常麻烦并且换一个表就得重新写，效率很低；
            map.put("gradelevel",resultSet.getString(1));
            map.put("lowestsal",resultSet.getInt(2));
            map.put("highestsal",resultSet.getInt(3));
//            //新的方法读取每一个属性的数据，自动遍历列，注意要从一开始，和数据区分开
//            for(int i=1;i<=columnCount;i++){
//                //获取对应列的属性值：
//                Object value = resultSet.getObject(i);
//                //要是想加入map中，需要传入key和value，value已经有了，但是key：列名还没有：获取列的名称：这个方法可以获取列的别名，getcolumnname方法会获取列的名称，万一要是起了别名，就找不到了；
//                String columnLabel = metaData.getColumnLabel(i);
//                map.put(columnLabel,value);
//            }
//            list.add(map);
//        }
//        System.out.println(list);
//        for(Object data:list){
//            System.out.println(data);
//        }
//        resultSet.close();
//        preparedStatement.close();
//        connection.close();
        String sql="select * from job_grades";
        Class<Job_grades> clas = Job_grades.class;
        List<Job_grades> a = executeQuery(clas, sql);
        for (Object o:a){
            System.out.println(o);
        }
    }
}
class Job_grades{
    private String grade_level;
    private int lowest_sal;
    private int highest_sal;
    public String toString(){
        return grade_level+" "+lowest_sal+" "+highest_sal;
    }


}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1358344.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

新年福利｜这款价值数万的报表工具永久免费了

新年福利｜这款价值数万的报表工具永久免费了

随着数据资产的价值逐渐凸显&#xff0c;越来越多的企业会希望采用报表工具来处理数据分析&#xff0c;了解业务经营状况&#xff0c;从而辅助经营决策。不过&#xff0c;企业在选型报表工具的时候经常会遇到以下几个问题&#xff1a; 各个报表工具有很多功能和特性&#xff0c…
阅读更多...
Python数据处理库之tablib详解

Python数据处理库之tablib详解

概要 Python 提供了许多库和工具来处理数据&#xff0c;其中之一就是 tablib。tablib 是一个功能强大且易于使用的库&#xff0c;用于处理各种数据格式&#xff0c;包括Excel、CSV、JSON等。它不仅可以用于数据导入和导出&#xff0c;还支持数据转换、过滤、合并等操作。本文将…
阅读更多...
《C++语言程序设计（第5版）》（清华大学出版社，郑莉 董渊编著）习题——第2章 C++语言简单程序设计

《C++语言程序设计（第5版）》（清华大学出版社，郑莉 董渊编著）习题——第2章 C++语言简单程序设计

2-28 用穷举法找出1~100的质数并显示出来。分别使用while、do-while、for循环语句实现。 // 使用while循环#include <iostream>using namespace std;int main() {int number 2;cout << "1~100之间的质数有&#xff1a;";while (number < 100) {int …
阅读更多...
HarmonyOS应用开发之ArkTS语言学习记录

HarmonyOS应用开发之ArkTS语言学习记录

1、ArkTS介绍 ArkTS是鸿蒙生态的应用开发语言。它在保持TypeScript&#xff08;简称TS&#xff09;基本语法风格的基础上&#xff0c;对TS的动态类型特性施加更严格的约束&#xff0c;引入静态类型。同时&#xff0c;提供了声明式UI、状态管理等相应的能力&#xff0c;让开发者…
阅读更多...
Xcode15在iOS12系统上崩溃的原因

Xcode15在iOS12系统上崩溃的原因

1.1.崩溃在_dyld_start&#xff0c;如图&#xff1a; 崩溃截图 解决办法&#xff1a;在other link flags添加-ld64 注意&#xff1a;该办法只能解决运行真机&#xff0c;archive出来的包依然报错闪退...... 1.2 SwiftUI导致iOS12及以下系统闪退问题 SwiftUI是iOS13开始使用&…
阅读更多...
MongoDB 启动时：服务名无效

MongoDB 启动时：服务名无效

1.问题场景 电脑睡眠后&#xff0c;再连接服务发现无法连接&#xff0c;启动服务报&#xff1a;服务名无效。 2.打开服务管理&#xff1a; 发现服务中没有MongoDB的服务 3.解决 &#xff08;1&#xff09;先找打MongoDB安装路径&#xff0c;把data文件夹下所有文件删除 &a…
阅读更多...
Python之安装和环境配置

Python之安装和环境配置

python的下载 1.可以去python官网下载&#xff0c;https://www.python.org/ 2.下载完成后&#xff0c;安装即可。 python的检测 1.打开开始-运行-cmd&#xff08;快捷键winR&#xff09;。 如果是mac&#xff0c;打开使用工具-终端。 2.在终端里输入python&#xff0c;以下…
阅读更多...
魔法少女小Scarlet#洛谷

魔法少女小Scarlet#洛谷

题目描述 Scarlet 最近学会了一个数组魔法&#xff0c;她会在 n n n\times n nn 二维数组上将一个奇数阶方阵按照顺时针或者逆时针旋转 9 0 ∘ 90^\circ 90∘。 首先&#xff0c;Scarlet 会把 1 1 1 到 n 2 n^2 n2 的正整数按照从左往右&#xff0c;从上至下的顺序填入初…
阅读更多...
「Vue3面试系列」Vue3 所采用的 Composition Api 与 Vue2 使用的 Options Api 有什么不同？

「Vue3面试系列」Vue3 所采用的 Composition Api 与 Vue2 使用的 Options Api 有什么不同？

文章目录 开始之前正文一、Options Api二、Composition Api三、对比逻辑组织Options APICompostion API 逻辑复用 小结 开始之前 Composition API 可以说是Vue3的最大特点&#xff0c;那么为什么要推出Composition Api&#xff0c;解决了什么问题&#xff1f; 通常使用Vue2开…
阅读更多...
山西电力市场日前价格预测【2024-01-06】

山西电力市场日前价格预测【2024-01-06】

日前价格预测 预测说明&#xff1a; 如上图所示&#xff0c;预测明日&#xff08;2024-01-06&#xff09;山西电力市场全天平均日前电价为261.48元/MWh。其中&#xff0c;最高日前电价为424.18元/MWh&#xff0c;预计出现在18:00。最低日前电价为0.00元/MWh&#xff0c;预计出…
阅读更多...
vivado non-project

vivado non-project

https://www.xilinx.com/video/hardware/using-the-non-project-batch-flow.html --video https://cloud.tencent.com/developer/article/1169476 bd related run_my_design.tcl 交互模式 start_gui stop_gui
阅读更多...
图解设计模式-中介者模式（Mediator）

图解设计模式-中介者模式（Mediator）

中介者模式 定义 使用一个中介者对象&#xff08;mediator&#xff09;集中封装多个具有依赖/关联关系的对象&#xff08;colleague&#xff0c;同事对象&#xff09;之间的交互&#xff0c;使各对象之间不再互相引用&#xff0c;降低对象之间的强耦合程度&#xff0c;对象之…
阅读更多...
Vue CLI组件通信

Vue CLI组件通信

目录 一、组件通信简介1.什么是组件通信&#xff1f;2.组件之间如何通信3.组件关系分类4.通信解决方案5.父子通信流程6.父向子通信代码示例7.子向父通信代码示例8.总结 二、props1.Props 定义2.Props 作用3.特点4.代码演示 三、props校验1.思考2.作用3.语法4.代码演示 四、prop…
阅读更多...
借助文档控件Aspose.Words，使用 Java 在 Word 文档中创建表格

借助文档控件Aspose.Words，使用 Java 在 Word 文档中创建表格

Microsoft Word 是一种流行的文字处理应用程序&#xff0c;用于创建各种类型的文档。这些文档可能包含多种类型的元素&#xff0c;包括文本、图像、表格和图表。当涉及到用 Java 自动创建和操作文档时&#xff0c;您可能需要一个轻松的解决方案来在 Word 文档中创建表格。因此&…
阅读更多...
CentOS 8 基于官方源码制作openssh 9.6 rpm包(含ssh-copy-id、openssl) —— 筑梦之路

CentOS 8 基于官方源码制作openssh 9.6 rpm包(含ssh-copy-id、openssl) —— 筑梦之路

CentOS 8 制作openssh9.6 rpm(含ssh-copy-id命令)包 —— 筑梦之路_centos8 rpmbuild -ba openssh.spec 9.6-CSDN博客 CentOS 8 制作openssh9.0/9.2/9.3 rpm包——筑梦之路_centos8 openssl rpm包-CSDN博客 效果截图&#xff1a; 和使用官方默认的spec文件制作的区别&#xff…
阅读更多...
2014年多线冲刺1000万

2014年多线冲刺1000万

1、盯重要的科技股票等待机会低价买入&#xff08;投入不超过20万&#xff0c;全亏也认了。&#xff09;目标20倍取出即400万。3次机会达1000万就收手。 2、公司&#xff0c;找机会。1000万。 3、创业&#xff0c;经商做企业。1000万。 4、直播&#xff0c;视频&#xff0c;课程…
阅读更多...
x-cmd pkg | tig - git 文本模式界面

x-cmd pkg | tig - git 文本模式界面

目录 简介首次用户功能特点类似工具与竞品进一步探索 简介 tig 由 Jonas Fonseca 于 2006 年使用 C 语言创建的 git 交互式文本命令行工具。旨在开启交互模式快速浏览 git 存储库的信息以及 git 命令的运行。 首次用户 使用 x tig 即可自动下载并使用 在终端运行 eval "…
阅读更多...
『番外篇十』SwiftUI 实战：打造一款“五脏俱全”的网络图片显示 App（下）

『番外篇十』SwiftUI 实战：打造一款“五脏俱全”的网络图片显示 App（下）

概览 在上篇文章中，我们初步实现了一款小巧的网络图片显示器。 我们先是创建了 json 数据对应的图片模型，然后将 App 界面“分而治之”划分为独立的三个组件以便“逐个击破”，最后我们将所有这些融合在一起。 不过，目前的实现仍有一些问题。比如我们添加了一层不必要的 …
阅读更多...
每周一算法：倍增法求最近公共祖先（LCA）

每周一算法：倍增法求最近公共祖先（LCA）

最近公共祖先 最近公共祖先简称 LCA&#xff08;Lowest Common Ancestor&#xff09;。两个节点的最近公共祖先&#xff0c;就是这两个点的公共祖先里面&#xff0c;离根最远的那个。 题目链接 祖孙询问 题目描述 给定一棵包含 n n n 个节点的有根无向树&#xff0c;节点…
阅读更多...
P1025 [NOIP2001 提高组] 数的划分———C++(动态规划、DFS)

P1025 [NOIP2001 提高组] 数的划分———C++(动态规划、DFS)

目录 [NOIP2001 提高组] 数的划分题目描述输入格式输出格式样例 #1样例输入 #1样例输出 #1 提示 动态规划的解题思路Code运行结果DFSCode运行结果 [NOIP2001 提高组] 数的划分 题目描述 将整数 n n n 分成 k k k 份&#xff0c;且每份不能为空&#xff0c;任意两个方案不相…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023