1. JDBC
1.1. 日期字段
日期字段插入的两种方式
---数据库的表 情况 1 createTime 该条记录的插入时间
create table t_user1(
t_id int auto_increment primary key,
t_userName varchar(30),
t_pwd varchar(30),
createTime varchar(30)
)engine=InnoDB;
---数据库的表 情况2 createTime 该条记录的插入时间 年-月-日
create table t_user2(
t_id int auto_increment primary key,
t_userName varchar(30),
t_pwd varchar(30),
createTime date
)engine=InnoDB;
---数据库的表 情况3 createTime 该条记录的插入时间 年-月-日 时：分：秒
create table t_user3(
t_id int auto_increment primary key,
t_userName varchar(30),
t_pwd varchar(30),
createTime dateTime
)engine=InnoDB;
---数据库的表 情况4 createTime 该条记录的插入时间 年-月-日 时：分：秒,要求时间实时
create table t_user4(
t_id int auto_increment primary key,
t_userName varchar(30),
t_pwd varchar(30),
createTime dateTime
)engine=InnoDB;
（1） 数据库表中createTime varchar(30),当前代码中如何插入，如何取出
String sql="insert into t_user1(t_userName,t_pwd,createTime) values(?,?,?)";
pst=conn.prepareStatement(sql);
pst.setString(1, userName);
pst.setString(2, pwd);
pst.setString(3, createTime);
while(rs.next()){
System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"+rs.getString("createTime"));
}
（2） 数据库表中createTime date
String sql="insert into t_user2(t_userName,t_pwd,createTime) values(?,?,?)";
pst=conn.prepareStatement(sql);
pst.setString(1, userName);
pst.setString(2, pwd);
//设置占位符 getTime()获取的java.util.Date对象的毫秒数
pst.setTimestamp(3, new Timestamp(createTime.getTime()));
//pst.setObject(3, createTime);
while(rs.next()){
System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getDate("createTime"));
/*System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getObject("createTime"));*/
}
（3） 数据库表中createTime dateTime
String sql="insert into t_user3(t_userName,t_pwd,createTime) values(?,?,?)";
pst=conn.prepareStatement(sql);
pst.setString(1, userName);
pst.setString(2, pwd);
//设置占位符 getTime()获取的java.util.Date对象的毫秒数
pst.setTimestamp(3, new Timestamp(createTime.getTime()));
//pst.setObject(3, createTime);
while(rs.next()){
System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getTimestamp("createTime"));
/*System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getObject("createTime"));*/
}
（4） 数据库表中createTime dateTime,但是要求时间是实时的
String sql="insert into t_user4(t_userName,t_pwd,createTime) values(?,?,now())";
pst=conn.prepareStatement(sql);
pst.setString(1, userName);
pst.setString(2, pwd);
while(rs.next()){
System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getTimestamp("createTime"));
/*System.out.println(rs.getInt("t_id")+"\t" +rs.getString("t_userName")+"\t"+rs.getString("t_pwd")+"\t"
+rs.getObject("createTime"));*/
}
1.2. DAO设计模式
DAO模式是一种分层思想。
1.3. DAO层
DAO(Data Access Object) 数据访问对象
面向对象的思想，对表的增删改查行为，放到一个类中。
dao包里的接口（XXXDao）以及实现类(XXXDaoImpl)主要负责和数据操作相关的事情。
t_user表->UserDao.java->针对t_user表做CRUD
t_student表->StudentDao.java->针对t_student表做CRUD
如何统一管理所有的Dao.java文件？
新建项目包com.njwangbo
在包com.njwangbo中新建一个包dao
把所有的xxxxDao.java文件放到包com.njwangbo.dao中
举例：
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import com.mysql.jdbc.Connection;
import com.njwb.entity.User;
/**
* 新增用户
* public void addUser(User u);
* 根据用户编号，修改用户信息（用户名，密码）
* public void updateUser(User u);
* 根据用户编号，删除用户信息
* public void delUser(int id);
* 查询所有用户
* 根据指定的用户名，密码，查询单个 用户 ,如果找到单个用户，返回该用户对象
* public User queryByCondition(User u);
* @author Administrator
*
*/
public class UserDao {
/**
* 新增用户
* @param u
*/
public void addUser(User u){
Connection conn=null;
PreparedStatement pst=null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn=(Connection) DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/njwangbo1", "root", "root");
String sql="insert into t_user3(t_userName,t_pwd,createTime) values(?,?,?)";
pst=conn.prepareStatement(sql);
pst.setString(1, u.getUserName());
pst.setString(2, u.getPwd());
//设置占位符
pst.setObject(3, u.getCreateTime());
int count=pst.executeUpdate();
if(count>0){
System.out.println("新增成功");
}else{
System.out.println("新增失败");
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
finally{
//关闭资源
}
}
/**
* 查询所有用户
* @param u
*/
public List<User> queryAll(){
//新建集合对象
List<User> list = new ArrayList<User>();
Connection conn=null;
PreparedStatement pst=null;
ResultSet rs = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn=(Connection) DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/njwangbo1", "root", "root");
String sql="select * from t_user3";
pst=conn.prepareStatement(sql);
rs = pst.executeQuery();
while(rs.next()){
//一条记录，对应的是一个User对象
User u = new User();
//把查询到一行数据封装成1个User对象，将该User对象添加到集合list中
u.setId(rs.getInt("t_id"));
u.setUserName(rs.getString("t_userName"));
u.setPwd(rs.getString("t_pwd"));
u.setCreateTime(rs.getTimestamp("createTime"));
//u.setCreateTime((java.util.Date)rs.getObject("createTime"));
list.add(u);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
finally{
//关闭资源
}
return list;
}
}
1.4. entity实体类
没有业务逻辑。实体类是用于对必须存储的信息和相关行为建模的类。
如：
Person.java Book.java Goods.java User.java
如何统一管理所有的实体类？
在包com.njwangbo中新建一个包entity
把所有的实体类放到包com.njwangbo.entity中
名词解释POJO
POJO（Plain Ordinary Java Object）简单的Java对象，POJO可以理解为不含业务逻辑的简单的JAVA对象。
1.5. 使用继承提取公共代码到BaseDao
在dao包中新建BaseDao.java，保存dao层中的公共代码（通用字符串，加载驱动，获取连接，关闭资源），UserDao继承BaseDao
package com.njwb.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 抽取共有的代码到父类里
* com.mysql.jdbc.Driver
* jdbc:mysql://127.0.0.1:3306/njwangbo1 root root
*
* 加载驱动 放到静态代码块，只需要执行一次 （加载一次）
* 获取连接对象 Connection 对象
* @author Administrator
*
*/
public class BaseDao {
private static final String CLASS_NAME="com.mysql.jdbc.Driver";
private final String URL = "jdbc:mysql://127.0.0.1:3306/njwangbo1";
private final String USERNAME = "root";
private final String PWD = "root";
//加载驱动
static{
try {
Class.forName(CLASS_NAME);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 该方法用于获取连接对象 ，并将连接对象返回 ，修饰符用protected修饰，不管子类在不在同一个包下，都可以访问
* @return
*/
protected Connection getConnection(){
Connection conn = null;
try {
conn = DriverManager.getConnection(URL, USERNAME, PWD);
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
/**
* 关闭资源
* @param rs
* @param ps
* @param conn
*/
protected void close(ResultSet rs,PreparedStatement ps,Connection conn){
if(null!=rs){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(null!=ps){
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(null!=conn){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
package com.njwb.dao;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.njwb.entity.User;
/**
* 封装BaseDao,抽取共有的代码，将剩余3个方法补齐 ,新的子类UserDao2 继承的BaseDao
* 新增用户
* public int addUser(User u);
* 根据用户编号，修改用户信息（用户名，密码）
* public int updateUser(User u);
* 根据用户编号，删除用户信息
* public int delUser(int id);
* 查询所有用户
* public List<User> queryAll();
* 根据指定的用户名，密码，查询单个 用户 ,如果找到单个用户，返回该用户对象
* public User queryByCondition(User u);
* @author Administrator
*
*/
public class UserDao2 extends BaseDao {
/**
* 新增用户
* @param u
*/
public int addUser(User u){
int count = 0;
//1.加载驱动 父类里已经加载了
//2.获取连接对象
Connection conn = super.getConnection();
//3.准备sql语句，获取sql执行器对象
String sql = "insert into t_user3(t_userName,t_pwd,createTime) values(?,?,now())";
PreparedStatement ps=null;
try {
ps = conn.prepareStatement(sql);
//4.设置占位符
ps.setString(1, u.getUserName());
ps.setString(2, u.getPwd());
//5.执行，并返回处理结果
count = ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
super.close(null, ps, conn);
}
return count;
}
/**
* 根据用户编号，更新用户信息
* @param u
*/
public int updateUser(User u){
int count = 0;
//1.加载驱动 父类里已经加载了
//2.获取连接对象
Connection conn = super.getConnection();
//3.准备sql语句，获取sql执行器对象
String sql = "update t_user3 set t_userName=?,t_pwd=? where t_id=?";
PreparedStatement ps=null;
try {
ps = conn.prepareStatement(sql);
//4.设置占位符
ps.setString(1, u.getUserName());
ps.setString(2, u.getPwd());
ps.setInt(3, u.getId());
//5.执行，并返回处理结果
count = ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
super.close(null, ps, conn);
}
return count;
}
/**
* 根据用户编号，删除用户信息
* @param id
*/
public int delUser(int id){
int count = 0;
//1.加载驱动 父类里已经加载了
//2.获取连接对象
Connection conn = super.getConnection();
//3.准备sql语句，获取sql执行器对象
String sql = "delete from t_user3 where t_id=?";
PreparedStatement ps=null;
try {
ps = conn.prepareStatement(sql);
//4.设置占位符
ps.setInt(1, id);
//5.执行，并返回处理结果
count = ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
super.close(null, ps, conn);
}
return count;
}
/**
* 查询所有
* @return
*/
public List<User> queryAll(){
List<User> list = new ArrayList<User>();
//1.加载驱动 （父类已经加载了）
//2.获取连接
Connection conn = super.getConnection();
//3.准备sql语句，获取sql执行器对象ps
String sql = "select * from t_user3";
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
//4.设置占位符
//5.执行，并返回处理结果
rs = ps.executeQuery();
while(rs.next()){
//一行数据，映射成1个User对象，将该User对象添加到List中
User u = new User();
u.setUserName(rs.getString("t_userName"));
u.setPwd(rs.getString("t_pwd"));
u.setId(rs.getInt("t_id"));
//u.setCreateTime(rs.getTimestamp("createTime"));
u.setCreateTime((java.util.Date)rs.getObject("createTime"));
//添加
list.add(u);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
super.close(rs, ps, conn);
}
return list;
}
/**
* 查询单个用户
* @param u
* @return
*/
public User queryByCondition(User u){
User user = null;
//1.加载驱动 （父类已经加载了）
//2.获取连接
Connection conn = super.getConnection();
//3.准备sql语句，获取sql执行器对象ps
String sql = "select * from t_user3 where t_userName=? and t_pwd = ?";
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
//4.设置占位符
ps.setString(1, u.getUserName());
ps.setString(2, u.getPwd());
//5.执行，并返回处理结果
rs = ps.executeQuery();
if(rs.next()){
//一行数据，映射成1个User对象，将该User对象添加到List中
user = new User();
user.setUserName(rs.getString("t_userName"));
user.setPwd(rs.getString("t_pwd"));
user.setId(rs.getInt("t_id"));
user.setCreateTime((java.util.Date)rs.getObject("createTime"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
super.close(rs, ps, conn);
}
return user;
}
}
测试类
package com.njwb.test;
import java.util.List;
import com.njwb.dao.UserDao2;
import com.njwb.entity.User;
/**
* 测试UserDao2
* @author Administrator
*
*/
public class TestUserDao02 {
public static void main(String[] args) {
UserDao2 ud = new UserDao2();
User u = new User();
u.setUserName("kiki");
u.setPwd("123123");
//执行新增的方法
//int count = ud.addUser(u);
//System.out.println(count>0?"新增成功":"新增失败");
//查询所有用户
/*List<User> list = ud.queryAll();
//遍历集合
for(User ui:list){
System.out.println(ui);
}*/
//测试更新用户信息
/*User u2 = new User();
u2.setUserName("hehe");
u2.setId(3);
u2.setPwd("112afa");
int count2 = ud.updateUser(u2);
System.out.println(count2>0?"修改成功":"修改失败");*/
//测试删除用户信息
/*int count3 = ud.delUser(3);
System.out.println(count3>0?"删除成功":"删除失败");*/
//测试查询单个用户
User u3 = new User();
u3.setUserName("jack1");
u3.setPwd("111111");
User u4 = ud.queryByCondition(u3);
if(u4!=null){
System.out.println("找到了："+u4);
}else{
System.out.println("查无此人");
}
}
}
1.6. 把增删改查提取到父类中
为什么要把增删改查提取到父类？
所有对表的操作都继承父类，每个对表操作的子类可以直接调用父类的方法，不用自己实现增删改查。父类里添加 增删改方法，查询方法。
package com.njwb.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* 共有的字符串 4个
* 加载驱动
* 获取连接对象 protected Connection getConnection()--->设置连接对象 private void setConnection();
* 关闭资源 protected void close(ResultSet rs,PreparedStatement ps,Connection conn);
* 新增加的方法
* 增，删，改---->封装成1个方法，方便子类调用
* protected int executeUpdate(String sql,Object... params) params占位符列表 既可以表示1个参数，多个参数，还可以0个参数
* 查询--->封装成1个方法，方便子类调用
* protected void executeQuery(String sql, Object...params)
* 集合对象不指定类型
* @author Administrator
*
*/
public class BaseDao {
private static final String CLASS_NAME="com.mysql.jdbc.Driver";
private final String URL = "jdbc:mysql://127.0.0.1:3306/njwangbo1";
private final String USERNAME = "root";
private final String PWD = "root";
protected Connection conn = null;
protected PreparedStatement ps = null;
protected ResultSet rs = null;
static{
try {
Class.forName(CLASS_NAME);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 设置连接对象 ,访问修饰符private 供本类使用
*/
private void setConnection(){
try {
this.conn = DriverManager.getConnection(URL, USERNAME, PWD);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 增，删，改
* @param sql
* @param params
* @return
*/
protected int executeUpdate(String sql,Object...params){
int count = 0;
//1.加载驱动（静态代码块已经加载了）
//2.设置连接对象
this.setConnection();
try {
//3.准备sql语句，获取执行器对象
this.ps = this.conn.prepareStatement(sql);
//4.设置占位符 ,封装成1个私有的方法
this.setParams(params);
//5.执行，并返回处理结果
count = this.ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
//6.关闭资源
this.close();
//this.close(null,ps,conn); //如果带参的方法，这样调用
}
return count;
}
/**
* 设置占位符
* @param params
* @throws SQLException
*/
private void setParams(Object...params) throws SQLException{
if(params!=null && params.length>0){
for(int i=0;i<params.length;i++){
this.ps.setObject((i+1), params[i]);
}
}
}
/**
* 查询封装的方法
* @param sql
* @param params
*
*/
protected void executeQuery(String sql, Object...params){
//2.设置连接对象
this.setConnection();
try {
//3.准备sql语句，获取执行器对象
this.ps = this.conn.prepareStatement(sql);
//4.设置占位符
this.setParams(params);
//5.执行，并返回处理结果
this.rs = this.ps.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
}
//6.不能关闭资源 ，必须等子类使用完后，再关闭
}
/**
* 设置成带参方法，不带参方法都可以，总之你要关闭的BaseDao里 rs,ps,conn
*/
protected void close(){
if(null!=rs){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(null!=ps){
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(null!=conn){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
1.7. 给用户表增加创建时间字段
1.7.1. 修改表结构
createTime
create table t_user3(
t_id int auto_increment primary key,
t_userName varchar(30),
t_pwd varchar(30),
createTime dateTime
)engine=InnoDB;
1.7.2. 修改实体类
package com.njwb.entity;
import java.util.Date;
import com.njwb.util.DateUtil;
/**
* t_user3 t_id int t_userName varchar t_pwd varchar createTime dateTime
* 建一个实体类entity类 User
* id int userName String pwd String createTime java.util.Date
* @author Administrator
*
*/
public class User {
private int id; //用户编号
private String userName; //用户名
private String pwd; //用户密码
private Date createTime; //该条记录的插入时间
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public User() {
}
public User(int id, String userName, String pwd, Date createTime) {
super();
this.id = id;
this.userName = userName;
this.pwd = pwd;
this.createTime = createTime;
}
@Override
public String toString() {
return "[id="+id+",userName="+this.userName+",pwd="+this.pwd+",createTime="+DateUtil.getStrFromDate("yyyy-MM-dd HH:mm:ss",this.createTime)+"]";
}
}
1.7.3. 修改UserDao.java
package com.njwb.dao;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import com.njwb.entity.User;
/**
* 任务：封装baseDao, 补齐剩余的3个方法 更新 ，删除 ，查询单个用户
* @author Administrator
*
*/
public class UserDao extends BaseDao {
/**
* 新增用户信息
* @param u
* @return
*/
public int addUser(User u){
String sql = "insert into t_user3(t_userName,t_pwd,createTime) values(?,?,now())";
int count = super.executeUpdate(sql, u.getUserName(),u.getPwd());
return count;
}
/**
* 删除用户信息
* @param id
* @return
*/
public int delUser(int id){
String sql = "delete from t_user3 where t_id=?";
return super.executeUpdate(sql, id);
}
/**
* 更新用户信息
* @param u
* @return
*/
public int updateUser(User u){
String sql = "update t_user3 set t_userName=?,t_pwd=? where t_id=?";
int count = super.executeUpdate(sql, u.getUserName(),u.getPwd(),u.getId());
return count;
}
/**
* 查询所有用户
* @return
*/
public List<User> queryAll(){
List<User> list = new ArrayList<User>();
String sql = "select * from t_user3";
super.executeQuery(sql);
//遍历父类的结果集对象rs
try {
while(super.rs.next()){
User u = new User();
u.setId(rs.getInt("t_id"));
u.setUserName(rs.getString("t_userName"));
u.setPwd(rs.getString("t_pwd"));
u.setCreateTime(rs.getTimestamp("createTime"));
list.add(u);
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
super.close();
}
return list;
}
/**
* 根据用户名，密码，查询单个用户信息，如果能够查询到，返回该用户对象
* @param u
* @return
*/
public User queryByCondition(User u){
User ui = null;
String sql = "select * from t_user3 where t_userName=? and t_pwd=?";
super.executeQuery(sql,u.getUserName(),u.getPwd());
//遍历父类的结果集对象rs
try {
if(super.rs.next()){
ui = new User();
ui.setId(rs.getInt("t_id"));
ui.setUserName(rs.getString("t_userName"));
ui.setPwd(rs.getString("t_pwd"));
ui.setCreateTime(rs.getTimestamp("createTime"));
}
} catch (SQLException e) {
e.printStackTrace();
}finally{
super.close();
}
return ui;
}
}
测试类
package com.njwb.test;
import java.util.List;
import com.njwb.dao.UserDao;
import com.njwb.entity.User;
import com.njwb.util.DateUtil;
public class TestUserDao {
public static void main(String[] args) {
UserDao ud = new UserDao();
User u = new User();
u.setUserName("jack3");
u.setPwd("1234561");
//调用新增方法
/*int count = ud.addUser(u);
System.out.println(count>0?"新增成功":"新增失败");*/
//查询所有
/*List<User> list = ud.queryAll();
for(User ui:list){
System.out.println(ui.getId()+"\t"+ui.getUserName()+"\t"+ui.getPwd()+"\t"+DateUtil.getStrFromDate("yyyy-MM-dd HH:mm:ss", ui.getCreateTime()));
}*/
//更新用户信息
/*User u2 = new User();
u2.setId(5);
u2.setUserName("aacc");
u2.setPwd("123123");
//调用更新方法
int count = ud.updateUser(u2);
System.out.println(count>0?"更新成功":"更新失败");*/
//测试删除单条用户记录
/*int count3 = ud.delUser(2);
System.out.println(count3>0?"删除成功":"删除失败");*/
//查询单个用户信息
User u4 = new User();
u4.setUserName("jack1");
u4.setPwd("111111");
User u5 = ud.queryByCondition(u4);
System.out.println(u5!=null?u5.getId()+"\t"+u5.getUserName()+"\t"+u5.getPwd()+"\t"+DateUtil.getStrFromDate("yyyy-MM-dd HH:mm:ss", u5.getCreateTime()):"查无此人");
}
}
1.8. 设计UserDao接口
新建一个包 com.njwb.dao.impl ,将 UserDao类拷贝到该包下，将类重命名为UserDaoImpl.java. ，新的类必须extends BaseDao imlements UserDao接口
原先的UserDao类 改成接口，里面的方法全部改成抽象方法。
测试类 main方法中 以前是UserDao ud = new UserDao() --à改为 UserDao ud = new UserDaoImpl(); //接口类型，指向具体的实现类对象。
1.9. 编写UserDaoImpl实现UserDao接口
面向接口编程，好的设计思想。
如何调用Dao访问数据库？
UserDao ud = new UserDaoImpl();测试类的其他代码不动。
1.10. 总结
1， 加载驱动，获取连接，获取执行器，执行并返回处理结果，关闭资源 放在1个方法中
2， 将加载驱动，获取连接对象，关闭资源 放到BaseDao中 ，子类UserDao的代码简写了一点，发现子类的addUser() updateUser() …..这些方法，还是有代码的冗余。
3， 再次封装 ，加载驱动，设置连接对象，关闭资源， 放到BaseDao中，再多封装2个方法 增，删，改 public int executeUpdate(String sql,Object… params) , 查询 public void executeQuery(String sql,Object…params); 后期 会将public void executeQuery(String sql,Object…params);--à改成返回集合对象public void executeQuery(String sql, MapperObject mapper, Object…params);
增，删，改方法中，查询方法中，设置占位符部分代码重复 ，单独提取了一个方法，设置占位符 。private void setParams(Object…params);
4. 采用面向接口编程的设计思想，将UserDao提取成interface ,重新建包 com.njwb.dao.impl，创建UserDao接口的实现类UserDaoImpl.
5108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
