2020-10-22

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

JDBC

就是一组Java连接数据库的API，这些API不是数据库厂商提供，是sun公司给我们封装好一些接口，具体的实现是由各个数据库厂商来实现的。我们想要操作不同的数据库，就需要用到各个数据库厂商给我们提供的接口的实现类。

操作JDBC四个步骤：
1.加载驱动
2.连接数据库
3.操作数据库
4.关闭数据库连接

常用的类:
DriverManager:是java.sql包下的类，管理数据库的一组API，我们在使用DriverManager的时候最常用的就是getConnection()方法，通过此方法，我们可以获取到Connection对象.
DriverManager常用的方法：
getConnection(String url,String user,String password):此方法是一个静态方法，此方法的作用是获取Connection接口的对象，其中参数url代表想要连接的数据库的网络地址，user代表用户名，password代表密码
MySQL的url的格式：jdbc:mysql://主机地址:端口号/要连接的数据库的名称

Connection:是java.sql包下的接口，代表与特定的数据库之间的连接(会话)，在连接上下文中执行SQl语句并返回执行的结果。
Connection常用的方法：
1.close():关闭数据库连接
2.createStatement()：此方法会返回一个Statement对象

Statement：是java.sql包下的接口，Statement对象的作用就是用来执行静态SQL语句,并返回SQL语句的执行结果的对象。
Statement给我们提供的常用的方法：
1.execute(String sql):用来执行SQL语句的方法，此方法的返回值是boolean类型的对象，如果返回的第一个结果是ResultSet结果集对象，则此方法的返回值是true,否则是false.一般来讲我们不会用此方法执行查询，我们都是通过此方法执行除了查询之外的其他的SQL语句。
2.close():关闭当前操作数据库的Statement对象
3.executeQuery(String sql) :此方法的作用是用来执行查询语句并返回查询结果，返回值是ResultSet对象。

