Java21：JDBC

最新推荐文章于 2024-05-19 17:03:37 发布
最新推荐文章于 2024-05-19 17:03:37 发布
阅读量1k 收藏 23
点赞数 18
分类专栏： java 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzx_nihao/article/details/136439053
版权

一：定义：

jdbc: Java Database Connectiontivity  数据库连接技术

通俗点说，在java代码中，使用JDBC提供的方法，可以发送字符串类型的sql语句到数据库管理软件（mysql，Oracle）并获取执行语句结果，进而实现数据库数据curd操作的技术

二：核心api

》DriverManager:1)根据第三方厂商提供的驱动jar包注册到程序中2）根据驱动程序获取数据库连接

》Connection ：是接口，和数据库建立的连接对象，可以多次执行curd操作，并可以获取Statement,PreparedStatement,CallalbeStatement, 其中PreparedStatement为重点

》PesultSet ：接口， 为返回的查询的结果集，并包含一个指针

三：实例

1.Statement使用方式（局限：只能执行固定的sql语句 属于硬编码）

public class StatementTest {
    public static void main(String[] args) throws Exception {

        //1.注册驱动 方式一：
        //DriverManager.registerDriver(new Driver());
        //方式二 ：反射 ；Class.forName("com.mysql.cj.jdbc.Driver");
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.建立连接 :getConnection()三个参数
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1", "root", "root");
//        getConnection()二个参数
//        Properties pro =new Properties();
//        pro.put("user","root");
//        pro.put("password","root");
//        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1", pro);
        //getConnection()1个参数
        //Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test1?user=root&password=root");

        //3.创建statement对象
        Statement statement = connection.createStatement();

        //4.发送sql，并返回结果集
        String sql="select id ,name, salary from emp ";
        ResultSet resultSet = statement.executeQuery(sql);
        //5.解析结果集,
        while(resultSet.next()){
           int id = resultSet.getInt("id");
           // 也可以调用列的索引，重左向右，从1开始
           //int id = resultSet.getInt(1);
            String name = resultSet.getString("name");

            double salary = resultSet.getDouble("salary");
            System.out.println(id +"-"+name+"-"+ salary);

        }
        //6.关闭资源
        resultSet.close();
        statement.close();
        connection.close();




    }

2.PreparedStatement :预定义的方式，开发主要使用该种方法

public class PreparedStatementTest1 {
    public static void main(String[] args) throws Exception {
        //实现从键盘登录系统并判断是否登录成功
        Scanner scan =new Scanner(System.in);
        System.out.println("请输入用户名：");
        String user = scan.nextLine();
        System.out.println("请输入密码：");
        String password = scan.nextLine();

        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建PreparedStatement对象
        String sql="select name,password from user where name=? and password=?";
        PreparedStatement pres= connection.prepareStatement(sql);
        //4.占位符赋值
        pres.setObject(1,user);
        pres.setObject(2,password);
        //5.发送sql并返回结果集
        ResultSet resultSet = pres.executeQuery();
        if(resultSet.next()){
            System.out.println("登录成功！");
        }else{
            System.out.println("登录失败！");
        }
        //6.关闭资源
        resultSet.close();
        pres.close();
        connection.close();

    }
}

3.PreparedStatement 的curd的操作

public class PreparedStatementTest2 {
    @Test
    //新增一条记录
    public void insertTest() throws Exception {
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建PreparedStatement对象
        String sql = "insert into user (id,name,password)values(?,?,?)";
        PreparedStatement pres = connection.prepareStatement(sql);
        //4.占位符赋值
        pres.setObject(1, 2);
        pres.setObject(2, "jerry");
        pres.setObject(3, 111111);
        //5.发送sql语句并返回执行结果，执行结果为影响的行数
        int rows = pres.executeUpdate();
        System.out.println(rows);
        //6.关闭资源

        pres.close();
        connection.close();

    }

    @Test
    //修改记录
    public void updateTest() throws Exception {
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建PreparedStatement对象
        String sql = "update user set password=? where id=?";
        PreparedStatement pres = connection.prepareStatement(sql);
        //4.占位符赋值
        pres.setObject(1, "222222");
        pres.setObject(2, 3);
        //5.发送sql语句并返回执行结果，执行结果为影响的行数
        int rows = pres.executeUpdate();
        System.out.println(rows);
        //6.关闭资源

        pres.close();
        connection.close();


    }

