2021年2月24日星期三

Mybatis高级:Mybatis注解开发单表操作,Mybatis注解开发多表操作,构建sql语句,综合案例学生管理系统使用接口注解方式优化

Mybatis高级:Mybatis注解开发单表操作,Mybatis注解开发多表操作,构建sql

知识点梳理

课堂讲义

一.Mybatis注解开发单表操作 ***

1.1 MyBatis的常用注解

  • 之前我们在Mapper映射文件中编写的sql语句已经各种配置，其实是比较麻烦的

  • 而这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了

  • 常用注解

    • @Select("查询的 SQL 语句")：执行查询操作注解

    • @Insert("查询的 SQL 语句")：执行新增操作注解

    • @Update("查询的 SQL 语句")：执行修改操作注解

    • @Delete("查询的 SQL 语句")：执行删除操作注解

1.2 注解实现查询操作

  1. 表：我们还是用db1中的student表

     

     

  2. 新建mybatis04项目

     

     

    • 导入所需要的包

    • 配置相关的几个配置文件（配置文件的内容与之前项目都一致，这里就不在罗列）

    • 新建所需要的包

  3. javabean

    package com.itheima.bean;
    ​
    public class Student {
        private Integer id;
        private String name;
        private Integer age;
    ​
        public Student() {
       }
    ​
        public Student(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
       }
    ​
        public Integer getId() {
            return id;
       }
    ​
        public void setId(Integer id) {
            this.id = id;
       }
    ​
        public String getName() {
            return name;
       }
    ​
        public void setName(String name) {
            this.name = name;
       }
    ​
        public Integer getAge() {
            return age;
       }
    ​
        public void setAge(Integer age) {
            this.age = age;
       }
    ​
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
       }
    }

  4. 创建mapper接口

    package com.itheima.mapper;
    ​
    import com.itheima.bean.Student;
    import org.apache.ibatis.annotations.Select;
    ​
    import java.util.List;
    ​
    public interface StudentMapper {
        //查询全部
        @Select("SELECT * FROM student")
        public abstract List<Student> selectAll();
    }
    ​

  5. 配置MyBatisConfig.

    <!--配置映射关系：这里已经没有Mapper映射文件了，但是我们需要配置mapper接口所在的包-->
    <mappers>
        <package name="com.itheima.mapper"/>
    </mappers>
    <!--其实是注解的方式帮助我们生成了映射文件，所以我们依然是在mappers节点里配置-->

  6. 测试类：com.itheima.test.Test01

      @Test
        public void selectAll() throws Exception{
            //1.加载核心配置文件
            InputStream is = Resources.getResourceAsStream("MyBatisConfig.​
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    ​
            //3.通过工厂对象获取SqlSession对象
            SqlSession sqlSession = sqlSessionFactory.openSession(true);
    ​
            //4.获取StudentMapper接口的实现类对象
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    ​
            //5.调用实现类对象中的方法，接收结果
            List<Student> list = mapper.selectAll();
    ​
            //6.处理结果
            for (Student student : list) {
                System.out.println(student);
           }
       }

  • 注意：

    • 修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可

    <mappers>
        <!--扫描使用注解的类-->
        <mapper class="com.itheima.mapper.UserMapper"></mapper>
    </mappers>

    • 或者指定扫描包含映射关系的接口所在的包也可以

    <mappers>
        <!--扫描使用注解的类所在的包-->
        <package name="com.itheima.mapper"></package>
    </mappers>

1.3 注解实现新增操作

  1. StudentMapper新增接口方法

    //新增操作: sql的参数与之前的写法一致，从insert方法的参数中获取对应属性值
    @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Student stu);

  2. 测试方法

    @Test
    public void insert() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.​
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    ​
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
    ​
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    ​
        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",26);
        Integer result = mapper.insert(stu);
    ​
        //6.处理结果
        System.out.println(result);
    ​
        //7.释放资源
        sqlSession.close();
        is.close();
    }

  3. 返回自动增长主键

    1. 介绍

       

       

    2. 代码

       

       

      • 在insert注解之上添加Options注解

      • 指定主键列为id，主键属性为id（意味会将注解列id最终的自增结果返回，并且赋值给stu的id属性）

    3. 测试

       

       

      • 在mapper.insert(stu)之后，会将操作结果返回，并且也会对stu本身的id进行赋值

    4. 结果

       

       

     

