Java 之 JDBC

时间 2019-11-08

标签 java jdbc 栏目 Java 繁體版

原文原文链接

1、认识JDBC

JDBC是用于在Java语言编程中与数据库链接的API.JDBC是一个规范，它提供了一整套接口，容许以一种可移植的访问底层数据库API。使用JDBC驱动程序来访问数据库，并用于存储数据到数据库中.html

解释上面两幅图：java

java应用程序经过JDBC API首先链接到JDBC Driver，这些JDBC驱动器都是由各大数据库厂家针对JDBC提供的，咱们能够在网上下载jar包来使用，而后经过JDBC驱动器就能链接到咱们的数据库了。mysql

第一步添加驱动git

1.在项目当中建立一个文件夹为lib
2.把Mysql驱动包复制到该文件夹下
3.builder path 编译路径
复制代码

第二步链接到数据库github

package con.meils.jdbc.conn;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionClass {

	public static void main(String[] args) throws ClassNotFoundException, SQLException {
		// TODO Auto-generated method stub
		
		
		// 一、加载驱动
		// 把com.mysql.jdbc.Driver这份字节码加载进JVM
		// 当一份字节码加载进JVM的时候，就会执行字节码文件中的静态代码块
		// 这里加载该字节码以后会实例化一个驱动器
		Class.forName("com.mysql.jdbc.Driver");
		
		// 二、链接
		String url = "jdbc:mysql://localhost:3306/mytest";
		String username = "root";
		String password = "zjj19970517";
		Connection connection = DriverManager.getConnection(url, username, password);
		
		// 三、验证链接
		System.out.println(connection); // 若是有输出，代表链接成功
	}

}

复制代码

第三步操做数据库建立表sql

package con.meils.jdbc.ddl;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class CreateTable {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		// 1\加载驱动
		// 把com.mysql.jdbc.Driver这份字节码加载进JVM
		// 当一份字节码加载进JVM的时候，就会执行字节码文件中的静态代码块
		// 这里加载该字节码以后会实例化一个驱动器
		Class.forName("com.mysql.jdbc.Driver");

		String url = "jdbc:mysql://localhost:3306/jdbc_db";
		String username = "root";
		String password = "zjj19970517";
		// 2\ 链接数据库
		Connection connection = DriverManager.getConnection(url, username, password);
		
		
		// 3\建立sql语句
		String sql = "create table stu (id int , name varchar(20), age int)";
		
		// 4\执行sql语句
		Statement st = connection.createStatement();
		int row = st.executeUpdate(sql);
		
		// 5\释放
		st.close();
		connection.close();
		
		
		
	}

}

复制代码

为何要释放资源呢？数据库

第四步插入数据编程

package con.meils.jdbc.dml;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class InsertClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
		// ================ 插入数据 ================
		
		Connection conn = null;
		
		Statement st = null;
		
		
		try {
			// 一、加载驱动
			Class.forName("com.mysql.jdbc.Driver");
			
			// 二、建立链接
			String url = "jdbc:mysql://localhost:3306/mytest";
			String user = "root";
			String password = "zjj19970517";
			conn = DriverManager.getConnection(url, user, password);
			
			// 三、建立sql语句
			String sql = "insert into stu values(1, 'zjj', 20)";
			st = conn.createStatement();
			
			// 四、执行语句
			int row = st.executeUpdate(sql);
			System.out.println(row);
		}catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 五、释放
			if(st!=null) {
				try {
					st.close();
				}catch (Exception e) {
					e.printStackTrace();
				}
			}
			if(conn!=null) {
				try {
					conn.close();
				}catch (Exception e) {
					e.printStackTrace();
				}
			}
			
			
		}
		
	}

}

复制代码

第五步查询操做数组

package con.meils.jdbc.dql;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class QueryClass {

	public static void main(String[] args) throws SQLException, ClassNotFoundException {
		// TODO Auto-generated method stub

		// ================ 查询数据 ================
		
		// 1\加载驱动
				// 把com.mysql.jdbc.Driver这份字节码加载进JVM
				// 当一份字节码加载进JVM的时候，就会执行字节码文件中的静态代码块
				// 这里加载该字节码以后会实例化一个驱动器
				Class.forName("com.mysql.jdbc.Driver");

				String url = "jdbc:mysql://localhost:3306/mytest";
				String username = "root";
				String password = "zjj19970517";
				// 2\ 链接数据库
				Connection connection = DriverManager.getConnection(url, username, password);
				
				
				// 3\建立sql语句 
				String sql = "select count(*) as total from stu"; // 查询一共有几行数据
				
				// 4\执行sql语句
				Statement st = connection.createStatement();
				ResultSet rs = st.executeQuery(sql);
				
				if(rs.next()) {
					int count = rs.getInt("total");
					System.out.println(count); // 1
				}
				
				// 5\释放
				st.close();
				connection.close();
	}

}

