JDBC 学习笔记 day02 用 PreparedStatement 实现 CRUD 操作

最新推荐文章于 2024-07-08 14:58:49 发布
最新推荐文章于 2024-07-08 14:58:49 发布
阅读量97 收藏
点赞数
分类专栏： java 文章标签： java 数据库 jdbc sql mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yu1590/article/details/119579448
版权

JDBC 学习笔记 day02

PreparedStatement

此处的多种方式仍然采用迭代形式给出，了解优化过程是有意义的。

相比于 Statement 的好处

  1. 解决了 Statement 的 SQL 注入问题
  2. PreparedStatement 能操作 Blob 类型的数据
  3. 可以实现更高效的批量操作

PreparedStatement 实现 增，删，改 操作

简介：增，删，改操作的共性就是不需要数据库返回数据，故归结为一类操作。

	@Test
    //方式一：实现增加操作
    public void testInsert() {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            //1.读取配置文件的四个基本信息
            InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("data.properties");
            Properties pro = new Properties();
            pro.load(is);
            String url = pro.getProperty("url");
            String className = pro.getProperty("className");
            String user = pro.getProperty("user");
            String password = pro.getProperty("password");
            //2.注册驱动
            Class.forName(className);
            //3.获取连接
            con = DriverManager.getConnection(url, user, password);
            //4.预编译 sql 语句，返回 PreparedStatement 实例
            String sql = "insert into customers(name, email, birth) values(?, ?, ?)";
            ps = con.prepareStatement(sql);
            //5.填充占位符
            ps.setString(1,"哪吒");
            ps.setString(2,"nezha@126.com");
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = simpleDateFormat.parse("2000-10-10");
            ps.setDate(3,new java.sql.Date(parse.getTime()));
            //6.执行操作
            ps.execute();
        } catch (Exception e) {
            e.printStackTrace();
        }  finally {
            //7.关闭资源
            if(ps != null){
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(con != null){
                try {
                    con.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    //通过编写 JDBCUtils 工具类，将重复操作封装在其中，实现删除操作
    public void testDelete() {
        Connection con = null;
        PreparedStatement ps = null;
        try {
            //1.获取连接
            con = JDBCUtils.createConnection();
            //2.预编译 sql 语句，返回 PreparedStatement 实例
            String sql = "delete from customers where id = ?";
            ps = con.prepareStatement(sql);
            //3.填充占位符
            ps.setInt(1, 20);
            //4.执行操作
            ps.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.关闭资源
            JDBCUtils.closeSource(con, ps);
        }
    }

javaUtils类的编写

public class JDBCUtils {
    public static Connection createConnection() throws Exception {
        //1.读取配置文件的四个基本信息
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("data.properties");
        Properties pro = new Properties();
        pro.load(is);
        String url = pro.getProperty("url");
        String className = pro.getProperty("className");
        String user = pro.getProperty("user");
        String password = pro.getProperty("password");
        //2.注册驱动
        Class.forName(className);
        //3.获取连接
        Connection con = DriverManager.getConnection(url, user, password);

        return con;
    }

    public static void closeSource(Connection con, PreparedStatement ps) {
        //7.关闭资源
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void closeSource(Connection con, PreparedStatement ps, ResultSet rs) {
        //7.关闭资源
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

PreparedStatement 实现查询操作

简介：在查询时，数据库会返回满足过滤条件的结果集，需要用 java 中的 ResultSet类的实例接收。
那么从数据库返回的数据应该用什么数据结构接受呢？在 java 中，万事万物都是对象，所以有了 ORM 的编程思想。

/*
    ORM 的编程思想 (Object Relational Mapping)
    一个数据表对应一个 Java 类
    表中的一条记录对应着一个对象
    表中的一个字段对应着 Java 类中的一个属性
 */
public class Customer {
    private int id;
    private String name;
    private String email;
    private Date birth;
    //其他方法省略
}

	@Test
    public void testSelect() {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        try {
            //1.获取连接
            con = JDBCUtils.createConnection();
            //2.预编译 sql 语句，返回 PreparedStatement 实例
            String sql = "select id, name, email, birth from customers where id = ?";
            ps = con.prepareStatement(sql);
            //3.填充占位符
            ps.setInt(1, 1);
            //4.执行操作,并返回结果集
            resultSet = ps.executeQuery();
            //5.处理结果集
            while(resultSet.next()){

                int id = resultSet.getInt(1);
                String name = resultSet.getString(2);
                String email = resultSet.getString(3);
                java.sql.Date birth = resultSet.getDate(4);

                Customer customer = new Customer(id, name, email, birth);
                System.out.println(customer);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //6.关闭资源
            JDBCUtils.closeSource(con, ps, resultSet);
        }
    }

改进一：通过反射技术实现对一张表的通用查询

public class CustomersForQuery {
    @Test
    public void test() {
        String sql = "select id, name, email from customers where id = ?";
        Customer customer = queryForCustomers(sql, 3);
        System.out.println(customer);//Customer{id=3, name='林志玲', email='linzl@gmail.com', birth=null}
    }

    public Customer queryForCustomers(String sql, Object... objs)  {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        try {
            //1.获取连接
            con = JDBCUtils.createConnection();
            //2.预编译 sql 语句，获取 PreparedStatement 对象
            ps = con.prepareStatement(sql);
            //3.填充占位符
            for (int i = 0; i < objs.length; i++) {
                ps.setObject(i + 1, objs[i]);
            }
            //4.获取结果集
            resultSet = ps.executeQuery();
            //5.获取结果集元数据，以获取列信息
            ResultSetMetaData metaData = resultSet.getMetaData();
            //6.处理数据，创建对象
            if (resultSet.next()) {
                Customer cust = new Customer();
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    //通过 getColumnLabel() 获取列的别名来替换 getColumnName()
                    //因为当遇到列名与类的属性名不一致时，需要通过给列起别名来解决
                    //说明：如果在 sql 中没有给类起别名，则获取的还是列名
                    String columnLabel = metaData.getColumnLabel(i + 1);

                    Field field = Customer.class.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(cust, resultSet.getObject(i + 1));
                }
                return cust;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //7.关闭资源
            JDBCUtils.closeSource(con, ps, resultSet);
        }
        return null;
    }
}

改进二：通过泛型实现对任意表的通用查询

public class QueryTest {
    @Test
    public void test(){
        String sql = "select id, name, email, birth from customers where id = ?";
        Customer customer = queryAny(Customer.class , sql, 4);
        System.out.println(customer);//Customer{id=4, name='汤唯', email='tangw@sina.com', birth=1986-06-13}

        sql = "select order_id orderId, order_name orderName, order_date orderDate from `order` where order_id = ?";
        Order order = queryAny(Order.class, sql, 2);
        System.out.println(order);//Order{orderId=2, orderName='BB', orderDate=2000-02-01}
    }

    public <T> T queryAny(Class<T> clazz, String sql, Object... objs)  {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        try {
            //1.获取连接
            con = JDBCUtils.createConnection();
            //2.预编译 sql 语句，获取 PreparedStatement 对象
            ps = con.prepareStatement(sql);
            //3.填充占位符
            for (int i = 0; i < objs.length; i++) {
                ps.setObject(i + 1, objs[i]);
            }
            //4.获取结果集
            resultSet = ps.executeQuery();
            //5.获取结果集元数据，以获取列信息
            ResultSetMetaData metaData = resultSet.getMetaData();
            //6.处理数据，创建对象
            if (resultSet.next()) {
                T t = clazz.getDeclaredConstructor().newInstance();
                for (int i = 0; i < metaData.getColumnCount(); i++) {
                    //通过 getColumnLabel() 获取列的别名来替换 getColumnName()
                    //因为当遇到列名与类的属性名不一致时，需要通过给列起别名来解决
                    //说明：如果在 sql 中没有给类起别名，则获取的还是列名
                    String columnLabel = metaData.getColumnLabel(i + 1);

                    Field field = clazz.getDeclaredField(columnLabel);
                    field.setAccessible(true);
                    field.set(t, resultSet.getObject(i + 1));
                }
                return t;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //7.关闭资源
            JDBCUtils.closeSource(con, ps, resultSet);
        }
        return null;
    }
}

PreparedStatement 实现对 Blob 类型操作

public class BlobTest {
    @Test
    public void test() {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            con = JDBCUtils.createConnection();
            String sql = "select photo from customers where id = ?";
            ps = con.prepareStatement(sql);
            ps.setInt(1, 16);

            resultSet = ps.executeQuery();

            if (resultSet.next()) {
                Blob blob = resultSet.getBlob("photo");

                is = blob.getBinaryStream();
                fos = new FileOutputStream("guaitang.jpg");

                int cnt;
                byte[] buff = new byte[1024];
                while ((cnt = is.read(buff)) != -1) {
                    fos.write(buff, 0, cnt);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeSource(con, ps, resultSet);

            try {
                if (is != null)
                    is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fos != null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void test1() {
        Connection con = null;
        PreparedStatement ps = null;
        FileInputStream fis = null;
        try {
            con = JDBCUtils.createConnection();
            String sql = "insert into customers(name, email, birth, photo) values(?, ?, ?, ?)";
            ps = con.prepareStatement(sql);

            fis = new FileInputStream("tang.jpg");
            ps.setString(1,"汤圆");
            ps.setString(2,"tangyuan@126.com");
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date parse = simpleDateFormat.parse("2000-01-01");
            ps.setDate(3,new java.sql.Date(parse.getTime()));
            ps.setBlob(4, fis);

            ps.execute();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.closeSource(con, ps);
            try {
                if(fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
Ghost1590
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC(PreparedStatement)--Create Table
鬼剑愁的专栏
04-08 1181
JDBC(PreparedStatement)--Create Table
PreparedStatement对象
qq_44285582的博客
03-31 693
preparedStatement对象使用以及和statement对象的区别说明
jdbc(insert,update,,create,以及各个类详解)
giaogege666的博客
10-16 395
注册驱动获取数据库连接url:指定连接的路径写法:jdbc:mysql://ip地址:端口号/数据库名称细节（若是本地连接）：jdbc:mysql:///数据库名称1.获取执行sql的对象2.管理事务开启事务:void setAutoCommit(boolean autoCommit)调用方法设置参数为false，开启事务提交事务:void commit()回滚事务:rollback()1.boolean execute(String sql):可以执行任意sql。
java createstatement,java – 无法使用preparedStatement创建表
weixin_36481714的博客
03-19 316
我无法在数据库(mySQL)中创建表,使用preparedStatement并尝试使用preparedStatement.setInteger()输入future表的名称：static String queryCreateTable = "CREATE TABLE ?" +"(ID INTEGER not NULL ," +"BRAND VARCHAR(40)," +"MODEL VARCHAR(...
使用PreparedStatement执行sql语句
QQ1012421396的博客
03-18 6962
使用PreparedStatement执行sql语句 package com.cn.preparedStatement;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import org.junit.Test;import com.cn.Util.JdbcUtil;
JDBC学习笔记 day02 使用PreparedStatement实现CRUD操作
Alu_em的博客
09-03 201
第3章：使用PreparedStatement实现CRUD操作 3.1 操作和访问数据库 数据库连接被用于向数据库服务器发送命令和 SQL 语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。 在 java.sql 包中有 3 个接口分别定义了对数据库的调用的不同方式： Statement：用于执行静态 SQL 语句并返回它所生成结果的对象。 PrepatedStatement：SQL 语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。 Callable
JDBC学习笔记02【ResultSet类详解、JDBC登录案例练习、PreparedStatement类详解】
upward
02-06 873
ResultSet类详解、JDBC登录案例练习、PreparedStatement类详解
mybatis学习笔记 day02
vengu733的博客
08-03 109
帮助程序猿将数据存入到数据库中。方便传统的JDBC代码太复杂了。简化。框架。自动化。不用Mybatis也可以。更容易上手。技术没有高低之分优点：1.简单易学2.灵活3.sql和代码的分离，提高了可维护性。4.提供映射标签，支持对象与数据库的orm字段关系映射5.提供对象关系映射标签，支持对象关系组建维护6.提供xml标签，支持编写动态sql。...
JDBC笔记_JDBC学习笔记_
10-03
在本篇JDBC学习笔记中，我们将深入探讨JDBC的基础知识、核心概念以及实际应用。 一、JDBC基础 1. JDBC驱动程序：JDBC驱动是连接Java应用程序和数据库之间的桥梁。根据实现方式，JDBC驱动分为四种类型：类型1（JDBC...
JDBC学习笔记(精华版)-1
04-19
本篇JDBC学习笔记将深入探讨JDBC的核心概念、操作步骤以及最佳实践。 **一、JDBC基本概念** 1. **驱动程序**：JDBC驱动程序是Java应用程序与数据库之间的桥梁，分为四种类型：JDBC-ODBC桥接驱动、本地API驱动、...
配套学习资料：Java开发 - 尚硅谷JDBC学习笔记
03-15
Java开发 - 尚硅谷JDBC学习笔记是一套深入解析Java数据库连接（JDBC）技术的教程，涵盖了从基础到进阶的各种知识点。JDBC是Java编程语言中用于访问数据库的标准应用编程接口，它允许程序员使用Java来执行SQL语句，...
Java后端学习笔记 — JDBC(一)
12-14
    Ⅲ 使用PreparedStatement实现CRUD操作 Ⅰ JDBC概述 数据的持久化   持久化(persistence)：把数据保存到可掉电式存储设备中以供之后使用。大多数情况下，特别是企业级应用，数据持久化意味着将内存中的...
JDBC学习笔记（笔记+包含详细注释的代码）
09-03
**JDBC学习笔记** Java Database Connectivity (JDBC) 是Java平台中用于与各种数据库进行交互的一组接口和类。它是Java SE的一部分，允许Java应用程序连接到数据库，执行SQL语句，处理结果集，并进行事务管理。这篇...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 559
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 804
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 216
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 676
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
maven配置使用nexus仓库
ApexPredator的博客
07-03 246
maven配置使用nexus仓库
使用PreparedStatement实现查询操作并解释
04-02
以下是使用PreparedStatement实现查询操作的示例代码： ```java public void queryData(int id) { Connection conn = null; PreparedStatement stmt = null; ResultSet rs = null; try { conn = getConnection...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值