JDBC总结

最新推荐文章于 2024-05-11 10:24:57 发布
最新推荐文章于 2024-05-11 10:24:57 发布
阅读量759 收藏 16
点赞数 24
分类专栏： JavaWeb 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lastingboy/article/details/135578223
版权

目录

dao

jdbc

pojo 数据承载bean

service

utils

JDBC

JDBC（Java Database Connectivity） Java 连接数据库的规范（标准），可以使用 Java 语言连接数据库完成 CRUD 操作

JDBC 核心思想

Java 中定义了访问数据库的接口，可以为多种关系型数据库提供统一的访问方式。由数据库厂商提供驱动实现类（Driver 数据库驱动）。

在这里插入图片描述

JDBC开发步骤

环境准备

a、将数据库连接驱动包赋值到当前工程的lib文件夹下

b、将jar包添加到类路径(class文件生成的位置)中。右击jar包 —> add as library（jvm只解析类路径）

注册数据库驱动

创建Driver对象，注册Driver

//1、注册数据库驱动
//实现方式一：不推荐使用
//Driver driver = new Driver();
//DriverManager.registerDriver(driver);
//Driver类里有个静态代码块，相当于注册两次
//实现方式二：推荐使用
Class.forName("com.mysql.jdbc.Driver");//主动触发类加载，执行静态代码块，进而注册驱动————反射

获取数据库的连接

// 2、获取数据库连接对象Connection
/**
  网络编程三要素
* 协议+地址+端口
* jdbc:mysql://localhost:3306/数据库名?serverTimezone=UTC
*/
Connection conn =
DriverManager.getConnection("jdbc:mysql://localhost:3306/java2105", "root",
"123456");

获取数据库操作对象Statement

// 3、获取数据库操作对象
Statement statement = conn.createStatement();

通过Statement对象执行SQL语句

// 4、通过数据库操作对象执行SQL语句
int count = statement.executeUpdate(
"insert into emp (empno,ename,job,mgr,hiredate,sal,comm,deptno)
values (6666,'张三','java',7369,'2021-05-01',30000,200,30)");

处理返回结果

// 5、处理结果
if(count > 0){
System.out.println("插入成功！！");
}else{
System.out.println("插入失败！！");
}

释放资源

//6、释放资源
statement.close();
conn.close();

ResultSet结果集

查询操作，返回的是结果集

//5、处理结果集
/**
\* ResultSet提供了一组方法
\* next(); 判断是否有下一行数据，如果有返回true，并将游标移动到下一行
\* getXXX("字段名"); XXX表示字段在java中的对应的类型

\* getXXX(列的下标); XXX表示字段在java中的对应的类型
*/
//释放资源也得关掉
while(rs.next()){
int empno = rs.getInt("empno");
//int empno = rs.getInt(1);
System.out.println(empno);
String ename = rs.getString("ename");
System.out.println(ename);
}

登陆案例

/**
* 登录的思路：
* 1、根据用户输入的用户名和密码到数据库中查询
* select * from tb_user where username = "你输入的用户名" and password =
"你输入的密码"
* select * from tb_user where username = admin and password = 123
* 如果有结果：登录成功
* 如果没有结果：登录失败
*/

登陆实现

public class JDBCDemo05 {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.nextLine();
System.out.println("请输入密码");
String password = sc.nextLine();
Class.forName("com.mysql.jdbc.Driver");
Connection conn =
DriverManager.getConnection("jdbc:mysql:///java2105", "root",
"123456");
Statement statement = conn.createStatement();
String sql = " select * from tb_user where username = '" +
username + "' and password = '" + password +"'";
System.out.println(sql);
ResultSet rs = statement.executeQuery(sql);
if(rs.next()){
//登录成功
System.out.println("登录成功");
}else{
//登录失败
System.out.println("登录失败");
}
rs.close();
statement.close();
conn.close();
}
}

登录案例分析