复制代码

数据类型对照表：安全

上面咱们基本学会了如何与数据库打交道，可是这样使用存在许多的弊端，好比：每一步操做都进行一次数据库链接，形成浪费，因此咱们在实际中要使用DAO思想来处理。

2、DAO设计

一、什么是DAO

DAO（Data Access Object）数据存储对象，介于业务逻辑层和持久层之间，实现持久化数据访问。

不使用DAO的时候：

使用DAO的状况：

3、ORM映射关系

4、Domain

一、认识domain

二、domain类

三、保存数据

四、获取数据

5、DAO设计规范

案例

咱们能够编写一个DAO接口，定义了经常使用的数据库操做方法，这时候咱们同时会链接多个数据库，好比是mysql 和 oracle ，咱们能够分别实现oracleDao和mysqlDao两个类，不一样类里面定义不一样的操做数据库的代码，实现的功能确实相同的。

因此面向接口编程是很重要的，也是一个很好的方式。

一、包命名规范

二、类命名规范

三、开发步骤

目录以下

内容实现：

接口实现类的具体内容：

package com.meils.jdbc.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

import com.meils.jdbc.dao.IStudentDao;
import com.meils.jdbc.domain.Student;
import com.meils.jdbc.utils.JdbcUtil;

/**
 * 实现DAO接口的类
 * @author apple
 *
 */
public class StudentDaoImpl implements IStudentDao{

	@Override
	/**
	 * 存储学生
	 * @param stu
	 */
	public void save(Student stu) {
		// TODO Auto-generated method stub
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			// 链接数据库
			conn = JdbcUtil.getConnection();
			
			String sql = "insert into student (name, age) values (? , ?)";
			
			// 建立预编译
			ps = conn.prepareStatement(sql);
			ps.setString(1, stu.getName());
			ps.setInt(2, stu.getAge());
			
			// 执行更新
			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtil.close(conn, ps, null);
		}
	}

	@Override
	public void delete(int id) {
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			// 链接数据库
			conn = JdbcUtil.getConnection();
			
			String sql = "delete from student where id = ?";
			
			// 建立预编译
			ps = conn.prepareStatement(sql);
			ps.setInt(1, id);
			// 执行更新
			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtil.close(conn, ps, null);
		}
	}

	@Override
	public void update(int id, Student stu) {
		
		Connection conn = null;
		PreparedStatement ps = null;
		try {

			conn = JdbcUtil.getConnection();
			
			String sql = "update student set name=?, age=? where id = ? ";
			ps = conn.prepareStatement(sql);
			
			ps.setString(1, stu.getName());
			ps.setInt(2, stu.getAge());
			ps.setInt(3, id);
			// 执行
			ps.executeUpdate();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtil.close(conn, ps, null);
		}
		
	
	}

	@Override
	public Student findOne(int id) {
		Connection conn = null;
		PreparedStatement ps = null;
		ResultSet rs = null;
		try {
			
			conn = JdbcUtil.getConnection();
			// sql语句
			String sql = "select * from student where id = ?";
			ps = conn.prepareStatement(sql);
			ps.setInt(1, id);
			// 执行
			rs = ps.executeQuery();
			
			if (rs.next()) {
				// 保存数据
				Student stu = new Student();
				stu.setName(rs.getString("name"));
				stu.setAge(rs.getInt("age"));
				stu.setId(rs.getInt("id"));
				return stu;
			}

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 销毁
			JdbcUtil.close(conn, ps, rs);

		}
		
		return null;
	}

	@Override
	public List<Student> findAll() {
		
		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			
			
			conn = JdbcUtil.getConnection();
			
			
			st = conn.createStatement();
			String sql = "select * from student ";
			
			rs = st.executeQuery(sql);
			
			List<Student> list = new ArrayList<Student>();
			while (rs.next()) {
				Student stu = new Student();
				stu.setName(rs.getString("name"));
				stu.setAge(rs.getInt("age"));
				stu.setId(rs.getInt("id"));
				list.add(stu);
			}
			return list;

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			JdbcUtil.close(conn, st, rs);
		}
		return null;
	}
	
}

复制代码

编写测试类：

package com.meils.jdbc.dao.test;

import java.util.List;

import org.junit.Test;

import com.meils.jdbc.dao.IStudentDao;
import com.meils.jdbc.dao.impl.StudentDaoImpl;
import com.meils.jdbc.domain.Student;

/**
 * StudentDao测试类
 * @author apple
 */
