|
一.Mybatis注解开发单表操作 ***
1.1 MyBatis的常用注解
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 {
-
配置MyBatisConfig.xml
-
测试类：com.itheima.test.Test01
@Test
public void selectAll() throws Exception{
1.3 注解实现新增操作
-
StudentMapper新增接口方法
-
测试方法
@Test
public void insert() throws Exception{
-
返回自动增长主键
-
介绍
-
代码
-
测试
-
结果
1.4 注解实现修改操作
-
StudentMapper新增接口方法
-
测试方法
@Test
public void update() throws Exception{
1.5 注解实现删除操作
-
StudentMapper新增接口方法
-
测试方法
@Test
public void delete() throws Exception{
1.6 注解开发总结
注解可以简化开发操作，省略映射配置文件的编写
-
常用注解
@Select(“查询的 SQL 语句”)：执行查询操作注解
@Insert(“查询的 SQL 语句”)：执行新增操作注解
@Update(“查询的 SQL 语句”)：执行修改操作注解
@Delete(“查询的 SQL 语句”)：执行删除操作注解
-
配置映射关系
<mappers> <package name="接口所在包"/> </mappers>
二.MyBatis注解开发的多表操作
2.1 MyBatis的注解实现复杂映射开发
2.2 一对一查询
2.2.0 准备工作
-
创建项目: mybatis05
-
javabean - card
package com.itheima.bean;
public class Card {
private Integer id;
-
javabean - person
package com.itheima.bean;
public class Person {
private Integer id;
-
cardMapper接口：我们的核心就是要在Card中做一些处理，实现一对一的查询
package com.itheima.one_to_one;
import com.itheima.bean.Card;
import java.util.List;
public interface CardMapper {
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语句
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 语句的方法
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;
}
}
-
@SelectProvider：生成查询用的 SQL 语句注解（调用提供sql语句的方法，获取到查询的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语句）
-
修改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语句）
-
修改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 删除功能的实现
-
修改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.
*/
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.
*/
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.
*/
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();
}
}
-
员工管理也有增删改查，大家可以作为课下作业
-
|