1.4 注解实现修改操作

  1. StudentMapper新增接口方法

    //修改操作
    @Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}")
    public abstract Integer update(Student stu);

  2. 测试方法

    @Test
    public void update() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.​
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    ​
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
    ​
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    ​
        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",36);
        Integer result = mapper.update(stu);
    ​
        //6.处理结果
        System.out.println(result);
    ​
        //7.释放资源
        sqlSession.close();
        is.close();
    }

1.5 注解实现删除操作

  1. StudentMapper新增接口方法

    //删除操作
    @Delete("DELETE FROM student WHERE id=#{id}")
    public abstract Integer delete(Integer id);

  2. 测试方法

    @Test
    public void delete() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.​
        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
    ​
        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
    ​
        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    ​
        //5.调用实现类对象中的方法，接收结果
        Integer result = mapper.delete(4);
    ​
        //6.处理结果
        System.out.println(result);
    ​
        //7.释放资源
        sqlSession.close();
        is.close();
    }

1.6 注解开发总结

注解可以简化开发操作，省略映射配置文件的编写

  • 常用注解

    @Select("查询的 SQL 语句")：执行查询操作注解

    @Insert("查询的 SQL 语句")：执行新增操作注解

    @Update("查询的 SQL 语句")：执行修改操作注解

    @Delete("查询的 SQL 语句")：执行删除操作注解

  • 配置映射关系 

    <mappers> <package name="接口所在包"/> </mappers>    

二.MyBatis注解开发的多表操作

2.1 MyBatis的注解实现复杂映射开发

  • 实现复杂关系映射之前我们可以在映射文件中通过配置<resultMap>来实现，

  • 使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

 

 

 

 

2.2 一对一查询

2.2.0 准备工作

  1. 创建项目: mybatis05

     

     

  2. javabean - card

    package com.itheima.bean;
    ​
    public class Card {
        private Integer id;     //主键id
        private String number;  //身份证号
    ​
        private Person p;       //所属人的对象
    ​
        public Card() {
       }
    ​
        public Card(Integer id, String number, Person p) {
            this.id = id;
            this.number = number;
            this.p = p;
       }
    ​
        public Integer getId() {
            return id;
       }
    ​
        public void setId(Integer id) {
            this.id = id;
       }
    ​
        public String getNumber() {
            return number;
       }
    ​
        public void setNumber(String number) {
            this.number = number;
       }
    ​
        public Person getP() {
            return p;
       }
    ​
        public void setP(Person p) {
            this.p = p;
       }
    ​
        @Override
        public String toString() {
            return "Card{" +
                    "id=" + id +
                    ", number='" + number + '\'' +
                    ", p=" + p +
                    '}';
       }
    }

  3. javabean - person

    package com.itheima.bean;
    ​
    public class Person {
        private Integer id;     //主键id
        private String name;    //人的姓名
        private Integer age;    //人的年龄
    ​
        public Person() {
       }
    ​
        public Person(Integer id, String name, Integer age) {
            this.id = id;
            this.name = name;
            this.age = age;
       }
    ​
        public Integer getId() {
            return id;
       }
    ​
        public void setId(Integer id) {
            this.id = id;
       }
    ​
        public String getName() {
            return name;
       }
    ​
        public void setName(String name) {
            this.name = name;
       }
    ​
        public Integer getAge() {
            return age;
       }
    ​
        public void setAge(Integer age) {
            this.age = age;
       }
    ​
        @Override
        public String toString() {
            return "Person{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
       }
    }
    ​

  4. cardMapper接口：我们的核心就是要在Card中做一些处理，实现一对一的查询

    package com.itheima.one_to_one;
    ​
    import com.itheima.bean.Card;
    ​
    import java.util.List;
    ​
    public interface CardMapper {
        //查询全部
        public abstract List<Card> selectAll();
    }