public class StudentDaoTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
	
	@Test
	public void save() {
		Student stu = new Student();
		stu.setName("张伟");
		stu.setAge(21);
		
		IStudentDao dao = new StudentDaoImpl();
		dao.save(stu);
	}
	
	@Test
	public void delete() {
		IStudentDao dao = new StudentDaoImpl();
		dao.delete(4);
	}

	@Test
	public void update () {
		Student stu = new Student();
		stu.setName("mmmmm");
		stu.setAge(16);
		
		IStudentDao dao = new StudentDaoImpl();
		dao.update(5, stu);
	}
	
	@Test
	public void findOne() {
		IStudentDao dao = new StudentDaoImpl();
		Student stu = dao.findOne(5);
		System.out.println(stu);
	}
	
	
	@Test
	public void findAll() {
		IStudentDao dao = new StudentDaoImpl();
		List<Student> allStu = dao.findAll();
		System.out.println(allStu);
	}
	
	
	
	
}

复制代码

JDBC工具类：

package com.meils.jdbc.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * JDBC  工具类
 * @author apple
 *
 */
public class JdbcUtil {
	// 配置信息
	public static String driverName = "com.mysql.jdbc.Driver";
	public static String url = "jdbc:mysql://localhost:3306/mytest";
	public static String userName = "root";
	public static String password = "zjj19970517";
	