    @Test
    //删除记录
    public void deleteTest() throws Exception {
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建PreparedStatement对象
        String sql = "delete from  user  where id=?";
        PreparedStatement pres = connection.prepareStatement(sql);
        //4.占位符赋值
        pres.setObject(1, 2);
        //5.发送sql语句并返回执行结果，执行结果为影响的行数
        int rows = pres.executeUpdate();
        System.out.println(rows);
        //6.关闭资源
        pres.close();
        connection.close();

    }
    @Test
    //查询记录
    public void queryTest() throws Exception {
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建PreparedStatement对象
        String sql = "select id,name,password from user where id=?";
        PreparedStatement pres = connection.prepareStatement(sql);
        //4.占位符赋值
        pres.setObject(1, 3);
        //5.发送sql语句并返回执行结果
        ResultSet resultSet = pres.executeQuery();
        while(resultSet.next()){
            int id = resultSet.getInt(1);
            String name = resultSet.getString(2);
            String password = resultSet.getString(3);
            System.out.println(id+","+name+","+password);
        }
            //6.关闭资源
            resultSet.close();
            pres.close();
            connection.close();


    }
}

4.使用PreparedStatement 实现查询数据，并把结果集信息存到List<Map>中

public class PreparedStatementTest3 {
    public static void main(String[] args) throws Exception {
        //实现查询数据，并把结果集信息存到List<Map>中

        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.编写sql语句
        String sql = "select id ,name ,password as ps from user where id<?";
        //4.创建PreparedStaement 对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //5.占位符赋值
        preparedStatement.setObject(1,100);
        //6.发送sql语句,并返回结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        //7.解析结果集并封装到List中
        List<Map> list =new ArrayList<>();


        //获取列的数据集（元数据）
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取列的总数
        int columnCount = metaData.getColumnCount();

        //方式一：该种方式不好，如果列有别名解析不出来
      while(resultSet.next()){
//            Map map =new HashMap();
//            int id = resultSet.getInt("id");
//            String name = resultSet.getString("name");
//            String password = resultSet.getString("password");
//            map.put("id",id);
//            map.put("name",name);
//            map.put("password",password);
//            list.add(map);
          //每一行创建一个map
          Map map =new HashMap();
          for(int i=1;i<=columnCount;i++){
              Object value = resultSet.getObject(i);
              //获取指定列的标签，可以获取别名
              String columnLabel = metaData.getColumnLabel(i);
              //把每一列的值存到map中
              map.put(columnLabel,value);

          }
          list.add(map);


       }


        System.out.println(list);
        //8.关闭资源
        resultSet.close();
        preparedStatement.close();
        connection.close();


    }

5.使用PreparedStatement  获取自增长主键

public class PreparedStatementTest4 {
    public static void main(String[] args) throws Exception {
        //获取自增长主键值

        // 前置条件：创建自增主键表并导入数据
//        create table user1
//        (id int primary key auto_increment,
//        name varchar(20),
//        password varchar(20));
//        insert into user1(name,password)values('tom',123456),('kate','111111');

        //1.注册驱动
      Class.forName("com.mysql.cj.jdbc.Driver");
      //2.创建连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.创建sql语句
        String sql ="insert into user1(name,password)values(?,?)";
        //4.创建PreparedStament对象,使用带返回主键的参数
        PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
        //5.占位符赋值
        preparedStatement.setObject(1,"jerry");
        preparedStatement.setObject(2,"666666");
        //6.发送sql语句并返回结果集
        int rows = preparedStatement.executeUpdate();

        if(rows>0){
            System.out.println("插入数据成功");
            //7.获取主键结果集
            ResultSet generatedKeys = preparedStatement.getGeneratedKeys();
            //移动光标
            generatedKeys.next();
            int key = generatedKeys.getInt(1);
            System.out.println("输入数据的主键为："+key);

        }else{
            System.out.println("插入数据失败");
        }
        //8.关闭资源
        preparedStatement.close();
        connection.close();


    }
}

6.数据库的批量操作

public class PreparedStatementTest5 {
    @Test
    public void  BatchTest1() throws Exception {
        //1.原始方法批量添加，并计算耗时
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.执行sql
        String sql = "insert into user1(name,password)values(?,?)";
        //4.获取PreparedStatement 对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //5.占位符赋值,并计算耗时
        long start = System.currentTimeMillis();
        for(int i=0;i<=10000;i++){
            preparedStatement.setObject(1,"test0"+i);
            preparedStatement.setObject(2,"111111"+i);
            preparedStatement.executeUpdate();
        }
        long end = System.currentTimeMillis();
        //总耗时为：75997ms
        System.out.println("总耗时为："+(end-start)+"ms");
        //6.关闭资源
        preparedStatement.close();
        connection.close();
    }


