Java实验项目六——使用DAO模式实现对职工表的操作

Program：

　　利用JDBC访问职工信息表，实现对职工信息的添加、更新、删除、按照职工号查找、查找全部职工的功能。

Description：在这里我采用了DAO设计模式完成对职工表的操作，下面介绍一下我的项目目录的组成(包.类)

com.vo.Worker：定义职工类，其中的Field名字和数据库中表的属性名字对应

com.db.DBConnection：实现控制数据库的连接和关闭,

com.dao.WorkerDao：定义接口，接口中定义与实际业务相对应的的数据库操作方法，具体操作由实现它的类完成

com.daoimpl.WorkerDaoImpl：数据层，实现WorkerDao接口，并覆写接口中的方法，实现对数据库的操作

com.daoimpl.WorkerService：业务逻辑层，实现WorkerDao接口，结合WorkerDaoImpl完成相应的业务操作

com.factory.Factory：定义工厂类，获得业务操作的对象，即WorkerService的实例化对象

main.TestDemo：测试类，测试业务逻辑操作

具体代码如下：

com.vo.Worker

/*
 * Description:定义职工类
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package com.vo;              //vo即为(Value Object 值对象 )

import java.util.Date;

public class Worker {

    String workerId;          //职工号
    String workerName;        //职工姓名
    String workerSex;         //职工性别
    String workerPartment;    //职工部门
    Date workerBirthday;      //职工出生日期
    

    //定义构造方法
    public Worker() {
        
    }
    
    public Worker(String id,String name,String sex,String partment,Date birthday) {
        
        this.workerId = id;
        this.workerName = name;
        this.workerSex = sex;
        this.workerPartment = partment;
        this.workerBirthday = birthday;
    }

    
    //定义setter()和getter()方法
    public String getWorkerId() {
        return workerId;
    }

    public void setWorkerId(String workerId) {
        this.workerId = workerId;
    }

    public String getWorkerName() {
        return workerName;
    }

    public void setWorkerName(String workerName) {
        this.workerName = workerName;
    }

    public String getWorkerSex() {
        return workerSex;
    }

    public void setWorkerSex(String workerSex) {
        this.workerSex = workerSex;
    }

    public String getWorkerPartment() {
        return workerPartment;
    }

    public void setWorkerPartment(String workerPartment) {
        this.workerPartment = workerPartment;
    }

    public Date getWorkerBirthday() {
        return workerBirthday;
    }

    public void setWorkerBirthday(Date workerBirthday) {
        this.workerBirthday = workerBirthday;
    }

    //覆写toString方法
    @Override
    public String toString() {
        return "Worker [workerId=" + workerId + ", workerName=" + workerName
                + ", workerSex=" + workerSex + ", workerPartment="
                + workerPartment + ", workerBirthday=" + workerBirthday
                + ", workerBeginDate=" + "]";
    }
    
}

com.db.DBConnection

/*
 * Description:定义数据库连接类。只负责数据库的连接和关闭
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package com.db;

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

public class DBConnection {

    //定义数据库驱动类
    private static final String DBDRIVER = "com.mysql.jdbc.Driver";
    //定义数据库URL
    private static final String DBURL = "jdbc:mysql://localhost:3306/Workers?characterEncoding=utf8&useSSL=true";
    //定义数据库连接用户名
    private static final String DBUSER = "root";
    //定义数据库连接指令
    private static final String DBPASS = "Cz123";
    
    //声明数据库连接对象
    Connection con = null;
    
    //定义构造方法，并实例化数据库连接对象
    public DBConnection() throws Exception {
        
        try {
            
            Class.forName(DBDRIVER);
            this.con = DriverManager.getConnection(DBURL,DBUSER,DBPASS);
        }catch(Exception e) {
            
            throw e;
        }
    }
    
    
    //取得数据库连接对象
    public Connection getConnection() throws Exception {
        
        return this.con;
    }
    
    //关闭数据库连接
    public void close() throws Exception{
        
        if( this.con != null ) {
            
            try {
                
                con.close();
            }catch(Exception e) {
                
                throw e;
            }
        }
    }
    
}

com.dao.WorkerDao

/*
 * Description:定义DAO接口，在该接口中只是定义对员工的操作，
 *                 具体操作需要实现该接口的类完成
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */


