下次自动登录
现在的位置:
& 综合 & 正文
java学习笔记——使用JDBC，对数据库进行增删改查(方案二)
工具类BaseDao.java
package com.accp.
import java.sql.C
import java.sql.DriverM
import java.sql.PreparedS
import java.sql.ResultS
import java.sql.ResultSetMetaD
import java.sql.SQLE
import java.util.ArrayL
import java.util.HashM
import java.util.L
import java.util.M
import org.apache.log4j.L
public class BaseDao {
// 使用log4j记录日志
private static Logger logger = Logger.getLogger(BaseDao.class);
// 连接驱动
private static final String DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
// 连接路径
private static final String URL = "jdbc:sqlserver://localhost:1433;databaseName=test";
private static final String USERNAME = "sa";
private static final String PASSWORD = "sa";
//静态代码块
// 加载驱动
Class.forName(DRIVER);
} catch (ClassNotFoundException e) {
e.printStackTrace();
logger.error("加载驱动失败", e);
* 获取数据库连接
public Connection getConnection() {
Connection conn =
logger.debug("开始连接数据库");
//与数据库建立连接
conn=DriverManager.getConnection(URL, USERNAME, PASSWORD);
}catch(SQLException e){
e.printStackTrace();
logger.error("数据库连接失败！",e);
logger.debug("数据库连接成功");
* 关闭数据库连接，注意关闭的顺序
public void close(ResultSet rs, PreparedStatement ps, Connection conn) {
//注意：最后打开的最先关闭
if(rs!=null){
rs.close();
}catch(SQLException e){
e.printStackTrace();
logger.error("关闭ResultSet失败",e);
if(ps!=null){
ps.close();
}catch(SQLException e){
e.printStackTrace();
logger.error("关闭PreparedStatement失败",e);
if(conn!=null){
conn.close();
}catch(SQLException e){
e.printStackTrace();
logger.error("关闭Connection失败",e);
* 查询多个对象的方法
* sql: 要执行的sql语句
* obj：可变参数列表
public List&Map&String,Object&& queryList(String sql,Object... obj){
List&Map&String,Object&& data=new ArrayList&Map&String,Object&&();
Connection conn=getConnection(); //获得连接
PreparedStatement ps=
ResultSet rs=
//创建PreparedStatement对象
ps=conn.prepareStatement(sql);
//为查询语句设置参数
setParameter(ps, obj);
//获得ResultSet结果集
rs=ps.executeQuery();
//获得结果集信息
ResultSetMetaData rsmd=rs.getMetaData();
// 获得列的总数
int columnCount=rsmd.getColumnCount();
Map&String,Object& row=
// 遍历结果集，根据信息封装成Map
while(rs.next()){
row=new HashMap&String, Object&();
for(int i=0;i&columnCi++){
String columnLabel=rsmd.getColumnLabel(i+1);
row.put(columnLabel, rs.getObject(columnLabel));
data.add(row);
}catch(SQLException e){
e.printStackTrace();
logger.error("数据库操作异常",e);
//关闭连接
close(rs,ps,conn);
logger.debug("释放资源成功");
* 查询一个对象的方法
* sql: 要执行的sql语句
* obj：可变参数列表
public Map&String,Object& query(String sql,Object... obj){
Map&String,Object& data=
Connection conn=getConnection(); //获得连接
PreparedStatement ps=
ResultSet rs=
//创建PreparedStatement对象
ps=conn.prepareStatement(sql);
//为查询语句设置参数
setParameter(ps, obj);
//获得ResultSet结果集
rs=ps.executeQuery();
//获得结果集信息
ResultSetMetaData rsmd=rs.getMetaData();
// 获得列的总数
int columnCount=rsmd.getColumnCount();
// 遍历结果集，根据信息封装成Map
while(rs.next()){
data=new HashMap&String, Object&();
for(int i=0;i&columnCi++){
String columnLabel=rsmd.getColumnLabel(i+1);
data.put(columnLabel, rs.getObject(columnLabel));
}catch(SQLException e){
e.printStackTrace();
logger.error("数据库操作异常",e);
//关闭连接
close(rs,ps,conn);
logger.debug("释放资源成功");
* 增加、修改、删除,的方法
* obj: 可变参数列表
public int update(String sql,Object...obj ){
Connection conn=getConnection(); //获得连接
PreparedStatement ps=
int rows=0;
//创建PreparedStatement对象
ps=conn.prepareStatement(sql);
//为查询语句设置参数
setParameter(ps, obj);
//获得受影响的行数
rows=ps.executeUpdate();
}catch(SQLException e){
e.printStackTrace();
logger.error("数据库操作异常",e);
//关闭连接
close(null,ps,conn);
logger.debug("释放资源成功");
* 为预编译对象设置参数
public void setParameter(PreparedStatement ps,Object... obj)
throws SQLException {
if(obj!=null && obj.length&0){
//循环设置参数
for (int i = 0; i & obj. i++) {
ps.setObject(i+1, obj[i]);
操作类，进行增删改查 UserDao.java
package com.accp.
import java.sql.C
import java.sql.PreparedS
import java.sql.ResultS
import java.sql.ResultSetMetaD
import java.sql.SQLE
import java.sql.S
import java.util.L
import java.util.M
import com.accp.entity.U
public class UserDao extends BaseDao {
public static void main(String[] args) {
UserDao user=new UserDao();
//查询id&20的数据
user.queryUser();
//查询单条数据
user.queryUserById(10);
//更新数据
User u=new User();
u.setId(2);
u.setName("张龙");
u.setAge(22);
System.out.println("更新"+user.updateUser(u)+"条数据");
//删除数据
System.out.println("删除"+user.deleteUser(15)+"条数据");
//插入数据
User u1=new User();
u1.setName("张三");
u1.setAge(18);
user.insertUser(u1);
//查询多条信息
public void queryUser(){
List&Map&String,Object&& dataUser=queryList("select * from users where id&20");
//遍历结果集
for(Map&String,Object& u:dataUser){
System.out.println(u);
//查询单条数据
public void queryUserById(int id){
System.out.println(query("select * from users where id=?",id));
//更新数据
public int updateUser(User user){
String sql="update users set name=?,age=? where id=?";
return update(sql, user.getName(),user.getAge(),user.getId());
//删除数据
public int deleteUser(int id){
String sql="delete from users where id=?";
return update(sql,id);
//插入数据，并返回自动增长的的主键值
public void insertUser(User user){
Connection conn=getConnection(); //获得连接
PreparedStatement ps=
ResultSet rs=
String sql="insert into users values(?,?)";
// 创建能返回自动生成的主键的值的预编译对象
ps=conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
ps.setString(1,user.getName());
ps.setInt(2, user.getAge());
int rows=ps.executeUpdate();
// 获得自动增长的的主键值
rs=ps.getGeneratedKeys();
rs.next();
int id=rs.getInt(1);
System.out.println("成功添加："+rows+"条数据，id是："+id);
}catch(SQLException e){
e.printStackTrace();
close(rs,ps,conn);
插入测试数据 InsertTest.java
package com.accp.
import java.sql.C
import java.sql.PreparedS
import java.sql.SQLE
public class InsertTest extends BaseDao
public static void main(String[] args) {
InsertTest user=new InsertTest();
user.insertUser();
public void insertUser() {
String sql = "insert into users values(?,?)";
Connection conn = getConnection();
PreparedStatement ps =
// 禁止自动提交事务
conn.setAutoCommit(false);
// 创建能返回自动生成的主键的值的预编译对象
ps = conn.prepareStatement(sql);
//开始时间的毫秒数
Long start=System.currentTimeMillis();
for (int i = 0; i & 10000; i++) {
ps.setString(1, i+"");
ps.setInt(2, 22);
ps.addBatch();// 添加到批处理命令中
ps.executeBatch();// 执行批处理
conn.commit();// 提交事务
//结束时间的毫秒数
Long stop=System.currentTimeMillis();
//得到总耗时
Long ms=stop-
System.out.println("插入一万记录耗时："+ms+"毫秒");
} catch (SQLException e) {
e.printStackTrace();
//取消事务
conn.rollback();
}catch(SQLException ee){
ee.printStackTrace();
} finally {
//打开自动提交事务
conn.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
close(null, ps, conn);
【上篇】【下篇】正文 Java通过JDBC进行简单的增删改查MySQL数据库
Java通过JDBC进行简单的增删改查MySQL数据库
发布时间： & 编辑：www.jquerycn.cn
jquery中文网为您提供Java通过JDBC进行简单的增删改查MySQL数据库等资源，欢迎您收藏本站，我们将为您提供最新的Java通过JDBC进行简单的增删改查MySQL数据库资源
JDBC基本操作
下面的所有方法和数据成员都在public class JDBCOperation内部。
(1)定义记录的类（可选）
这样做主要是为了便于操作和接口定义，是非必须的。
static class Student {
&&&&&&& private String Id;
&&&&&&& private String N
&&&&&&& private String S
&&&&&&& private String A
&&&&&&& Student(String Name, String Sex, String Age) {
&&&&&&&&&&& this.Id = //default
&&&&&&&&&&& this.Name = N
&&&&&&&&&&& this.Sex = S
&&&&&&&&&&& this.Age = A
&&&&&&& public String getId() {
&&&&&&&&&&& return Id;
&&&&&&& public void setId(String Id) {
&&&&&&&&&&& this.Id = Id;
&&&&&&& public String getName() {
&&&&&&&&&&& return N
&&&&&&& public void setName(String Name) {
&&&&&&&&&&& this.Name = N
&&&&&&& public String getSex() {
&&&&&&&&&&& return S
&&&&&&& public void setSex(String Sex) {
&&&&&&&&&&& this.Sex = S
&&&&&&& public String getAge() {
&&&&&&&&&&& return A
&&&&&&& public void setage(String Age) {
&&&&&&&&&&& this.Age = A
(2)连接的获取
在操作前必须先获取与数据库的连接。
private static Connection getConn() {
&&& String driver = &com.mysql.jdbc.Driver&;
&&& String url = &jdbc:mysql://localhost:3306/samp_db&;
&&& String username = &root&;
&&& String password = &&;
&&& Connection conn =
&&&&&&& Class.forName(driver); //classLoader,加载对应驱动
&&&&&&& conn = (Connection) DriverManager.getConnection(url, username, password);
&&& } catch (ClassNotFoundException e) {
&&&&&&& e.printStackTrace();
&&& } catch (SQLException e) {
&&&&&&& e.printStackTrace();
private static int insert(Student student) {
&&& Connection conn = getConn();
&&& int i = 0;
&&& String sql = &insert into students (Name,Sex,Age) values(?,?,?)&;
&&& PreparedS
&&&&&&& pstmt = (PreparedStatement) conn.prepareStatement(sql);
&&&&&&& pstmt.setString(1, student.getName());
&&&&&&& pstmt.setString(2, student.getSex());
&&&&&&& pstmt.setString(3, student.getAge());
&&&&&&& i = pstmt.executeUpdate();
&&&&&&& pstmt.close();
&&&&&&& conn.close();
&&& } catch (SQLException e) {
&&&&&&& e.printStackTrace();
private static int update(Student student) {
&&& Connection conn = getConn();
&&& int i = 0;
&&& String sql = &update students set Age='&
student.getAge()
&' where Name='&
student.getName()
&&& PreparedS
&&&&&&& pstmt = (PreparedStatement) conn.prepareStatement(sql);
&&&&&&& i = pstmt.executeUpdate();
&&&&&&& System.out.println(&resutl: &
&&&&&&& pstmt.close();
&&&&&&& conn.close();
&&& } catch (SQLException e) {
&&&&&&& e.printStackTrace();
以select * from XXX为例。
private static Integer getAll() {
&&& Connection conn = getConn();
&&& String sql = &select * from students&;
&&& PreparedS
&&&&&&& pstmt = (PreparedStatement)conn.prepareStatement(sql);
&&&&&&& ResultSet rs = pstmt.executeQuery();
&&&&&&& int col = rs.getMetaData().getColumnCount();
&&&&&&& System.out.println(&============================&);
&&&&&&& while (rs.next()) {
&&&&&&&&&&& for (int i = 1; i &= i
&&&&&&&&&&&&&&& System.out.print(rs.getString(i)
&&&&&&&&&&&&&&& if ((i == 2) && (rs.getString(i).length() & 8)) {
&&&&&&&&&&&&&&&&&&& System.out.print(&\t&);
&&&&&&&&&&&&&&& }
&&&&&&&&&&&& }
&&&&&&&&&&& System.out.println(&&);
&&&&&&&&&&& System.out.println(&============================&);
&&& } catch (SQLException e) {
&&&&&&& e.printStackTrace();
private static int delete(String name) {
&&& Connection conn = getConn();
&&& int i = 0;
&&& String sql = &delete from students where Name='&
&&& PreparedS
&&&&&&& pstmt = (PreparedStatement) conn.prepareStatement(sql);
&&&&&&& i = pstmt.executeUpdate();
&&&&&&& System.out.println(&resutl: &
&&&&&&& pstmt.close();
&&&&&&& conn.close();
&&& } catch (SQLException e) {
&&&&&&& e.printStackTrace();
在测试前，需要在系统中打开对应数据库的服务。MySQL在Windows下的启动命令为
net start mysql
public static void main(String args[]) {
&&& JDBCOperation.getAll();
&&& JDBCOperation.insert(new Student(&Achilles&, &Male&, &14&));
&&& JDBCOperation.getAll();
&&& JDBCOperation.update(new Student(&Bean&, &&, &7&));
&&& JDBCOperation.delete(&Achilles&);
&&& JDBCOperation.getAll();
Eclipse中的输出
============================
1&&& Ender&&&&&&& male&&& 8&&&
2&&& Bean&&&&&&& male&&& 6&&&
3&&& Petra&&&&&&& fema&&& 9&&&
4&&& Peter&&&&&&& male&&& 9&&&
5&&& _Graff&&&&&&& male&&& 40&&&
6&&& GOD&&&&&&& fema&&& 255&&&
============================
============================
1&&& Ender&&&&&&& male&&& 8&&&
2&&& Bean&&&&&&& male&&& 6&&&
3&&& Petra&&&&&&& fema&&& 9&&&
4&&& Peter&&&&&&& male&&& 9&&&
5&&& _Graff&&&&&&& male&&& 40&&&
6&&& GOD&&&&&&& fema&&& 255&&&
7&&& Achilles&&& Male&&& 14&&&
============================
============================
1&&& Ender&&&&&&& male&&& 8&&&
2&&& Bean&&&&&&& male&&& 7&&&
3&&& Petra&&&&&&& fema&&& 9&&&
4&&& Peter&&&&&&& male&&& 9&&&
5&&& _Graff&&&&&&& male&&& 40&&&
6&&& GOD&&&&&&& fema&&& 255&&&
============================
在上述对数据库进行增删改查的过程中，可以发现其共性部分，即通用的流程：
(1)创建Connection对象、SQL查询命令字符串；
(2)对Connection对象传入SQL查询命令，获得PreparedStatement对象；
(3)对PreparedStatement对象执行executeUpdate()或executeQurey()获得结果；
(4)先后关闭PreparedStatement对象和Connection对象。
可见，使用JDBC时，最常打交道的是Connection、PreparedStatement这两个类，以及select中的ResultSet类。查阅Java API手册可以了解其具体的意义和方法。
下面引用的Java API的资料出自
http://download.oracle.com/technetwork/java/javase/6/docs/zh/api/index.html。
Connection
接口 Connection
所有超级接口：
与特定数据库的连接（会话）。在连接上下文中执行 SQL 语句并返回结果。
Connection 对象的数据库能够提供描述其表、所支持的 SQL 语法、存储过程、此连接功能等等的信息。此信息是使用 getMetaData 方法获得的。
PreparedStatemnt
接口 PreparedStatement
所有超级接口：
Statement, Wrapper
所有已知子接口：
CallableStatement
表示预编译的 SQL 语句的对象。
SQL 语句被预编译并存储在 PreparedStatement 对象中。然后可以使用此对象多次高效地执行该语句。
boolean& execute()
在此 PreparedStatement 对象中执行 SQL 语句，该语句可以是任何种类的 SQL 语句。
ResultSet& executeQuery()
在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
int& executeUpdate()
在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
接口 ResultSet
所有超级接口：
所有已知子接口：
CachedRowSet, FilteredRowSet, JdbcRowSet, JoinRowSet, RowSet, SyncResolver, WebRowSet
表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
1.每次SQL操作都需要建立和关闭连接，这势必会消耗大量的资源开销，如何避免？
分析：可以采用连接池，对连接进行统一维护，不必每次都建立和关闭。事实上这是很多对JDBC进行封装的工具所采用的。
2.Java代码中，传入的数据格式与数据库定义不同怎么办？如把Java的String对象赋值给数据库的tinyint属性。
分析：在执行SQL语句时，数据库会尝试进行转换。根据我的实验，如果用内容为纯字母的String对象传入tinyint的age属性时，会被转化成0。具体转化规则应该和数据库有关。您可能感兴趣的文章：一、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
1 package com.study.
3 import java.sql.C
4 import java.sql.DriverM
5 import java.sql.ResultS
6 import java.sql.S
8 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.ResultS
while(rs.next()){//如果对象中有数据，就会循环打印出来
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
2、搭建模型层
采用MVC三层架构：建议由下往上开发（DB-&view,需求读懂以后，设计数据库，然后根据数据库映射模型，再写控制层，再写视图层）
View视图层&&展示数据，反馈用户行为
&Control控制层&&控制数据流通过程，协调视图层和数据层
&Model模型层&&与数据库建立映射，与数据进行交互
（DB数据库）
先新增对应的model层：按照数据库表对应的字段编写实体类。
1 package com.study.
3 import java.util.D
5 public class Goddess {
private String userN
private String createU
private Date createD
private String updateU
private Date updateD
private Integer isD
public Integer getId() {
public void setId(Integer id) {
public String getUserName() {
return userN
public void setUserName(String userName) {
this.userName = userN
public Integer getSex() {
public void setSex(Integer sex) {
this.sex =
public Integer getAge() {
public void setAge(Integer age) {
this.age =
public Date getBirthday() {
public void setBirthday(Date birthday) {
this.birthday =
public String getEmail() {
public void setEmail(String email) {
this.email =
public String getMobile() {
public void setMobile(String mobile) {
this.mobile =
public String getCreateUser() {
return createU
public void setCreateUser(String createUser) {
this.createUser = createU
public Date getCreateDate() {
return createD
public void setCreateDate(Date createDate) {
this.createDate = createD
public String getUpdateUser() {
return updateU
public void setUpdateUser(String updateUser) {
this.updateUser = updateU
public Date getUpdateDate() {
return updateD
public void setUpdateDate(Date updateDate) {
this.updateDate = updateD
public Integer getIsDel() {
return isD
public void setIsDel(Integer isDel) {
this.isDel = isD
然后开始新增Dao层，并修改DBUtil.java
DBUtil.java代码如下：
1 package com.study.
3 import java.sql.C
4 import java.sql.DriverM
5 import java.sql.ResultS
6 import java.sql.SQLE
7 import java.sql.S
9 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;
//静态代码块（将加载驱动、连接数据库放入静态块中）
//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(){
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.ResultS
while(rs.next()){//如果对象中有数据，就会循环打印出来
System.out.println(rs.getString("user_name")+","+rs.getInt("age"));
goddessDao.java 代码如下：
1 package com.study.
3 import java.sql.C
4 import java.sql.ResultS
5 import java.sql.SQLE
6 import java.sql.S
7 import java.util.ArrayL
8 import java.util.L
10 import com.study.db.DBU
11 import com.study.model.G
13 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);
//查询单个女神
public Goddess get(){
return null;
新增Controller层：GoddessAction.java
1 package com.study.
3 import java.util.L
5 import com.study.dao.GoddessD
6 import com.study.model.G
8 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操作：
1 //添加女神
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.
import java.util.D
import java.util.L
import com.study.dao.GoddessD
import com.study.model.G
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("");
g1.setMobile("");
g1.setCreateUser("admin");
g1.setUpdateUser("admin");
g1.setIsDel(1);
//添加女神
gd.addGoddess(g1);
修改、删除、查询(根据id)操作：
1 //更新女神
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();
26 //删除女神
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();
40 //查询单个女神(根据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"));
&查询（根据name\mobile等）操作
1 //查询单个女神(根据姓名等信息去查询)
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);//将结果封装到对象中
1 package com.study.
3 import java.util.D
4 import java.util.L
6 import com.study.dao.GoddessD
7 import com.study.model.G
9 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("");
g1.setMobile("");
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=, email=, mobile=, createUser=ADMIN, createDate=, updateUser=ADMIN, updateDate=, isDel=0]
&查询操作的进一步完善：
1 //查询单个女神(根据姓名等信息去查询)-----&使用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);//将结果封装到对象中
1 //查询单个女神(根据姓名等信息去查询)-----&使用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=, email=, mobile=, createUser=ADMIN, createDate=, updateUser=ADMIN, updateDate=, 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&...&WHERE&1=1&"+动态构造条件子句。
4、搭建控制层
控制层起到一个桥梁的作用，连接模型层和视图层。
1 package com.study.
3 import java.util.L
4 import java.util.M
6 import com.study.dao.GoddessD
7 import com.study.model.G
9 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、搭建视图层
代码实例：
1 package com.study.
3 import java.text.ParseE
4 import java.text.SimpleDateF
5 import java.util.D
6 import java.util.L
7 import java.util.S
9 import com.study.controller.GoddessAction1;
10 import com.study.model.G
12 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())){
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;
birthday = sf.parse(in);
goddess.setBirthday(birthday);
System.out.println("请输入女神的［邮箱］");
} catch (ParseException e) {
e.printStackTrace();
System.out.println("您输入的格式有误，请重新输入");
}else if(5==step){
goddess.setEmail(in);
System.out.println("请输入女神的［手机号］");
}else if(6==step){
goddess.setMobile(in);
action.add(goddess);
System.out.println("新增女神成功");
} catch (Exception e) {
e.printStackTrace();
System.out.println("新增女神失败");
if(OPERATION_ADD.equals(prenious)){
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与数据库分开，开发者只需关心内部逻辑的实现而不需注重数据库连接的具体实现。（没有中间环节，是推荐方式！）
阅读(...) 评论()