Java_部门操作实现

现在要求利用dept表开发出以下功能：

　　实现部门数据增加

　　实现部门数据修改

　　实现部门数据删除

　　可以根据编号查询出一个部门信息

　　可以查询出全部部门信息

沿用之前的项目继续编写，DatabaseConnection已经存在了。

1.定义Dept.java类

需要在vo包中创建，也要实现Serializable接口 

package xxx.vo;

import java.io.Serializable;

public class Dept implements Serializable {
    private Integer deptno;
    private String dname;
    private String loc;
    public Integer getDeptno() {
        return deptno;
    }
    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }
    public String getDname() {
        return dname;
    }
    public void setName(String dname) {
        this.dname = dname;
    }
    public String getLoc() {
        return loc;
    }
    public void setLoc(String loc) {
        this.loc = loc;
    }
}

 

2.定义IDeptDAO接口（不用这个，用泛型的方式）

package xxx.dao;

import java.util.List;
import java.util.Set;

import xxx.vo.Dept;

public interface IDeptDAO {
    public boolean doCreate(Dept vo) throws Exception;
    public boolean doUpdate(Dept vo) throws Exception;
    public boolean doRemove(Set<Integer> ids) throws Exception;
    public Dept findById(Integer id) throws Exception;
    public List<Dept> findAll() throws Exception;
}

整个代码里除了VO类型、ID类型不一样之外，该用的之前都有了。所以不用上门的方法再下一遍，用泛型

范例：定义IDAO的公共接口，这个接口不定义具体的VO或者主键的类型

 

package xxx.dao;

import java.util.List;
import java.util.Set;

/**
 * 
 * @author James
 *
 * @param <K>要操作数据表的主键数据类型
 * @param <V>要操作的VO类型
 */
public interface IDAO<K,V> {
    
    /**数据增加的操作，执行的是INSERT语句
     * @param vo 包含了要增加的数据信息
     * @return 如果数据增加成功 返回true 否则返回false
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public boolean doCreate(V vo) throws Exception;
    
    /**
     * 数据修改操作，执行UPDATE语句，本次的修改会根据ID将所有的数据进行变更
     * @param vo 包含了要修改数据的信息
     * @return 如果数据修改成功 返回true 否则返回false
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     
     */
    public boolean doUpdate(V vo) throws Exception;
    
    /**数据删除操作，需在执行前根据删除的编号，拼凑出SQL语句
     * @param ids 所有要删除的编号数据
     * @return 如果数据删除成功 返回true 否则返回false
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public boolean doRemove(Set<K>ids) throws Exception;
    
    /**根据雇员编号查询出表一行的完整信息，并且将返回结果填充到VO类对象中
     * @param id 要查询的数据编号
     * @return 如果查询到则将内容以vo对象的形式返回，如果查到没有数据返回null
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public V findById(K id) throws Exception;
    
    /**查询数据表中的全部数据，每行数据通过vo类包装，而后通过List保存多个返回结果
     * @return 全部的查询数据行，如果没有数据返回，集合长度为0（size() = 0）。
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public List<V> findAll() throws Exception;
    
    /**分页进行数据表的模糊查询操作，每行数据通过vo类包装，而后通过List保存多个返回结果
     * @param columun 要模糊查询的数据列
     * @param keyWord 要进行查询的关键字
     * @param currentPage 当前所在页
     * @param lineSize 每页显示的数据行数
     * @return 全部的查询数据行，如果没有数据返回，集合长度为0（size() = 0）。
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public List<V> findAllSplit(String column,String keyWord,Integer currentPage, Integer lineSize) throws Exception;
    
    /**使用COUNT()函数统计数据表中符合查询要求的数据量
     * @param columun 要模糊查询的数据列
     * @param keyWord 要进行查询的关键字
     * @return 返回COUNT()的统计结果，如果没有数据满足，则返回内容为0
     * @throws Exception 如果数据库没有连接，则出现NullPointerException,如果SQL语句错误抛出SQLException
     */
    public Integer getAllCount(String column,String keyWord) throws Exception;

}