ResultSet：是java.sql包下的接口，表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
ResultSet常用的方法：
next():此方法是将结果集中的光标指向下一条数据，在执行之前，此方法会判断是否存在下一条数据，如果存在，则向下移动光标并返回true,否则返回false.
close():关闭结果集对象
getInt(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的int类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。
getDouble(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的double类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。
getFloat(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的float类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。
getString(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的varchar类型或者char类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。
getDate(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的Date类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。
getTimeStamp(int columnIndex):此方法是用来获取数据库中结果集的当前这一行的TimeStamp或是Date类型的数据，参数代表当前字段在结果中出现的位置，位置从1开始的。

getInt(String columnName):此方法是用来获取数据库中结果集的当前这一行的int类型的数据，参数代表当前字段的名称
getDouble(String columnName):此方法是用来获取数据库中结果集的当前这一行的double类型的数据，参数代表当前字段的名称
getFloat(String columnName):此方法是用来获取数据库中结果集的当前这一行的float类型的数据，参数代表当前字段的名称
getString(String columnName):此方法是用来获取数据库中结果集的当前这一行的varchar类型或者char类型的数据，参数代表当前字段的名称
getDate(String columnName):此方法是用来获取数据库中结果集的当前这一行的Date类型的数据，参数代表当前字段的名称
getTimeStamp(String columnName):此方法是用来获取数据库中结果集的当前这一行的TimeStamp或是Date类型的数据，参数代表当前字段的名称

总结JDBCDemo的问题所在:
1.数据库的驱动我们在频繁的加载。
解决的思路：加载一次即可。
2.SQL语句中传递的字段的数据都是常量，每一次想要修改必须重写编写代码。
解决思路：可以考虑使用变量
3.对于insert、update、delete方法来讲只有SQL语句不同，其他的都一样。
解决思路：可以考虑将这些一样的进行封装。

Connection常用方法：
prepareStatement(String sql)：返回一个PreparedStatement接口对象。

PreparedStatement:是java.sql包下的一个接口，表示预编译的 SQL 语句的对象。
什么叫预编译的SQL语句，实际上就是指，在SQL语句中我们对于需要设置的字段的数据，我们可以采用占位符的形式进行编写，并预编译在SQL语句在中，之后我们只需要设置占位符即可。

DAO：数据访问对象，主要就是提供对数据库执行的方法进行封装。
VO：value Object 值对象，主要的作用就是用来传递数据。

package com.ran.demo1;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;

public class Test {

	public static void main(String[] args) {
		selectAllEmp();
		}
	public static void insertEmp(){
		//反射加载
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		// 获取数据库链接
		Connection conn = null;
		Statement stat=null;
		try {
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/java2020", "root", "root");
			//插入数据
			String sql="insert into emp(empid,ename,job,sal,hiredate) values(1,'lishi','manager',800,now());";
			stat=conn.createStatement();
			stat.execute(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 关闭数据库连接
			
			if(stat != null){
				try {
					stat.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	public static void updateEmp(){
		//反射加载
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		// 获取数据库链接
		Connection conn = null;
		Statement stat=null;
		try {
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/java2020", "root", "root");
			//插入数据SQL语句
			String sql="update emp set ename='zs',sal=1000 where empid=1";
			stat=conn.createStatement();
			stat.execute(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 关闭数据库连接
			if(stat != null){
				try {
					stat.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	public static void deleteEmp(){
		//反射加载
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		// 获取数据库链接
		Connection conn = null;
		Statement stat=null;
		try {
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/java2020", "root", "root");
			//插入数据SQL语句
			String sql="delete from emp where empid=1 ";
			stat=conn.createStatement();
			stat.execute(sql);
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 关闭数据库连接
			if(stat != null){
				try {
					stat.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
	public static void selectAllEmp(){
		//反射加载
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		// 获取数据库链接
		Connection conn = null;
		Statement stat=null;
		ResultSet rs=null;
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
		try {
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/java2020", "root", "root");
			//插入数据SQL语句
			String sql="select ename,empid,job from emp";
			stat=conn.createStatement();
			rs=stat.executeQuery(sql);
			while(rs.next()){
				int empid=rs.getInt("empid");
				String ename=rs.getString("ename");
				String job=rs.getString("job");
//				double sal=rs.getDouble(4);
//				Date t1=rs.getDate(5);
//				String t=sdf.format(t1);
				System.out.println(empid+ename+job);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			// 关闭数据库连接
			if(rs!=null){
				try {
					rs.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(stat != null){
				try {
					stat.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if (conn != null) {
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

二

package com.rang.excercise;

import java.util.Date;

public class Emp {

	public Emp(int empid, String ename, String job, double sal, Date hiredate) {
		super();
		this.empid = empid;
		this.ename = ename;
		this.job = job;
		this.sal = sal;
		this.hiredate = hiredate;
	}
	public Emp() {}
	private int empid;
	private String ename;
	private String job;
	private double sal;
	private Date hiredate;
	public int getEmpid() {
		return empid;
	}
	public void setEmpid(int empid) {
		this.empid = empid;
	}
	public String getEname() {
		return ename;
	}
	public void setEname(String ename) {
		this.ename = ename;
	}
	public String getJob() {
		return job;
	}
	public void setJob(String job) {
		this.job = job;
	}
	public double getSal() {
		return sal;
	}
	public void setSal(double sal) {
		this.sal = sal;
	}
	public Date getHiredate() {
		return hiredate;
	}
	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}
	@Override
	public String toString() {
		return "Emp [empid=" + empid + ", ename=" + ename + ", job=" + job + ", sal=" + sal + ", hiredate=" + hiredate
				+ "]";
	}
	
	
}


package com.rang.excercise;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class EmpDao implements BaseDao<Emp> {

    public EmpDao() {
    }

    @Override
    public void insert(Emp t) {
        String sql = "insert into emp(ename,job,sal,hiredate) values(?,?,?,?);";
        DbTools.executeUpdate(sql, t.getEname(), t.getJob(), t.getSal(), t.getHiredate());
    }

    @Override
    public void update(Emp t) {
        String sql = "update emp set ename=?,job=?,sal=?,hiredate=? where empid=?";
        DbTools.executeUpdate(sql, t.getEname(), t.getJob(), t.getSal(), t.getHiredate(), t.getEmpid());
    }

    @Override
    public void delete(Emp t) {
        String sql = "delete from emp where empid=?";
        DbTools.executeUpdate(sql, t.getEmpid());
    }

    @Override
    public Emp selectById(Emp t) {
        Emp emp = null;
        String sql = "select * from emp where empid=?";
        List<Object[]> list = DbTools.executeQuery(sql, t.getEmpid());
        if (list.size() > 0) {
            Object[] objs = list.get(0);
            int empid = (Integer) objs[0];
            String ename = (String) objs[1];
            String job = (String) objs[2];
            double sal = (Double) objs[3];
            Timestamp hd = (Timestamp) objs[4];
            emp=new Emp(empid,ename,job,sal,new java.util.Date(hd.getTime()));
        }
        return emp;
    }

    @Override
    public List<Emp> selectAll() {
        List<Emp> emps = new ArrayList<>();
		String sql = "select * from emp";
      	List<Object[]> list=DbTools.executeQuery(sql,null);
		if (list.size() > 0) {
			for(int i=0;i<list.size();i++){
				Object[] objs = list.get(i);
				int empid = (Integer) objs[0];
				String ename = (String) objs[1];
				String job = (String) objs[2];
				double sal = (Double) objs[3];
				Timestamp hd = (Timestamp) objs[4];
				Emp emp=new Emp(empid,ename,job,sal,new java.util.Date(hd.getTime()));
				emps.add(emp);
			}
		}
        return emps;
    }
}


package com.rang.excercise;

import java.util.List;

public interface BaseDao<T> {
	public abstract void insert(T t);
	public abstract void update(T t);
	public abstract void delete(T t);
	public abstract T selectById(T t);
	public abstract List<T> selectAll();
}


package com.rang.excercise;

import java.sql.*;

import java.util.ArrayList;
import java.util.List;

public class DbTools {
    //URL
    private  static  final String URL="jdbc:mysql://localhost:3306/test";
    //user
    private static final String USER="root";
    //pwd
    private static final String PWD="root";
    //PreparedStatement 对象
    private static PreparedStatement preparedStatement=null;
    //ResultSet对象
    private static ResultSet resultSet=null;
    //connection对象
    private  static Connection connection=null;
    //编写一个静态块用于加载驱动
    static  {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection()  {
        if (connection == null) {
            try {
                connection = DriverManager.getConnection(URL, USER, PWD);
                connection.setAutoCommit(false);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return  connection;
    }
    //insert,update,delete
    public static void executeUpdate(String sql,Object...objs){
        //获取connection 对象
        connection=getConnection();
        //获取PreparedStatement 对象
        try {
            preparedStatement=connection.prepareStatement(sql);
            if(objs!=null){
                for(int i=0;i<objs.length;i++){
                    preparedStatement.setObject(i+1,objs[i]);
                }
            }
            preparedStatement.executeUpdate();
            commit();
        } catch (SQLException e) {
            e.printStackTrace();
            rollback();
        }finally {
            close();
        }
    }
    //select方法
    public static List<Object[]> executeQuery(String sql,Object...objs){
        List<Object[]> list=new ArrayList<>();
        connection=getConnection();
        try {
            preparedStatement=connection.prepareStatement(sql);
            if(objs!=null&&objs.length>0){
                for(int i=0;i<objs.length;i++){
                    preparedStatement.setObject(i+1,objs[i]);
                }
            }
            resultSet=preparedStatement.executeQuery();
            while(resultSet.next()){
                Object[] datas=new Object[resultSet.getMetaData().getColumnCount()];
                for(int i=0;i<datas.length;i++){
                    datas[i]=resultSet.getObject(i+1);
                }
                list.add(datas);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            close();
        }
        return list;
    }
    //事务提交
    public  static  void commit(){
        if (connection!=null){
            try {
                connection.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //回滚
    public  static  void rollback(){
        if (connection!=null){
            try {
                connection.rollback();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    //静态方法关闭资源
    public static  void close(){
        if(resultSet!=null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(preparedStatement !=null){
            try {
                preparedStatement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(connection!=null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            connection=null;
        }
    }
}
七天快乐
关注
专栏目录
2020-10-24
kangkang188的博客
10-24 1763
E:\>d: D:\>dir 驱动器 D 中的卷是 软件 卷的序列号是 001A-F31A D:\ 的目录 2019/07/29 18:26 <DIR> 360downloads 2020/09/19 15:55 <DIR> 360驱动大师目录 2020/10/15 21:47 <DIR> DianNaoDian 2020/10/13 23:41 <DIR...
catchLogs_2020-10-22 at 00:15:09_6.30.1__.java.txt
07-24
catchLogs_2020-10-22 at 00:15:09_6.30.1__.java.txt
2020-04-10
m0_46591785的博客
04-10 2425
Super关键字 可以访问父类中定义的属性 可以调用父类中定义的成员方法 可以在子类构造器中调用父类构造器 .子类所有的构造器默认都访问父类中空参数的构造器 .子类一定会调用父类构造器（默认过程调用无参） //如果没有显示定义构造方法，Java编译阶段提供一个默认构造方法 //如果定义了自己的构造器，Java使用自己的构造器 //父类所有的构造器：子类必须实现它，子类默认当中一定使用到了父类的构造...
2020-05-10
zcz19920114的博客
05-10 1250
本人camera hal小白，无从下手有没有camera hal 的大佬可以指点一下或者提供一点资料，在此谢了
2020-06-07
lyyzxl的博客
06-07 2793
arcgis engine 实现栅格计算器，包括数学运算、逻辑运算、三角函数运算和代数运算。有大佬能帮一下吗？arcgis用10.2版本，环境用vs2015，代码加注释。求大佬。
2020-07-07
北漂猿
07-07 826
2020-06-08
qq_44880289的博客
06-08 3239
stm32属性上找不到编写好的hex 因为还没有编译！
2020-05-09
zero_one666的博客
05-09 1556
1/The easiest thing in the world is persistence. The hardest thing is persistence. Keep in mind that persistence is victory. 2/The idea of breaking at a stroke is not a dream.
2020-03-14
东哥的博客
03-14 1087
<% } %> 这个怎么改成随机
远程调用获取数据报错:Cannot deserialize value of type `java.util.Date` from String “2020-10-22 11:35:10“
热门推荐
wuxin1210的博客
03-22 2万+
com.netflix.hystrix.exception.HystrixRuntimeException: MallFeign#getGoodsOrderData(String) failed and no fallback available. Caused by: org.springframework.http.converter.HttpMessageNotReadableException: JSON parse error: Cannot deserialize value of type
CVE-2020-15778漏洞复现
m0_58606546的博客
11-30 2767
1.漏洞描述 （1）简介:2020年6月9日，研究人员Chinmay Pandya在Openssh中发现了一个漏洞，于7月18日公开。OpenSSH的8.3p1中的scp允许在scp.c远程功能中注入命令，攻击者可利用该漏洞执行任意命令。该漏洞属于命令执行漏洞，目前绝大多数linux系统受影响。 （2）scp介绍：scp是Linux下基于 ssh 登陆进行安全的远程文件拷贝命，用于不同Linux系统之间复制文件和目录。该命令由openssh的scp.c及其他相关代码实现。在本次漏洞复现中就是利用scp命
gmall2020-mock-log-2020-04-01.jar
12-30
用户行为日志生成脚本
MyRPG2020-10-22.rar
10-22
这是我的毕业设计项目，我正在开发一个MMORPG的游戏Demo，以后每隔一段时间我都会上传一份最新的Demo工程。
catchLogs_2020-10-22 at 00:15:10_6.30.1__.java.txt
07-24
catchLogs_2020-10-22 at 00:15:10_6.30.1__.java.txt
Simulator Screen Shot - iPhone 12 Pro Max - 2020-10-22 at 15.47.02.png
01-25
greg
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 921
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 353
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 700
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1016
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值