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

最新推荐文章于 2023-05-03 20:20:54 发布
最新推荐文章于 2023-05-03 20:20:54 发布
阅读量296 收藏 1
点赞数
分类专栏： java基础教程 文章标签： java基础
原文链接：https://www.cnblogs.com/859630097com/p/14439046.html
版权

知识点梳理

在这里插入图片描述

课堂讲义
一.Mybatis注解开发单表操作 ***
1.1 MyBatis的常用注解
之前我们在Mapper映射文件中编写的sql语句已经c#教程各种配置，其实是比较麻烦的

而这几年来注解开发越来越流行，Mybatis也可以使用java基础注解开发方式，这样我们就可以减少编写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();
}

返回自动增长主键

介绍

在这里插入图片描述

代码

在这里插入图片描述

在insert注解之上添加Options注解

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

测试

在这里插入图片描述

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

结果

在这里插入图片描述

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 语句”)：执行删除操作注解

配置映射关系


二.MyBatis注解开发的多表操作
2.1 MyBatis的注解实现复杂映射开发
实现复杂关系映射之前我们可以在映射文件中通过配置来实现，

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

在这里插入图片描述

在这里插入图片描述

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 一对一查询的模型
一对一查询的需求：查询一个用户信息，与此同时查询出该用户对应的身份证信息

在这里插入图片描述

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

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

在这里插入图片描述