package com.dao;

import java.util.List;

import com.vo.Worker;

public interface WorkerDao {

    //向职工表中添加职工信息
    public boolean add(Worker worker) throws Exception;
    
    //根据职工号删除职工表中对应的职工
    public boolean remove(String id) throws Exception;
    
    //按照职工号查找职工
    public Worker search(String id) throws Exception;
    
    //查找全部职工
    public List<Worker> getWorkers() throws Exception;
    
    //更新职工信息
    public boolean update(Worker worker) throws Exception;
    
}

com.daoimpl.WorkerDaoImpl

/*
 * Description:实现DAO接口，完成具体数据库操作
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package com.daoimpl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Date;
import com.dao.WorkerDao;
import com.vo.Worker;

public class WorkerDaoImpl implements WorkerDao {
    
    private Connection con = null;            //定义数据库连接对象
    private PreparedStatement state = null;    //当以数据库操作对象

    //定义构造方法，并实例化数据路连接对象
    public WorkerDaoImpl(Connection con) {
        
        this.con = con;
    }
    
    //覆写插入方法
    @Override
    public boolean add(Worker worker) throws Exception {
        
        boolean flag = false;
        //如果数据库中不存在相同id的员工，则可插入数据
        if( worker != null ) {
            
            //定义插入的sql语句
            String insertSql = " insert into worker(workerId,workerName,workerSex,workerPartment,workerBirthday) "
                    + " values(?,?,?,?,?) ";
            
            //转换日期类型：util.Date -> sql.Date
            Date date = worker.getWorkerBirthday();
            java.sql.Date d = new java.sql.Date(date.getTime());
            
            //取得操作数据库的对象
            this.state = this.con.prepareStatement(insertSql);
            
            this.state.setString(1, worker.getWorkerId());
            this.state.setString(2, worker.getWorkerName());
            this.state.setString(3, worker.getWorkerSex());
            this.state.setString(4, worker.getWorkerPartment());
            this.state.setDate(5, d);
            
            if( this.state.executeUpdate() > 0 ) {        //成功插入数据
                
                flag = true;
            }

            this.state.close();        //关闭数据库操作对象
        }
        
        return flag;        //返回判断标志
    }

    //覆写删除方法
    @Override
    public boolean remove(String id) throws Exception {
        
        boolean flag = false;    //判断是否删除成功
        
        //定义用于删除的sql语句
        String removeSql = " delete from worker where workerId = ? ";
            
        this.state = this.con.prepareStatement(removeSql);
        this.state.setString(1, id);
            
        if( this.state.executeUpdate() > 0 ) {        //删除成功
                
            flag = true;
        }
            
        this.state.close();        //关闭连接
        
        return flag;
        
    }

    //覆写查询方法
    @Override
    public Worker search(String id) throws Exception {
        
        Worker worker = null;        //接受查询返回的对象
        ResultSet rs = null;        //接受查询结果
        
        //id不为空，且不为""
        if( id != null && !"".equals(id) ) {        
            
            //定义用于查询的sql语句
            String selectSql = "select workerId,workerName,workerSex,workerPartment,workerBirthday"
            +" from worker where workerId=? ";
            
            this.state = this.con.prepareStatement(selectSql);
            this.state.setString(1, id);
            rs = this.state.executeQuery();
            
            //查询成功
            if( rs.next() ) {
                
                worker = new Worker();        //实例化Worker类对象
                worker.setWorkerId(rs.getString(1));
                worker.setWorkerName(rs.getString(2));
                worker.setWorkerSex(rs.getString(3));
                worker.setWorkerPartment(rs.getString(4));
                worker.setWorkerBirthday(new Date( rs.getDate(5).getTime() ));
            }
            
            this.state.close();        //关闭连接
        }
        
        return worker;
    }

    //覆写取得所有Worker类对象的方法
    @Override
    public List<Worker> getWorkers() throws Exception {
        
        //保存所有职工对象
        List<Worker> list = new ArrayList<Worker>();
        //保存返回的的查询结果
        ResultSet rs = null;
        //定义用于查询的sql语句
        String selectSql = " select * from worker ";
        
        this.state = this.con.prepareStatement(selectSql);
        rs = this.state.executeQuery();
        
        
        while( rs.next() ) {
            
            Worker worker = new Worker();        //实例化职工对象
            
            worker.setWorkerId(rs.getString(1));
            worker.setWorkerName(rs.getString(2));
            worker.setWorkerSex(rs.getString(3));
            worker.setWorkerPartment(rs.getString(4));
            worker.setWorkerBirthday(new Date( rs.getDate(5).getTime() ));
            
            list.add(worker);            //加入集合
        }
        
        this.state.close();        //关闭连接
        
        return list;            //返回集合

    }

    //覆写更新员工信息方法
    @Override
    public boolean update(Worker worker) throws Exception {
        
        boolean flag = false;        //标记是否更新成功
        
        if( worker != null ) {
            
            //定义更新语句
            String updateSql = " update worker set workerName = ?,workerSex = ?,workerPartment = ?, "
                    + " workerBirthday = ? where workerId = ?";
            
            //转换日期类型：util.Date -> sql.Date
            Date date = worker.getWorkerBirthday();
            java.sql.Date d = new java.sql.Date(date.getTime());
            
            this.state = this.con.prepareStatement(updateSql);
            this.state.setString(1, worker.getWorkerName());
            this.state.setString(2, worker.getWorkerSex());
            this.state.setString(3, worker.getWorkerPartment());
            this.state.setDate(4, d);
            this.state.setString(5, worker.getWorkerId());
            
            if( this.state.executeUpdate() > 0 ) {        //更新成功
                    
                flag = true;
            }
            
            this.state.close();            //关闭连接
        }
        
        return flag;
    }
    

}

com.daoimpl.WorkerService

/*
 * Description:实现具体的业务逻辑
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package com.daoimpl;

import java.util.List;

import com.dao.WorkerDao;
import com.db.DBConnection;
import com.vo.Worker;

public class WorkerService implements WorkerDao {
    
    DBConnection dbc = null;    //声明负责数据库连接关闭对象
    WorkerDao workerDao = null;    //声明业务逻辑操作接口对象
    
    //定义构造方法，并实例化属性
    public WorkerService() throws Exception {
        
        this.dbc = new DBConnection();        //实例化数据库连接和关闭对象
        this.workerDao = new WorkerDaoImpl(this.dbc.getConnection());    //实例化数据库操作对象
    }
    
    //添加职工信息
    public boolean add(Worker worker) throws Exception {
        
        boolean flag = false;
        
        try {
            if( this.workerDao.search(worker.getWorkerId()) == null ) {
                
                flag = this.workerDao.add(worker);    //调用WorkerDaoImpl类中add()方法
            }
            
        }catch(Exception e) {
            
            throw e;
        }finally {
            
            this.dbc.close();    //关闭数据库连接
        }
        
        return flag;
    }
    
    //删除职工信息
    public boolean remove(String workerId) throws Exception {
        
        boolean flag = false;
        
        try {
            if( this.workerDao.search(workerId) != null ) {
                
                flag = this.workerDao.remove(workerId);    //调用WorkerDaoImpl类中的remove()方法
            }
        }catch(Exception e) {
            
            throw e;
        }finally {
            
            this.dbc.close();    //关闭数据库连接
        }
        
        return flag;
    }
    
    //查询职工信息
    public Worker search(String workerId) throws Exception {
        
        Worker worker = null;
        
        try {
            
            worker = this.workerDao.search(workerId);    //调用WorkerDaoImpl类中的search()方法
        }catch(Exception e) {
            
            throw e;
        }finally {
            
            this.dbc.close();    //关闭数据库连接
        }
        
        return worker;
    }
    
    //取得所有职工信息
    
    public List<Worker> getWorkers() throws Exception {
        
        List<Worker> list = null;
        
        try {
            
            list =  this.workerDao.getWorkers();    //调用WorkerDaoImpl类中的getWorkers()方法
        }catch(Exception e) {
            
            throw e;
        }finally {
            
            this.dbc.close();    //关闭数据库连接
        }
        
        return list;
    }
    
    //更新员工信息
    public boolean update(Worker worker) throws Exception {
        
        boolean flag = false;
        
        try {
            if( this.workerDao.search(worker.getWorkerId()) != null ) {
                
            flag = this.workerDao.update(worker);    //调用WorkerDaoImpl类中的update()方法
            }
        }catch(Exception e) {
            
            throw e;
        }finally {
            
            this.dbc.close();    //关闭数据库连接
        }
        
        return flag;
    }

}

com.factory.Factory

/*
 * Description:定义工厂类，获得WorkerService类的实例
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package com.factory;

import com.dao.WorkerDao;
import com.daoimpl.WorkerService;

public class Factory {

    //定义静态方法，返回实例化的WorkerService类对象
    /*
     * 通过工厂类的静态方法，获得业务处理类实例化对象，可以让我们不用在表现层再去new对象，
     * 并且当我们的业务操作层需要换一种方法实现时，同时又想保留原来的业务层的实现，这样我们直接可以
     * 修改静态方法中的代码，不用去表现层中再一个一个的修改new对象的类型
     * 
     * */
    public static WorkerDao getWorkerServiceInstance() throws Exception  {
        
        return new WorkerService();        
    }
    
}

