public interface StudentDao {

    /**

     * 新增学生信息

     */

    void addStudent(Student student);

    // 新增完毕之后有ID

    void addStudentCacheId(Student student);

    // 删除学生信息

    void deleteStudent(Integer id);

    // 修改

    void updateStudent(Student student);

    // 查询所有

    List<Student> selectAllStudents();

    // 查询出来的是一个map集合

    Map<String, Object> selectAllStudentsMap();

    // 查询指定的

    Student selectById(Integer id);

    // 根据姓名模糊查询

    List<Student> selectByName(String name);

}

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE mapper

PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"

"http://mybatis.org/dtd/mybatis-3-Mapper.dtd">

<mapper namespace="student">

    <!--新增学生  -->

    <insert id="addStudent" parameterType="Student">

        insert into

        student(age,name) values(#{age},#{name})

    </insert>

    <insert id="addStudentCacheId" parameterType="Student">

        insert into

        student(age,name) values(#{age},#{name})

        <selectKey resultType="int" keyProperty="id" order="AFTER">

            select

            @@identity

        </selectKey>

    </insert>

    <!--删除 deleteStudent -->

    <delete id="deleteStudent">

        <!--#{sa} sa仅仅就是一个占位符 写成什么都是可以的 -->

        delete from student where id=#{sa}

    </delete>

    <!--修改updateStudent -->

    <update id="updateStudent">

        <!-- 这里面的｛｝必须是和实体类中的属性名一致 -->

        update student set name=#{name},age=#{age},id=#{id}

        where id=#{id}

    </update>

    <!-- 查询所有 list 必须指定返回值的类型resultType是一个学生对象 不然底层没法封装 -->

    <select id="selectAllStudents" resultType="Student">

        select id,name,age

        from student

    </select>

    <!-- 查询指定id学生信息 xxx还是占位符 -->

    <select id="selectById" resultType="Student">

        select * from student where

        id=#{xxx}

    </select>

    <!-- 模糊查询 -->

    <select id="selectByName" resultType="Student">

        <!-- 01.这种肯定不行 select * from student where name like '%2%' -->

        <!-- 02. select * from student where name like concat('%',#{xxx},'%') -->

        <!-- 03. 使用的是动态参数绑定 底层走的是preparedStatement 常用 select * from student where

            name like '%' #{xxx} '%' -->

        <!-- 04. 这种底层是使用了Statement 不安全 用户可以sql注入 select * from student where name

            like '%${value}%' -->

    </select>

</mapper>

public class StudentDaoImpl implements StudentDao {

    SqlSession session = null;

    /**

     * 新增学生信息

     */

    public void addStudent(Student student) {

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            /**

             *  "addStudent" 要和mapper.xml文件中的id一致

             *   增删改 操作  底层 执行的都是update方法

             */

            session.insert("addStudent", student);

            // 必须手动让session提交 底层默认就提交了事务

            session.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

    }

    public void addStudentCacheId(Student student) {

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            session.insert("addStudentCacheId", student);

            // 必须手动让session提交 底层默认就提交了事务

            session.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

    }

    // 删除

    public void deleteStudent(Integer id) {

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            session.delete("deleteStudent", id);

            // 必须手动让session提交 底层默认就提交了事务

            session.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

    }

    // 修改学生信息

    public void updateStudent(Student student) {

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            session.update("updateStudent", student);

            // 必须手动让session提交 底层默认就提交了事务

            session.commit();

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

    }

    // 查询返回list集合

    public List<Student> selectAllStudents() {

        List<Student> students = new ArrayList<Student>();

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            students = session.selectList("selectAllStudents");

            // 查询就不需要提交事务了

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

        return students;

    }

    // 返回map集合

    public Map<String, Object> selectAllStudentsMap() {

        Map<String, Object> students = new HashMap<String, Object>();

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            // 还是之前list的方法 但是 key放什么？ key必须是查询出来实体类的属性值

            students = session.selectMap("selectAllStudents", "name");

            // 查询就不需要提交事务了

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

        return students;

    }

    // 根据id查询指定的学生信息

    public Student selectById(Integer id) {

        Student students = null;

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            // 还是之前list的方法 但是 key放什么？ key必须是查询出来实体类的属性值

            students = session.selectOne("selectById", id);

            // 查询就不需要提交事务了

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

        return students;

    }

    // 根据name模糊查询 返回list集合

    public List<Student> selectByName(String name) {

        List<Student> students = new ArrayList<Student>();

        try {

            // 通过工具类获取session

            session = SessionUtil.getSession();

            students = session.selectList("selectByName", name);

            // 查询就不需要提交事务了

        } catch (Exception e) {

            e.printStackTrace();

        } finally {

            if (session != null) {

                session.close(); // 关闭session

            }

        }

        return students;

    }

}

public class StudentTest {

    StudentDao dao;

    @Before

    public void before() {

        dao = new StudentDaoImpl();

    }

    @Test

    public void test() {

        /**

         * 之前和之后 都是显示 我们赋予的id值，

         * 但因为数据库中 我们设置了 主键的自增，所以我们的id相当于没有从数据库中查询到

        */

        Student student = new Student("小黑333", 10);

        System.out.println("方法之前==" + student);

        dao.addStudent(student);

        System.out.println("方法之后==" + student);

    }

    @Test

    public void addStudentCacheId() {

        Student student = new Student("小黑33", 10);

        // 方法之前因为没有insert语句 所以也是没有ID的

        System.out.println("方法之前==" + student);

        dao.addStudentCacheId(student);

        // 产生了 数据库中的id

        System.out.println("方法之后==" + student);

    }

    // 删除

    @Test

    public void delete() {

        dao.deleteStudent(17);

    }

    // 修改

    @Test

    public void update() {

        Student student = new Student(19, "小黑3111", 10);

        student.setId(17);

        dao.updateStudent(student);

    }

    // 返回list

    @Test

    public void selectList() {

        List<Student> allStudents = dao.selectAllStudents();

        for (Student student : allStudents) {

            System.out.println(student);

        }

    }

    // 返回map

    @Test

    public void selectMap() {

        Map<String, Object> students = dao.selectAllStudentsMap();

        /**

         * 因为以name属性作为 了key

         * map集合key不允许出现重复的数据

         * 所以后一个会覆盖前一个

         */

        System.out.println(students.get("小黑122"));

    }

    // 返回指定的一个学生信息

    @Test

    public void selectOne() {

        Student students = dao.selectById(1);

        System.out.println(students);

    }

    // 模糊查询学生信息

    @Test

    public void selectByName() {

        List<Student> students = dao.selectByName("1");

        for (Student student : students) {

            System.out.println(student);

        }

    }

}