chinaherolts2008
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis案例四：基于注解的学生管理程序
qq_54085202的博客
02-28 3125
在数据库中创建一个学生表s_student和班级表c_class 学生表（s_student） 学生（id） 学生姓名（name） 学生年龄（age） 所属班级（cid） 1 张三 18 1 2 李四 18 2 3 王五 19 2 4 赵六 20 1 班级表（c_class） 班级id（id） 班级名称（classname） 1 一班 2 二班 要求： 1.查询
JAVA EE案例：基于MyBatis注解的学生管理程序
WHT869706733的博客
04-11 6325
1.题目 现有一个学生表s_student（学生id、学生姓名、学生年龄、所属班级）和一个班级表c_class（班级id、班级名称），其中，班级表c_class和学生表s_student是一对多的关系。 表5-1学生表（s_student） 学生（id） 学生姓名（name） 学生年龄（age） 所属班级（cid） 1 张三 18 1 2 李四 18 2 3 王五 19 2 4 赵六 20 1
Mybatis 基于注解方式实现学生成绩管理系统（完整代码）
AsajuHuishi的博客
01-26 2276
Mybatis学生成绩管理系统（Service+Dao）简介任务环境相关工作目录结构具体实现使用MySQL生成表配置文件实体类数据访问层业务逻辑层测试实现结果 简介 本文基于Mybatis3.4.5和Spring5框架实现一个简单的学生成绩管理系统。它基于注解方式实现Dao层以及Service层的基本功能。 任务 环境 JDK 1.8 Intellij IDEA 2020.3.1 相关工作 MySQL+java: 实现学生成绩管理系统（1.0版本） MySQL+java: 实现学生成绩管理系统（2.0
【JavaEE案例】基于MyBatis注解的学生管理程序
weixin_66697650的博客
03-25 4816
现有一个学生表s_student和一个班级表c_class，其中，班级表c_class和学生表s_student是一对多的关系。创建持久化类IClass，并在类中定义相关属性和方法，该类用于封装IClass对象的id、班级名称以及关联的学生集合等属性。创建持久化类IStudent，并在类中定义相关属性和方法，该类用于封装IStudent对象的id、姓名、年龄和班级等属性。根据表格在数据库分别创建一个学生表s_student和一个班级表c_class，并查询id为2的学生的信息。
基于MyBatis注解的学生管理程序-ssm彻底掌握的练手项目
08-29
基于MyBatis注解的学生管理程序-ssm彻底掌握的练手项目 1.包含项目所有需要的离线jar junit-4.7 log4j-1.2.16 mybatis-3.2.2-sources mybatis-3.3.0 mysql-connector-java-5.1.0-bin mysql-connector-java-8.0.26 2....
Mybatis基于注解形式的sql语句生成实例代码
08-29
主要介绍了 Mybatis基于注解形式的sql语句生成实例代码,需要的朋友可以参考下
demo.zip_Mybatis注解时的sql语句拼接方法_SSM 注解_SSM分页查询_mybatis注解分页_基于ssm
09-24
在做基于SSM框架时，因用的是全注解模式开发，在做些查询+分页工作时Mybatis注解并不能很好的进行sql编写，因而用到了这个java类，对实现了sql语句的拼接。
mybatis中注解映射SQL示例代码
08-29
主要给大家介绍了关于mybatis中注解映射SQL的相关资料，文中给出了详细的示例代码供大家参考学习，对大家的学习或者共组具有一定的参考学习价值，需要的朋友们下面跟着小编来一起学习学习吧。
mybatis注解与xml常用语句汇总
08-26
最近一直在用mybatis，由于需要使用到了动态sql，遇到了一些问题，现在来总结一下，经验教训。下面这篇文章主要给大家总结介绍了mybatis注解与xml常用语句的相关资料，文中通过示例代码介绍的非常详细，需要的朋友...
基于Mybatis注解的学生管理程序
诉衷情の麻雀的博客
04-02 1409
现有一个学生表s_student和一个班级表c_class，其中，班级表c_class和学生表s_student是一对多的关系。学生表s_student和班级表c_class如表1和表2所示。在核心配置文件mybatis-config.xml中的元素下引入IStudentMapper接口，将IStudentMapper接口加载到核心配置文件中，具体代码如下所示。根据表1和表2在数据库分别创建一个学生表s_student和一个班级表c_class， 并查询id为2的学生的信息。
MyBatis——基于MyBatis注解的学生管理程序
m0_72151428的博客
11-03 2214
MyBatis——基于MyBatis注解的学生管理程序
基于MyBatis注解的学生管理程序
执着&你
04-25 5405
除了XML的映射方式，MyBatis还支持通过注解实现POJO对象和数据表之间的关联映射。使用MyBatis注解时，一般将SQL语句直接写在接口上。与XML相比，基于注解的映射方式相对简单和且不会增加系统的开销。MyBatis提供了@Select 、@Delect 、@Update、@Insert和@Param等用于增删改查，以及传递参数的常用注解。
第5章 MyBatis的注解开发
小猪宝宝的博客
08-30 1315
但在实际开发中，大量的XML配置文件的编写是非常繁琐的，为此，MyBatis提供了更加简便的基于注解的配置方式。
MyBatis动态创建表
weixin_33737774的博客
07-10 1026
　　转载请注明出处：https://www.cnblogs.com/Joanna-Yan/p/9187538.html  　　项目中业务需求的不同，有时候我们需要动态操作数据表（如：动态建表、操作表字段等）。常见的我们会把日志、设备实时位置信息等存入数据表，并且以一定时间段生成一个表来存储，log_201806、log_201807等。在这里我们用MyBatis实现，会用到动态SQL。 　　动态S...
使用mybatis在程序运行时创建数据库表
qq_41244721的博客
08-03 5232
springBoot+mybatis实现在程序运行时动态创建数据库表
Mybatis—基础
qq_48384411的博客
05-03 2715
会查询id,username,password,email这四个列，而自定义的方法返回值是User，里面的name，pwd属性没有找到列名，相当于查找``select id,name,pwd,email from USER where id=6`,user表没有name和pwd这两个列名所以返回了null。还有许多类似的使用场景。创建对应的Mapper接口类的xml文件，实现对应方法的sql语句；中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。
Mybatis建表
bsegebr的博客
04-13 2529
如果建表语句的静态的那完全不用Mybatis，在数据库就可以建。最近工作中遇到问题需要在Mybatis动态建表，尝试来解决这个问题。 首先我们拿到建表语句 String sqlText = “…” 。 正确方案 应该将表名跟建表语句分开，使之大致拼成一个CREATE TABLE 的SQL,如： <update id="createNewTable"> CREATE TABLE ${tableName} AS ${sqlText} </update>
MyBatis
博客的博客
07-30 762
MyBatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架 MyBatis 避免了几乎所有的JDBC代码和手动设置参数以及获取结果集 MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和ava的POJO(Plain Old Javaobjects，普通的Java对象）映射成数据库中的记录 MyBatis是一个半自动的ORM (Object Relation Mapping —— 对象关系映射)框架......
mybatis注解开发动态sql
最新发布
09-13
MyBatis注解开发动态SQL可以通过使用MyBatis的注解来生成动态SQL语句。下面是一些常用的注解和示例： 1. @SelectProvider：用于动态生成SELECT语句的注解。可以根据方法的参数动态生成不同的查询条件。 示例： ```java @SelectProvider(type = UserSqlProvider.class, method = "getUserById") User getUserById(Long id); ``` 2. @InsertProvider：用于动态生成INSERT语句的注解。可以根据对象的属性动态生成插入语句。 示例： ```java @InsertProvider(type = UserSqlProvider.class, method = "insertUser") void insertUser(User user); ``` 3. @UpdateProvider：用于动态生成UPDATE语句的注解。可以根据对象的属性动态生成更新语句。 示例： ```java @UpdateProvider(type = UserSqlProvider.class, method = "updateUser") void updateUser(User user); ``` 4. @DeleteProvider：用于动态生成DELETE语句的注解。可以根据方法的参数动态生成删除条件。 示例： ```java @DeleteProvider(type = UserSqlProvider.class, method = "deleteUserById") void deleteUserById(Long id); ``` 在使用上述注解时，需要提供一个对应的SQL提供者类（如上面示例中的UserSqlProvider），该类中定义了对应的SQL语句生成逻辑。 希望以上信息能对你有所帮助！如果你有其他问题，请继续提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值