    @Test
    public void  BatchTest2() throws Exception {
        //2.批量添加，并计算耗时
        //1.注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test1", "root", "root");
        //3.执行sql
        String sql = "insert into user1(name,password)values(?,?)";
        //4.获取PreparedStatement 对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //5.占位符赋值,并计算耗时
        long start = System.currentTimeMillis();
        for(int i=0;i<=10000;i++){
            preparedStatement.setObject(1,"test0"+i);
            preparedStatement.setObject(2,"111111"+i);
            preparedStatement.addBatch();//只添加到vauls后面，不执行
        }
        //批量执行
        preparedStatement.executeBatch();
        long end = System.currentTimeMillis();
        //总耗时为：76953ms
        System.out.println("总耗时为："+(end-start)+"ms");
        //6.关闭资源
        preparedStatement.close();
        connection.close();

    }
}

7.数据库的事务操作

public class BankDAO {
// 数据库数据准备sql：
//    create table t_bank
//            (id int primary key auto_increment,
//             account varchar(20)comment '账号',
//             money int  unsigned  comment'余额不能小于0')
//
//    insert into t_bank (account,money)values('wangdacui',1000),('ergouzhi',1000);



    //加钱
    public void add(Connection connection,String addaccount, int money) throws Exception {

        //创建sql
        String sql = "update t_bank set money=money+? where account=?";
        //创建PreparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //占位符赋值
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,addaccount);
        //发送sql语句
        preparedStatement.executeUpdate();
        System.out.println("加钱成功");
        //7.关闭连接
        preparedStatement.close();



    }

    //减钱
    public void sub(Connection connection,String subaccount ,int money) throws Exception {

        //创建sql
        String sql = "update t_bank set money=money-? where account=?";
        //创建PreparedStatement
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //占位符赋值
        preparedStatement.setObject(1,money);
        preparedStatement.setObject(2,subaccount);
        //发送sql语句
        preparedStatement.executeUpdate();
        System.out.println("减钱成功");
        //7.关闭连接
        preparedStatement.close();


    }
}
public class BankService {

    @Test
    public  void testTransfer() throws Exception {

        transfer("wangdacui","ergouzhi",500);
    }

    public void transfer(String addaccount,String subaccount,int money) throws Exception {

        BankDAO bankdao =new BankDAO();

        Connection connection = JdbcUtil2.getConnection();
        try {
            //关闭事务自动提交
            connection.setAutoCommit(false);
            //数据库操作，加钱
            bankdao.add(connection, addaccount, money);
            System.out.println("__________________");
            //数据库操作，减钱
            bankdao.sub(connection, subaccount, money);
            //事务提交
            connection.commit();

        }catch (Exception e){
            //事务回滚
            connection.rollback();
            //抛出异常
            throw e;
        }finally {
           JdbcUtil2.freeConnection();
        }
    }
}

8.数据库连接池的使用（druid 为阿里产品）

配置文件：为src下的druid.properties

配置内容：

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/test1
username=root
password=root
    @Test
    public void testsoft() throws Exception {
        Properties pro =new Properties();
        //类的加载器读取文件
        InputStream ips = DruitTest1.class.getClassLoader().getResourceAsStream("druid.properties");
        //
        pro.load(ips);
        //获取连接池对象
        DataSource dataSource = DruidDataSourceFactory.createDataSource(pro);

        //获取连接
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        //数据库crud

        //回收连接
        connection.close();

    }

}

9.封装数据库工具类

public class JdbcUtil2 {

    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal =new ThreadLocal<Connection>();