	static {
		try {
			// 加载驱动，由于是在static块中，因此只会加载一次
			Class.forName(JdbcUtil.driverName);
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 链接数据库
	 * @return 返回链接对象
	 */
	public static Connection getConnection() {
		try {
			return DriverManager.getConnection(JdbcUtil.url, JdbcUtil.userName, JdbcUtil.password);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 关闭链接，并释放资源
	 * @param conn
	 * @param st
	 * @param rs
	 */
	public static void close(Connection conn, Statement st, ResultSet rs) {
		if(conn!=null) {
			try {
				conn.close();
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
		
		if(st!=null) {
			try {
				st.close();
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
		
		if(rs!=null) {
			try {
				rs.close();
			}catch(Exception e) {
				e.printStackTrace();
			}
		}
	}
}

复制代码

项目github地址

三、DAO代码重构

四、Statement接口

1 Statement 是父接口，PreparedStatement 和 CallableStatement 是子接口。

2 Statement 用于java应用程序与数据库之间的传送数据，好比传送sql语句过去，到数据库执行操做。

3 Statement 用于通用的访问，使用静态sql，其实并很差，容易SQL注入

4 PreparedStatement 用于预编译模版SQL语句，能够在运行的时候传入参数

5 CallableStatement 访问存储过程的时候使用
复制代码

五、预编译语句

防止SQL注入：

java JDBC DAO封装教程

六、经过DB类来操做数据库

JDBC的另外一种封装方法：

package com.meils.jdbc.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MysqlDB {
	Connection conn = null; // 建立链接对象
	Statement st = null; // 建立编译语句对象
	PreparedStatement ps = null; // 建立预编译语句对象
	ResultSet rs1 = null;  // 结果集

	// 配置信息
	// 驱动名称
	private static final String driverName = "com.mysql.jdbc.Driver";
	// 数据库的地址
	private static final String URL = "jdbc:mysql://localhost:3306/mytest";
	// 数据库登陆用户名
	private static final String userName = "root";
	// 数据库登陆密码
	private static final String pwd = "zjj19970517";
	
	/**
	 * 链接数据库
	 * @return
	 */
	public Connection getConnection() {
		try {
			Class.forName(driverName);
			
			this.conn = DriverManager.getConnection(URL, userName, pwd);
			System.out.println("链接成功");
			
			return conn;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	// 构造函数
	public MysqlDB() {
		this.getConnection();
	}
	
	/**
	 * 查询
	 * @param sql sql语句，完整的语句，查询通常比较安全
	 * @return
	 */
	public ResultSet query(String sql) {
		try {
			this.st = this.conn.createStatement();
			this.rs1 = this.st.executeQuery(sql);
			return rs1;
		} catch (SQLException e) {
			e.printStackTrace();
		} 
		
		return null;
	}
	
	/**
	 * 更新
	 * @param sql  // 预编译sql语句
	 * @param args // 参数数组
	 */
	public void update(String sql, String [] args) {
		try {
			this.ps = this.conn.prepareStatement(sql);
			for (int i = 0 ; i < args.length ; i++) {
				this.ps.setString(i+1, args[i]);
			}
			
			this.ps.executeUpdate();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			this.close();
		}
		
	}
	
	/**
	 * 删除
	 * @param sql
	 * @return
	 */
	public int delete(String sql){
        try {
            this.st = this.conn.createStatement();
            int num = this.st.executeUpdate(sql);
            return num;
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }  finally {
			this.close();
		}
        return 0;
    }
	
	/**
	 * 释放资源
	 */
	public void close () {
		try {
            if(rs1!=null) {
                rs1.close();
            }
            if(st!=null) {
                st.close();
            }
            if(ps!=null) {
                ps.close();
            }
            if(conn!=null) {
                conn.close();
            }

        } catch (SQLException e) {
            // TODO: handle exception
        	e.printStackTrace();
        }
	}

}

复制代码

测试如下：

package com.meils.jdbc.db;

import java.sql.ResultSet;
import java.sql.SQLException;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		Conn();
		delete();
	}

	// 测试链接
	public static void Conn() {
		MysqlDB m = new MysqlDB();
	}

	// 测试查询
	public static void queryTest() {
		MysqlDB m = new MysqlDB();
		String sql = "select * from student";
		ResultSet result = m.query(sql);
		System.out.println(result);
		try {
			while (result.next()) {
				System.out.println(result.getString("name"));
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			m.close();
		}
	}
	// 更新
	public static void update() {
		MysqlDB m = new MysqlDB();
		String sql = "update student set name = ? where id = ?";
		String [] args = {"梅子111", "7"};
		
		m.update(sql, args);
	}
	
	// 删除
	public static void delete() {
		MysqlDB m = new MysqlDB();
		String sql = "delete from student where id = 8";
		System.out.println(m.delete(sql));
	}
	
	
	

}

复制代码

七、调用存储过程

首先咱们熟悉一下存储过程

// 新建存储过程
DELIMITER //
create PROCEDURE getStudent1(in n varchar(20))
BEGIN

	select * from student where name = n;
END //
DELIMITER ;

// 执行
call getStudent1('张锦杰');
复制代码

测试一下：（很是尴尬好像并无结果，也没有报错，不知道是什么缘由～～）

package com.meils.jdbc.dao.test;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import com.meils.jdbc.domain.Student;
import com.meils.jdbc.utils.JdbcUtil;

public class ProductTest {

	public static void main(String[] args) {
		CallableStatement cstmt = null;
		try {
			//1.链接
			Connection conn = JdbcUtil.getConnection();
			//2.
			CallableStatement cs = conn.prepareCall("{ call getStu(?)}");
			//3.设置参数
			cs.setString(1, "张锦杰");
			//4.执行
			ResultSet rs = cs.executeQuery();
			if(rs.next()) {
				Student stu = new Student();
				stu.setId(rs.getInt("id"));
				stu.setName(rs.getString("name"));
				stu.setAge(rs.getInt("age"));
				System.out.println(stu);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		

	}

}

复制代码

带有参数和输出的存储过程

// 带有参数和输出的存储过程

DELIMITER //
CREATE PROCEDURE getName ( IN i INT, OUT n VARCHAR ( 50 ) ) BEGIN
	SELECT NAME INTO
		n 
	FROM
		student 
	WHERE
		id = i;

END // DELIMITER;

call getName(1, @name);
select @name;
复制代码

测试一下：

package com.meils.jdbc.dao.test;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

import com.meils.jdbc.domain.Student;
import com.meils.jdbc.utils.JdbcUtil;

public class ProductTest {

	public static void main(String[] args) {
		CallableStatement cstmt = null;
		try {
			//1.建立链接
			Connection conn = JdbcUtil.getConnection();
			//2.建立预编译语句
			CallableStatement cs = conn.prepareCall("{ call getName(?,?)}");
			//3.设置参数
			cs.setInt(1, 1);
			//4.设置输出参数
			cs.registerOutParameter(2, Types.VARCHAR);
			//5.执行
			cs.execute();
			
			//6.获取到输出的参数
			String name = cs.getString(2);
			System.out.println(name); // 张锦杰
		} catch (Exception e) {
			e.printStackTrace();
		}
		

	}

}

复制代码

八、事物

实例：

首先在减小钱以前关闭自动提交事务，期间能够进行多个操做，此时的事务提交必须手动了，须要使用conn.commit();。若是在中间发生了异常，那么就进行回滚，释放资源。

九、批处理

一般状况下若是咱们想要一次性执行许多条sql语句，咱们都是一条执行完毕再执行下一条，当咱们使用了批处理以后，咱们就能够一次性执行多条语句，话费的事件将大大缩短。

十、将文件存入数据库

一般咱们不会这么作的，由于数据库的空间是很是宝贵的，文件较大，占用的空间也较大，成本也就高了，假如咱们须要存文件，那么就要选择blob类型了，它是以二进制的形式来存取的，能够存视频、图片、等多媒体信息。

首先须要设置数据库中的字段类型为blob。
复制代码

存储文件到数据库：

将数据库中的文件取出来：

十一、获取自动生成的主键id

需求分析：

咱们可能回遇到这样的情景，咱们首先注册信息，填入用户明和密码后，注册成功，此时的数据库中的id是自动添加进去的，接下来回让本身去完善本身的信息，这就要须要咱们刚才建立的id了，那么如何返回id给咱们下次使用呢？

两种方式获取：