Mybatis注解开发单表、多表操作的实现代码

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

返回自动增长主键

介绍

代码

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

配置映射关系

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

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

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

  • 实现复杂关系映射之前我们可以在映射文件中通过配置 <resultMap> 来实现，
  • 使用注解开发后，我们可以使用@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<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();
 }
}

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

到此这篇关于Mybatis注解开发单表、多表操作的实现代码的文章就介绍到这了,更多相关Mybatis注解开发内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

赞 (0)

相关推荐

  • SpringBoot整合Mybatis注解开发的实现代码

    官方文档: https://mybatis.org/mybatis-3/zh/getting-started.html SpringBoot整合Mybatis 引入maven依赖 (IDEA建项目的时候直接选就可以了) <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <ve

  • MyBatis使用注解开发实现过程详解

    使用注解开发 1.面向接口编程 面向接口编程的根本原因:解耦,可扩展,提高复用,分层开发中.上层不用管具体的实现,大家都遵守共同的标准,使得开发变得容易,规范性好 2.使用注解开发 注解在接口上实现 @Select(value = "select * from user") List<User> getUsers(); 需要在核心配置文件中绑定接口 <!--绑定接口--> <mappers> <mapper class="rui.da

  • MyBatis 多表操作的实现

    1.1 一对一查询 1.1.1 概述   关系数据库中第一个表中的单个行只可以与第二个表中的一个行相关,且第二个表中的一个行也只可以与第一个表中的一个行相关. 1.1.2 创建实体类 public class Student { private Integer id; private String name; private Boolean age; private String sex; private StudentStatus studentStatus; // set and get }

  • 使用Mybatis对数据库进行单表操作的实现示例

    简介 该篇文章主要是介绍如何使用MyBatis对Mysql数据库进行单表操作(对于mybatis的下载以及配置文件的作用和具体信息,我在上一篇文章中也已经提到了),使用的环境如下: JDK版本:1.8 编译器:IDEA2019 JDBC版本:8.0.18 mybatis版本:3.5.3 配置文件 首先需要有两个配置文件,一个是configuration.xml文件,配置的是连接数据库的环境以及对于mapper.xml文件的映射,还有另一个文件就是mapper.xml,这个文件主要是用来写sql语

  • Mybatis注解开发单表、多表操作的实现代码

    Mybatis注解开发单表、多表操作的实现代码

    一.Mybatis注解开发单表操作 *** 1.1 MyBatis的常用注解 之前我们在Mapper映射文件中编写的sql语句已经各种配置,其实是比较麻烦的 而这几年来注解开发越来越流行,Mybatis也可以使用注解开发方式,这样我们就可以减少编写Mapper映射文件了 常用注解 @Select("查询的 SQL 语句"):执行查询操作注解 @Insert("查询的 SQL 语句"):执行新增操作注解 @Update("查询的 SQL 语句"):

  • Mybatis示例讲解注解开发中的单表操作

    Mybatis示例讲解注解开发中的单表操作

    目录 Mybatis注解开发单表操作 MyBatis的常用注解 MyBatis的增删改查 注解开发总结 常用注解 配置映射关系 练习项目代码 Mybatis注解开发单表操作 MyBatis的常用注解 Mybatis也可以使用注解开发方式,这样我们就可以减少编写Mapper映射文件了.我们先围绕一些基本的CRUD来学习,再学习复杂映射多表操作. 注解 说明 @Insert 实现新增 @Update 实现更新 @Delete 实现删除 @Select 实现查询 @Result 实现结果集封装 @Re

  • MyBatis学习教程(二)—如何使用MyBatis对users表执行CRUD操作

    上一篇文章MyBatis入门学习教程(一)-MyBatis快速入门中我们讲了如何使用Mybatis查询users表中的数据,算是对MyBatis有一个初步的入门了,今天讲解一下如何使用MyBatis对users表执行CRUD操作.在没奔主题之前,先给大家补充点有关mybatis和crud的基本知识. 什么是 MyBatis? MyBatis 是支持普通 SQL 查询,存储过程和高级映射的优秀持久层框架. MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及对结果集的检索.MyBa

  • Mybatis基于xml配置实现单表的增删改查功能

    Mybatis基于xml配置实现单表的增删改查功能

    Mybatis入门-基于配置实现单表的增删改查 Mybatis简介 官网链接:https://mybatis.org/mybatis-3/zh/index.html.更加详细的信息可以去官网查看. MyBatis 是一款优秀的持久层框架,它支持自定义 SQL.存储过程以及高级映射.MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作.MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型.接口和 Java POJO(Plain Old Java Object

  • MyBatis学习教程(五)-实现关联表查询方法详解

    MyBatis学习教程(五)-实现关联表查询方法详解

    一.一对一关联  1.1.提出需求 根据班级id查询班级信息(带老师的信息) 1.2.创建表和数据 创建一张教师表和班级表,这里我们假设一个老师只负责教一个班,那么老师和班级之间的关系就是一种一对一的关系. CREATE TABLE teacher( t_id INT PRIMARY KEY AUTO_INCREMENT, t_name VARCHAR() ); CREATE TABLE class( c_id INT PRIMARY KEY AUTO_INCREMENT, c_name VAR

  • JS document form表单元素操作完整示例

    JS document form表单元素操作完整示例

    本文实例讲述了JS document form表单元素操作.分享给大家供大家参考,具体如下: <html> <head> <title>form表单操作</title> <meta charset="UTF-8"/> <script type="text/javascript"> function testForm(){ // 获取form对象 方法一,通过id,比较普遍的方法 var fm=d

  • MyBatis Plus 实现多表分页查询功能的示例代码

    在Mybatis Plus 中,虽然IService 接口帮我们定义了很多常用的方法,但这些都是 T 对象有用,如果涉及到 多表的查询,还是需要自定义Vo 对象和自己编写sql 语句,Mybatis Plus提供了一个Page 对象,查询是需要设置其中的 size 字段 和 current 字段的值 一.分页配置 可以直接使用selectPage这样的分页,但返回的数据确实是分页后的数据,但在控制台打印的SQL语句其实并没有真正的物理分页,而是通过缓存来获得全部数据中再进行的分页,这样对于大数据

  • C语言实现顺序表的全操作详解

    C语言实现顺序表的全操作详解

    目录 线性表 顺序表 顺序表接口实现 1.顺序表初始化 2.顺序表空间增容 3.顺序表打印 4.尾插数据 5.尾删数据 6.头插数据 7.头删数据 8.在pos下标处插入数据 9.删除pos下标处数据 10.数据查找 11.顺序表摧毁 线性表 线性表(linear list)是n个具有相同特性的数据元素的有限序列.线性表是一种在实际中广泛使用的数据结构,常见的线性表有:顺序表.链表.栈.队列.字符串等. 线性表在逻辑上是线性结构,也就是连续的一条直线.但在物理结构上并不一定是连续的,线性表在物理

  • Mybatis详解动态SQL以及单表多表查询的应用

    目录 单表查询操作 参数占位符#{}和${} SQL 注入 like模糊查询 多表查询操作 一对一多表查询 一对多多表查询 动态SQL使用 if标签 trim标签 where标签 set标签 foreach标签 单表查询操作 参数占位符#{}和${} #{}:相当于JDBC里面替换占位符的操作方式(#{}->“”).相当于预编译处理(预编译处理可以防止SQL注入问题) ${}:相当于直接替换(desc这种关键字),但这种不能预防SQL注入 select * from userinfo where

  • mybatis水平分表实现动态表名的项目实例

    目录 一.水平分表 二.项目实现 目录结构 三.扩展 一.水平分表 当业务需求的数据量过大时,一个表格存储数据会非常之多,故时长采用水平分表的方式来减少每张表的数据量即是提升查询数据库时的效率. 水平分表时,各表的结构完全一样,表名不同. 例如:这里我们建了10张user表,每张表的结构完全一致,表名由0~9. 表中包含有id和name属性且都采用varchar的存储类型. 为什么id没有采用int自增的形式? 大型项目极有可能采用分布式数据库,若采用自增的方式,会导致id重复.且id也不一定只

随机推荐