    //静态代码块 实例化datasource
    static {

        Properties pro=new Properties();
        InputStream input= JdbcUtil2.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            pro.load(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataSource = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    public  static Connection getConnection() throws SQLException {
        //从共享线程变量获取连接
        Connection connection = threadLocal.get();
        if(connection==null){
            connection=dataSource.getConnection();
            threadLocal.set(connection);
        }
        return connection;

    }

    public static void freeConnection() throws SQLException {
        Connection connection = threadLocal.get();
        if(connection!=null){
            threadLocal.remove();
            connection.setAutoCommit(true);
            connection.close();//回收到线程池
        }

    }



}

10.工具类封装数据库操作

public abstract class BaseDao {

    public  int exeupdate(String sql,Object ... params) throws SQLException {
        //获取连接
        Connection connection = JdbcUtil2.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        int length = params.length;
        //可变形参可以当成数组使用,遍历赋值
        for(int i=0;i<length;i++){
            preparedStatement.setObject(i+1,params[i]);
        }
        int row = preparedStatement.executeUpdate();
        //根据是否开启事务，决定是否关闭连接
        if(connection.getAutoCommit()){
            JdbcUtil2.freeConnection();
        }

       return  row;

    }

    //<T>:返回的类型不确认，所以定义为泛型
    //:Class<T>clazz, 传入clazz 类型 一是确定T类型，然后为了调用反射给属性赋值
    public  <T> List<T> executeQuery(Class<T>clazz, String sql , Object ... params) throws Exception {
        //获取连接
        Connection connection = JdbcUtil2.getConnection();
        //创建preparedStatement对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //占位符赋值
        for(int i=1;i<=params.length;i++){
            preparedStatement.setObject(i,params[i-1]);
        }
        //发送数据并返回结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        //获取列的元数据集
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取结果集的列数
        int columnCount = metaData.getColumnCount();
        List<T> list =new ArrayList<>();
        while(resultSet.next()){
            //通过反射，获取对象
            T t = clazz.newInstance();
            for(int i=1;i<columnCount;i++){
                //获取列的值
                Object object = resultSet.getObject(i);
                //获取列名或者别名
                String columnLabel = metaData.getColumnLabel(i);
                //通过反射获取 对象的指定属性
                Field declaredField = clazz.getDeclaredField(columnLabel);
                //设置属性可访问
                declaredField.setAccessible(true);
                //给属性赋值
                declaredField.set(t,object);
            }
           list.add(t);
        }
        //关闭资源
        resultSet.close();
        preparedStatement.close();
        //未开启事务
        if(connection.getAutoCommit()){
            JdbcUtil2.freeConnection();
        }

        return  list;


    }
}

四：综合练习：实现客户管理的数据库后台操作

主要结构：

javabean： Customer类

service:  CustomerService 类：业务层的类

Dao:   数据库操作类：BaseDao,CustomerDao

Util: JdbcUtil2:数据库工具类

main:CustomerManage :测试类

1.Customer 类代码：

public class Customer {
    private int id;
    private String name;
    private String gender;
    private int age;
    private double salary;
    private String phone ;

    public Customer() {
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

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

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", phone='" + phone + '\'' +
                '}';
    }
}

 2.CustomerService代码：

public class CustomerService {


    private CustomerDao custdao =new CustomerDao();
    // 返回所有客户
    public List<Customer>getList()  {
        try {
            return  custdao.findAll();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    //返回指定客户
    public Customer findCustomer(int id)  {
        try {
            return custdao.findById(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //新增客户
    public boolean addCustomer(Customer cust){
        try {
            return custdao.addCustomer(cust);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }
    //修改客户
    public  boolean  modifyCustomer(int id ,Customer cust){
        try {
            return custdao.updateCustomer(cust);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }
    //删除客户
    public Boolean removeCustomer(int id ){
        try {
            return  custdao.deleteCustomer(id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return false;
    }


}

3. BaseDao和CustomerDao 代码：

public abstract class BaseDao {

    public  int exeupdate(String sql,Object ... params) throws SQLException {
        //获取连接
        Connection connection = JdbcUtil2.getConnection();
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        int length = params.length;
        //可变形参可以当成数组使用,遍历赋值
        for(int i=0;i<length;i++){
            preparedStatement.setObject(i+1,params[i]);
        }
        int row = preparedStatement.executeUpdate();
        //根据是否开启事务，决定是否关闭连接
        if(connection.getAutoCommit()){
            JdbcUtil2.freeConnection();
        }

       return  row;

    }

    //<T>:返回的类型不确认，所以定义为泛型
    //:Class<T>clazz, 传入clazz 类型 一是确定T类型，然后为了调用反射给属性赋值
    public  <T> List<T> executeQuery(Class<T>clazz, String sql , Object ... params) throws Exception {
        //获取连接
        Connection connection = JdbcUtil2.getConnection();
        //创建preparedStatement对象
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        //占位符赋值
        for(int i=1;i<=params.length;i++){
            preparedStatement.setObject(i,params[i-1]);
        }
        //发送数据并返回结果集
        ResultSet resultSet = preparedStatement.executeQuery();
        //获取列的元数据集
        ResultSetMetaData metaData = resultSet.getMetaData();
        //获取结果集的列数
        int columnCount = metaData.getColumnCount();
        List<T> list =new ArrayList<>();
        while(resultSet.next()){
            //通过反射，获取对象
            T t = clazz.newInstance();
            for(int i=1;i<columnCount;i++){
                //获取列的值
                Object object = resultSet.getObject(i);
                //获取列名或者别名
                String columnLabel = metaData.getColumnLabel(i);
                //通过反射获取 对象的指定属性
                Field declaredField = clazz.getDeclaredField(columnLabel);
                //设置属性可访问
                declaredField.setAccessible(true);
                //给属性赋值
                declaredField.set(t,object);
            }
           list.add(t);
        }
        //关闭资源
        resultSet.close();
        preparedStatement.close();
        //未开启事务
        if(connection.getAutoCommit()){
            JdbcUtil2.freeConnection();
        }

        return  list;


    }


}

public class CustomerDao extends BaseDao{
    public List<Customer> findAll() throws Exception {
        String sql="select * from t_customer";
        List<Customer> customers = executeQuery(Customer.class, sql);
        return  customers;


    }

    public Customer findById(int id) throws Exception {
        String sql="select * from t_customer where id=?";
        List<Customer> customers = executeQuery(Customer.class, sql, 2);
        if(customers!=null&&customers.size()>0){
            return  customers.get(0);
        }
        return null;
    }

    public boolean addCustomer(Customer cust) throws SQLException {
        String sql="insert into t_customer (name,gender,age,salary,phone)values(?,? ,?,?,? )";
        int rows = exeupdate(sql, cust.getName(), cust.getGender(), cust.getAge(), cust.getSalary(), cust.getPhone());
        if(rows==0){
            return false;
        }
        return true;
    }

    public boolean updateCustomer(Customer cust) throws SQLException {
        String sql="update t_customer set name=?,gender=?, age=?,salary=?,phone=? where id=? ";
        int rows = exeupdate(sql, cust.getName(), cust.getGender(), cust.getAge(), cust.getSalary(), cust.getPhone(), cust.getId());
        if(rows==0){
            return false;
        }
        return true;
    }

    public Boolean deleteCustomer(int id ) throws SQLException {
        String sql="delete from t_customer  where id=? ";
        int rows = exeupdate(sql, id);
        if(rows==0){
            return false;
        }
        return true;


    }
}

4.jdbcUtil工具类代码：

public class JdbcUtil2 {

    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal =new ThreadLocal<Connection>();

    //静态代码块 实例化datasource
    static {

        Properties pro=new Properties();
        InputStream input= JdbcUtil2.class.getClassLoader().getResourceAsStream("druid.properties");
        try {
            pro.load(input);
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            dataSource = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    public  static Connection getConnection() throws SQLException {
        //从共享线程变量获取连接
        Connection connection = threadLocal.get();
        if(connection==null){
            connection=dataSource.getConnection();
            threadLocal.set(connection);
        }
        return connection;

    }

    public static void freeConnection() throws SQLException {
        Connection connection = threadLocal.get();
        if(connection!=null){
            threadLocal.remove();
            connection.setAutoCommit(true);
            connection.close();//回收到线程池
        }

    }



}

5.CustomerManage 测试类代码：

public class CustomerManage {
    public static void main(String[] args) {
        CustomerService service = new CustomerService();
        Customer cust =new Customer();

        cust.setName("kate");
        cust.setSalary(5000.00);
        cust.setGender("女");
        cust.setPhone("13828384844");
        cust.setAge(20);
        //新增客户
        boolean addCustomer = service.addCustomer(cust);
        System.out.println(addCustomer);
        //获取所有客户
        List<Customer> list = service.getList();
        System.out.println(list);
        //获取指定客户
        Customer customer = service.findCustomer(2);
        System.out.println(customer);
        //修改客户
        Customer customer1 = service.findCustomer(2);
        customer1.setPhone("8888888");
        boolean modifyCustomer = service.modifyCustomer(2, customer1);
        System.out.println(modifyCustomer);
        //删除客户

        Boolean removeCustomer = service.removeCustomer(3);
        System.out.println(removeCustomer);


    }
}
zzx_nihao
关注
  • 18
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mariadb mysql jdbc驱动_Java：jdbc连接数据库MariaDB/Mysql
weixin_35564059的博客
01-19 3953
这里是用的Mysql的分支版本MariaDB，除了安装的包不同外，操作基本相同。本人用的是Archlinux，也只是安装软件的方式不同。一、MariaDB安装MariaDB(参见ArchWiki)+ [安装](https://wiki.archlinux.org/index.php/Pacman)位于[官方软件源](https://wiki.archlinux.org/index.php/Offi...
Error: Could not open client transport with JDBC Uri: jdbc:hive2://hadoop103:10000: java.net.Connect
pcOnline_TT的博客
09-02 3603
在配置hive的时候报这个错误，Error: Could not open client transport with JDBC Uri: jdbc:hive2://hadoop103:10000: java.net.ConnectException: 拒绝连接 (Connection refused) (state=08S01,code=0) 网上看了很多什么jar包冲突等等都没有解决。 最后在b站有同志给出了解决方法，我用了很有效。 设置impersonation，这样hive server会以提交用户
java.io.FileNotFoundException: jdbc.properties (系统找不到指定的文件。)解决方法
有头脑和超高兴
06-23 5086
用java读取数据库配置文件时 InputStream in=new FileInputStream("jdbc.properties"); 出现错误 在eclipse-workspace中找到jdbc.properties的路径 修改为 InputStream in=new FileInputStream("C:\\Users\\12842\\eclipse-workspace\\First\\src\\jdbc.properties"); 即可 ...
hive中 beeline连接时报错
qq_37668945的博客
11-01 2688
错误1. Error: Could not open client transport with JDBC Uri: jdbc:hive2://192.168.136.128:10000/mydb/: Failed to open new session: java.lang.RuntimeException: org.apache.hadoop.ipc.RemoteException(org....
连接数据库报错问题：严重: init datasource error, url: jdbc:mysql:
weixin_46200533的博客
07-08 1万+
原因：版本不一致： 练习时用的MYSQL驱动包是5.1版本，而本地MYSQL安装的是8.0，需使用8.0版本jar包，同时更改数据库连接配置。 更改数据库连接配置： jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&userSSL=false&serverTimezone=GMT%2B8 在数据库
Druid连接池，报错：unkow jdbc Driver : jdbc:highgo://xxxxxx
HighGO
02-11 3287
瀚高数据库 目录 环境 症状 问题原因 解决方案 环境 系统平台：Linux x86-64 Red Hat Enterprise Linux 7,Microsoft Windows (64-bit) 10 版本：4.5 症状 使用Druid连接池，连接瀚高数据库启动应用报错，报错信息如下： 问题原因 原因是使用druid的自动识别URL串功能，Driver免配置，即配置文件中仅需配置连接串信息，即可根据连接串中的类型自动确定数据库类型，从而自动选择Driver。但是目前Druid不支持自动识别highgo
java.lang.IllegalArgumentException: jdbcUrl is required with driverClassName.
热门推荐
白面小生的博客
06-05 2万+
springboot 配置多数据源时，启动出现java.lang.IllegalArgumentException: jdbcUrl is required with driverClassName. 修改 spring.datasource.url -->spring.datasource.jdbc-url. 如下： spring.datasource.url 数据库的 JDBC ...
create connection SQLException, url: jdbc:mysql://192.168.231.144:3306/gulimall_pms?
一个菜鸡的博客
10-12 2781
这个错误卡了俩天没有解决掉，网上看了看各种各样的方法，有的说的权限问题，需要修改权限，有的说是版本问题，但是后面看了各种各样的玩意还是没解决掉。你问我为什么能跑了？能跑就完了，可以进行下一步了。最后突发奇，直接粘贴下人人网的快速的配置文件进行修改，以为我人人网的能跑。
java-jdbc:JDBC的OpenTracing工具
05-04
OpenTracing JDBC工具JDBC的OpenTracing工具。安装pom.xml < dependency> < groupId>io.opentracing.contrib</ groupId> < artifactId>opentracing-jdbc</ artifactId> < version>VERSION</ version></ dependency>...
极简JAVA九：JDBC与连接池
06-21
 本门课程为极简java系列课程的第五篇，详细介绍了JDBC访问数据库方面的知识，包括jdbc,连接池技术，spring jdbc框架的使用， 课程采用案例教学，通过丰富的案例从各个角度阐释知识点，深入浅出的讲解确保每个知识...
JDBC-example-in-Java:JDBC应用程序
06-20
JDBCApp（私有） JDBCApp 连接到一个 mySQL 数据库，以查看和执行查询。 它正在围绕“finaleventdb”数据库进行修改。
java芋道源码-sqlite-jdbc:JDBC的SQLite/Spatialite驱动程序
06-05
java芋道源码SQLite JDBC 驱动程序 Taro L. Saito 开发的 SQLite JDBC 驱动程序是使 Java 能够访问数据库文件的扩展。 我们的 SQLiteJDBC 库作为 的一部分开发，不需要配置，因为所有适用于 Windows、Mac OS X、...
Java项目:在线新闻平台系统(java+jsp+jdbc+mysql)
12-06
一、项目简述 功能： 用户的登录注册，新闻的分类查询，评论留言，投稿，新闻的后台管理，发布，审核，投稿管理以及汇总...项目技术： Jsp + Jdbc + Servlert + html+ css + JavaScript + JQuery + Ajax + Fileupload
mysql事务(原理)
最新发布
m0_74347016的博客
05-19 519
mysql事务原理
数据库SQL编写规范-SQL书写规范整理（SQL语句书写规范全解-Word原件）
xx_123321456的博客
05-14 304
​​​​​​工作安排任务书，可行性分析报告，立项申请审批表，产品需求规格说明书，需求调研计划，用户需求调查单，用户需求说明书，概要设计说明书，技术解决方案，数据库设计说明书，详细设计说明书，单元测试报告，总体测试计划，单元测试计划，产品集成计划，集成测试报告，集成测试计划，系统测试报告，产品交接验收单，验收报告，验收测试报告，压力测试报告，项目总结报告，立项结项审批表，成本估算表，项目计划，项目周报月报，风险管理计划，质量保证措施，项目甘特图，项目管理工具，操作手册，接口设计文档，软件实施方案，运维方案，安
php centos选择sqlserver的驱动和扩展选择版本的说明
Z.X的博客
05-14 440
2023年2月23日13:41:48首先是php php扩展 驱动 数据库的关系 官方文档说明： https://learn.microsoft.com/zh-cn/sql/connect/php/step-1-configure-development-environment-for-php-development?view=sql-server-2017https://learn.microsoft.com/zh-cn/sql/connect/php/system-requirements-for-th
生产报表工具PI DataLInk 与 行列视之间的区别
2401_83701843的博客
05-17 247
行列视，全名“行列视生产数据应用系统”，行列视品牌所面对的业务范围远远超越了PIDatalink报表工具，他首先是一款本地部署的在线Excel文档管理系统，解决个人报表在线管理问题，其次，她和PIDataLInk一样，也是面向实时数据库报表需求的一套工具，其区别在于行列视品牌兼容国内外大多数实时数据库，也可以同时连接多个数据源，也就是她完全可以替代PI-DataLINk，同时也适用于其他品牌下的实时数据库系统；
MySQL存储过程添加二十万条数据日常练习
mi_mx的博客
05-17 304
【代码】MySQL日常练习。
linux中查找某个文件或文件夹
DN金猿的博客
05-18 238
locate命令将会在整个系统中搜索文件和文件夹，并通过正则表达式匹配以"/folder_name"结尾的路径。这将会在指定的路径（/path/to/search）中递归地列出所有文件和文件夹，并使用grep命令匹配以"/folder_name"结尾的行。该命令将会在指定的路径（/path/to/search）中查找名称为"folder_name"的文件夹。此方法与第2种方法类似，但使用了find命令来递归搜索文件夹，并使用grep命令来匹配以"/folder_name"结尾的行。
java.lang.IllegalArgumentException: jdbcUrl is required with driverClassName
05-09
这个异常通常是由于在使用 JDBC 连接数据库时没有正确地设置 JDBC URL 导致的。JDBC URL 是连接数据库的重要参数，必须与驱动程序的类名一起使用。请检查您的代码中是否正确地设置了 JDBC URL 和驱动程序的类名。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值