java6.19上午实训总结

昨天我们码好了net.qt.student.dao.impl下的ColloegeDaoImpl、StatusDaoImpl两个类，并且在test下测试了，今天上午就码了StudentDaoImpl、UserDaoImpl,同样的，也进行了测试：

接下来看看我的成果吧！当程序都可以成功运行的时候，真的很有满足感呢！

package net.qt.student.dao.impl;

import net.qt.student.bean.Student;
import net.qt.student.dao.StudentDao;
import net.qt.student.dbutil.ConnectionManager;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

/**
 * 包名：net.qt.student.dao.impl
 * 类名：StudentDaoImpl
 * 描述：状态数据访问接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class StudentDaoImpl implements StudentDao {
    /**
     * 插入学生记录
     * @param student
     * @return
     */
    @Override
    public int insert(Student student) {
        //定义插入记录数
        int count = 0;
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "insert into t_student (id, name, sex, age, department, class,telephone)"
                +"values(?, ?, ?, ?, ?, ?, ?)";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,student.getId());
            pstmt.setString(2,student.getName());
            pstmt.setString(3,student.getSex());
            pstmt.setInt(4,student.getAge());
            pstmt.setString(5,student.getDepartment());
            pstmt.setString(6,student.getClazz());
            pstmt.setString(7,student.getTelephone());
            //5.执行SQL，返回插入的记录数
            count = pstmt.executeUpdate();
            //6.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        //返回插入的记录数
        return count;
    }

    /**
     * 按照学号删除学生记录
     * @param id
     * @return
     */

    @Override
    public int deleteById(String id) {
        //定义插入记录数
        int count = 0;
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "delete from t_student where id = ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,id);
            //5.执行SQL，返回插入的记录数
            count = pstmt.executeUpdate();
            //6.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }
        //返回插入的记录数
        return count;
    }

    /**
     * 按照班级删除学生记录
     * @param clazz
     * @return
     */
    @Override
    public int deleteByClass(String clazz) {
        //定义插入记录数
        int count = 0;
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "delete from t_student where class = ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,clazz);
            //5.执行SQL，返回插入的记录数
            count = pstmt.executeUpdate();
            //6.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        //返回插入的记录数
        return count;
    }

    /**
     * 按照系部删除学生记录
     * @param department
     * @return
     */
    @Override
    public int deleteByDepartment(String department) {

        //定义插入记录数
        int count = 0;
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "delete from t_student where department = ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,department);
            //5.执行SQL，返回插入的记录数
            count = pstmt.executeUpdate();
            //6.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭数据库连接
            ConnectionManager.closeConnection(conn);
        }

        //返回插入的记录数
        return count;
    }

    /**
     * 更新表的记录
     * @param student
     * @return
     */
    @Override
    public int update(Student student) {

        //定义更新记录数
        int count = 0;

        //1.获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "UPDATE t_student SET name = ?, sex = ?, age = ?,"
                +"department = ?, class = ?, telephone = ? WHERE id = ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道

            pstmt.setString(1,student.getName());
            pstmt.setString(2,student.getSex());
            pstmt.setInt(3,student.getAge());
            pstmt.setString(4,student.getDepartment());
            pstmt.setString(5,student.getClazz());
            pstmt.setString(6,student.getTelephone());
            pstmt.setString(7,student.getId());
            //5.执行SQL查询，返回结果集
            count = pstmt.executeUpdate();
            //6.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return count;
    }

    /**
     * 按学号查询学生记录
     * @param id
     * @return
     */
    @Override
    public Student findById(String id) {
        //声明学生列表
        Student student = null;
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "select * from t_student where id = ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,id);
            //5.执行SQL语句
            ResultSet rs = pstmt.executeQuery();
            //6.遍历结果集
            while (rs.next()){
                //创建学生实体
                student = new Student();
                //利用当前记录各个字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
            }
            //7.关闭结果集
            rs.close();
            //8.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return student;
    }

    /**
     * 根据姓查找学生
     * @param name
     * @return
     */
    @Override
    public List<Student> findByName(String name) {
        //声明学生列表
        List<Student>students = new ArrayList<Student>();
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "select * from t_student where name like ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,name+"%");
            //5.执行SQL语句
            ResultSet rs = pstmt.executeQuery();
            //6.遍历结果集
            while (rs.next()){
                //创建学生实体
                Student student = new Student();
                //利用当前记录各个字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                //将实体添加到学生列表
                students.add(student);
            }
            //7.关闭结果集
            rs.close();
            //8.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return students;
    }

    /**
     * 按照班级查找学生信息
     * @param clazz
     * @return
     */
    @Override
    public List<Student> findByClass(String clazz) {
        //声明学生列表
        List<Student>students = new ArrayList<Student>();
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串delete from t_student where class = ?
        String strSQL = "select * from t_student where class like ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,clazz+"%");
            //5.执行SQL语句
            ResultSet rs = pstmt.executeQuery();
            //6.遍历结果集
            while (rs.next()){
                //创建学生实体
                Student student = new Student();
                //利用当前记录各个字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                //将实体添加到学生列表
                students.add(student);
            }
            //7.关闭结果集
            rs.close();
            //8.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return students;
    }

    /**
     * 按照系部查找学生信息
     * @param department
     * @return
     */
    @Override
    public List<Student> findByDepartment(String department) {
        //声明学生列表
        List<Student>students = new ArrayList<Student>();
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串delete from t_student where class = ?
        String strSQL = "select * from t_student where department like ?";
        try {
            //3.创建预备语句对象
            PreparedStatement pstmt = conn.prepareStatement(strSQL);
            //4.设置占位符的道
            pstmt.setString(1,department + "%");
            //5.执行SQL语句
            ResultSet rs = pstmt.executeQuery();
            //6.遍历结果集
            while (rs.next()){
                //创建学生实体
                Student student = new Student();
                //利用当前记录各个字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                //将实体添加到学生列表
                students.add(student);
            }
            //7.关闭结果集
            rs.close();
            //8.关闭预备语句对象
            pstmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return students;
    }

    /**
     * 查找所有学生信息
     * @return
     */
    @Override
    public List<Student> findAll() {
        //声明学生列表
        List<Student>students = new ArrayList<Student>();
        //1.获得数据库的连接
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL = "select * from t_student ";
        try {
            //3.获取预备语句对象
            Statement stmt = conn.createStatement();
            //4.执行SQL，返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            //5.遍历结果集
            while (rs.next()){
                //创建学生实体
                Student student = new Student();
                //利用当前记录各个字段值设置学生实体属性
                student.setId(rs.getString("id"));
                student.setName(rs.getString("name"));
                student.setSex(rs.getString("sex"));
                student.setAge(rs.getInt("age"));
                student.setDepartment(rs.getString("department"));
                student.setClazz(rs.getString("class"));
                student.setTelephone(rs.getString("telephone"));
                //将实体添加到学生列表
                students.add(student);
            }
            //7.关闭结果集
            rs.close();
            //8.关闭预备语句对象
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        return students;
    }

    /**
     * 按照性别统计人数
     * @return
     */
    @Override
    public Vector findRowsBySex() {
        //定义行集向量
        Vector rows = new Vector();
        //1.获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL ="select sex as '性别', count(*) as '人数'" + " from t_student group by sex order by sex desc";
        try {
            //3.创建语句对象
            Statement stmt = conn.createStatement();
            //4.执行SQL,返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            //5.遍历结果集
            while(rs.next()){
                //定义当前行向量
                Vector<String> currentRow = new Vector();
                //利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("性别"));
                currentRow.addElement(rs.getInt("人数")+"");
                //将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        //返回行集向量
        return rows;
    }

    /**pstmt.setString(6,student.getClazz());
     * 按照班级统计人数
     * @return
     */
    @Override
    public Vector findRowsByClass() {

        //定义行集向量
        Vector rows = new Vector();
        //1.获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL ="select sex as '班级', count(*) as '人数'" + " from t_student group by class order by class desc";
        try {
            //3.创建语句对象
            Statement stmt = conn.createStatement();
            //4.执行SQL,返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            //5.遍历结果集
            while(rs.next()){
                //定义当前行向量
                Vector<String> currentRow = new Vector();
                //利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("班级"));
                currentRow.addElement(rs.getInt("人数")+"");
                //将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        //返回行集向量
        return rows;
    }

    /**
     * 按照系部统计人数
     * @return
     */
    @Override
    public Vector findRowsByDepartment() {

        //定义行集向量
        Vector rows = new Vector();
        //1.获取数据库连接对象
        Connection conn = ConnectionManager.getConnection();
        //2.定义SQL字符串
        String strSQL ="select sex as '系部', count(*) as '人数'" + " from t_student group by department order by department desc";
        try {
            //3.创建语句对象
            Statement stmt = conn.createStatement();
            //4.执行SQL,返回结果集
            ResultSet rs = stmt.executeQuery(strSQL);
            //5.遍历结果集
            while(rs.next()){
                //定义当前行向量
                Vector<String> currentRow = new Vector();
                //利用当前记录字段值设置当前行向量的元素值
                currentRow.addElement(rs.getString("系部"));
                currentRow.addElement(rs.getInt("人数")+"");
                //将当前行向量添加到行集向量
                rows.addElement(currentRow);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            ConnectionManager.closeConnection(conn);
        }
        //返回行集向量
        return rows;
    }
}

package net.qt.student.test;

import net.qt.student.bean.Student;
import net.qt.student.dao.StudentDao;
import net.qt.student.dao.impl.StudentDaoImpl;
import org.junit.Test;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;

/**
 * 功能：测试学生数据访问接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class TestStudentDaoImpl {
    @Test
    public void testInsert(){
        Student student = new Student();
        student.setId("18205119");
        student.setName("谯婷");
        student.setSex("女");
        student.setAge(18);
        student.setDepartment("信息工程系");
        student.setClazz("软件三班");
        student.setTelephone("185423690147");

        StudentDao dao = new StudentDaoImpl();
        int count = dao.insert(student);
        if(count>0){
            System.out.println("恭喜，学生记录插入成功！");
        }else{
            System.out.println("遗憾，学生记录插入失败！");
        }

    }

    @Test
    public void testDeleteById(){
        StudentDao dao = new StudentDaoImpl();
        String id = "18205119";
        int count = dao.deleteById(id);
        if(count>0){
            System.out.println("恭喜，学生删除插入成功！");
        }else{
            System.out.println("遗憾，学生删除插入失败！");
        }
}
    @Test
    public void testDeleteByClass(){
        StudentDao dao = new StudentDaoImpl();
        String clazz = "11英教1班";
        int count = dao.deleteByClass(clazz);
        if(count>0){
            System.out.println("恭喜，【"+ clazz + "】学生记录删除成功！");
        }else{
            System.out.println("遗憾，【"+ clazz + "】学生记录删除失败！");
        }
    }

    @Test
    public void testDeleteByDepartment(){
        StudentDao dao = new StudentDaoImpl();
        String department = "";
        int count = dao.deleteByClass(department);
        if(count>0){
            System.out.println("恭喜，【"+ department + "】学生记录删除成功！");
        }else{
            System.out.println("遗憾，【"+ department + "】学生记录删除失败！");
        }
    }

    @Test
    public void testUpdate(){
        StudentDao dao = new StudentDaoImpl();
        Student student = dao.findById("10080301");
        student.setName("陈刚");
        student.setSex("女");
        student.setAge(18);
        student.setDepartment("信息工程系");
        student.setClazz("软件三班");
        student.setTelephone("185423690147");

        dao.update(student);
        student =  dao.findById("10080301");
        System.out.println(student);
    }

    @Test
    public void testFindByName(){
        StudentDao dao = new StudentDaoImpl();
        String name = "李";
        List<Student> students = dao.findByName(name);
        if(students.size()>0) {
            for (Student student : students) {
                System.out.println(students);
            }
        }else{
            System.out.println("温馨提示：查无此人！");
        }
    }
    @Test
    public void testFindByClass(){
        StudentDao dao = new StudentDaoImpl();
        String clazz = "11英教1班";
        List<Student> students = dao.findByClass(clazz);
        if(students.size()>0) {
            for (Student student : students) {
                System.out.println(students);
            }
        }else{
            System.out.println("温馨提示：查无此班！");
        }
    }
    @Test
    public void testFindByDepartment(){
        StudentDao dao = new StudentDaoImpl();
        String department = "11英教1班";
        List<Student> students = dao.findByDepartment(department);
        if(students.size()>0) {
            for (Student student : students) {
                System.out.println(students);
            }
        }else{
            System.out.println("温馨提示：查无此系！");
        }
    }
    @Test
    public void testFindAll(){
        StudentDao dao = new StudentDaoImpl();
        List<Student> students = dao.findAll();
        System.out.println(students);

    }

    @Test
    public void testFindRowsBySex(){
        StudentDao dao = new StudentDaoImpl();
        Vector rows = dao.findRowsBySex();
        //迭代器
        Iterator iterator = rows.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
    @Test
    public void testFindRowsByClass(){
        StudentDao dao = new StudentDaoImpl();
        Vector rows = dao.findRowsByClass();
        //迭代器
        Iterator iterator = rows.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    @Test
    public void testFindRowsByDepartment(){
        StudentDao dao = new StudentDaoImpl();
        Vector rows = dao.findRowsByDepartment();
        //迭代器
        Iterator iterator = rows.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

是不是看起来很厉害的样子呢？这是自己第一次在一个类里面码这么多内容呢！过程里面肯定也遇到了一些小问题，不过后来都在老师或者同学的帮助下解决了（PS：haha,其实有时候就是自己乱点一通，问题就解决啦~比如说当出现红色字体的时候，将鼠标移到字体那，那么在该行最左边就会出现一个红色小灯泡，这时候就可以点一下那个小灯泡再随便选择一下就不会报错了，不过这个方法只是有时候管用）



就比如下面这样：当缺少类的申明时就可以点击小灯泡，或者直接alt+enter就可以解决掉咯~蛮有趣的。

我们可以明显的看到，最初数据库的学生表里第一条信息就是id为10080301，name为‘谯婷’。。。。的信息

在学生表执行更新语句的时候，测试代码中将id为10080301的对应的name改成了陈刚。

一眼看过来在StudentDaoImpl中也没有出现报错
but。。。。为啥没得效果呢？
噢~~原来设置占位符的道 的时候必须要按照上面SQL 语句中字段出现的顺序来设置，改成如下之后效果就运行成功啦@_@

8.服务接口实现类
这里是跟着老师码的，话不多说，上图：

package net.qt.student.service.impl;

import net.qt.student.bean.College;
import net.qt.student.dao.CollegeDao;
import net.qt.student.dao.impl.CollegeDaoImpl;
import net.qt.student.service.CollegeService;

/**
 * 学校服务接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class CollegeServiceImpl implements CollegeService {
    /**
     * 声明学校数据访问对象
     * @param id
     * @return
     */
    private CollegeDao collegeDao = new CollegeDaoImpl();
    @Override
    public College findCollegeById(int id) {
        return collegeDao.findById(id);
    }

    @Override
    public int updateCollege(College college) {
        return collegeDao.update(college);
    }
}

package net.qt.student.service.impl;

import net.qt.student.bean.Status;
import net.qt.student.dao.StatusDao;
import net.qt.student.dao.impl.StatusDaoImpl;
import net.qt.student.service.StatusService;

/**
 * 状态服务接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class StatusServiceImpl implements StatusService {
    /**
     * 声明数据访问对象
     * @param id
     * @return
     */
    private StatusDao statusDao = new StatusDaoImpl();

    @Override
    public Status findStatusById(int id) {
        return statusDao.findById(id);
    }

    @Override
    public int updateStatus(Status status) {
        return statusDao.update(status);
    }
}

package net.qt.student.service.impl;

import net.qt.student.bean.Student;
import net.qt.student.dao.StudentDao;
import net.qt.student.dao.impl.StudentDaoImpl;
import net.qt.student.service.StudentService;

import java.util.List;
import java.util.Vector;

/**
 * 学生服务接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class StudentServiceImpl implements StudentService {
    /**
     * 声明学生数据访问对象
     * @param student
     * @return
     */
    private StudentDao studentDao = new StudentDaoImpl();
    @Override
    public int addStudent(Student student) {
        return studentDao.insert(student);
    }

    @Override
    public int deleteStudentById(String id) {
        return studentDao.deleteById(id);
    }

    @Override
    public int deleteStudentByClass(String clazz) {
        return studentDao.deleteByClass(clazz);
    }

    @Override
    public int deleteStudentByDepartment(String department) {
        return studentDao.deleteByDepartment(department);
    }

    @Override
    public int updateStudent(Student student) {
        return studentDao.update(student);
    }

    @Override
    public Student findStudentById(String id) {
        return studentDao.findById(id);
    }

    @Override
    public List<Student> findStudentsByName(String name) {
        return studentDao.findByName(name);
    }

    @Override
    public List<Student> findStudentsByClass(String clazz) {
        return studentDao.findByClass(clazz);
    }

    @Override
    public List<Student> findStudentsByDepartment(String department) {
        
        return studentDao.findByDepartment(department);
    }

    @Override
    public List<Student> findAllStudents() {
        
        return studentDao.findAll();
    }

    @Override
    public Vector findRowsBySex() {
        
        return studentDao.findRowsBySex();
    }

    @Override
    public Vector findRowsByClass() {
        
        return studentDao.findRowsByClass();
    }

    @Override
    public Vector findRowsByDepartment() {
        
        return studentDao.findRowsByDepartment();
    }
}

package net.qt.student.service.impl;

import net.qt.student.bean.User;
import net.qt.student.dao.UserDao;
import net.qt.student.dao.impl.UserDaoImpl;
import net.qt.student.service.UserService;

import java.util.List;

/**
 * 用户服务接口实现类
 * 作者：谯婷
 * 日期：2019.6.19
 */
public class UserServiceImpl implements UserService {
    /**
     * 声明用户数据访问对象
     * @param user
     * @return
     */
    private UserDao userDao = new UserDaoImpl();
    @Override
    public int addUser(User user) {
        return userDao.insert(user);
    }

    @Override
    public int deleteUserById(int id) {
        return userDao.deleteById(id);
    }

    @Override
    public int updateUser(User user) {
        return userDao.update(user);
    }

    @Override
    public User findUserById(int id) {
        return userDao.findById(id);
    }

    @Override
    public List<User> findAllUsers() {
        return userDao.findAll();
    }

    @Override
    public User login(String username, String password) {
        return userDao.login(username,password);
    }
}

呼呼~~后面的接口服务测试类，就等明天在发出来吧——因为还有部分没有弄好嘞

有趣的事情就是最值得做的事情，哈哈哈~晚安！！