以上代码会出现SQL注入问题

  • 用户输入的数据中有 SQL 关键字或语法并且参与了 SQL 语句的编译，导致 SQL 语句编译后的条件含义为 true，一直得到正确的结果。这种现象称为 SQL 注入。
  • 字符串的拼接操作也是非常的不方便

更新

public class JDBCDemo06 {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名");
String username = sc.nextLine();
System.out.println("请输入密码");
String password = sc.nextLine();
Class.forName("com.mysql.jdbc.Driver");
Connection conn =
DriverManager.getConnection("jdbc:mysql:///java2105", "root",
"123456");
//3、获取数据库操作对象PreparedStatement 预加载SQL语句
PreparedStatement ps =
conn.prepareStatement("select * from tb_user where username = ? and
password = ?");
//3.1 设置占位符的值
/**
* PreparedStatement对象中提供了一组方法
* setXXX(index从1开始,要传入的值) XXX表示对应的java类型
*/
ps.setString(1,username);
ps.setString(2,password);
System.out.println(ps);
//4、执行SQL语句
ResultSet rs = ps.executeQuery();
if(rs.next()){
//登录成功
System.out.println("登录成功");
}else{
//登录失败
System.out.println("登录失败");
}
rs.close();
ps.close();
conn.close();
}
}

PreparedStatement

PreparedStatement 继承了 Statement 接口，执行 SQL 语句的方法无异。
作用：

  • 预编译SQL 语句，效率高。
  • 安全，避免SQL注入

ORM映射

ORM （Object Relational Mapping)

将数据库中的表的数据，一行一行的映射到Java对象中

多行数据：List empList;

开放中交给前端

在这里插入图片描述

一行数据
Emp emp = new Emp(empno,ename,job,mgr,hiredate,sal,comm,deptno);

javaBean实体类的规范

不用写，有插件，注解

  • 私有化属性提供set，get方法
  • 提供有参无参构造
  • 类名要与表 一致，属性名和字段名字一致
  • 基本数据类型要使用包装类（默认值为null）
  • 在有需要的话实现序列化接口

代码

public class JDBCDemo04 {
public static void main(String[] args) throws Exception {
//1、注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2、获取数据库连接对象
Connection conn = DriverManager.getConnection("jdbc:mysql:///java2105",
"root", "123456");
//3、获取数据库操作对象
Statement statement = conn.createStatement();
//4、执行SQL语句
ResultSet rs = statement.executeQuery("select * from emp");
//5、处理结果集
//定义List集合保存所有的emp对象
List<Emp> empList = new ArrayList<>();
while(rs.next()){
        int empno = rs.getInt("empno");
        String ename = rs.getString("ename");
        String job = rs.getString("job");
        int mgr = rs.getInt("mgr");
        Date hiredate = rs.getDate("hiredate");
        double sal = rs.getDouble("sal");
        double comm = rs.getDouble("comm");
        int deptno = rs.getInt("deptno");
        //将查询的结果存放到Emp对象中
        Emp emp = new Emp(empno,ename,job,mgr,hiredate,sal,comm,deptno);
        //将Emp对象添加到List中
        empList.add(emp);
}
//遍历集合中所有元素
empList.forEach(System.out::println);
// for(Emp emp : empList){
// System.out.println(emp);
// }
//6、释放资源
rs.close();
statement.close();
conn.close();
}
}

封装工具类

  • 注册数据库驱动（静态代码块）

    • 数据库只需注册一次，放在静态代码块中
    • 只会在类加载时执行一次
    • 静态代码块中不能抛出异常，只能捕获

  • 获取数据库连接 （方法：getConnection）

    • 不用每次暴漏

  • 释放资源 （方法：closeAll(Connection , Statement , ResultSet )）

  • 硬编码，不利于维护，在src根目录下创建一个db.propertoes(新建file--xx.properties格式)

  • 将配置信息放到properties配置文件中，减少硬编码

