Java连接 JDBC基础知识（操作数据库：增删改查）-eolink官网

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、打通数据库

然后新建相应的数据库和表。

编写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 query() throws Exception{

Connection con=DBUtil.getConnection();

Statement stmt=con.createStatement();

ResultSet rs=stmt.executeQuery("select user_name,age from imooc_goddess");

List gs=new ArrayList();

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 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.exehttp://cute();

/**

* 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("xiaoxia@qq.com");

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 get(String name,String mobile) throws SQLException{

List result=new ArrayList();

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 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("xiaoxia@qq.com");

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 list = gd.get("小溪", "139");

//遍历结果集

for(int i=0;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=xiaoxi@163.com, mobile=13911111111, createUser=ADMIN, createDate=2015-01-08, updateUser=ADMIN, updateDate=2015-01-08, isDel=0]

查询操作的进一步完善：

//查询单个女神(根据姓名等信息去查询)----->使用Map存储条件信息；防止条件为空可加一条where 1=1

public List get(List> params) throws SQLException{

List result=new ArrayList();

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

Map 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> params=new ArrayList>();

Map param=new HashMap();

param.put("name", "user_name");

// param.put("rela", "=");

// param.put("value", "'小溪'");//注意加上单引号，因为这个变量是字符串的形式

param.put("rela", "like");

param.put("value", "'%小溪%'");//注意加上单引号，因为这个变量是字符串的形式

params.add(param);

param=new HashMap();

param.put("name", "mobile");

param.put("rela", "like");

param.put("value", "'%139%'");

params.add(param);

List list1 = gd.get(params);

//遍历结果集

for(int i=0;i

System.out.println(list1.get(i).toString());

}

运行结果：

select * from imooc_goddess where 1=1 and user_name like '%小溪%' and mobile like '%139%'

这个查询的亮点在于：使用get(List> params) 和 where 1=1；

jdbc传参数过多的时候：用List> params双泛型作为参数.

我们查询的每一个条件都是一个键值对。键值对的数据结构就是Map。

然后是因为查询的条件可能是多个，数量不确定，所以用List 比较好，所以就会是List>这样的数据结构了。

上面使用where 1=1的原因主要是下面的语句直接就跟着一个and。SQL语句后面需要跟着where，但不确定where后面是否有语句，就要加上1=1，保证语法不会出错。

一般用于构造动态SQL语句，"SELECT ... FROM ... WHERE 1=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 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 get(List> 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 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与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！）

System.out.println(list.get(i).toString());

}

运行结果：

select * from imooc_goddess where user_name like ? and mobile like ?

查询操作的进一步完善：

//查询单个女神(根据姓名等信息去查询)----->使用Map存储条件信息；防止条件为空可加一条where 1=1

public List get(List> params) throws SQLException{

List result=new ArrayList();

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

Map 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> params=new ArrayList>();

Map param=new HashMap();

param.put("name", "user_name");

// param.put("rela", "=");

// param.put("value", "'小溪'");//注意加上单引号，因为这个变量是字符串的形式

param.put("rela", "like");

param.put("value", "'%小溪%'");//注意加上单引号，因为这个变量是字符串的形式

params.add(param);

param=new HashMap();

param.put("name", "mobile");

param.put("rela", "like");

param.put("value", "'%139%'");

params.add(param);

List list1 = gd.get(params);

//遍历结果集

for(int i=0;i

System.out.println(list1.get(i).toString());

}

运行结果：

select * from imooc_goddess where 1=1 and user_name like '%小溪%' and mobile like '%139%'

这个查询的亮点在于：使用get(List> params) 和 where 1=1；

jdbc传参数过多的时候：用List> params双泛型作为参数.

我们查询的每一个条件都是一个键值对。键值对的数据结构就是Map。

然后是因为查询的条件可能是多个，数量不确定，所以用List 比较好，所以就会是List>这样的数据结构了。

一般用于构造动态SQL语句，"SELECT ... FROM ... WHERE 1=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 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 get(List> 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 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之间架起了一台专门用于数据库连接的服务器（一般有数据库厂商提供）

4、JDBC + DATABASE的连接方式。

特点：这使得Application与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！）

Map 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> params=new ArrayList>();

Map param=new HashMap();

param.put("name", "user_name");

// param.put("rela", "=");

// param.put("value", "'小溪'");//注意加上单引号，因为这个变量是字符串的形式

param.put("rela", "like");

param.put("value", "'%小溪%'");//注意加上单引号，因为这个变量是字符串的形式

params.add(param);

param=new HashMap();

param.put("name", "mobile");

param.put("rela", "like");

param.put("value", "'%139%'");

params.add(param);

List list1 = gd.get(params);

//遍历结果集

for(int i=0;i

System.out.println(list1.get(i).toString());

}

运行结果：

select * from imooc_goddess where 1=1 and user_name like '%小溪%' and mobile like '%139%'

这个查询的亮点在于：使用get(List> params) 和 where 1=1；

jdbc传参数过多的时候：用List> params双泛型作为参数.

我们查询的每一个条件都是一个键值对。键值对的数据结构就是Map。

然后是因为查询的条件可能是多个，数量不确定，所以用List 比较好，所以就会是List>这样的数据结构了。

一般用于构造动态SQL语句，"SELECT ... FROM ... WHERE 1=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 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 get(List> 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 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之间架起了一台专门用于数据库连接的服务器（一般有数据库厂商提供）

4、JDBC + DATABASE的连接方式。

特点：这使得Application与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！）

System.out.println(list1.get(i).toString());

}

运行结果：

select * from imooc_goddess where 1=1 and user_name like '%小溪%' and mobile like '%139%'

这个查询的亮点在于：使用get(List> params) 和 where 1=1；

jdbc传参数过多的时候：用List> params双泛型作为参数.

我们查询的每一个条件都是一个键值对。键值对的数据结构就是Map。

然后是因为查询的条件可能是多个，数量不确定，所以用List 比较好，所以就会是List>这样的数据结构了。

一般用于构造动态SQL语句，"SELECT ... FROM ... WHERE 1=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 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 get(List> 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 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之间架起了一台专门用于数据库连接的服务器（一般有数据库厂商提供）

4、JDBC + DATABASE的连接方式。

特点：这使得Application与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！）

Flask接口签名sign原理与实例代码浅析

336 2022-10-30

Java连接 JDBC基础知识（操作数据库：增删改查）

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

java中的接口是类吗

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！