2.2.1 一对一查询的模型

一对一查询的需求：查询一个用户信息，与此同时查询出该用户对应的身份证信息

 

 

2.2.2 一对一查询的语句

对应的sql语句：

SELECT * FROM card； -- 只根据这个sql语句只能查询出来card的数据SELECT * FROM person WHERE id=#{id}; -- 需要根据card表中查询出来的pid，再次查询person数据才能将person数据也查询出来
2.2.3 创建PersonMapper接口
public interface PersonMapper { //根据id查询 @Select("SELECT * FROM person WHERE id=#{id}") public abstract Person selectById(Integer id);}
2.2.4 使用注解配置CardMapper
public interface CardMapper { //查询全部 @Select("SELECT * FROM card") @Results({   @Result(column = "id",property = "id"),   @Result(column = "number",property = "number"),   @Result(     property = "p",    // 被包含对象的变量名     javaType = Person.class, // 被包含对象的实际数据类型     column = "pid",    // 根据查询出的card表中的pid字段来查询person表     /*      one、@One 一对一固定写法      select属性：指定调用哪个接口中的哪个方法      */     one = @One(select = "com.itheima.one_to_one.PersonMapper.selectById")   ) }) public abstract List<Card> selectAll();}
2.2.5 测试类
package com.itheima.one_to_one;import com.itheima.bean.Card;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;import org.junit.Test;import java.io.InputStream;import java.util.List;public class Test01 { @Test public void selectAll() throws Exception{  //1.加载核心配置文件  InputStream is = Resources.getResourceAsStream("MyBatisConfig.
  • 结果
     
     
2.2.6 一对一配置总结
@Results：封装映射关系的父注解。	Result[] value()：定义了 Result 数组@Result：封装映射关系的子注解。	column 属性：查询出的表中字段名称	property 属性：实体对象中的属性名称	javaType 属性：被包含对象的数据类型	one 属性：一对一查询固定属性 @One：一对一查询的注解。	select 属性：指定调用某个接口中的方法
2.2.7 分析
 
 
2.3 一对多查询
2.3.1 一对多查询的模型
一对多查询的需求：查询一个课程，与此同时查询出该该课程对应的学生信息
 
 
2.3.2 一对多查询的语句
对应的sql语句：
SELECT * FROM classesSELECT * FROM student WHERE cid=#{cid}
2.3.3 创建StudentMapper接口
public interface StudentMapper { //根据cid查询student表 @Select("SELECT * FROM student WHERE cid=#{cid}") public abstract List<Student> selectByCid(Integer cid);}
2.3.4 使用注解配置Mapper
public interface ClassesMapper { //查询全部 @Select("SELECT * FROM classes") @Results({   @Result(column = "id",property = "id"),   @Result(column = "name",property = "name"),   @Result(     property = "students", // 被包含对象的变量名     javaType = List.class, // 被包含对象的实际数据类型     column = "id",   // 根据查询出的classes表的id字段来查询student表     /*      many、@Many 一对多查询的固定写法      select属性：指定调用哪个接口中的哪个查询方法      */     many = @Many(select = "com.itheima.one_to_many.StudentMapper.selectByCid")   ) }) public abstract List<Classes> selectAll();}
2.3.5 测试类
public class Test01 { @Test public void selectAll() throws Exception{  //1.加载核心配置文件  InputStream is = Resources.getResourceAsStream("MyBatisConfig.
2.3.6 一对多配置总结
@Results：封装映射关系的父注解。	Result[] value()：定义了 Result 数组@Result：封装映射关系的子注解。	column 属性：查询出的表中字段名称	property 属性：实体对象中的属性名称	javaType 属性：被包含对象的数据类型	many 属性：一对多查询固定属性@Many：一对多查询的注解。	select 属性：指定调用某个接口中的方法
2.3.7 分析
 
 
2.4 多对多查询
2.4.1 多对多查询的模型
多对多查询的需求：查询学生以及所对应的课程信息
 
 
2.4.2 多对多查询的语句
对应的sql语句：
SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.idSELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}
2.4.3 添加CourseMapper 接口方法
public interface CourseMapper { //根据学生id查询所选课程 @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}") public abstract List<Course> selectBySid(Integer id);}
2.4.4 使用注解配置Mapper
public interface StudentMapper { //查询全部 @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id") @Results({   @Result(column = "id",property = "id"),   @Result(column = "name",property = "name"),   @Result(column = "age",property = "age"),   @Result(     property = "courses", // 被包含对象的变量名     javaType = List.class, // 被包含对象的实际数据类型     column = "id",   // 根据查询出student表的id来作为关联条件，去查询中间表和课程表     /*      many、@Many 一对多查询的固定写法      select属性：指定调用哪个接口中的哪个查询方法      */     many = @Many(select = "com.itheima.many_to_many.CourseMapper.selectBySid")   ) }) public abstract List<Student> selectAll();}
2.4.5 测试类
public class Test01 { @Test public void selectAll() throws Exception{  //1.加载核心配置文件  InputStream is = Resources.getResourceAsStream("MyBatisConfig.
2.4.6 多对多配置总结
@Results：封装映射关系的父注解。	Result[] value()：定义了 Result 数组@Result：封装映射关系的子注解。	column 属性：查询出的表中字段名称	property 属性：实体对象中的属性名称	javaType 属性：被包含对象的数据类型	many 属性：一对多查询固定属性@Many：一对多查询的注解。	select 属性：指定调用某个接口中的方法
2.4.7 分析
 
 
三.构建sql
3.1 SQL构建对象介绍 
  • 我们之前通过注解开发时，相关 SQL 语句都是自己直接拼写的。一些关键字写起来比较麻烦、而且容易出错。
  • MyBatis 给我们提供了 org.apache.ibatis.jdbc.SQL 功能类，专门用于构建 SQL 语句 
     
     
  • 创建项目：将之前的注解的所有相关代码，配置文件拿过来
     
  • 新建测试类： com.itheima.sql.SqlTest
    package com.itheima.sql;public class SqlTest { public static void main(String[] args) {  String sql = getSql();  System.out.println(sql); } //定义方法，获取查询student表的sql语句 public static String getSql() {  String sql = "SELECT * FROM student";  return sql; }}
    • 如果sql语句比较长，sql中的关键字较多时，就可能会写错
  • 修改代码：使用SQL类通过的方法来编写sql语句
    package com.itheima.sql;import org.apache.ibatis.jdbc.SQL;public class SqlTest { public static void main(String[] args) {  String sql = getSql();  System.out.println(sql); } //定义方法，获取查询student表的sql语句 /*public static String getSql() {  String sql = "SELECT * FROM student";  return sql; }*/ public static String getSql() {  String sql = new SQL(){//通过SQL类提供的方法来实现sql语句的编写   {    SELECT("*");    FROM("student");   }  }.toString();  return sql; }}
  • 结果
     
     
3.2 查询功能的实现
  • 定义功能类并提供获取查询的 SQL 语句的方法
    • 新建类：com.itheima.sql.ReturnSql，定义获取sql语句的方法
    package com.itheima.sql;import org.apache.ibatis.jdbc.SQL;public class ReturnSql { //定义方法，返回查询的sql语句 public String getSelectAll() {  return new SQL() {   {    SELECT("*");    FROM("student");   }  }.toString(); 	//以上代码说明：内层的花括号是一个构造代码块，在实例化一个对象时会先于构造方法执行，编译时会将构造代码块移入构造方法中  //如果上述不理解，可以使用以下方式：Builder风格  String sql = new SQL()    .SELECT("*")    .FROM("student")    .toString();   return sql; }}
    • 那么如何获取这个提供了sql语句的方法呢？
    • 之前是在Mapper接口中直接通过注解(@Select，@Insert等)来设置的sql
    • 现在有提供了sql语句的方法，如何获取呢？
    • 通过@SelectProvider注解来获取
  • @SelectProvider：生成查询用的 SQL 语句注解（调用提供sql语句的方法，获取到查询的sql语句）
    • type 属性：用于指定生成 SQL 语句功能的类对象 
  • method 属性：用于指定类中要执行获取sql语句的方法 (指定方法名，不加小括号)
  • 修改StudentMapper
    //查询全部//@Select("SELECT * FROM student")//注意：method只是指定一个方法的名字，SelectProvider内部会自己调用@SelectProvider(type = ReturnSql.class , method = "getSelectAll")public abstract List<Student> selectAll();
  • 运行test包中的Test01的selectAll方法，能查询出数据即可
3.3 新增功能的实现
  • 定义功能类并提供获取新增的 SQL 语句的方法，在ReturnSql中增加如下方法：
    //定义方法，返回新增的sql语句public String getInsert(Student stu) { return new SQL() {  {   INSERT_INTO("student");   INTO_VALUES("#{id},#{name},#{age}");  } }.toString();}
  • @InsertProvider：生成新增用的 SQL 语句注解（调用提供sql语句的方法，获取到新增的sql语句）
    • type 属性：生成 SQL 语句功能类对象 
  • method 属性：指定调用方法 
  • 修改StudentMapper
    //新增功能//@Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")@InsertProvider(type = ReturnSql.class , method = "getInsert")public abstract Integer insert(Student stu);
  • 运行test包中的Test01的insert方法，能插入数据即可
3.4 修改功能的实现
  • 定义功能类并提供获取修改的 SQL 语句的方法
    //定义方法，返回修改的sql语句public String getUpdate(Student stu) { return new SQL() {  {   UPDATE("student");   SET("name=#{name}","age=#{age}");   WHERE("id=#{id}");  } }.toString();}
  • @UpdateProvider：生成修改用的 SQL 语句注解（调用提供sql语句的方法，获取到更新的sql语句）
    • type 属性：生成 SQL 语句功能类对象
  • method 属性：指定调用方法 
  • 修改StudentMapper
    //修改功能//@Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}")@UpdateProvider(type = ReturnSql.class , method = "getUpdate")public abstract Integer update(Student stu);
  • 运行test包中的Test01的update方法，能更新数据即可
3.5 删除功能的实现
  • 定义功能类并提供获取删除的 SQL 语句的方法
     //定义方法，返回删除的sql语句 public String getDelete(Integer id) {  return new SQL() {   {    DELETE_FROM("student");    WHERE("id=#{id}");   }  }.toString(); }
  • @DeleteProvider：生成删除用的 SQL 语句注解（调用提供sql语句的方法，获取到删除的sql语句）
    • type 属性：生成 SQL 语句功能类对象 
  • method 属性：指定调用方法 
  • 修改StudentMapper
    //删除功能//@Delete("DELETE FROM student WHERE id=#{id}")@DeleteProvider(type = ReturnSql.class , method = "getDelete")public abstract Integer delete(Integer id);
  • 运行test包中的Test01的delete方法，能删除数据即可
四.综合案例 ***
4.1 系统介绍
 我们之前在做学生管理系统时，使用的是原始JDBC操作数据库的，操作非常麻烦，现在我们使用MyBatis操作数据库，简化Dao的开发。
4.2 环境搭建
  1. 创建数据库
    -- 创建db3数据库CREATE DATABASE db3;-- 使用db3数据库USE db3;-- 创建用户表CREATE TABLE USER(	uid VARCHAR(50) PRIMARY KEY,	-- 用户id	ucode VARCHAR(50),		-- 用户标识	loginname VARCHAR(100),		-- 登录用户名	PASSWORD VARCHAR(100),		-- 登录密码	username VARCHAR(100),		-- 用户名	gender VARCHAR(10),		-- 用户性别	birthday DATE,			-- 出生日期	dutydate DATE     -- 入职日期);-- 添加一条测试数据INSERT INTO USER VALUES ('11111111', 'zhangsan001', 'zhangsan', '1234', '张三', '男', '2008-10-28', '2018-10-28');-- 创建student表CREATE TABLE student(	sid INT PRIMARY KEY AUTO_INCREMENT,	-- 学生id	NAME VARCHAR(20),			-- 学生姓名	age INT,				-- 学生年龄	birthday DATE				-- 学生生日);-- 添加数据INSERT INTO student VALUES (NULL,'张三',23,'1999-09-23'),(NULL,'李四',24,'1998-08-10'),(NULL,'王五',25,'1996-06-06'),(NULL,'赵六',26,'1994-10-20');
  2. 将之前的"JDBC基础网页版"项目copy过来
     
     
  3. 运行起来：注意这个项目的虚拟目录必须是/，因为界面中的链接写死了
     
     
  4. 输入zhangsan，1234，登陆进去，我们现在要处理的是 在校学生管理：
     
     
  5. 在这里，可以对学生进行增删改查，之前是通过jdbc实现的这些功能，现在我们需要通过mybatis来实现
  6. 增加jar包：
     
     
  7. 复制相关的配置文件：log4j和MyBatisConfig
     
     
  8. 修改config.properties（这个其实就是jdbc配置文件）
    driver=com.mysql.jdbc.Driverurl=jdbc:mysql://192.168.59.143:3306/db3username=rootpassword=itheima
  9. 修改MyBatisConfig主配置文件：
    <!--引入数据库连接的配置文件--><properties resource="config.properties"/>起别名的配置删掉<!--配置映射关系--><mappers>	<package name="com.itheima.dao"/></mappers>
  10. 删除StudentDaoImpl，我们不需要实现类，我们会通过接口代理的方式来实现
  11. 修改StudentDao，给接口方法通过注解的方式配置sql语句
    package com.itheima.dao;import com.itheima.domain.Student;import org.apache.ibatis.annotations.Delete;import org.apache.ibatis.annotations.Insert;import org.apache.ibatis.annotations.Select;import org.apache.ibatis.annotations.Update;import java.util.ArrayList;/* Dao层接口 */public interface StudentDao { //查询所有学生信息 @Select("SELECT * FROM student") public abstract ArrayList<Student> findAll(); //条件查询，根据id获取学生信息 @Select("SELECT * FROM student WHERE sid=#{sid}") public abstract Student findById(Integer sid); //新增学生信息 @Insert("INSERT INTO student VALUES (#{sid},#{name},#{age},#{birthday})") public abstract int insert(Student stu); //修改学生信息 @Update("UPDATE student SET name=#{name},age=#{age},birthday=#{birthday} WHERE sid=#{sid}") public abstract int update(Student stu); //删除学生信息 @Delete("DELETE FROM student WHERE sid=#{sid}") public abstract int delete(Integer sid);}
  12. 修改StudentServiceImpl，删除之前的DaoImpl的逻辑
    package com.itheima.service.impl;import com.itheima.domain.Student;import com.itheima.service.StudentService;import java.util.List;/** * 学生的业务层实现类 * @author 黑马程序员 * @Company */public class StudentServiceImpl implements StudentService { @Override public List<Student> findAll() {   } @Override public Student findById(Integer sid) { } @Override public void save(Student student) { } @Override public void update(Student student) { } @Override public void delete(Integer sid) { }}
4.3 代码改造
  • 我们主要是将原来的jdbc实现的方式改为mybatis实现
  • 新建com.itheima.utils.MyBatisUtils.java
    package com.itheima.utils;import org.apache.ibatis.io.Resources;import org.apache.ibatis.session.SqlSession;import org.apache.ibatis.session.SqlSessionFactory;import org.apache.ibatis.session.SqlSessionFactoryBuilder;import java.io.IOException;/* 工具类 */public class MyBatisUtils { // 私有构造方法 private MyBatisUtils(){} // 声明连接工厂对象 private static SqlSessionFactory sqlSessionFactory; // 静态代码块，读取核心配置文件并工厂对象赋值 static {  try {   sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("MyBatisConfig.
  • 修改StudentServiceImpl代码
    package com.itheima.service.impl;import com.itheima.dao.StudentDao;import com.itheima.domain.Student;import com.itheima.service.StudentService;import com.itheima.utils.MyBatisUtils;import org.apache.ibatis.session.SqlSession;import java.util.ArrayList;import java.util.List;/** * 学生的业务层实现类 * @author 黑马程序员 * @Company */public class StudentServiceImpl implements StudentService { @Override public List<Student> findAll() {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  ArrayList<Student> list = mapper.findAll();  // 释放资源  sqlSession.close();  // 返回结果  return list; } @Override public Student findById(Integer sid) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  Student stu = mapper.findById(sid);  // 释放资源  sqlSession.close();  // 返回结果  return stu; } @Override public void save(Student student) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.insert(student);  // 释放资源  sqlSession.close(); } @Override public void update(Student student) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.update(student);  // 释放资源  sqlSession.close(); } @Override public void delete(Integer sid) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.delete(sid);  // 释放资源  sqlSession.close(); }}package com.itheima.service.impl;import com.itheima.dao.StudentDao;import com.itheima.domain.Student;import com.itheima.service.StudentService;import com.itheima.utils.MyBatisUtils;import org.apache.ibatis.session.SqlSession;import java.util.ArrayList;import java.util.List;/** * 学生的业务层实现类 * @author 黑马程序员 * @Company */public class StudentServiceImpl implements StudentService { @Override public List<Student> findAll() {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  ArrayList<Student> list = mapper.findAll();  // 释放资源  sqlSession.close();  // 返回结果  return list; } @Override public Student findById(Integer sid) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  Student stu = mapper.findById(sid);  // 释放资源  sqlSession.close();  // 返回结果  return stu; } @Override public void save(Student student) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.insert(student);  // 释放资源  sqlSession.close(); } @Override public void update(Student student) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.update(student);  // 释放资源  sqlSession.close(); } @Override public void delete(Integer sid) {  // 获取SqlSession对象  SqlSession sqlSession = MyBatisUtils.getSqlSession();  // 获取StudentDao接口的实现类对象  StudentDao mapper = sqlSession.getMapper(StudentDao.class);  // 调用实现类对象相应的功能  mapper.delete(sid);  // 释放资源  sqlSession.close(); }}
  • 员工管理也有增删改查，大家可以作为课下作业
     
     
     
  •  
 



 
 
 

		
原文转载：http://www.shaoqun.com/a/581586.html
跨境电商：https://www.ikjzd.com/
vava：https://www.ikjzd.com/w/2780
 
拍拍：https://www.ikjzd.com/w/2205
 
Mybatis高级:Mybatis注解开发单表操作,Mybatis注解开发多表操作,构建sql知识点梳理课堂讲义一.Mybatis注解开发单表操作***1.1MyBatis的常用注解之前我们在Mapper映射文件中编写的sql语句已经各种配置，其实是比较麻烦的而这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了常用注解@Select("查
taofenba：https://www.ikjzd.com/w/1725
转口贸易：https://www.ikjzd.com/w/1427
淘粉8：https://www.ikjzd.com/w/1725.html
小白必看！你的亚马逊之路难以避免的套路：https://www.ikjzd.com/home/20258
Amazon欧洲站卖家注意了，2020年不办CE等将导致产品下架！：https://www.ikjzd.com/home/129595
做亚马逊跨境电商，如何规避风险？：https://www.ikjzd.com/home/110357
发帖者 时间：

没有评论:

发表评论

订阅： 博文评论 (Atom)