JDBC连接MySql数据库步骤 以及查询、插入、删除、更新等
程序员文章站
2023-12-09 15:13:03
主要内容：
jdbc连接数据库步骤。
一个简单详细的查询数据的例子。
封装连接数据库，释放数据库连接方法。
实现查询，插入，删除，更...
主要内容：
- jdbc连接数据库步骤。
- 一个简单详细的查询数据的例子。
- 封装连接数据库，释放数据库连接方法。
- 实现查询，插入，删除，更新等十一个处理数据库信息的功能。（包括事务处理，批量更新等）
- 把十一个功能都放在一起。
- 安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序(这本该是第一步，但是由于属于安装类，所以我们放在最后)
一.jdbc连接数据库(编辑)步骤(主要有六个步骤)
1.注册驱动： class.forname("com.mysql.jdbc.driver");显示的加载到jvm中
2.获取连接：(1) param1: 要连接数据库的url-----》 string url="jdbc:mysql://localhost:3306/test?"+ "useunicode=true&characterencoding=utf8";//防止乱码
param2：要连接数据库的用户名--》 string user="h4";
param3：要连接数据库的密码----》 string pass="111";
connection conn=drivermanager.getconnection(url,user,pass)；//drivermanager下的方法：getconnection(string url,string username,string password)
(2)接下来我们分析下url："jdbc(这是协议以jdbc开头):mysql(这是子协议，数据库管理系统名称)://localhost(数据库来源地址):3306(目标端口)/test(要查询的表)?"
"useunicode=true&characterencoding=utf8";添加这个是为了防止乱码，指定使用unicode字符集 ，且使用utf-8来编辑。
3.创建一个statement语句对象(主要三种方法): statement stmt=conn.createstatement();//connection接口下的方法：statement createstatement()
preparedstatement pstmt = conn.preparedstatement() ;
callablestatement cstmt = conn.preparecall("{call demosp(? , ?)}") ;
下面我们来分析下他们：(1) statement与 preparedstatement对象的区别，后者可以动态设置查询参数
(2)设置参数的方法 preparedstatement.setxxxx(parameterindex,value)，如果数据库参数类型是varchar 则用setstring，如果参数类型是integer 则用setint
(3)callablestatement.setxxxx(parameterindex,value) //按照参数的顺序设置value
callablestatement.setxxxx(parametername,value) //按照参数的名字来设置value,这个名字是在定义存储过程的时候的形式参数的名字
(4)callablestatement.registeroutparameter方法用于声明一个存储过程输出类型的参数，用以接收存储过程的输出值
4.执行sql语句: resultset rs=stmt.executequery(sql);除了查询语句是executequery();其他全部是executeupdate();
statement接口下的方法：
boolean execute(string sql):执行sql语句，如果返回值是结果集则为true,否则为false
resultset executequery(string sql):执行sql语句，返回值为resultset
int executeupdate(string sql):执行sql语句，返回值为所影响的行数
5.处理结果集：resultset对象的getxxxx方法，取决于数据库中表的字段的类型，例如：varchar2 对应方法是getstring ,如果是 integer 对应方法是getint/getlong
while(rs.next()){
rs.getint(columnindex); //通过列的序号来获取字段的值
rs.getstring(columnname);//通过列的名字来获取字段的值
resultset接口下常见的方法：beforefirst();将游标移动到resultset中第一条记录(的前面)
afterlast();将游标移动到resultset中最后一条记录(的后面)
absolute(intcolumn):将游标移动到相对于第一行的指定行，负数则为相对于最后一条记录
previous():将游标上移一行
next():将游标下移一行
resultset.type_scroll_sensitive 结果集可以滚动
resultset.concur_read_only 结果集只读，不能修改
6.关闭资源： 操作完以后要关闭jdbc来释放jdbc资源。但是顺序要和你定义对象的时候相反，就像关门一样，从里面先关，一直往外关。
如下示例：
if(rs !=null){//1.关闭结果集
try{
rs.close();
} catch (sqlexception e){
e.printstacktrace();
}
}
if(stmt !=null){//2.关闭声明的对象
try{
stmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
if(conn !=null){//3.关闭连接 （记住一定要先关闭前面的1.2.然后在关闭连接）
try{
conn.close();
}catch(exception e){
e.printstacktrace();
}
}
二.下面是一个简单的(详细的)查询数据的例子
package javacore1;//这是你建的一个包名。
import java.sql.callablestatement;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.resultset; //左边这五个是你在写程序时要导入的包名，记住是要在java.sql下的包。
import java.sql.sqlexception;
import java.sql.statement;
public class jdbc { //定义一个类
public static void main(string[] args){ //主方法
try{
string driver="com.mysql.jdbc.driver"; //1.定义驱动程序名为driver内容为com.mysql.jdbc.driver
string url="jdbc:mysql://localhost:3306/test?" //2.定义url；jdbc是协议；mysql是子协议：表示数据库系统管理名称；localhost：3306是你数据库来源的地址和目标端口；test是我本人建的表位置所在处，你以你的为标准。
+ "useunicode=true&characterencoding=utf8"; //防止乱码；useunicode=true表示使用unicode字符集；characterencoding=utf8表示使用utf-8来编辑的。
string user="h4"; //3.定义用户名，写你想要连接到的用户。
string pass="111"; //4.用户密码。
string querysql="select * from employees"; //5.你想要查找的表名。
class.forname(driver); //6.注册驱动程序，用java.lang包下面的class类里面的class.froname();方法 此处的driver就是1里面定义的driver，也可以 class.forname("com.mysql.jdbc.driver");
connection conn=drivermanager.getconnection(url,user,pass);//7.获取数据库连接,使用java.sql里面的drivermanager的getconnectin(string url , string username ,string password )来完成
//括号里面的url，user，pass便是前面定义的2,3,4步骤内容；
statement stmt=conn.createstatement(); //8.构造一个statement对象来执行sql语句：主要有statement，preparedstatement，callablestatement三种实例来实现
// 三种实现方法分别为：statement stmt = con.createstatement() ;
// preparedstatement pstmt = conn.preparestatement(sql) ;
// callablestatement cstmt = conn.preparecall("{call demosp(? , ?)}") ;
resultset rs=stmt.executequery(querysql);//9.执行sql并返还结束 ；resultset executequery(string sqlstring)：用于返还一个结果集（resultset）对象。
while(rs.next()){ //10.遍历结果集
system.out.println("人员编号:"+rs.getstring("employee_id")+"工资:"+rs.getstring("salary")+"姓名:"+rs.getstring("last_name"));//使用getstring()方法获取你表里的资料名
}
if(rs !=null){//11.关闭记录集
try{
rs.close();
} catch (sqlexception e){
e.printstacktrace();
}
}
if(stmt !=null){//12.关闭声明的对象
try{
stmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
if(conn !=null){//13.关闭连接 （记住一定要先关闭前面的11.12.然后在关闭连接，就像关门一样，先关里面的，最后关最外面的）
try{
conn.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
}catch(exception e){
e.printstacktrace();
}
}
}
三.为了更加直观，我们把获取数据库连接和释放连接封装在方法里，以便于后面更好的操作
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
public class jdbc{
public static void main(string[] args){
connection conn= getconnection("h4", "111"); //获取数据库连接
/*,,,,此处为方法名来获取连接,例如 query(conn),,,,,*/
releaseconnection(conn); // 释放数据库连接
}
/*,,,,,,,,,,此处构建一个你想要的功能的方法,,,,,,,,,,,,*/
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
四.实现查询、插入、删除、更新等十一个处理数据库信息的功能
1.查询数据
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.resultset;
import java.sql.sqlexception;
import java.sql.statement;
public class query {
public static void main(string[] args) {
connection conn = getconnection("h4", "111");// 获取数据库连接
query(conn); //方法名调用数据库连接
releaseconnection(conn);//释放数据库连接
}
//查询数据，定义的query方法
public static void query(connection conn){
string sql="select * from employees";
try{
statement stmt=conn.createstatement(); //也可以使用preparedstatement来做
resultset rs=stmt.executequery(sql);//执行sql语句并返还结束
while(rs.next()){//遍历结果集 ，向下一行
system.out.println("人员编号:"+rs.getstring("employee_id")+"工资:"+rs.getstring("salary"));
}
if(rs !=null){
try{
rs.close();
} catch (sqlexception e){
e.printstacktrace();
}
}
if(stmt !=null){
try{
stmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
if(conn !=null){
try{
conn.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
}catch(exception e){
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
//查询数据，结果倒着显示，倒序
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.resultset;
import java.sql.sqlexception;
import java.sql.statement;
public class query {
public static void main(string[] args) {
connection conn = getconnection("h4", "111");// 获取数据库连接
query(conn); //方法名调用数据库连接
releaseconnection(conn);//释放数据库连接
}
//查询数据，定义的query方法
public static void query(connection conn){
string sql="select * from employees";
try{
statement stmt=conn.createstatement(); //也可以使用preparedstatement来做
resultset rs=stmt.executequery(sql);//执行sql语句并返还结束
rs.afterlast(); //先跳到最后一行
while(rs.previous()){//遍历结果集 ，向上一行
system.out.println("人员编号:"+rs.getstring("employee_id")+"工资:"+rs.getstring("salary"));
}
if(rs !=null){
try{
rs.close();
} catch (sqlexception e){
e.printstacktrace();
}
}
if(stmt !=null){
try{
stmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
if(conn !=null){
try{
conn.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
}catch(exception e){
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
2.插入数据
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.sqlexception;
import java.sql.statement;
public class insert {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
insert(conn); //方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//插入数据
public static void insert(connection conn) {
try {
string sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"
+ " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句
statement stmt1 =conn.createstatement(); // 创建用于执行静态sql语句的statement对象
int count = stmt1.executeupdate(sql); // 执行插入操作的sql语句，并返回插入数据的个数
system.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果
conn.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
3.删除数据
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.sqlexception;
import java.sql.statement;
public class delete {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
delete(conn); //方法名调用数据库连接；
releaseconnection(conn);// 释放数据库连接
}
//删除数据
public static void delete(connection conn){
string sql = "delete from employees where employee_id=100009";
try {
statement stmt = conn.createstatement();// 或者用preparedstatement方法
stmt.executeupdate(sql);//执行sql语句
if (stmt != null) {
try {
stmt.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
4.更新数据
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.sqlexception;
import java.sql.statement;
public class update {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
update(conn); //方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//更新数据
public static void update(connection conn){
string sql = "update employees set salary=8000 where employee_id=100005";
try {
statement stmt1 = conn.createstatement();//或者用preparedstatement方法
stmt1.executeupdate(sql);//执行sql语句
if (stmt1 != null) {
try {
stmt1.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
5.转账（事物处理）
jdbc处理事务通过关闭连接的自动提交实现的：
connection.setautocommit(false);
提交事务：
connection.commit();
回滚事务
回滚部分：
connection.rollback(savepoint);
全部回滚：
connection.rollback();
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.statement;
public class transcash {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111");// 获取数据库连接
transcash(conn); //方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//转账(数据调换)(原来数据为100和500，实现这个功能后变成500和100，其实说白了就是更新数据，改数据)
public static void transcash(connection conn){
statement stmt = null;
try{
conn.setautocommit(false);//关闭自动提交
string sql = "update employees set salary=500 where employee_id=100001";
stmt = conn.createstatement();
stmt.executeupdate(sql);
sql = "update employees set salary=100 where employee_id=100002";
stmt.executeupdate(sql);//执行sql语句，上面的两个工资将会调换
//int i=1/0;如果这样，那么将不可以完成任务，因为这是一个完整的事物，有一点失败，将全部失败
conn.commit();//提交事务
}catch(exception e){
e.printstacktrace();
}finally{
try{
if(stmt != null){ stmt.close();
}catch(exception e){
e.printstacktrace();
}
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
6.查找存储过程无参数的
package javacore1;
import java.sql.callablestatement;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.sqlexception;
public class execproc {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
execproc(conn);//方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//调用无参存储过程；
public static void execproc(connection conn){
string sql = "{call raisesalary}";
try {
callablestatement cstmt = conn.preparecall(sql);
cstmt.executeupdate();
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
7.查找存储过程有参数的
package javacore1;
import java.sql.callablestatement;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.types;
public class getmulti {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
int cnt = getmulti(conn); //查找存储过程；
system.out.println("人员编号：" + cnt);
releaseconnection(conn);// 释放数据库连接
}
//查找存储过程有参
public static int getmulti(connection conn) {
int dept_id = 100001;
int cnt = 0;
string sql = "{call calc_emp_count(?,?)}";
try {
callablestatement cstmt = conn.preparecall(sql);//初始化statement对象
cstmt.setint(1, dept_id);//callablestatement.setxxx(参数，值)或者(数字,值),而preparedstatement.setxxx(数字,值)只能这样
cstmt.setint(2, cnt); //
cstmt.registeroutparameter(2, types.integer);//声明输出参数
cstmt.executeupdate();//执行sql语句
cnt = cstmt.getint(2);//获取结果
if (cstmt != null) {
cstmt.close();// 释放statement对象
}
} catch (exception e) {
e.printstacktrace();
}
return cnt;
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
8.普通处理
package javacore1;
import java.sql.connection;
import java.sql.date;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.sqlexception;
public class planinsert {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
planinsert(conn); //方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//普通处理
public static void planinsert(connection conn) {
try {
string sql = "insert into test_user1(userid,username,loadingtime)"
+ " values (?,?,?)"; // 插入数据的sql语句
preparedstatement pstmt=conn.preparestatement(sql);
long starttime=system.currenttimemillis();
for(int i=0;i<1000;i++){
pstmt.setlong(1, i);
pstmt.setstring(2, "user"+i);
pstmt.setdate(3, new date(system.currenttimemillis()));
pstmt.executeupdate();
}
system.out.println("总共耗时："+(system.currenttimemillis() - starttime));
pstmt.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
9.批量处理
获得原来jdbc事务的模式：
boolean currenttransactionmodle = con.getautocommit();
设置成事务模式(关闭自动提交)：
con.setautocommit(false);
statement stm = con.createstatement();
三个异构的sql语句：
string sql1 = "delete from user where id = 8";
string sql2 = "update user set name='java' where id = 7";
string sql3 = "insert into user(name,password) values('jdbc','jdbc')";
添加到statement的批量处理缓冲区中：
stm.addbatch(sql1);
stm.addbatch(sql2);
stm.addbatch(sql3);
执行批量更新：
stm.executebatch();
提交本次批量更新的事务：
con.commit();
回复原来的事务模式：
con.setautocommit(currenttransactionmodle);
package javacore1;
import java.sql.connection;
import java.sql.date;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.sqlexception;
public class batchinsert {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
batchinsert(conn); //方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//批量插入的速度要比普通处理的速度快
public static void batchinsert(connection conn) {
try {
string sql = "insert into test_user1(userid,username,loadingtime)"
+ " values (?,?,?)"; // 插入数据的sql语句
preparedstatement pstmt=conn.preparestatement(sql);
long starttime=system.currenttimemillis();
for(int i=0;i<1000;i++){
pstmt.setlong(1, i);
pstmt.setstring(2, "user"+i);
pstmt.setdate(3, new date(system.currenttimemillis()));
pstmt.addbatch();//添加到批量处理
}
int[] result=pstmt.executebatch();
system.out.println("总共耗时："+(system.currenttimemillis() - starttime));
pstmt.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
10.分页显示
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.sql.sqlexception;
public class paging {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
paging(conn,1,3);//方法名调用数据库连接,且定义显示第几行到第几行
releaseconnection(conn);// 释放数据库连接
}
//分页查询
public static void paging(connection conn,int startindex,int total){
try{
string sql="select * from employees limit ?,?";
preparedstatement pstmt=conn.preparestatement(sql);
pstmt.setint(1, startindex);
pstmt.setint(2, total);
resultset rs=pstmt.executequery();
while(rs.next()){
system.out.print("工号："+rs.getint(1));
system.out.println("部门编号："+rs.getint("department_id"));
}rs.close();
pstmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
11.结果集可以滚动
package javacore1;
import java.sql.connection;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.sql.sqlexception;
public class scrpllresult {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
scrpllresult(conn);//方法名调用数据库连接
releaseconnection(conn);// 释放数据库连接
}
//结果集滚动显示
public static void scrpllresult(connection conn){
try{
string sql="select * from employees"; //结果集可以滚动 //并发性,结果集只读，不可以修改
preparedstatement pstmt=conn.preparestatement(sql, resultset.type_scroll_sensitive, resultset.concur_read_only);
resultset rs=pstmt.executequery();
while(rs.next()){ //向下一行遍历
system.out.print("工号："+rs.getlong(1));
system.out.println("名字"+rs.getstring("last_name"));
}while(rs.previous()){//向上一行遍历
system.out.print("工号："+rs.getlong(1));
system.out.println("工资"+rs.getint("salary"));
}
rs.absolute(6);//表示直接跳到第几行
if(rs.next()){
system.out.print("工号："+rs.getlong(1));
system.out.println("..........部门编号："+rs.getstring("department_id"));
}
rs.close();
pstmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
// 释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
五.把上面十一个放在一起当然最方便省事。(需要用谁，只需把前面的注释打开便行)
package javacore1;
import java.sql.callablestatement;
import java.sql.connection;
import java.sql.date;
import java.sql.drivermanager;
import java.sql.preparedstatement;
import java.sql.resultset;
import java.sql.sqlexception;
import java.sql.statement;
import java.sql.types;
public class jdbcmysql {
public static void main(string[] args) {
connection conn = getconnection("h3", "111111"); // 获取数据库连接
//query(conn); //1.查询数据
//insert(conn);//2.插入数据
//delete(conn);//3.删除数据
//update(conn);//4.更新数据
//transcash(conn);//5.转账
//execproc(conn);//6.查找存储过程无参数的
//int cnt = getmulti(conn);//7.查找存储过程有参数的
//system.out.println("人员编号：" + cnt);//查找存储过程有参数的
//planinsert(conn);//8.普通处理
//batchinsert(conn);//9.批量处理
// paging(conn,1,3);//10.分页显示
//scrpllresult(conn);//11.结果集可以滚动
releaseconnection(conn);// 释放数据库连接
}
//1.查询数据，定义的query方法
public static void query(connection conn){
string sql="select * from employees";
try{
statement stmt=conn.createstatement(); //也可以使用preparedstatement来做
resultset rs=stmt.executequery(sql);//执行sql语句并返还结束
while(rs.next()){//遍历结果集
system.out.println("人员编号:"+rs.getstring("employee_id")+"工资:"+rs.getstring("salary"));
}
if(rs !=null){
try{
rs.close();
} catch (sqlexception e){
e.printstacktrace();
}
}
if(stmt !=null){
try{
stmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
if(conn !=null){
try{
conn.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
}catch(exception e){
e.printstacktrace();
}
}
//2.插入数据
public static void insert(connection conn) {
try {
string sql = "insert into employees(employee_id,last_name,salary,department_id,userid)"
+ " values ('100010', 'xiaogou', '7000','004','9')"; // 插入数据的sql语句
statement stmt1 =conn.createstatement(); // 创建用于执行静态sql语句的statement对象
int count = stmt1.executeupdate(sql); // 执行插入操作的sql语句，并返回插入数据的个数
system.out.println("向biao中插入了 " + count + " 条数据"); //输出插入操作的处理结果
conn.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//3.删除数据
public static void delete(connection conn){
string sql = "delete from employees where employee_id=100009";
try {
statement stmt = conn.createstatement();// 或者用preparedstatement方法
stmt.executeupdate(sql);//执行sql语句
if (stmt != null) {
try {
stmt.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
} catch (sqlexception e) {
e.printstacktrace();
}
}
//4.更新数据
public static void update(connection conn){
string sql = "update employees set salary=8000 where employee_id=100005";
try {
statement stmt1 = conn.createstatement();//或者用preparedstatement方法
stmt1.executeupdate(sql);//执行sql语句
if (stmt1 != null) {
try {
stmt1.close();
} catch (sqlexception e) {
e.printstacktrace();
}
}
} catch (sqlexception e) {
e.printstacktrace();
}
}
//5.转账(数据调换)(原来数据为100和500，实现这个功能后变成500和100，其实说白了就是更新数据，改数据)
public static void transcash(connection conn){
statement stmt = null;
try{
conn.setautocommit(false);//关闭自动提交
string sql = "update employees set salary=500 where employee_id=100001";
stmt = conn.createstatement();
stmt.executeupdate(sql);
sql = "update employees set salary=100 where employee_id=100002";
stmt.executeupdate(sql);//执行sql语句，上面的两个工资将会调换
conn.commit();//提交事务
}catch(exception e){
e.printstacktrace();
}finally{
try{
if(stmt != null)stmt.close();
}catch(exception e){
e.printstacktrace();
}
}
}
//6.调用无参存储过程；
public static void execproc(connection conn){
string sql = "{call raisesalary}";
try {
callablestatement cstmt = conn.preparecall(sql);
cstmt.executeupdate();
} catch (sqlexception e) {
e.printstacktrace();
}
}
//7.查找存储过程有参
public static int getmulti(connection conn) {
int dept_id = 100001;
int cnt = 0;
string sql = "{call calc_emp_count(?,?)}";
try {
callablestatement cstmt = conn.preparecall(sql);//初始化statement对象
cstmt.setint(1, dept_id);//callablestatement.setxxx(参数，值)或者(数字,值),而preparedstatement.setxxx(数字,值)只能这样
cstmt.setint(2, cnt); //
cstmt.registeroutparameter(2, types.integer);//声明输出参数
cstmt.executeupdate();//执行sql语句
cnt = cstmt.getint(2);//获取结果
if (cstmt != null) {
cstmt.close();// 释放statement对象
}
} catch (exception e) {
e.printstacktrace();
}
return cnt;
}
//8.普通处理
public static void planinsert(connection conn) {
try {
string sql = "insert into test_user1(userid,username,loadingtime)"
+ " values (?,?,?)"; // 插入数据的sql语句
preparedstatement pstmt=conn.preparestatement(sql);
long starttime=system.currenttimemillis();
for(int i=0;i<1000;i++){
pstmt.setlong(1, i);
pstmt.setstring(2, "user"+i);
pstmt.setdate(3, new date(system.currenttimemillis()));
pstmt.executeupdate();
}
system.out.println("总共耗时："+(system.currenttimemillis() - starttime));
pstmt.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//9.批量插入的速度要比普通处理的速度快
public static void batchinsert(connection conn) {
try {
string sql = "insert into test_user1(userid,username,loadingtime)"
+ " values (?,?,?)"; // 插入数据的sql语句
preparedstatement pstmt=conn.preparestatement(sql);
long starttime=system.currenttimemillis();
for(int i=0;i<1000;i++){
pstmt.setlong(1, i);
pstmt.setstring(2, "user"+i);
pstmt.setdate(3, new date(system.currenttimemillis()));
pstmt.addbatch();//添加到批量处理
}
int[] result=pstmt.executebatch();
system.out.println("总共耗时："+(system.currenttimemillis() - starttime));
pstmt.close(); //关闭数据库连接
} catch (sqlexception e) {
e.printstacktrace();
}
}
//10.分页查询
public static void paging(connection conn,int startindex,int total){
try{
string sql="select * from employees limit ?,?";
preparedstatement pstmt=conn.preparestatement(sql);
pstmt.setint(1, startindex);
pstmt.setint(2, total);
resultset rs=pstmt.executequery();
while(rs.next()){
system.out.print("工号："+rs.getint(1));
system.out.println("部门编号："+rs.getint("department_id"));
}rs.close();
pstmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
//11.结果集滚动显示
public static void scrpllresult(connection conn){
try{
string sql="select * from employees"; //结果集可以滚动 //并发性,结果集只读，不可以修改
preparedstatement pstmt=conn.preparestatement(sql, resultset.type_scroll_sensitive, resultset.concur_read_only);
resultset rs=pstmt.executequery();
while(rs.next()){ //向下一行遍历
system.out.print("工号："+rs.getlong(1));
system.out.println("名字"+rs.getstring("last_name"));
}while(rs.previous()){//向上一行遍历
system.out.print("工号："+rs.getlong(1));
system.out.println("工资"+rs.getint("salary"));
}
rs.absolute(6);//表示直接跳到第几行
if(rs.next()){
system.out.print("工号："+rs.getlong(1));
system.out.println("..........部门编号："+rs.getstring("department_id"));
}
rs.close();
pstmt.close();
}catch(sqlexception e){
e.printstacktrace();
}
}
//数据库连接
public static connection getconnection(string user, string pass) {
connection conn = null;//声明连接对象
string driver = "com.mysql.jdbc.driver";// 驱动程序类名
string url = "jdbc:mysql://localhost:3306/test?" // 数据库url
+ "useunicode=true&characterencoding=utf8";// 防止乱码
try {
class.forname(driver);// 注册(加载)驱动程序
conn = drivermanager.getconnection(url, user, pass);// 获取数据库连接
} catch (exception e) {
e.printstacktrace();
}
return conn;
}
//释放数据库连接
public static void releaseconnection(connection conn) {
try {
if (conn != null)
conn.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
六.安装下载的数据库驱动程序jar包,不同的数据库需要不同的驱动程序（但是安装方法都是一样的）
在使用jdbc编程时需要连接数据库，导入jar包是必须的，导入其它的jar包方法同样如此，导入的方法是
打开eclipse
1.右击要导入jar包的项目，点properties
2.左边选择java build path,右边选择libraries
3.选择add external jars
4.选择jar包的按照路径下的
确定后就行了。
java连接mysql的最新驱动包下载地址
http://www.mysql.com/downloads/connector/j
1.鼠标放在你建的根目录上面。右击，然后选择最下面的properties。
2.然后左边选择java build path,右边选择libraries ，在选择右边的add external jars ，选择jar包的路径，点击确定就可以了
3.装好后，图如下出现你要添加的包。