知识点梳理

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

课堂讲义

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

1.1 MyBatis的常用注解

之前我们在Mapper映射文件中编写的sql语句已经各种配置，其实是比较麻烦的
而这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了
常用注解
- @Select(“查询的 SQL 语句”)：执行查询操作注解
- @Insert(“查询的 SQL 语句”)：执行新增操作注解
- @Update(“查询的 SQL 语句”)：执行修改操作注解
- @Delete(“查询的 SQL 语句”)：执行删除操作注解

1.2 注解实现查询操作

表：我们还是用db1中的student表
新建mybatis04项目
- 导入所需要的包
- 配置相关的几个配置文件（配置文件的内容与之前项目都一致，这里就不在罗列）
- 新建所需要的包

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

创建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();
}

配置MyBatisConfig.xml

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

测试类：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 注解实现新增操作

StudentMapper新增接口方法

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

测试方法

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

返回自动增长主键
1. 介绍
2. 代码
  - 在insert注解之上添加Options注解
  - 指定主键列为id，主键属性为id（意味会将注解列id最终的自增结果返回，并且赋值给stu的id属性）
3. 测试
  - 在mapper.insert(stu)之后，会将操作结果返回，并且也会对stu本身的id进行赋值
4. 结果

1.4 注解实现修改操作

StudentMapper新增接口方法

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

测试方法

@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 注解实现删除操作

StudentMapper新增接口方法

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

测试方法

@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注解组合完成复杂关系的配置

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

2.2 一对一查询

2.2.0 准备工作

创建项目: mybatis05

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

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

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 一对一查询的模型

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

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

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 分析

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

2.3 一对多查询

2.3.1 一对多查询的模型

一对多查询的需求：查询一个课程，与此同时查询出该该课程对应的学生信息

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

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 分析

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

2.4 多对多查询

2.4.1 多对多查询的模型

多对多查询的需求：查询学生以及所对应的课程信息

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

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 分析

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

三.构建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 环境搭建

创建数据库

-- 创建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');

将之前的“JDBC基础网页版”项目copy过来
运行起来：注意这个项目的虚拟目录必须是/，因为界面中的链接写死了
输入zhangsan，1234，登陆进去，我们现在要处理的是在校学生管理：
在这里，可以对学生进行增删改查，之前是通过jdbc实现的这些功能，现在我们需要通过mybatis来实现
增加jar包：
复制相关的配置文件：log4j和MyBatisConfig

修改config.properties（这个其实就是jdbc配置文件）

driver=com.mysql.jdbc.Driver

url=jdbc:mysql://192.168.59.143:3306/db3

username=root

password=itheima

修改MyBatisConfig主配置文件：

<!--引入数据库连接的配置文件-->

<properties resource="config.properties"/>

起别名的配置删掉

<!--配置映射关系-->

<mappers>

	<package name="com.itheima.dao"/>

</mappers>

删除StudentDaoImpl，我们不需要实现类，我们会通过接口代理的方式来实现

修改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);

}

修改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();

    }

}

员工管理也有增删改查，大家可以作为课下作业