詳解Java數據庫連接JDBC基礎知識(操作數據庫：增刪改查)
一、JDBC簡介
JDBC是連接java應用程序和數據庫之間的橋梁。
什麼是JDBC?
Java語言訪問數據庫的一種規范,是一套API。
JDBC (Java Database Connectivity) API，即Java數據庫編程接口，是一組標準的Java語言中的接口和類，使用這些接口和類，Java客戶端程序可以訪問各種不同類型的數據庫。比如建立數據庫連接、執行SQL語句進行數據的存取操作。
JDBC代表Java數據庫連接。
JDBC庫中所包含的API任務通常與數據庫使用：
- 連接到數據庫
- 創建SQL或MySQL語句
- 在數據庫中執行SQL或MySQL查詢
- 查看和修改記錄
比如：
二、JDBC使用詳解
1、打通數據庫
先新建Java 工程，將jar包導進去：
然後新建相應的數據庫和表。
編寫DBUtil.java
package com.study.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class DBUtil {
private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
private static final String NAME="root";
private static final String PASSWORD="root";
public static void main(String[] args) throws Exception{
//1.加載驅動程序
Class.forName("com.mysql.jdbc.Driver");
//2.獲得數據庫的連接
Connection conn = DriverManager.getConnection(URL, NAME, PASSWORD);
//3.通過數據庫的連接操作數據庫，實現增刪改查
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//選擇import java.sql.ResultSet;
while(rs.next()){//如果對象中有數據，就會循環打印出來
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
}
}
}
2、搭建模型層
采用MVC三層架構：建議由下往上開發（DB->view,需求讀懂以後，設計數據庫，然後根據數據庫映射模型，再寫控制層，再寫視圖層）
- View視圖層——展示數據，反饋用戶行為
- Control控制層——控制數據流通過程，協調視圖層和數據層
- Model模型層——與數據庫建立映射，與數據進行交互（DB數據庫）
先新增對應的model層：按照數據庫表對應的字段編寫實體類。
package com.study.model;
import java.util.Date;
public class Goddess {
private Integer id;
private String userName;
private Integer sex;
private Integer age;
private Date birthday;
private String email;
private String mobile;
private String createUser;
private Date createDate;
private String updateUser;
private Date updateDate;
private Integer isDel;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
public String getCreateUser() {
return createUser;
}
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
public Date getCreateDate() {
return createDate;
}
public void setCreateDate(Date createDate) {
this.createDate = createDate;
}
public String getUpdateUser() {
return updateUser;
}
public void setUpdateUser(String updateUser) {
this.updateUser = updateUser;
}
public Date getUpdateDate() {
return updateDate;
}
public void setUpdateDate(Date updateDate) {
this.updateDate = updateDate;
}
public Integer getIsDel() {
return isDel;
}
public void setIsDel(Integer isDel) {
this.isDel = isDel;
}
}
然後開始新增Dao層，並修改DBUtil.java
DBUtil.java代碼如下：
package com.study.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class DBUtil {
private static final String URL="jdbc:mysql://localhost:3306/demo_jdbc";
private static final String NAME="root";
private static final String PASSWORD="root";
private static Connection conn=null;
//靜態代碼塊（將加載驅動、連接數據庫放入靜態塊中）
static{
try {
//1.加載驅動程序
Class.forName("com.mysql.jdbc.Driver");
//2.獲得數據庫的連接
conn = DriverManager.getConnection(URL, NAME, PASSWORD);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
//對外提供一個方法來獲取數據庫連接
public static Connection getConnection(){
return conn;
}
public static void main(String[] args) throws Exception{
//3.通過數據庫的連接操作數據庫，實現增刪改查
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("select user_name,age from imooc_goddess");//選擇import java.sql.ResultSet;
while(rs.next()){//如果對象中有數據，就會循環打印出來
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
}
}
}
goddessDao.java 代碼如下：
package com.study.dao;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import com.study.db.DBUtil;
import com.study.model.Goddess;
public class GoddessDao {
public void addGoddess(){
}
public void updateGoddess(){
}
public void delGoddess(){
}
public List<Goddess> query() throws Exception{
Connection con=DBUtil.getConnection();
Statement stmt=con.createStatement();
ResultSet rs=stmt.executeQuery("select user_name,age from imooc_goddess");
List<Goddess> gs=new ArrayList<Goddess>();
Goddess g=null;
while(rs.next()){//如果對象中有數據，就會循環打印出來
g=new Goddess();
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
gs.add(g);
}
return gs;
}
//查詢單個女神
public Goddess get(){
return null;
}
}
新增Controller層：GoddessAction.java
package com.study.controller;
import java.util.List;
import com.study.dao.GoddessDao;
import com.study.model.Goddess;
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao gd=new GoddessDao();
List<Goddess> gs=gd.query();
for (Goddess goddess : gs) {
System.out.println(goddess.getUserName()+","+goddess.getAge());
}
}
}
PS：CRUD：增加(Create)、讀取(Retrieve)（重新得到數據–>高級應用：報表、分頁）、更新(Update)和刪除(Delete)
3、搭建模型層——CRUD操作
新增create操作：
//添加女神
public void addGoddess(Goddess g) throws Exception{
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
String sql="" +
"insert into imooc_goddess"+
"(user_name,sex,age,birthday,email,mobile,"+
"create_user,create_date,update_user,update_date,isdel) "+
"values("+
"?,?,?,?,?,?,?,current_date(),?,current_date(),?)";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sql);
//先對應SQL語句，給SQL語句傳遞參數
psmt.setString(1, g.getUserName());
psmt.setInt(2, g.getSex());
psmt.setInt(3, g.getAge());
//註意：setDate()函數第二個參數需要的是java.sql.Date類型，我們傳進來的是java.util.Date，類型不符，需要做一下轉換
psmt.setDate(4, new Date(g.getBirthday().getTime()));
psmt.setString(5, g.getEmail());
psmt.setString(6, g.getMobile());
psmt.setString(7, g.getCreateUser());
psmt.setString(8, g.getUpdateUser());
psmt.setInt(9, g.getIsDel());
//執行SQL語句
psmt.execute();
/**
* prepareStatement這個方法會將SQL語句加載到驅動程序conn集成程序中，但是並不直接執行
* 而是當它調用execute()方法的時候才真正執行；
*
* 上面SQL中的參數用?表示，相當於占位符，然後在對參數進行賦值。
* 當真正執行時，這些參數會加載在SQL語句中，把SQL語句拼接完整才去執行。
* 這樣就會減少對數據庫的操作
*/
}
測試：
package com.study.controller;
import java.util.Date;
import java.util.List;
import com.study.dao.GoddessDao;
import com.study.model.Goddess;
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao gd=new GoddessDao();
Goddess g1=new Goddess();
g1.setUserName("小夏");
g1.setAge(22);
g1.setSex(1);
g1.setBirthday(new Date());
g1.setEmail("[email protected]");
g1.setMobile("123456789");
g1.setCreateUser("admin");
g1.setUpdateUser("admin");
g1.setIsDel(1);
//添加女神
gd.addGoddess(g1);
}
}
修改、刪除、查詢(根據id)操作：
//更新女神
public void updateGoddess(Goddess g) throws SQLException{
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
String sql="" +
"update imooc_goddess "+
"set user_name=?,sex=?,age=?,birthday=?,email=?,mobile=?,"+
"update_user=?,update_date=current_date(),isdel=?) "+
"where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sql);
//先對應SQL語句，給SQL語句傳遞參數
psmt.setString(1, g.getUserName());
psmt.setInt(2, g.getSex());
psmt.setInt(3, g.getAge());
//註意：setDate()函數第二個參數需要的是java.sql.Date類型，我們傳進來的是java.util.Date，類型不符，需要做一下轉換
psmt.setDate(4, new Date(g.getBirthday().getTime()));
psmt.setString(5, g.getEmail());
psmt.setString(6, g.getMobile());
psmt.setString(7, g.getUpdateUser());
psmt.setInt(8, g.getIsDel());
psmt.setInt(9, g.getId());
//執行SQL語句
psmt.execute();
}
//刪除女神
public void delGoddess(Integer id) throws SQLException{
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
String sql="" +
"delete from imooc_goddess "+
"where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sql);
//先對應SQL語句，給SQL語句傳遞參數
psmt.setInt(1, id);
//執行SQL語句
psmt.execute();
}
//查詢單個女神(根據id去查詢)
public Goddess get(Integer id) throws SQLException{
Goddess g=null;
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
String sql="" +
"select * from imooc_goddess "+
"where id=?";//參數用?表示，相當於占位符;用mysql的日期函數current_date()來獲取當前日期
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sql);
//先對應SQL語句，給SQL語句傳遞參數
psmt.setInt(1, id);
//執行SQL語句
/*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
ResultSet rs = psmt.executeQuery();//返回一個結果集
//遍歷結果集
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
g.setSex(rs.getInt("sex"));
//rs.getDate("birthday")獲得的是java.sql.Date類型。註意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換瞭。
g.setBirthday(rs.getDate("birthday"));
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreateUser(rs.getString("create_user"));
g.setCreateDate(rs.getDate("create_date"));
g.setUpdateUser(rs.getString("update_user"));
g.setUpdateDate(rs.getDate("update_date"));
g.setIsDel(rs.getInt("isdel"));
}
return g;
}
查詢（根據name\mobile等）操作
//查詢單個女神(根據姓名等信息去查詢)
public List<Goddess> get(String name,String mobile) throws SQLException{
List<Goddess> result=new ArrayList<Goddess>();
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
StringBuffer sb=new StringBuffer();
sb.append("select * from imooc_goddess ");
sb.append("where user_name like ? and mobile like ?");
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sb.toString());
//先對應SQL語句，給SQL語句傳遞參數
psmt.setString(1, "%"+name+"%");
psmt.setString(2, "%"+mobile+"%");
System.out.println(sb.toString());
//執行SQL語句
/*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
ResultSet rs = psmt.executeQuery();//返回一個結果集
Goddess g=null;
//遍歷結果集
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
g.setSex(rs.getInt("sex"));
//rs.getDate("birthday")獲得的是java.sql.Date類型。註意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換瞭。
g.setBirthday(rs.getDate("birthday"));
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreateUser(rs.getString("create_user"));
g.setCreateDate(rs.getDate("create_date"));
g.setUpdateUser(rs.getString("update_user"));
g.setUpdateDate(rs.getDate("update_date"));
g.setIsDel(rs.getInt("isdel"));
result.add(g);//將結果封裝到對象中
}
return result;
}
測試：
package com.study.controller;
import java.util.Date;
import java.util.List;
import com.study.dao.GoddessDao;
import com.study.model.Goddess;
public class GoddessAction {
public static void main(String[] args) throws Exception {
GoddessDao gd=new GoddessDao();
/*//查詢所有女神
List<Goddess> gs=gd.query();
for (Goddess goddess : gs) {
System.out.println(goddess.getUserName()+","+goddess.getAge());
}*/
Goddess g1=new Goddess();
g1.setUserName("小夏");
g1.setAge(22);
g1.setSex(1);
g1.setBirthday(new Date());
g1.setEmail("[email protected]");
g1.setMobile("123456789");
g1.setCreateUser("admin");
g1.setUpdateUser("admin");
g1.setIsDel(1);
//添加女神
// gd.addGoddess(g1);
//查詢單個女神（根據id）
/*Goddess g2 = gd.get(4);
System.out.println(g2.toString());*/
//查詢單個女神（根據姓名等信息）
List<Goddess> list = gd.get("小溪", "139");
//遍歷結果集
for(int i=0;i<list.size();i++){
System.out.println(list.get(i).toString());
}
}
}
運行結果：
select * from imooc_goddess where user_name like ? and mobile like ?
Goddess [id=1, userName=小溪, sex=1, age=22, birthday=2000-12-12, [email protected], mobile=13911111111, createUser=ADMIN, createDate=2015-01-08, updateUser=ADMIN, updateDate=2015-01-08, isDel=0]
查詢操作的進一步完善：
//查詢單個女神(根據姓名等信息去查詢)----->使用Map存儲條件信息；防止條件為空可加一條where 1=1
public List<Goddess> get(List<Map<String, Object>> params) throws SQLException{
List<Goddess> result=new ArrayList<Goddess>();
Connection con=DBUtil.getConnection();//首先拿到數據庫的連接
StringBuffer sb=new StringBuffer();
sb.append("select * from imooc_goddess where 1=1 ");//註意where 1=1 的小技巧
if(params !=null && params.size()>0){//先判斷集合是否為空
//遍歷集合
for(int i=0;i<params.size();i++){
Map<String, Object> map=params.get(i);
sb.append("and "+map.get("name")+" " +map.get("rela")+" "+map.get("value")+" ");//查詢什麼？關系是什麼？以及值是什麼，我們都可以通過參數傳進來。
}
}
//預編譯sql語句
PreparedStatement psmt = con.prepareStatement(sb.toString());
System.out.println(sb.toString());
//執行SQL語句
/*psmt.execute();*///execute()方法是執行更改數據庫操作（包括新增、修改、刪除）;executeQuery()是執行查詢操作
ResultSet rs = psmt.executeQuery();//返回一個結果集
Goddess g=null;
//遍歷結果集
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
g.setSex(rs.getInt("sex"));
//rs.getDate("birthday")獲得的是java.sql.Date類型。註意：java.sql.Date類型是java.util.Date類型的子集，所以這裡不需要進行轉換瞭。
g.setBirthday(rs.getDate("birthday"));
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreateUser(rs.getString("create_user"));
g.setCreateDate(rs.getDate("create_date"));
g.setUpdateUser(rs.getString("update_user"));
g.setUpdateDate(rs.getDate("update_date"));
g.setIsDel(rs.getInt("isdel"));
result.add(g);//將結果封裝到對象中
}
return result;
}
測試：
//查詢單個女神(根據姓名等信息去查詢)----->使用Map存儲條件信息
List<Map<String, Object>> params=new ArrayList<Map<String,Object>>();
Map<String, Object> param=new HashMap<String, Object>();
param.put("name", "user_name");
// param.put("rela", "=");
// param.put("value", "'小溪'");//註意加上單引號，因為這個變量是字符串的形式
param.put("rela", "like");
param.put("value", "'%小溪%'");//註意加上單引號，因為這個變量是字符串的形式
params.add(param);
param=new HashMap<String, Object>();
param.put("name", "mobile");
param.put("rela", "like");
param.put("value", "'%139%'");
params.add(param);
List<Goddess> list1 = gd.get(params);
//遍歷結果集
for(int i=0;i<list1.size();i++){
System.out.println(list1.get(i).toString());
}
運行結果：
select * from imooc_goddess where 1=1 and user_name like ‘%小溪%’ and mobile like ‘%139%’
Goddess [id=1, userName=小溪, sex=1, age=22, birthday=2000-12-12, [email protected], mobile=13911111111, createUser=ADMIN, createDate=2015-01-08, updateUser=ADMIN, updateDate=2015-01-08, isDel=0]
這個查詢的亮點在於：使用get(List<Map<String,Object>> params) 和 where 1=1；
jdbc傳參數過多的時候：用List<Map<String,Object>> params雙泛型作為參數.
我們查詢的每一個條件都是一個鍵值對。鍵值對的數據結構就是Map。
然後是因為查詢的條件可能是多個，數量不確定，所以用List 比較好，所以就會是List<Map<key,value>>這樣的數據結構瞭。
上面使用where 1=1的原因主要是下面的語句直接就跟著一個and。SQL語句後面需要跟著where，但不確定where後面是否有語句，就要加上1=1，保證語法不會出錯。
一般用於構造動態SQL語句，”SELECT…FROM…WHERE1=1″+動態構造條件子句。
4、搭建控制層
控制層起到一個橋梁的作用，連接模型層和視圖層。
package com.study.controller;
import java.util.List;
import java.util.Map;
import com.study.dao.GoddessDao;
import com.study.model.Goddess;
public class GoddessAction1 {
//添加女神
public void add(Goddess goddess) throws Exception{
GoddessDao dao=new GoddessDao();
goddess.setSex(1);
goddess.setIsDel(0);
dao.addGoddess(goddess);
}
//修改女神
public void edit(Goddess goddess) throws Exception{
GoddessDao dao=new GoddessDao();
dao.updateGoddess(goddess);
}
//刪除女神
public void del(Integer id) throws Exception{
GoddessDao dao=new GoddessDao();
dao.delGoddess(id);
}
//查詢所有女神信息
public List<Goddess> query() throws Exception{
GoddessDao dao=new GoddessDao();
return dao.query();
}
//查詢單個女神信息(根據id)
public Goddess get(Integer id) throws Exception{
GoddessDao dao=new GoddessDao();
return dao.get(id);
}
//查詢單個女神信息（根據姓名等信息）
public List<Goddess> get(List<Map<String, Object>> params) throws Exception{
GoddessDao dao=new GoddessDao();
return dao.get(params);
}
}
5、搭建視圖層
代碼實例：
package com.study.view;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Scanner;
import com.study.controller.GoddessAction1;
import com.study.model.Goddess;
public class View {
//提示語
private static final String CONTEXT="歡迎來到女神禁區：\n" +
"下面是女神禁區的功能列表：\n" +
"[MAIN/M]:主菜單\n" +
"[QUERY/Q]:查看全部女神的信息\n" +
"[GET/G]:查看某位女神的詳細信息\n" +
"[ADD/A]:添加女神信息\n" +
"[UPDATE/U]:更新女神信息\n" +
"[DELETE/D]:刪除女神信息\n" +
"[SEARCH/S]:查詢女神信息(根據姓名、手機號來查詢)\n" +
"[EXIT/E]:退出女神禁區\n" +
"[BREAK/B]:退出當前功能，返回主菜單";
//操作標記
private static final String OPERATION_MAIN="MAIN";
private static final String OPERATION_QUERY="QUERY";
private static final String OPERATION_GET="GET";
private static final String OPERATION_ADD="ADD";
private static final String OPERATION_UPDATE="UPDATE";
private static final String OPERATION_DELETE="DELETE";
private static final String OPERATION_SEARCH="SEARCH";
private static final String OPERATION_EXIT="EXIT";
private static final String OPERATION_BREAK="BREAK";
public static void main(String[] args) {
//輸出提示
System.out.println(CONTEXT);
//怎麼保持程序的一直運行:while(true){}
Scanner scanner=new Scanner(System.in);//接受控制臺的輸入
Goddess goddess=new Goddess();
GoddessAction1 action=new GoddessAction1();
String prenious=null;//標記，記住上一次請求
Integer step=1;//步驟標記
while(scanner.hasNext()){//scanner.hasNext()有數值時才進行循環，沒有就不進行循環
String in=scanner.next().toString();
if(OPERATION_EXIT.equals(in.toUpperCase())
|| OPERATION_EXIT.substring(0, 1).equals(in.toUpperCase())){
System.out.println("您已成功退出女神禁區。");
break;//退出當前while循環
}else if(OPERATION_QUERY.equals(in.toUpperCase())
||OPERATION_QUERY.substring(0, 1).equals(in.toUpperCase())){
try {
List<Goddess> list=action.query();
for (Goddess go : list) {
System.out.println(go.getId()+",姓名："+go.getUserName());
}
} catch (Exception e) {
e.printStackTrace();
}
}else if(OPERATION_ADD.equals(in.toUpperCase())
|| OPERATION_ADD.substring(0, 1).equals(in.toUpperCase())
|| OPERATION_ADD.equals(prenious)){
prenious=OPERATION_ADD;
//新增女神
if(1==step){//如果是第一次進來
System.out.println("請輸入女神的［姓名］");
}else if(2==step){
goddess.setUserName(in);
System.out.println("請輸入女神的［年齡］");
}else if(3==step){
goddess.setAge(Integer.valueOf(in));//string轉換為int型
System.out.println("請輸入女神的［生日］，格式如：yyyy-MM-dd");
}else if(4==step){
SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd");
Date birthday=null;
try {
birthday = sf.parse(in);
goddess.setBirthday(birthday);
System.out.println("請輸入女神的［郵箱］");
} catch (ParseException e) {
e.printStackTrace();
System.out.println("您輸入的格式有誤，請重新輸入");
step=3;
}
}else if(5==step){
goddess.setEmail(in);
System.out.println("請輸入女神的［手機號］");
}else if(6==step){
goddess.setMobile(in);
try {
action.add(goddess);
System.out.println("新增女神成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("新增女神失敗");
}
}
if(OPERATION_ADD.equals(prenious)){
step++;
}
}else{
System.out.println("您輸入的值為："+in);
}
}
}
}
運行結果:
三、JDBC總結
1、JDBC的基本概念：JDBC是連接數據庫的橋梁；
是由Java語言編寫的類和接口組成，可以為多種數據庫提供統一的訪問。
2、采用MVC三層結構:
DB（數據庫）、Model（模型層）、Control（控制層）、View（視圖層）
模型層（DB + DAO）：封裝瞭實現類
控制層：負責調用模型層
視圖層調用控制層
3、JDBC各種連接方式的對比：
1、JDBC + ODBC橋的方式。特點：需要數據庫的ODBC驅動，僅適用於微軟的系統
這種方式，JDBC將調用傳遞給ODBC，然後ODBC再調用本地的數據庫驅動代碼。
2、JDBC + 廠商API的形式。特點：廠商API一般使用C編寫
這種方式，JDBC將調用直接傳遞給廠商API的服務，然後在調用本地的數據庫驅動。
3、JDBC + 廠商Database Connection Server + DataBase的形式。
特點：在JAVA與DATABASE之間架起瞭一臺專門用於數據庫連接的服務器（一般有數據庫廠商提供）
這種方式，JDBC將調用傳遞給中間服務器，中間服務器再將調用轉換成數據庫能夠被調用的形式，在調用數據庫服務器。中間增設數據庫服務器能夠提升效率，但不如直接操作數據庫便捷。
4、JDBC + DATABASE的連接方式。
特點：這使得Application與數據庫分開，開發者隻需關心內部邏輯的實現而不需註重數據庫連接的具體實現。（沒有中間環節，是推薦方式！）
到此這篇關於詳解Java數據庫連接JDBC基礎知識(操作數據庫：增刪改查)的文章就介紹到這瞭,更多相關Java數據庫連接JDBC內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- sqlserver和java將resultSet中的記錄轉換為學生對象
- Java使用通配符實現增強泛型詳解
- Java List的sort()方法改寫compare()實現升序,降序,倒序的案例
- 詳細總結Java for循環的那些坑
- JAVA語法糖原理你知道嗎