main.TestDemo

/*
 * Description:定义测试类，测试Dao模式下，对数据库中职工表的一系列操作
 * 
 * Written By:Cai
 * 
 * Date Written:2017-10-19
 * 
 * */

package main;

import java.util.Date;
import java.util.Iterator;
import java.util.List;

import com.factory.Factory;
import com.vo.Worker;

public class TestDemo {

    public static void main(String args[]) {
        
        List<Worker> list = null;
        
        try {
            
            //为了演示简单。所有的日期都直接new了
            Factory.getWorkerServiceInstance().add(new Worker("0001","大象","male","办公室",new Date()));
            Factory.getWorkerServiceInstance().add(new Worker("0002","狮子","male","办公室",new Date()));
            Factory.getWorkerServiceInstance().add(new Worker("0003","老虎","male","办公室",new Date()));
            Factory.getWorkerServiceInstance().add(new Worker("0004","蚂蚁","male","办公室",new Date()));
            
            //演示插入相同id的职工信息，此处打印false,(插入失败)
            System.out.println(Factory.getWorkerServiceInstance().add(new Worker("0004","蚂蚁","male","办公室",new Date())));
            //根据id找到对应员工，此处打印对应id的员工信息
            System.out.println(Factory.getWorkerServiceInstance().search("0004") );
            //删除指定id编号的员工信息,此处打印true(删除成功)
            System.out.println(Factory.getWorkerServiceInstance().remove("0004") );
            //删除指定不存在的id编号的员工信息,此处打印false(删除失败)
            System.out.println( Factory.getWorkerServiceInstance().remove("0004") );
            //更新员工信息，将办公室改成厕所(恶搞。。。)，此处打印true(更新成功)
            System.out.println(Factory.getWorkerServiceInstance().update(new Worker("0003","老虎","male","办公室",new Date())) );
            //获取所有职工的信息
            list = Factory.getWorkerServiceInstance().getWorkers();
            
        }catch(Exception e) {
            
            e.printStackTrace();
        }
        
        //迭代输出职工信息
        Iterator<Worker> ite = list.iterator();
        while( ite.hasNext() ) {
            
            System.out.println( ite.next() );
        }
        
        
    }
    
}