Mybatais02 增删改查

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);
}

2.修改StudentMapper

<?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">
 <!-- 

SELECT LAST_INSERT_ID();
SELECT @@identity;

-->

        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>

3.修改StudentDaoImpl

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;
    }
}

4.修改测试类

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);
        }
    }
}