/**
* 数据库工具类
*/
public class JDBCUtils {
/**
* 1、注册驱动(只需要注册一次)
* 可以将注册驱动的代码写到静态代码块中
* 2、获取数据库连接
* 提供静态一个方法，用于返回数据库连接对象
* 3、关闭资源
* 提供静态一个方法，用于释放资源
* 4、硬编码问题(.xml .properties)
* 将数据源信息保存到配置文件中，然后在代码中进行读取
* properties文件的格式：key和value都是String类型
* key=value，根据key取value
*/
private static String driver;
private static String url;
private static String username;
private static String password;
static{
try {
//读取配置文件
Properties properties = new Properties();
//通过类对象读取当前类路径下的资源
//获取类对象，有个方法，获取类加载器（加载src下的资源有个方法）会返回一个io流
//任何一个类都是通过类加载器加载到方法区的
InputStream in =
JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
//将配置文件中的信息读取到Properties集合中
//test格式也行，但不用切割，直接用load方法就行
properties.load(in);
//从集合中取出数据
//根据key取value    
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");
//注册驱动
Class.forName(driver);
} catch (Exception e) {
e.printStackTrace();
}
}
//后面的参数就不写死    
    
public static Connection getConnection(){
Connection conn = null;
try {
conn = DriverManager.getConnection(url,username,password);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return conn;
 //为什么只传个statement，而不是prestatement————父类
//多态
 
public static void closeAll(Connection conn, Statement statement, ResultSet
rs){
try {
    //判断一下，不用写多个
if(rs!=null)
rs.close();
if(statement != null)
statement.close();
if(conn != null)
conn.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}

配置文件 db.properties

driver123=com.mysql.jdbc.Driver
url=jdbc:mysql:///java2105
username=root
password=123456

工具类测试

public class JDBCDemo01 {
public static void main(String[] args) throws SQLException {
//2、获取数据库连接
Connection conn = JDBCUtils.getConnection();
//3、获取数据库操作对象
PreparedStatement ps = conn.prepareStatement("select * from emp");
//4、执行SQL语句
ResultSet rs = ps.executeQuery();
//5、处理结果集
while(rs.next()){
int empno = rs.getInt("empno");
String ename = rs.getString("ename");
String job = rs.getString("job");
int mgr = rs.getInt("mgr");
Date hiredate = rs.getDate("hiredate");
double sal = rs.getDouble("sal");
double comm = rs.getDouble("comm");
int deptno = rs.getInt("deptno");
System.out.println(ename);
}
//6、释放资源
JDBCUtils.closeAll(conn,ps,rs);
}
}

DAO （Data Access Object）

DAO 实现了业务逻辑与数据库访问相分离。

  • 对同一张表的所有操作封装在XxxDaoImpl对象中。
  • 根据增删改查的不同功能实现具体的方法（insert、update、delete、select、selectAll）。
  • 一个DAO对应数据库中的一张表，按照面向接口设计

开发流程

EmpDao接口

public interface EmpDao {
//增加员工
int insertEmp(Emp emp) throws SQLException;
//删除员工
int deleteEmp(int empno);
//修改员工
int updateEmp(Emp emp) throws SQLException;
//查询所有员工
List<Emp> selectAll() throws SQLException;
//查询单个员工
Emp selectOne(int empno);
}

实体类

com.qf.pojo包下创建实体类

public class Emp {
private Integer empno;
private String ename;
private String job;
private Integer mgr;
private Date hiredate;
private Double sal;
private Double comm;
private Integer deptno;
//省略get、set、构造方法
}
EmpDao实现类
public class EmpDaoImpl implements EmpDao {
@Override
public int insertEmp(Emp emp) throws SQLException {
//2、获取数据库连接对象
Connection conn = JDBCUtils.getConnection();
//3、获取数据库操作对象
PreparedStatement ps = conn.prepareStatement("insert into emp
values(?,?,?,?,?,?,?,?)");
//3.1设置占位符的值
ps.setInt(1,emp.getEmpno());
ps.setString(2,emp.getEname());
ps.setString(3,emp.getJob());
ps.setInt(4,emp.getMgr());
//将util.date 转换成 sql.date
//emp中保存的是java.util.Date,setDate方法要传的是java.sql.date
ps.setDate(5,new Date(emp.getHireadate().getTime()));
ps.setDouble(6,emp.getSal());
ps.setDouble(7,emp.getComm());
ps.setInt(8,emp.getDeptno());
//4、执行SQL语句
int count = ps.executeUpdate();
//5、处理结果
//6、释放资源
JDBCUtils.closeAll(conn,ps,null);
return count;
}
                                             
                                             
@Override
public int deleteEmp(int empno) {
return 0;
}
                                             
                                             
@Override
public int updateEmp(Emp emp) throws SQLException {
//2、获取数据库连接对象
Connection conn = JDBCUtils.getConnection();
//3、获取数据库操作对象
//String sql="update empset ename=?,job=?....where empno=?"
PreparedStatement ps = conn.prepareStatement("update emp set
ename=?,job=?,mgr=?,hiredate=?,sal=?,comm=?,deptno=? where empno = ?");
//3.1设置占位符的值
ps.setString(1,emp.getEname());
ps.setString(2,emp.getJob());
ps.setInt(3,emp.getMgr());
//将util.date 转换成 sql.date
ps.setDate(4,new Date(emp.getHireadate().getTime()));
ps.setDouble(5,emp.getSal());
ps.setDouble(6,emp.getComm());
ps.setInt(7,emp.getDeptno());
ps.setInt(8,emp.getEmpno());
//4、执行SQL语句
int count = ps.executeUpdate();
//5、处理结果
//6、释放资源
JDBCUtils.closeAll(conn,ps,null);
return count;
}
                                             
                                             
@Override
public List<Emp> selectAll() throws SQLException {
//2、获取数据库连接对象
Connection conn = JDBCUtils.getConnection();
//3、获取数据库操作对象
//String sql="select *from emp";
PreparedStatement ps = conn.prepareStatement("select * from emp");
//4、执行SQL语句
ResultSet rs = ps.executeQuery();
//5、处理结果集
List<Emp> empList = new ArrayList<>();
while(rs.next()){
    int empno = rs.getInt("empno");
    String ename = rs.getString("ename");
    String job = rs.getString("job");
    int mgr = rs.getInt("mgr");
    Date hiredate = rs.getDate("hiredate");
    double sal = rs.getDouble("sal");
    double comm = rs.getDouble("comm");
    int deptno = rs.getInt("deptno");
    //将查询的结果存放到Emp对象中
    Emp emp = new Emp(empno,ename,job,mgr,hiredate,sal,comm,deptno);
    //将Emp对象添加到List中
    empList.add(emp);
}
//6、释放资源
JDBCUtils.closeAll(conn,ps,rs);
return empList;
}
                                             
@Override
public Emp selectOne(int empno) {
    //设置占位符得的值
    //ps.setInt(1,empno)
return null;
}
}
测试类
public class TestEmpDao {
public static void main(String[] args) throws Exception {
//测试查询所有
// EmpDao empDao = new EmpDaoImpl();
// List<Emp> empList = empDao.selectAll();
// System.out.println(empList);
//测试增加
// EmpDao empDao = new EmpDaoImpl();
// Emp emp = new Emp(9000,"韩梅梅","mysql",7369,new Date(),4000d,200d,30);
// System.out.println(empDao.insertEmp(emp));
//测试修改
EmpDao empDao = new EmpDaoImpl();
Emp emp = new Emp(9000,"李雷","java",7369,new Date(),40000d,200d,30);
System.out.println(empDao.updateEmp(emp));
}
}

Service 业务

什么是业务

代表用户完成的一个业务功能，可以由一个或多个DAO的调用组成。（软件所提供的一个功能都叫业务）

先设计业务后DAO

一个业务对应一张表

业务接口——接口的实现类——

在这里插入图片描述

EmpService

public interface AccountService{
    //转账方法
    //转出方姓名，转出方密码，接收方姓名，转账金额
    String transferMoney(String fromName,String password,String toName,double money)   
}

AccountService

//重写转账操作
//判断我方账户时候合法，余额是否充足，对方账户是否合法，我方扣钱对方加钱
public class AccountServiceImpl implements AccountService {
    AccountDao accountDao = new AccountDaoImpl();
    @Override
    public String zhuanZhang(String fromName, String password, String toName,double money) {
    try {
        //1、验证我方用户密码
        Account account = accountDao.selectAccount(fromName);
        if(account == null){
        return "用户名不存在";
        }
        if(!account.getPassword().equals(password)){
        return "用户密码不正确";
        }
        //2、验证余额
        if(account.getMoney() < money){
        return "用户余额不足";
        }
        //3、验证敌方用户
        if(accountDao.selectAccount(toName) == null){
        return "敌方用户名不存在";
        }
        //4、我方扣钱
        accountDao.updateAccount(fromName,-money);
        System.out.println(10/0);
        //5、敌方加钱
        accountDao.updateAccount(toName,money);
        return "转账成功";
        } catch (SQLException throwables) {
        throwables.printStackTrace();
        }
        return "转账失败";
        }
}

Dao接口

public interface AccountDao{
//根据用户获取用户信息，如果返回值为null，表示用户不存在
	Account selectAccount (String name);
    //根据用户修改用户余额
    int updateAccount(String name,doule money);
}

pojo实体类

（数据承载bean）

public class Account{
	private Interger id;
	private String name;
	private String password;
	private String money;
	
	构造；
	setter/getter;
	toString();
}

AccountDao实现类

public class AccountDaoImpl implements AccountDao {
@Override
public Account selectAccount (String name) throws SQLException {
        //2、获取数据库连接对象
        Connection conn = JDBCUtils.getConnection();
        //3、获取数据库操作对象
        PreparedStatement ps = conn.prepareStatement("select *from tb_account where name=?");
        //3.1设置占位符的值
        ps.setString(1,name);
        //4、执行SQL语句
        ResultSet rs = ps.executeQuery();
    	While(rs.next()){
            int id = rs.getid("id");
            String password = rs.getString("password");
            double money = rs.getDouble("money");
            Account account = new Account(id,name,password,money);
            return account;
        }
        //5、处理结果
        //6、释放资源
        JDBCUtils.closeAll(conn,ps,null);
        return null;
        }

public Account updateAccount (String name,double money) throws SQLException {
        //2、获取数据库连接对象
        Connection conn = JDBCUtils.getConnection();
        //3、获取数据库操作对象
        PreparedStatement ps = conn.prepareStatement("update tb_account set money=money+? where name=?");
        //3.1设置占位符的值
        ps.setDouble(1,money);
        ps.setString(2,name);
        //4、执行SQL语句
        int count = ps.executeUpdate();
        //5、释放资源
        JDBCUtils.closeAll(conn,ps,null);
        return count;
        }
}

测试类

public class TestAcountService{
	public static void main(String[] args){
        AccountService accountService=new AccountServiceImpl();
        System.out.println(accountService.transFerMoney(jb,123,rose,100))
    }
}

事务

jdbc连接池

Druid连接池

在程序初始化时，预先创建指定数量的数据库连接对象存储在池中。当需要连接数据库时，从连接池中取出现有连接；使用完毕后，也不会进行关闭，而是放回池中，实现复用，节省资源。

  • 创建 db.properties 配置文件。
  • 引入druid的jar 文件。

db.properties

driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql:///java2105?useSSL=false
username=root
password=123456
#初始化连接 （初始化连接池的，里面默认就已经存在了20个Connection连接）
initialSize=20
#最大连接数量 （当初始的20个连接不够的时候，最大会创建到50个）
maxActive=50
#最小空闲连接 (当连接池中的连接，没有被使用，就会减少到5个)
minIdle=5
#超时等待时间 (当连接数超过最大连接数，会等待5秒，如果5秒后还没有空闲连接，就会抛出异常)
maxWait=5000

最终版JDBC工具类

public class JDBCUtils {
//定义数据库连接池
private static DataSource dataSource;
//初始化连接池对象
static{
try {
Properties properties = new Properties();
InputStream in =
JDBCUtils.class.getClassLoader().getResourceAsStream("db.properties");
properties.load(in);
//初始化连接池对象
dataSource = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}
//返回连接池对象
public static DataSource getDataSource(){
return dataSource;
}
//使用ThreadLocal保证Connection在同一个线程下唯一
static ThreadLocal<Connection> tl = new ThreadLocal<>();
public static Connection getConnection(){
Connection conn = tl.get();
try {
if(conn == null){
conn = dataSource.getConnection();
tl.set(conn);
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return conn;
}
public static void closeAll(Connection connection, Statement statement ,
ResultSet rs){
try {
if(rs!=null)
rs.close();
if(statement!=null)
statement.close();
if(connection!=null)
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
public static void begin(){
Connection conn = getConnection();
try {
conn.setAutoCommit(false);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
public static void commit(){
Connection conn = getConnection();
try {
conn.commit();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
try {
conn.close();
tl.remove();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void rollback(){
Connection conn = getConnection();
try {
conn.rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}finally {
try {
conn.close();
tl.remove();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
}

连接池测试

public class TestDruidDataSource {
public static void main(String[] args) throws SQLException {
// Connection conn1 = JDBCUtils.getConnection();
// System.out.println(conn1);
// Connection conn2 = JDBCUtils.getConnection();
// System.out.println(conn2);
for (int i = 0; i < 51; i++) {
Connection connection = JDBCUtils.getDataSource().getConnection();
System.out.println(connection);
connection.close();//并不是关闭连接，而是归还到连接池中
}
}
}

DBUtils工具类

DBUtils简介

DbUtils是Java编程中数据库操作实用小工具，小巧、简单、实用

  • 对于数据表的查询操作，可以把结果转换为List、Array、Set等集合。便于操作。
  • 对于数据表的DML操作，也变得很简单(只需要写SQL语句)。

DbUtils核心API

  • ResultSetHandler接口：转换类型接口
    • BeanHandler类：实现类，把一条记录转换成对象
    • BeanListHandler类：实现类，把多条记录转换成List集合。
    • ScalarHandler类：实现类，适合获取一行一列的数据。
    • MapHandler类： 实现类，把一条记录转换成Map集合
    • MapListHandler类：实现类，把多条记录转换成List集合。
  • QueryRunner：执行sql语句的类
    • 增、删、改：update();
    • 查询：query();

DbUtils的使用步骤

导入jar包

  • mysql连接驱动jar包
  • 导入druid 的jar包
  • database.properties配置文件
  • 导入commons-dbutils的jar包

DBUtils使用

使用DBUtils实现增删改查

public class EmpDaoImpl implements EmpDao {
@Override
public int insertEmp(Emp emp) throws SQLException {
//1、创建QueryRunner对象
//如果是更新（增删改）操作,那么就用无参的构造
QueryRunner qr = new QueryRunner();
//2、通过QueryRunner对象调用update
String sql = "insert into emp values(?,?,?,?,?,?,?,?)";
Object[] args =
{emp.getEmpno(),emp.getEname1(),emp.getJob(),emp.getMgr(),emp.getHireadate(),emp
.getSal(),emp.getComm(),emp.getDeptno()};
return qr.update(JDBCUtils.getConnection(),sql,args);
}
@Override
public int updateEmp(Emp emp) throws SQLException {
//1、创建QueryRunner对象
//如果是更新（增删改）操作,那么就用无参的构造
QueryRunner qr = new QueryRunner();
//2、通过QueryRunner对象调用update
String sql = "update emp set
ename=?,job=?,mgr=?,hiredate=?,sal=?,comm=?,deptno=? where empno = ?";
Object[] args =
{emp.getEname1(),emp.getJob(),emp.getMgr(),emp.getHireadate(),emp.getSal(),emp.g
etComm(),emp.getDeptno(),emp.getEmpno()};
return qr.update(JDBCUtils.getConnection(),sql,args);
}
@Override
public int deleteEmp(int empno) throws SQLException {
//1、创建QueryRunner对象
//如果是更新（增删改）操作,那么就用无参的构造
QueryRunner qr = new QueryRunner();
//2、通过QueryRunner对象调用update
String sql = "delete from emp where empno = ?";
Object[] args = {empno};
return qr.update(JDBCUtils.getConnection(),sql,args);
}
@Override
public List<Emp> selectAll() throws Exception {
//1、创建QueryRunner对象
//如果是查询操作,那么就用有参的构造，传递连接池对象（使用完成之后QueryRunner会自动关
闭(回收)）
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//2、通过QueryRunner对象调用query
String sql = "select empno,ename ename1,job,mgr,hiredate
hireadate,sal,comm,deptno from emp";
//如果是集合就创建BeanListHandler对象，如果是实体类就创建BeanHandler对象
List<Emp> empList = qr.query(sql, new BeanListHandler<Emp>(Emp.class));
return empList;
}
@Override
public Emp selectOne(int empno) throws SQLException {
//1、创建QueryRunner对象
//如果是查询操作,那么就用有参的构造，传递连接池对象（使用完成之后QueryRunner会自动关
闭(回收)）
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//2、通过QueryRunner对象调用query
String sql = "select * from emp where empno = ?";
Object[] args = {empno};
Emp emp = qr.query(sql, new BeanHandler<Emp>(Emp.class),args);
return emp;
}
@Override
public long count() throws SQLException {
//1、创建QueryRunner对象
//如果是查询操作,那么就用有参的构造，传递连接池对象（使用完成之后QueryRunner会自动关
闭(回收)）
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
String sql = "select count(*) from emp";
Long count = qr.query(sql, new ScalarHandler<Long>());
return count;
}
}

字段与属性名不一致

如果数据库的字段名与实体类中的属性名不一致，则无法完成映射，值会显示null

解决：在查询语句中取别名

@Override
public List<Emp> selectAll() throws Exception {
//1、创建QueryRunner对象
//如果是查询操作,那么就用有参的构造，传递连接池对象（使用完成之后QueryRunner会自动关闭(回
收)）
QueryRunner qr = new QueryRunner(JDBCUtils.getDataSource());
//2、通过QueryRunner对象调用query
//通过别名进行数据映射
String sql = "select empno,ename ename1,job,mgr,hiredate
hireadate,sal,comm,deptno from emp";
//如果是集合就创建BeanListHandler对象，如果是实体类就创建BeanHandler对象
List<Emp> empList = qr.query(sql, new BeanListHandler<Emp>(Emp.class));
return empList;
}

public class Emp {
private Integer empno;
private String ename1; //这个与数据库字段不一致
private String job;
private Integer mgr;
private Date hireadate; //这个与数据库字段不一致
private Double sal;
private Double comm;
private Integer deptno;
//省略set、get、构造方法
}
我是二次元穿越来的
关注
  • 24
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
jdbc总结
09-15
jdbc总结
java之jdbc总结
11-08
在学习Java的过程中，面对用Java操作数据库的时候，难免会遇见对于数据库连不上的问题，这是本人在学习过程中的一些总结，专门针对Java操作数据库的内容，包括jdbc的链接，分页，MySQL的存储过程等，仅供参考，不...
JDBC总结——事务
12-15
文章目录事务一、事务的基本介绍1、概念2、操作3、操作实例4、MySQL数据库中默认自动提交二、事务的四大特征三、事务的隔离级别1、概念2、存在的问题3、隔离级别四、Jdbc事务控制1、概述2、控制事务的API：3、核心...
使用JDBC总结操作数据库
12-08
1. 加载驱动Class.forName("oracle.jdbc.driver.OracleDriver");//相当于我们的第三方工具pl/sql 2. 通过驱动获取连接对象Connection con=DriverManager.getConnection(“jdbc:oracle:thin:@10.1.12.138:1521:orcl",...
jdbc资源总结jdbc
09-29
jdbc资源总结
jdk8新特性----Lambda表达式
最新发布
w_t_y_y的博客
05-11 184
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
java jar包如何运行或调用
NLP与推荐算法
05-08 254
java服务启动
【数据结构】二叉树
m0_73911405的博客
05-05 647
前序：根，左子树，右子树中序：左子树，根，右子树后序：左子树，右子树，根N代表空元素前序 1 2 3 N N N 4 5 N N 6 N N中序 N 3 N 2 N 1 N 5 N 4 N 6 N后序 N N 3 N 2 N N 5 N N 6 4 1层序 1 2 4 3 5 6一层层从左到右一个树分成根和子树，子树再分为根和子树。
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 342
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
《设计一款蓝牙热敏打印机》
唐顺才的博客
05-06 335
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 1130
一篇文章，系统性聊聊Java注解
Java代码基础算法练习-删除有序数组中的重复项-2024.05.07
Sakurapaid的博客
05-07 222
给一个有序数组（共10个元素），请在不新建数组的情况下，删除重复出现的元素，使 每个元素只出现一次，最后请输出删除重复元素后数组的新长度和数组元素。要删除有序数组中的重复项，且不使用额外数组，可以采用。
Java基础（三）：Java异常机制以及底层实现原理
Lee的博客
05-07 724
除了Java中提供的异常之外，我们也可以自定义一些异常，自定义异常可以自定义运行时异常和非运行时异常两种方式。自定义运行时异常之需要继承这个方法即可，这里我们加了一个构造方法，这样可以创建异常对象时加一些描述异常信息。自定义非运行时异常只需要继承Exception，这里也是加了一个构造方法，描述异常信息。
力扣：300. 最长递增子序列（Java，动态规划）
jungleirim的博客
05-07 287
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。解释：最长递增子序列是 [2,3,7,101]，因此长度为 4。给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。输入：nums = [10,9,2,5,3,7,101,18]输入：nums = [0,1,0,3,2,3]
leetcode刷题
weixin_42419365的博客
05-10 179
二叉搜索树的最近公共祖先。我真垃圾啊，写这么多if。二叉搜索树中的插入操作。
鸿蒙开发接口Ability框架：【@ohos.ability.featureAbility (FeatureAbility模块)】
2301_76813281的博客
05-06 823
FeatureAbility模块提供带有UI设计与用户交互的能力，包括启动新的ability、获取dataAbilityHelper、设置此Page Ability、获取当前Ability对应的窗口，连接服务等。本模块首批接口从API version 6开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。本模块接口仅可在FA模型下使用。
【Java】基本程序设计结构(二)
2301_80827065的博客
05-05 621
上一篇我们详细介绍了Java基本程序设计结构中前半部分，
C++初阶学习第五弹——类与对象（下）——类与对象的收官战
2301_80220607的博客
05-06 3913
C++类与对象连续篇（下）——这三篇小白可以好好看看，都是很重要的知识！！！
使用HashMap实现，对一个字符集进行哈夫曼编码
2301_80636143的博客
05-09 1095
int weight;//权重Node left;Node right;char ch;//关键字，字符//相应的哈夫曼编码public Node(char ch, int weight) {//构造方法，键值对//构造方法，只设置出现频率//重写compareTo方法@Overrideif(this.weight - node.weight==0){//如果两个字符出现的频率一样，那么就比较字典序（两个字符一定是不同的）//默认排列升序//重写toString方法。
postgresqljdbc
09-15
PostgreSQL JDBC是用于连接Java程序与PostgreSQL...总结起来，要使用PostgreSQL JDBC连接到PostgreSQL数据库，需要先下载并安装JDBC驱动程序，然后在Java程序中使用`DriverManager.getConnection()`方法连接到数据库。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是二次元穿越来的

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值