mybatis02–增删改查详解编程语言

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