ava基础MySQL存储过程 Java基础 JDBC连接MySQL数据库
1、MySQL存储过程
1.1、什么是存储过程
带有逻辑的sql语句；带有流程控制语句(if while)等等 的sql语句
1.2、存储过程的特点
1）执行效率非常快，存储过程是数据库的服务器端执行的。
2）移植性很差，不同数据库的存储过程是不能移植的。
2、存储过程的语法
-- 创建存储过程
1 DELIMITER $ -- 声明存储过程的结束符
2 CREATE PROCEDURE pro_test() -- 创建存储过程 存储过程的名称(参数列表)
3 BEGIN -- 开始
4
5 -- 这中间可以写多个sql语句 -- sql语句+流程控制等
6
7 END $ -- 结束 结束符
1 --执行存储过程
2 CALL pro_test(); -- call存储过程的名称(参数)
1 -- 存储过程名称里面的参数：
2 IN ：表示输入参数,可以携带数据存储过程中
3 OUT：表示输出参数,可以从存储过程中返回结果
4 INOUT：表示输入输出参数,既可以输入功能,也可输出功能
-- 删除存储过程
1 DROP PROCEDURE pro_test; -- 删除存储过程 存储过程的名称;
3、实例演示
3.1、带有参数的存储过程 Java代码调用存储过程的方法：https://www.cnblogs.com/dshore123/p/10582283.html
1 -- 需求：传入一个员工的id，查询员工的信息
2 DELIMITER $
3 CREATE PROCEDURE pro_findById(IN eid INT) -- IN: 输入参数； eid:传入参数的名称； int：传入参数的类型
4 BEGIN
5 SELECT * FROM employee WHERE id = eid;
6 END $
7
8 -- 调用
9 CALL pro_findByID(4)
调用pro_findByID() 后的结果图
3.2、带有输出参数的存储过程
1 -- 带有输出参数的存储过程
2 DELIMITER $
3 CREATE PROCEDURE pro_test_out(OUT str VARCHAR(20)) -- out:输出参数
4 BEGIN
5 -- 给参数赋值
6 SET str = 'helloMySQL';
7 END $
8
9 CALL pro_test_out(@NAME); -- 调用pro_test_out存储过程
10 SELECT @NAME; -- 查询pro_test_out存储过程
11
12 -- 如何返回接收的返回数值
13 -- ****mysql的变量******
14 -- 全局变量(内置变量)：mysql数据库中内置的变量(所有连接都起作用)
15 -- 查看所有的全局变量：show variables;
16 -- 查看某个全局变量：select @@变量名
17 -- 修改全局变量：set 变量名 = 新值
18
19 -- 会话变量：只存在于当前客户端与数据库的一次连接当中；如果断开，那么会话变量将全部失效(丢失)。
20 -- 定义会话变量: set @变量 = 值;
21 -- 查看会话变量: select @变量;
22 -- character_set_client: 服务器的接收编码
23 -- character_set_results: 服务器的输出编码
24
25 -- 局部变量：在存储过程中使用的变量就叫局部变量；只要存储过程执行完毕，局部变量就丢失。
26
结果图
3.3、带有输入输出参数的存储过程
1 -- 带有输入输出参数的存储过程
2 DELIMITER $
3 CREATE PROCEDURE pro_test_InOut(INOUT n INT) -- INOUT: 输入输出参数
4 BEGIN
5 -- 查看变量
6 SELECT n;
7 SET n=500;
8 END $
9
10 -- 调用
11 SET @n=10;
12 CALL pro_test_InOut(@n);
13 SELECT @n;
结果图
3.4、带有条件判断存储过程
1 -- 需求：输入一个整数，如果是1，则返回'星期一'；如果是2，则返回'星期二'；如果是3，则返回'星期三'。如果是其他，则返回'输入有误'
2 DELIMITER $
3 CREATE PROCEDURE pro_testIf(IN num INT,OUT str VARCHAR(32))
4 BEGIN
5 IF num=1 THEN
6 SET str = '星期一';
7 ELSEIF num = 2 THEN
8 SET str = '星期二';
9 ELSEIF num = 3 THEN
10 SET str = '星期三';
11 ELSE
12 SET str = '输入错误';
13 END IF;
14 END $
15
16 CALL pro_testIf(3,@str);
17 SELECT @str;
结果图
3.5、带有循环功能的存储过程
1 -- 需求：输入一个整数，求和。例如:输入100 ,统计1~100的和
2 DELIMITER $
3 CREATE PROCEDURE pro_testWhile(IN num INT,OUT result INT)
4 BEGIN
5 -- 定义一个局部变量 for(int i=1;i<=100;i++)
6 DECLARE i INT DEFAULT 1; -- 定义一个局部变量i，int类型，默认值为1。
7 DECLARE vsum INT DEFAULT 0; -- 定义一个局部变量vsum，int类型，默认值为0。
8 WHILE i <= num DO
9 SET vsum = vsum + i;
10 SET i = i + 1;
11 END WHILE;
12 SET result = vsum;
13 END $
14
15 CALL pro_testWhile(100,@result);
16 SELECT @result;
结果图
Java基础 JDBC连接MySQL数据库============================
本文知识点（目录）：
1、什么是jdbc
2、jdbc接口的核心API
3、使用JDBC技术连接MySQL数据库的方法
4、使用Statement执行sql语句（DDL、DML、DQL）
5、使用PreparedStatement执行sql语句
6、使用callablestaement执行sql语句，调用存储过程
7、附录（jdbc连接数据库 实操）
8、完整的JDBC封装过程，及调用jdbc的使用过程实例
1、什么是jdbc
简单的讲就是：使用java代码(程序)发送sql语句的技术，称为jdbc技术。
2、jdbc接口的核心API
1 |-Driver 接口：表示java驱动程序接口。所有的具体的数据库厂商要实现的接口.
2 |-connect(String url, Properties info)：连接数据库的方法
3 Url：连接数据库的URL
4 URL语法：jdbc协议:数据库子协议://主机:端口/数据库名
5 User：数据库的用户名
6 Password：数据的用户密码
7 |-DriverManager 类：驱动管理器类，用于管理所有的注册的驱动程序
8 |-registerDriver(Driver driver)：注册驱动类对象
9 |-getConnection(String url, String user, String password)：获取连接对象
10 |-Connection 接口：表示java程序和数据库的连接对象
11 |-createStatement()
12 |-prepareStatement(String sql)：创建PreparedStatement对象
13 |-prepareCall(String sql)：创建CallableStatement对象
14 |-statement 接口：用于执行静态的sql语句
15 |-executeUpdate(String sql): 执行静态的sql语句（DDL、DML）
16 |-executeQuery(String sql) ：静态的查询sql语句（DQL）
17 |-PreparedStatement 接口：用于执行预编译sql语句
18 |-executeUpdate(String sql)：执行静态的sql语句（DDL、DML）
19 |-executeQuery(String sql)：静态的查询sql语句（DQL）
20 |-CallableStatement 接口：用于执行存储过程的sql语句(call xxx)
21 |-ResultSet 接口：用于封装查询出来的数据
22 |-next()：将光标移到下一行
23 |-getxxx(int columnIndex)：获取列的值（有getInt()、getString()、getArray()、getURL() 等等）
24 |-getRow()：获取当前行编号。
3、使用JDBC技术连接MySQL数据库的方法
1 package com.shore.a_jdbc;
2
3 import java.sql.Connection;
4 import java.sql.Driver;
5 import java.sql.DriverManager;
6 import java.util.Properties;
7
8 /**
9 * @author DSHORE/2019-3-23
10 *
11 */
12 //连接MySQL数据库的几种方法
13 public class connJDBC {
14 // jdbc协议:数据库的子协议:主机:端口/要连接的数据库名称
15 private String url = "jdbc:mysql://localhost:3306/school";//连接数据库的URL链接
16 private String user = "root";//用户名
17 private String password = "123456";//密码
18 /*
19 * 第一种方法：
20 * */
21 public void test1() throws Exception{
22 //1.创建驱动程序类对象
23 Driver driver = new com.mysql.jdbc.Driver();
24 //Driver driver = new org.gjt.mm.mysql.Driver();//旧版本的创建方法
25 //设置用户名密码
26 Properties props = new Properties();
27 props.setProperty("user",user);
28 props.setProperty("password",password);
29 //2.连接数据库,返回连接对象
30 Connection conn = driver.connect(url, props);
31 System.out.println(conn);//返回值：com.mysql.jdbc.JDBC4Connection@29c56c60，表示已连接成功
32 }
33 /*
34 * 第二种方法：使用驱动管理器类连接数据库
35 * */
36 public void test2()throws Exception{
37 //1.创建驱动程序类对象
38 Driver driver = new com.mysql.jdbc.Driver();//MySQL数据库
39 //Driver driver2 = new com.oracle.jdbc.Driver();//Oracle数据库
40 //注册驱动程序(可以注册多个驱动)
41 DriverManager.registerDriver(driver);
42 //DriverManager.registerDriver(driver2);
43 //2.连接数据库
44 Connection conn=DriverManager.getConnection(url, user, password);
45 System.out.println(conn);
46 }
47 /*
48 * 第三种方法：使用加载驱动程序类 来注册 驱动程序。(推荐使用这种方式连接数据库)
49 * */
50 public void test3() throws Exception{
51 //通过得到字节码对象的方式加载静态代码块,从而注册驱动
52 Class.forName("com.mysql.jdbc.Driver");
53 //2.连接数据库
54 Connection conn = DriverManager.getConnection(url, user, password);
55 System.out.println(conn);
56 }
57 }
4、使用Statement执行sql语句
4.1、执行DDL语句
1 package com.shore.b_statement;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7
8 import org.junit.Test;
9 /*
10 *使用statement对象执行静态sql语句（创建表）
11 **/
12 public class Demo1 {
13 //连接数据库的URL
14 private String url="jdbc:mysql://localhost:3306/school";
15 //jdbc协议:数据库的子协议:主机:端口/连接的数据库
16 private String user="root";//用户名
17 private String password="123456";//密码
18
19 //执行DDL语句
20 @Test
21 public void test1(){
22 Statement statement = null;
23 Connection connection = null;
24 try {
25 //1.注册驱动
26 Class.forName("com.mysql.jdbc.Driver");
27 //2.获取连接对象
28 connection = DriverManager.getConnection(url, user, password);
29 //3.创建statement
30 statement = connection.createStatement();
31 //4.准备sql语句
32 String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(32),sex VARCHAR(2));";//创建表
33 int count = statement.executeUpdate(sql);
34 System.out.println("影响行数："+count+"行！");
35 } catch (ClassNotFoundException e) {
36 e.printStackTrace();
37 } catch (SQLException e) {
38 e.printStackTrace();
39 }finally{
40 //5.关闭连接(顺序：后代开的先关闭)
41 try {
42 if(statement != null) statement.close();
43 if(connection != null) connection.close();
44 } catch (SQLException e) {
45 e.printStackTrace();
46 }
47 }
48 }
49 }
4.2、执行DML语句
封装工具类(JdbcUtil.java) 文件。（由于连接数据库和关闭资源的那部分代码是不变的，所以将他们封装起来，用到时 就直接调用即可）
1 package com.shore.util;
2
3 import java.io.FileInputStream;
4 import java.io.FileNotFoundException;
5 import java.io.IOException;
6 import java.sql.Connection;
7 import java.sql.DriverManager;
8 import java.sql.ResultSet;
9 import java.sql.SQLException;
10 import java.sql.Statement;
11 import java.util.Properties;
12
13 public class JdbcUtil { //把固定不变的那部分代码封装起来
14 //动态连接数据
15 private static String url = null;
16 private static String user = null;//用户名
17 private static String password = null;//密码
18 private static String driverClass = null;
19 //静态代码块中(只加载一次)
20 static{
21 //读取db.properties
22 Properties props = new Properties();
23 try {
24 FileInputStream fis = new FileInputStream("./src/db.properties");
25 //加载文件
26 props.load(fis);
27 url = props.getProperty("url");
28 user = props.getProperty("user");
29 password = props.getProperty("password");
30 driverClass = props.getProperty("driverClass");
31 //注册驱动
32 Class.forName(driverClass);
33 } catch (FileNotFoundException e) {
34 e.printStackTrace();
35 } catch (IOException e) {
36 e.printStackTrace();
37 } catch (ClassNotFoundException e) {
38 e.printStackTrace();
39 System.out.println("注册驱动失败");
40 }
41 }
42 //获取连接
43 public static Connection getConnection(){
44 try {
45 Connection conn = DriverManager.getConnection(url, user, password);
46 return conn;
47 } catch (SQLException e) {
48 e.printStackTrace();
49 throw new RuntimeException();
50 }
51 }
52 //释放资源
53 public static void close(Connection conn,Statement stmt,ResultSet rs){
54 try {
55 if(stmt != null) stmt.close();
56 if(conn != null) conn.close();
57 if(rs != null) rs.close();
58 } catch (SQLException e) {
59 e.printStackTrace();
60 }
61 }
62 }
db.properties配置文件（存储数据库链接、用户及密码等）
1 url = jdbc:mysql://localhost:3306/school //把数据库的链接入口配置在一个文件中，方便以后操作(更改账号密码等等)
2 user = root
3 password = 123456
4 driverClass = com.mysql.jdbc.Driver
执行DML语句 正文
1 package com.shore.b_statement;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7
8 import org.junit.Test;
9
10 import com.bw.util.JdbcUtil;
11
12 /**
13 * 使用statement执行DML语句（添加、删除、修改数据）
14 *
15 */
16 public class Demo2 {
17 /*
18 * 向student表中添加数据
19 * */
20 @Test
21 public void testInsert(){
22 ResultSet rs = null;
23 Connection conn = null;
24 Statement stmt = null;
25 //通过工具类获取;连接对象
26 conn = JdbcUtil.getConnection();
27 //常见statement对象
28 try {
29 stmt=conn.createStatement();
30 } catch (SQLException e) {
31 e.printStackTrace();
32 }
33 String sql = "INSERT INTO student(NAME,sex) VALUES('张三','女');";
34 try {
35 int count = stmt.executeUpdate(sql);
36 System.out.println(count);
37 } catch (SQLException e) {
38 e.printStackTrace();
39 }
40 JdbcUtil.close(conn,stmt,rs);
41 }
42 /*
43 * 修改student表中的数据
44 * */
45 @Test
46 public void testUpdate(){
47 ResultSet rs = null;
48 Connection conn =null;
49 Statement stmt = null;
50 //通过工具类获取;连接对象
51 conn = JdbcUtil.getConnection();
52 //常见statement对象
53 try {
54 stmt = conn.createStatement();
55 } catch (SQLException e) {
56 e.printStackTrace();
57 }
58 String sql = "UPDATE student SET NAME = '王五' WHERE id = 1;";
59 try {
60 int count=stmt.executeUpdate(sql);
61 System.out.println(count);
62 } catch (SQLException e) {
63 e.printStackTrace();
64 }
65 JdbcUtil.close(conn,stmt,rs);
66 }
67 /*
68 * 删除student表中的数据
69 * */
70 @Test
71 public void testDelete(){
72 ResultSet rs = null;
73 Connection conn = null;
74 Statement stmt = null;
75 //通过工具类获取;连接对象
76 conn = JdbcUtil.getConnection();
77 //常见statement对象
78 try {
79 stmt = conn.createStatement();
80 } catch (SQLException e) {
81 e.printStackTrace();
82 }
83 String sql = "DELETE FROM student WHERE id = 3;";
84 try {
85 int count = stmt.executeUpdate(sql);
86 System.out.println(count);
87 } catch (SQLException e) {
88 e.printStackTrace();
89 }
90 JdbcUtil.close(conn,stmt,rs);
91 }
92 }
4.3、执行DQL语句
1 package com.shore.b_statement;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7
8 import org.junit.Test;
9
10 import com.bw.util.JdbcUtil;
11
12 /*
13 * 使用statement执行sql语句(查询操作语句)
14 * */
15 public class Demo3 {
16 @Test
17 public void test1(){
18 ResultSet rs = null;
19 Connection conn = null;
20 Statement stmt = null;
21 //获取连接
22 conn = JdbcUtil.getConnection();
23 //创建statement
24 try {
25 stmt = conn.createStatement();
26 } catch (SQLException e) {
27 e.printStackTrace();
28 }
29 //准备sql语句
30 String sql = "SELECT * FROM student;";//查询表中所有数据
31 try {
32 rs=stmt.executeQuery(sql);
33 /*//移动光标
34 boolean flag=rs.next();
35 if(flag){
36 //取出值
37 //索引
38 int id=rs.getInt(1);
39 String name=rs.getString(2);
40 String sex=rs.getString(3);
41 System.out.println(id+","+name+","+sex);
42 }*/
43 //遍历结果
44 while(rs.next()){
45 int id=rs.getInt("id");
46 String name=rs.getString("name");
47 String sex=rs.getString("sex");
48 System.out.println(id+","+name+","+sex);
49 }
50 } catch (SQLException e) {
51 e.printStackTrace();
52 }finally{
53 JdbcUtil.close(conn, stmt, rs);
54 }
55 }
56 }
5、使用PreparedStatement执行sql语句
1 package com.shore.c_prepared;
2
3 import java.sql.Connection;
4 import java.sql.PreparedStatement;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7
8 import org.junit.Test;
9
10 import com.bw.util.JdbcUtil;
11
12 /*
13 * preparedStatement执行sql语句（有效防止sql注入的问题）
14 * */
15 public class Demo1 {
16 //增加
17 @Test
18 public void testInsert(){
19 Connection conn = null;
20 PreparedStatement stmt = null;
21 ResultSet rs = null;
22 //1.获取连接
23 conn = JdbcUtil.getConnection();
24 //2准备预编译的sql
25 String sql = "INSERT INTO student(NAME,sex) VALUES(?,?);";//?表示一个参数的占位符
26 try {
27 //3执行预编译的sql语句(检查语法)
28 stmt = conn.prepareStatement(sql);
29 //4.设置参数
30 stmt.setString(1,"赵六"); //可用name作为参数代表“赵六” 从页面传值来此
31 stmt.setString(2,"女");
32 //5.发送参数,执行sql
33 int count = stmt.executeUpdate();
34 System.out.println("影响了"+count+"行");
35 } catch (SQLException e) {
36 e.printStackTrace();
37 }finally{
38 JdbcUtil.close(conn, stmt, rs);
39 }
40 }
41 }
6、使用callablestaement执行sql语句，调用存储过程
MySQL存储过程 相关知识点：https://www.cnblogs.com/dshore123/p/10559182.html
1 -- 1.带有输入参数的存储过程
2 DELIMITER $
3 CREATE PROCEDURE pro_test(IN sid INT)
4 BEGIN
5 SELECT * FROM student WHERE id=sid;
6 END $
7
8 CALL pro_test(2);
1 -- 2.执行带有输出参数的存储过程
2 DELIMITER $
3 CREATE PROCEDURE pro_test(IN sid INT,OUT sname VARCHAR(32))
4 BEGIN
5 SELECT NAME INTO sname FROM student WHERE id=sid;
6 END $
7
8 CALL pro_test(2,@sname);
9 SELECT @sname;
正文代码
1 package com.shore.d_callable;
2
3 import java.sql.CallableStatement;
4 import java.sql.Connection;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7
8 import org.junit.Test;
9
10 import com.bw.util.JdbcUtil;
11
12 /**
13 * 使用CallableSatement调用存储过程
14 * @author lx
15 *
16 */
17 public class Demo1 {
18
19 /*
20 * 1.带有输入参数的存储过程
21 * CALL pro_test(2)
22 * */
23 @Test
24 public void test1(){
25 Connection conn = null;
26 ResultSet rs = null;
27 CallableStatement stmt = null;
28 //获取连接
29 conn = JdbcUtil.getConnection();
30 //准备sql
31 String sql = "CALL pro_test(?);"; //可以执行预编译的sql
32 try {
33 //预编译
34 stmt = conn.prepareCall(sql);
35 //设置参数
36 stmt.setInt(1, 2);
37 //注意:所有的存储过程的sql语句都是使用executeQuery
38 rs = stmt.executeQuery();
39 //遍历起结果
40 while(rs.next()){
41 int id = rs.getInt("id");
42 String name = rs.getString("name");
43 String sex = rs.getString("sex");
44 System.out.println(id+","+name+","+sex);
45 }
46 } catch (SQLException e) {
47 e.printStackTrace();
48 }finally{
49 JdbcUtil.close(conn, stmt, rs);
50 }
51 }
52 /*
53 *
54 * 2.执行带有输出参数的存储过程
55 * */
56 @Test
57 public void test2(){
58 Connection conn = null;
59 ResultSet rs = null;
60 CallableStatement stmt = null;
61 //获取连接
62 conn = JdbcUtil.getConnection();
63 //准备sql
64 String sql = "CALL pro_test(?,?);"; //第一个?是输入参数,第二个?是输出参数
65 try {
66 //预编译
67 stmt = conn.prepareCall(sql);
68 //设置参数
69 stmt.setInt(1, 2);
70 //设置输出参数
71 /*
72 *参数 一:参数的位置
73 *参数二:存储过程中输出参数的jdbc类型 varchar(32)
74 * */
75 stmt.registerOutParameter(2,java.sql.Types.VARCHAR);
76 //发送参数,执行
77 stmt.executeQuery();
78 /* //得到输出参数的值
79 * 索引值:预编译sql中的输出参数的位置
80 * */
81 String result = stmt.getString(2);//getxxx方法专门用于获取存储过程中的输出参数
82 System.out.println(result);
83 } catch (SQLException e) {
84 e.printStackTrace();
85 }finally{
86 JdbcUtil.close(conn, stmt, rs);
87 }
88 }
89 }
附录
创建表：contact
1 create contact(
2 id varchar(32) primary key,
3 name varchar(32),
4 sxe varchar(32),
5 age int,
6 phone varchar(32),
7 email varchar(32),
8 qq varchar(32)
9 );
使用“增删改查(CRUD)”操作，连接数据库
1 package com.shore.dao.impl;
2
3 import java.sql.Connection;
4 import java.sql.PreparedStatement;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7 import java.util.ArrayList;
8 import java.util.List;
9 import java.util.UUID;
10
11 import com.shore.dao.ContactDAO;
12 import com.shore.entity.Contact;
13 import com.shore.util.JdbcUtil;
14
15 public class ContactDAOMySqlImpl implements ContactDAO{
16
17 //添加数据
18 public void addContact(Contact contact) {
19 Connection conn;
20 PreparedStatement stmt = null;
21 ResultSet rs = null;
22 conn = JdbcUtil.getConnection();
23 String sql = "insert into contact(id,name,sex,age,phone,email,qq) values(?,?,?,?,?,?,?)";
24 try {
25 //执行预编译的sql语句(检查语法)
26 stmt = conn.prepareStatement(sql);
27 String id = UUID.randomUUID().toString().replace("-","");
28 stmt.setString(1, id);
29 stmt.setString(2, contact.getName());
30 stmt.setString(3, contact.getSex());
31 stmt.setInt(4, contact.getAge());
32 stmt.setString(5, contact.getPhone());
33 stmt.setString(6, contact.getEmail());
34 stmt.setString(7, contact.getQq());
35 stmt.executeUpdate();
36 } catch (SQLException e) {
37 e.printStackTrace();
38 }finally{
39 JdbcUtil.close(conn, stmt, rs);
40 }
41 }
42
43 //查询所有数据
44 public List<Contact> finAll() {
45 Connection conn;
46 PreparedStatement stmt = null;
47 ResultSet rs = null;
48 //获取连接
49 conn = JdbcUtil.getConnection();
50 String sql = "select * from contact";
51 try {
52 //执行预编译的sql语句(检查语法)
53 stmt = conn.prepareStatement(sql);
54 //执行sql;
55 rs = stmt.executeQuery();
56 List<Contact> list = new ArrayList<Contact>();
57 while(rs.next()){
58 //创建Contact对象
59 Contact c = new Contact();
60 c.setId(rs.getString("id"));
61 c.setName(rs.getString("name"));
62 c.setSex(rs.getString("sex"));
63 c.setAge(rs.getInt("age"));
64 c.setPhone(rs.getString("phone"));
65 c.setEmail(rs.getString("email"));
66 c.setQq(rs.getString("qq"));
67 list.add(c);
68 }
69 return list;
70 } catch (SQLException e) {
71 e.printStackTrace();
72 throw new RuntimeException();
73 }finally{
74 JdbcUtil.close(conn, stmt, rs);
75 }
76 }
77
78 //根据id删除数据
79 public void delContact(String id) {
80 Connection conn;
81 PreparedStatement stmt = null;
82 ResultSet rs = null;
83 conn = JdbcUtil.getConnection();
84 String sql = "delete from contact where id=?";
85 try {
86 //执行预编译的sql语句(检查语法)
87 stmt = conn.prepareStatement(sql);
88 stmt.setString(1,id)
89 //发送参数,执行sql;
90 stmt.executeUpdate();
91 } catch (SQLException e) {
92 e.printStackTrace();
93 }finally{//关闭资源
94 JdbcUtil.close(conn, stmt, rs);
95 }
96 }
97
98 //修改数据
99 public void updateContact(Contact contact) {
100 Connection conn;
101 PreparedStatement stmt = null;
102 ResultSet rs = null;
103 conn = JdbcUtil.getConnection();
104 String sql = "update contact set name=?,sex=?,age=?,phone=?,email=?,qq=? where id=?";
105 try {
106 //执行预编译的sql语句(检查语法)
107 stmt=conn.prepareStatement(sql);
108 stmt.setString(1, contact.getName());
109 stmt.setString(2, contact.getSex());
110 stmt.setInt(3, contact.getAge());
111 stmt.setString(4, contact.getPhone());
112 stmt.setString(5, contact.getEmail());
113 stmt.setString(6, contact.getQq());
114 stmt.setString(7, contact.getId());
115 stmt.executeUpdate();
116 } catch (SQLException e) {
117 e.printStackTrace();
118 }finally{
119 JdbcUtil.close(conn, stmt, rs);
120 }
121 }
122
123 //根据id查询数据（作用于修改数据的时候）
124 public Contact findById(String id) {
125 Connection conn;
126 PreparedStatement stmt = null;
127 ResultSet rs = null;
128 //获取连接
129 conn = JdbcUtil.getConnection();
130 String sql = "select * from contact where id=?";
131 try {
132 //执行预编译的sql语句(检查语法)
133 stmt = conn.prepareStatement(sql);
134 stmt.setString(1, id);
135 rs = stmt.executeQuery();
136 Contact c = null;
137 while(rs.next()){
138 //创建Contact对象
139 c = new Contact();
140 c.setId(rs.getString("id"));
141 c.setName(rs.getString("name"));
142 c.setSex(rs.getString("sex"));
143 c.setAge(rs.getInt("age"));
144 c.setPhone(rs.getString("phone"));
145 c.setEmail(rs.getString("email"));
146 c.setQq(rs.getString("qq"));
147 }
148 return c;
149 } catch (SQLException e) {
150 e.printStackTrace();
151 throw new RuntimeException();
152 }finally{
153 JdbcUtil.close(conn, stmt, rs);
154 }
155 }
156
157 //判断账号昵称是否重复，若重复，页面端显示此账号已存在，请重新取名
158 public boolean checkContact(String name) {
159 Connection conn;
160 PreparedStatement stmt = null;
161 ResultSet rs = null;
162 //获取数据库的连接
163 conn = JdbcUtil.getConnection();
164 //准备sql
165 String sql = "select * from contact where name = ?";
166 try {
167 //执行预编译的sql语句(检查语法)
168 stmt = conn.prepareStatement(sql);
169 //设置参数
170 stmt.setString(1, name);
171 //发送参数,执行sql
172 rs = stmt.executeQuery();
173 if(rs.next()){
174 return true;
175 }else{
176 return false;
177 }
178 } catch (SQLException e) {
179 e.printStackTrace();
180 throw new RuntimeException();
181 }finally{//关闭资源
182 JdbcUtil.close(conn, stmt, rs);
183 }
184 }
185 }
完整的JDBC封装过程，及调用jdbc的使用过程实例
db.properties 配置文件（配置了数据库的驱动、入口连接、用户名、密码），主要作用：方便以后修改
1 jdbcDriver=com.mysql.jdbc.Driver
2 url=jdbc:mysql://localhost:3306/school
3 userName=root
4 passWord=123456
JdbcUtils类，把不变动的、且每次都使用到的那部分代码封装起来
1 package com.shore.utils;
2
3 import java.io.InputStream;
4 import java.sql.Connection;
5 import java.sql.DriverManager;
6 import java.sql.ResultSet;
7 import java.sql.SQLException;
8 import java.sql.Statement;
9 import java.util.Properties;
10
11 /**
12 * @author DSHORE/2019-5-29
13 *
14 */
15 public class JdbcUtils {
16 //静态代码块执行后，这几个参数，就有值了
17 private static String jdbcDriver = "";
18 private static String url = "";
19 private static String userName = "";
20 private static String passWord = "";
21
22 private JdbcUtils() {
23 }
24
25 static {//静态代码块
26 try {
27 //读取配置文件db.properties，用于获取数据库的入口连接url、用户名、密码，以及数据库的驱动
28 InputStream inputStream = JdbcUtils.class.getResourceAsStream("/db.properties");
29 Properties properties = new Properties();
30 properties.load(inputStream);//加载文件
31 inputStream.close();
32 jdbcDriver = properties.getProperty("jdbcDriver");
33 url = properties.getProperty("url");
34 userName = properties.getProperty("userName");
35 passWord = properties.getProperty("passWord");
36 Class.forName(jdbcDriver); //注册驱动
37 } catch (Exception e) {
38 e.printStackTrace();
39 }
40 }
41
42 //获取连接
43 public static Connection getConnection() throws SQLException {
44 return DriverManager.getConnection(url, userName, passWord);
45 }
46
47 //关闭资源（比较严谨的写法）
48 public static void close(Connection connection, Statement statement,ResultSet resultSet) {
49 if (resultSet != null) {
50 try {
51 resultSet.close();
52 } catch (SQLException e) {
53 e.printStackTrace();
54 }finally{
55 if (statement != null) {
56 try {
57 statement.close();
58 } catch (SQLException e) {
59 e.printStackTrace();
60 }finally{
61 if (connection != null) {
62 try {
63 connection.close();
64 } catch (SQLException e) {
65 e.printStackTrace();
66 }
67 }
68 }
69 }
70 }
71 }
72 }
73 }
↑ 此处封装已完成。
下面用个简单的例子来演示怎么使用：
1 package com.shore.test;
2
3 import java.sql.Connection;
4 import java.sql.PreparedStatement;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7
8 import org.junit.Test;
9
10 import com.shore.utils.JdbcUtils;
11
12 /**
13 * @author DSHORE/2019-5-29
14 *
15 */
16 public class jdbcTest {
17
18 @Test
19 public void testInsert(){
20 Connection connection = null;
21 PreparedStatement preparedStatement = null;
22 ResultSet resultSet = null;
23 try {
24 //1.获取连接
25 connection = JdbcUtils.getConnection();
26 //2.准备预编译的sql
27 String sql = "insert into teacher(sname,sex) values(?,?);";//?表示一个参数的占位符
28 //3.执行预编译的sql语句(检查语法)
29 preparedStatement = connection.prepareStatement(sql);
30 //4.设置参数
31 preparedStatement.setString(1,"赵六"); //可用name作为参数代表“赵六” 从页面传值来此
32 preparedStatement.setString(2,"女");
33 //5.发送参数,执行sql
34 int count = preparedStatement.executeUpdate();
35 System.out.println("影响了"+count+"行");
36 } catch (SQLException e) {
37 e.printStackTrace();
38 }finally{
39 JdbcUtils.close(connection, preparedStatement, resultSet);
40 }
41 }
42 }
运行后，结果图：
ava基础MySQL存储过程 Java基础 JDBC连接MySQL数据库的更多相关文章
- java用JDBC连接MySQL数据库的详细知识点
想实现java用JDBC连接MySQL数据库.需要有几个准备工作: 1.下载Connector/J的库文件,下载Connector/J的官网地址:http://www.mysql.com/downlo ...
- JAVA使用jdbc连接MYSQL简单示例
以下展示的为JAVA使用jdbc连接MYSQL简单示例: import java.sql.DriverManager; import java.sql.ResultSet; import java.s ...
- JAVA通过JDBC连接Oracle数据库详解【转载】
JAVA通过JDBC连接Oracle数据库详解 (2011-03-15 00:10:03) 转载▼http://blog.sina.com.cn/s/blog_61da86dd0100q27w.htm ...
- 【Java】JDBC连接MySQL
JDBC连接MySQL 虽然在项目中通常用ORM的框架实现持久化.但经常因测试某些技术的需要,要写一个完整的JDBC查询数据库.写一个在这儿备份. 首先引入驱动包: <dependencies& ...
- java 通过jdbc连接MySQL数据库
先了解下JDBC的常用接口 1.驱动程序接口Driver 每种数据库的驱动程序都应该提供一个实现java.sql.Driver接口的类,简称Driver类.通常情况下,通过java.lang.Clas ...
- Java使用JDBC连接MySQL数据库
1.引用 JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写 ...
- java通过jdbc连接mysql数据库
下载mysql驱动包: http://dev.mysql.com/downloads/file.php?id=456317 解压之后里面有个mysql-connector-java-5.1.35-bi ...
- 【转】Java 通过JDBC连接Mysql数据库的方法和实例【图文说明】
JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口 ...
- Java 通过JDBC连接Mysql数据库的方法和实例
JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口 ...
随机推荐
- web端项目如何测试
1.是否支持各种网络 2.网络如果演示能否正常加载 3.加载时断网还能加载出来么 4.浏览时断网页面是否保持 5.是否兼容各种不同的浏览器 6.不同的浏览器加载出的页面是否一致 7.页面效果如何 8. ...
- java46
1.迭代器遍历 import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public c ...
- WriteFile，CreateFile，ReadFile
原文链接:https://blog.csdn.net/Jeanphorn/article/details/44982273 将数据写入一个文件.该函数比fwrite函数要灵活的多.也可将这个函数应用于 ...
- 本人的CSDN博客
本人的CSDN博客链接: 传送门
- xargs--冬天里的一丝暖意
本文为博客园作者所写: 一寸HUI,个人博客地址:https://www.cnblogs.com/zsql/ 你有批量kill作业吗?有因为删除文件夹的内容太多而报错吗?-bash: /bin/rm: ...
- 使用douban源下载python包
需求 python默认使用国外源下载依赖包,由于一些其它因素(例如网络差了,国外机器炸了,我们强大的祖国了...)经常导致下载安装失败,so出现了以豆瓣为主的国内下载源 如何使用豆瓣进行下载 豆瓣下载 ...
- charles 常用功能（七）简易接口压力测试（repeat advance 功能）
接口请求次数.并发量.请求延迟时间均可配置 1.选中需要进行测试的接口,鼠标右键 选中[repeat advance] 设置迭代数量
- 第7章 Python类型、类、协议 第7.1节 面向对象程序设计的相关知识
Python被视为一种面向对象的语言,在介绍Python类相关的内容前,本节对面向对象程序设计相关的概念进行简单介绍. 一. 类和对象(实例) 在面向对象的程序设计(OOP)过程中有两个重要概念 ...
- Python匹配对象的groups、groupdict和group之间的关系
匹配对象的groups()方法返回一个包含所有参与匹配的子组(不含组0)的匹配到的搜索文本子串的元组,groupdict返回一个包含所有匹配到的命名组的组名为键值和命名组匹配到的搜索文本子串为值作为元 ...
- PyQt（Python+Qt）学习随笔：model/view架构中支持QListView列表中展示图标的两种方法
老猿Python博文目录 专栏:使用PyQt开发图形界面Python应用 老猿Python博客地址 在QListView列表视图中的项不但可以展示文字,也可以展示图标和复选框,同时可以指定项是否可以拖 ...