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.xml

    <!--配置映射关系:这里已经没有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.xml");

           //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.xml");

       //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.xml");

       //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.xml");

       //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.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取CardMapper接口的实现类对象
        CardMapper mapper = sqlSession.getMapper(CardMapper.class);

        //5.调用实现类对象中的方法,接收结果
        List<Card> list = mapper.selectAll();

        //6.处理结果
        for (Card card : list) {
            System.out.println(card);
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
  • 结果

     

     

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 classes

SELECT * 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.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取ClassesMapper接口的实现类对象
        ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);

        //5.调用实现类对象中的方法,接收结果
        List<Classes> list = mapper.selectAll();

        //6.处理结果
        for (Classes cls : list) {
            System.out.println(cls.getId() + "," + cls.getName());
            List<Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
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.id
SELECT 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.xml");

        //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.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println("\t" + cours);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
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.Driver
    url=jdbc:mysql://192.168.59.143:3306/db3
    username=root
    password=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 http://www.itheima.com
     */
    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.xml"));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        // 提供静态方法,返回SqlSession对象
        public static SqlSession getSqlSession() {
            return sqlSessionFactory.openSession(true);
        }
    }
    
  • 修改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 http://www.itheima.com
     */
    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 http://www.itheima.com
     */
    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();
        }
    }
  • 员工管理也有增删改查,大家可以作为课下作业

     

     

     

  •  

 

posted @ 2021-02-14 14:00  赶星而至  阅读(72)  评论(0编辑  收藏