如果现在子接口不需要扩充方法，那么就简单继承，并且设置泛型类型，如果要扩充方法，那么直接在子类中定义。

可以将IEmpDAO删掉重新建一个继承IDAO接口的IEmpDAO。

范例：定义IDeptDAO接口(用泛型方式)

 前提：先不处理外键

package xxx.dao;


import xxx.vo.Dept;

public interface IDeptDAO extends IDAO<Integer, Dept> {
}

 

 3.定义DeptDAOImpl子类

package xxx.dao.impl;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import xxx.dao.IDeptDAO;
import xxx.vo.Dept;

public class DeptDAOImpl implements IDeptDAO {
    private Connection conn;
    private PreparedStatement pstmt;
    public DeptDAOImpl(Connection conn) {
        this.conn = conn;
    }
    @Override
    public boolean doCreate(Dept vo) throws Exception {
        String sql = "INSERT INTO dept(deptno,dname,loc) VALUES(?,?,?)";
        this.pstmt = this.conn.prepareStatement(sql);
        this.pstmt.setInt(1,vo.getDeptno());
        this.pstmt.setString(2, vo.getDname());
        this.pstmt.setString(3, vo.getLoc());
        return this.pstmt.executeUpdate() > 0;
    }

    @Override
    public boolean doUpdate(Dept vo) throws Exception {
        String sql = "UPDATE dept SET dname=?,loc=? WHERE deptno=?";
        this.pstmt = this.conn.prepareStatement(sql);
        this.pstmt.setString(1, vo.getDname());
        this.pstmt.setString(2, vo.getLoc());
        this.pstmt.setInt(3,vo.getDeptno());
        return this.pstmt.executeUpdate() > 0;
    }

    @Override
    public boolean doRemove(Set<Integer> ids) throws Exception {
        StringBuffer buf = new StringBuffer();
        buf.append("DELETE FROM dept WHERE deptno IN(");
        Iterator<Integer> iter = ids.iterator();
        while(iter.hasNext()) {
            buf.append(iter.next()).append(",");
        }
        buf.delete(buf.length() - 1, buf.length()).append(")");
        this.pstmt = this.conn.prepareStatement(buf.toString());
        return this.pstmt.executeUpdate() == ids.size();
    }

    @Override
    public Dept findById(Integer id) throws Exception {
        Dept vo = null;
        String sql = "SELECT deptno,dname,loc FROM dept WHERE deptno = ?";
        this.pstmt = this.conn.prepareStatement(sql);
        this.pstmt.setInt(1, id);
        ResultSet rs = this.pstmt.executeQuery();
        if(rs.next()) {
            vo = new Dept();
            vo.setDeptno(rs.getInt(1));
            vo.setName(rs.getString(2));
            vo.setLoc(rs.getString(3));
        }
        return vo;
    }

    @Override
    public List<Dept> findAll() throws Exception {
        List<Dept> all = new ArrayList<Dept>();
        String sql = "SELECT deptno,dname,loc FROM dept WHERE deptno = ?";
        this.pstmt = this.conn.prepareStatement(sql);
        ResultSet rs = this.pstmt.executeQuery();
        while(rs.next()) {
            Dept vo = new Dept();
            vo.setDeptno(rs.getInt(1));
            vo.setName(rs.getString(2));
            vo.setLoc(rs.getString(3));
            all.add(vo);
        }
        return all;
    }

    @Override
    public List<Dept> findAllSplit(String column, String keyWord, Integer currentPage, Integer lineSize)
            throws Exception {
        // TODO Auto-generated method stub
        throw new Exception("此方法未实现！");
    }

    @Override
    public Integer getAllCount(String column, String keyWord) throws Exception {
        // TODO Auto-generated method stub
        throw new Exception("此方法未实现！");
    }

}

 4.在DAOFactory类中追加新的接口对象取得

package xxx.factory;

import java.sql.Connection;

import xxx.dao.IDeptDAO;
import xxx.dao.IEmpDAO;
import xxx.dao.impl.DeptDAOImpl;
import xxx.dao.impl.EmpDAOImpl;

public class DAOFactory {
    public static IEmpDAO getIEmpDAOInstance(Connection conn) {
        return new EmpDAOImpl(conn);
    }
    public static IDeptDAO getIDeptDAOInstance(Connection conn) {
        return new DeptDAOImpl(conn);
    }
}

 5.开发业务层操作

业务层一定是分开单独编写的，不能混在一起

package xxx.service;

import java.util.List;
import java.util.Set;

import xxx.vo.Dept;

public interface IDeptService {
    /**
     * 增加操作需要首先利用IDeptDAO.findById()判断，而后利用IDeptDAO.doCreate()保存
     * @param vo
     * @return
     * @throws Exception
     */
    public boolean inser(Dept vo) throws Exception;
    public boolean update(Dept vo) throws Exception;
    public boolean delete(Set<Integer> ids) throws Exception;
    public Dept get(Integer id) throws Exception;
    public List<Dept> list() throws Exception;
}

6.定义具体的子类

package xxx.service.impl;

import java.util.List;
import java.util.Set;

import xxx.dbc.DatabaseConnection;
import xxx.factory.DAOFactory;
import xxx.service.IDeptService;
import xxx.vo.Dept;

public class DeptServiceImpl implements IDeptService {
    private DatabaseConnection dbc = new DatabaseConnection();
    @Override
    public boolean inser(Dept vo) throws Exception {
        try {
            if(DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).findById(vo.getDeptno()) == null) {
                return DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).doCreate(vo);
            }
            return false;
        }catch (Exception e) {
            throw e;
        }finally {
            this.dbc.close();
        }
    }

    @Override
    public boolean update(Dept vo) throws Exception {
        try {
            return DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).doUpdate(vo);
        }catch (Exception e) {
            throw e;
        }finally {
            this.dbc.close();
        }
    }

    @Override
    public boolean delete(Set<Integer> ids) throws Exception {
        try {
            if(ids.size() ==0) {
                return false;
            }
            return DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).doRemove(ids);
        }catch (Exception e) {
            throw e;
        }finally {
            this.dbc.close();
        }
    }

    @Override
    public Dept get(Integer id) throws Exception {
        try {
            return DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).findById(id);
        }catch (Exception e) {
            throw e;
        }finally {
            this.dbc.close();
        }
    }

    @Override
    public List<Dept> list() throws Exception {
        try {
            return DAOFactory.getIDeptDAOInstance(this.dbc.getConnection()).findAll();
        }catch (Exception e) {
            throw e;
        }finally {
            this.dbc.close();
        }
    }

}

7.定义业务层工厂类

package xxx.factory;

import xxx.service.IDeptService;
import xxx.service.IEmpService;
import xxx.service.impl.DeptServiceImpl;
import xxx.service.impl.EmpSericeImpl;

public class ServiceFactory {
    public static IEmpService getIEmpServiceInstance() {
        return new EmpSericeImpl();
    }
    public static IDeptService getIDeptServiceInstance() {
        return new DeptServiceImpl();
    }
}

8. junit测试

package xxx.test.junit;

import static org.junit.jupiter.api.Assertions.*;

import javax.swing.DebugGraphics;

import org.junit.jupiter.api.Test;

import junit.framework.TestCase;
import xxx.factory.ServiceFactory;
import xxx.vo.Dept;

class IDeptServiceTest {

    @Test
    void testInser() {
        Dept vo = new Dept();
        vo.setDeptno(90);
        vo.setName("ciel");
        vo.setLoc("happy");
        try{
            TestCase.assertTrue(ServiceFactory.getIDeptServiceInstance().inser(vo));
        }catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    void testUpdate() {
        fail("Not yet implemented");
    }

    @Test
    void testDelete() {
        fail("Not yet implemented");
    }

    @Test
    void testGet() {
        fail("Not yet implemented");
    }

    @Test
    void testList() {
        fail("Not yet implemented");
    }

}