Java MyBatis

最新推荐文章于 2024-08-25 17:45:27 发布

最怕空气安静

最新推荐文章于 2024-08-25 17:45:27 发布

阅读量157

点赞数

分类专栏：基础文章标签： mybatis

本文链接：https://blog.youkuaiyun.com/m0_51047982/article/details/118230003

版权

基础专栏收录该内容

11 篇文章

订阅专栏

1、MyBatis的基本使用

step:

数据准备

数据库表
在这里插入图片描述
实体类

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

导入mybatis的相关jar包

导入数据库驱动jar包和mybatisjar包
在这里插入图片描述
右键选择Add as Library…添加到引用类库中就可以使用了

在这里插入图片描述

在resources目录下创建映射配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="StudentMapper">
    <select id="selectAll" resultType="com.zyk.Student">
        select * FROM student
    </select>
</mapper>

加载核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/db2" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

测试

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 Demo01 {

    @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 sqlSession = sqlSessionFactory.openSession();

        // 4.执行映射配置文件中的sql语句，接受结果
        List<Student> list = sqlSession.selectList("StudentMapper.selectAll");

        // 5.处理结果
        for (Student student : list) {
            System.out.println(student);
        }

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

在这里插入图片描述

2、Mybatis核心方法

返回值	方法名	说明
InputStream	getResourceAsStream(String fileName)	通过类加载器返回指定资源的字节输入流
SqlSessionFactory	build(InputStream is)	通过指定资源字节输入流获取SqlSession工厂对象
SqlSession	openSession()	获取SqlSeession构建者对象，并开启手动提交事务
SqlSession	openSession(boolean autoCommit)	获取SqlSession构建者对象，如果参数为true，则开启自动提交事务

Resources 加载资源的工具类
SqlSessionFactoryBuilder 获取SqlSessionFactory工厂对象的类
SqlSessionFactory 获取SqlSession构建者对象的工厂接口，指定事务的提交方式
SqlSession 构建者对象接口、执行sql语句、管理事务、接口代理

3、mybatis的配置文件

约束标签

<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

mapper：映射文件的根标签
namespace：名称空间
id：唯一标识
resultType：指定结果映射对象类型
parameterType：指定参数映射对象类型
#{属性名}：获取属性值

<mapper namespace="StudentMapper">

    <select id="selectAll" resultType="com.zyk.Student">
        select * FROM student
    </select>

    <select id="selectById" resultType="com.zyk.Student" parameterType="java.lang.Integer">
        select * from student where id = #{id}
    </select>

    <insert id="insert" parameterType="com.zyk.Student">
        insert into student values (#{id},#{name},#{age})
    </insert>

    <update id="update" parameterType="com.zyk.Student">
        update student set name = #{name},age = #{age} where id = #{id}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
        delete from student where id = #{id}
    </delete>

</mapper>

configuration：核心标签
environments：配置数据库环境
default：表示默认使用的是那个数据库环境
mappers：引入映射配置文件的标签

<configuration>
    <environments default="mysql">
    	<!--id 数据库环境的唯一标识-->
        <environment id="mysql">
        	<!--事务管理标签 type 表示事务处理类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--dataSource 数据源信息 type 表示使用连接池-->
            <dataSource type="POOLED">
            	<!--property 获取数据库配置信息-->
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/db2" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

jdbc.properties配置文件的使用

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db2
username=root
password=root

通过 ${键名} 的方式引入

<dataSource type="POOLED">
	<property name="driver" value="${driver}" />
	<property name="url" value="${url}" />
	<property name="username" value="${username}" />
	<property name="password" value="${password}" />
</dataSource>

起别名

<configuration>
	<typeAliases type="com.zyk.Student" alias="Student"/>
	<package name="com.zyk"/>
</configuration>

别名	数据类型
string	java.lang.String
long	java.lang.Long
int	java.lang.Integer
double	java.lang.Double
boolean	java.lang.Boolean

4、 MyBatis接口代理

所谓接口代理是指省略掉Dao层接口的实现类编写，由MyBatis框架根据接口的定义来创建该接口的动态代理对象。

实现规则：

映射配置文件中的名称空间必须和 Dao 层接口的全类名相同。
映射配置文件中的增删改查标签的 id 属性必须和 Dao 层接口的方法名相同。
映射配置文件中的增删改查标签的 parameterType 属性必须和 Dao 层接口方法的参数相同。
映射配置文件中的增删改查标签的 resultType 属性必须和 Dao 层接口方法的返回值相同。

step：

删除接口层的实现类，只保留接口类

package com.zyk.mapper;

import com.zyk.bean.Student;

import java.util.List;

/*
    持久层接口
 */
public interface StudentMapper {
    //查询全部
    public abstract List<Student> selectAll();

    //根据id查询
    public abstract Student selectById(Integer id);

    //新增数据
    public abstract Integer insert(Student stu);

    //修改数据
    public abstract Integer update(Student stu);

    //删除数据
    public abstract Integer delete(Integer id);

}

修改映射配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--
    mapper：核心根标签
    namespace属性：名称空间
-->
<mapper namespace="com.zyk.mapper.StudentMapper">

    <sql id="select" >SELECT * FROM student</sql>

    <!--
        select：查询功能的标签
        id属性：唯一标识
        resultType属性：指定结果映射对象类型
        parameterType属性：指定参数映射对象类型
    -->
    <select id="selectAll" resultType="student">
        <include refid="select"/>
    </select>

    <select id="selectById" resultType="student" parameterType="int">
        <include refid="select"/> WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES (#{id},#{name},#{age})
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name = #{name},age = #{age} WHERE id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        DELETE FROM student WHERE id = #{id}
    </delete>
    
</mapper>

修改service层接口的实现类，采用接口代理方式实现功能

package com.zyk.service.impl;

import com.zyk.bean.Student;
import com.zyk.mapper.StudentMapper;
import com.zyk.service.StudentService;
import com.zyk.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/*
    业务层实现类
 */
public class StudentServiceImpl implements StudentService {

    @Override
    public List<Student> selectAll() {
        // 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        // 调用实现类对象中的方法来完成操作
        List<Student> list = mapper.selectAll();
        // 释放资源
        sqlSession.close();
        // 返回结果
        return list;
    }

	@Override
    public Student selectById(Integer id) {
        // 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        // 调用实现类对象中的方法来完成操作
        Student stu = mapper.selectById(id)
        // 释放资源
        sqlSession.close();
        // 返回结果
        return stu;
    }

	@Override
    public Integer insert(Student stu) {
		// 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        // 调用实现类对象中的方法来完成操作
        Integer result = mapper.insert(stu)
        // 释放资源
        sqlSession.close();
        // 返回结果
        return result;
	}

	@Override
    public Integer update(Student stu) {
        // 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        // 调用实现类对象中的方法来完成操作
    	Integer result = mapper.update(stu);
		// 释放资源
        sqlSession.close();
        // 返回结果
        return result;
    }	

	@Override
    public Integer delete(Integer id) {
        // 获取SqlSession对象
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        // 获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        // 调用实现类对象中的方法来完成操作
    	Integer result = mapper.delete(id);
		// 释放资源
        sqlSession.close();
        // 返回结果
        return result;
    }	
}

package com.zyk.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;
import java.io.InputStream;

/*
    工具类
 */
public class MyBatisUtils {
    // 私有构造
    private MyBatisUtils() {}

    // 声明工厂对象
    private static SqlSessionFactory sqlSessionFactory;

    // 提供静态代码块，读取核心配置文件，并给工厂对象赋值
    static {
        try {
            InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");
            new SqlSessionFactoryBuilder().build(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 静态方法,获取SqlSession对象
    public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession(true);
    }
}

@Param注解
当接口中参数大于一个时，由于配置文件的resultType属性唯一，所以可以通过加@param注解的方式处理

public interface StudentMapper {
	List<Student> selectByNameOrAge(@Param("name") String name, @Param("age") Integer age);
}

<select id="selectByNameOrAge" resultType="student">
	SELECT * FROM student WHERE name=#{name} OR age=#{age}
</select>

5、动态sql语句

之前在xml文件中写的sql语句都是写死的，并且查询语句也是固定不变的，很不灵活。当业务逻辑复杂时，需要使用动态sql语句来完成不同需求功能。例如查询条件可以是一个两个或三个。

<where>：条件标签，如果有动态条件，则使用该标签代替where关键字。
<if>：条件判断标签。
	<if test="条件判断">
		查询条件拼接
	</if>

<foreach>：循环遍历标签，适用于多个参数或者的关系
collection：参数容量类型，(list-集合，array-数组)
open：开始的SQL语句
close：结束的SQL语句
item：参数变量名。
separator：分隔符
	<foreach collection="" open="" close="" item="" separator="">
		获取参数
	</foreach>

<sql>：抽取sql语句标签
<sql id="片段唯一标识" >抽取的sql语句</sql>
<include>：引入sql片段标签
<include refid="片段唯一标识"/>

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zyk.mapper.StudentMapper">

	<sql id="select" >SELECT * FROM student</sql>

    <select id="selectCondition" resultType="student" parameterType="student">
        <include refid="select"/>
        <where>
            <if test="id != null">
                id = #{id}
            </if>
            <if test="name != null">
                AND name = #{name}
            </if>
            <if test="age != null">
                AND age = #{age}
            </if>
        </where>
    </select>

    <select id="selectByIds" resultType="student" parameterType="list">
        <include refid="select"/>
        <where>
            <foreach collection="list" open="id IN (" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>
    </select>
</mapper>

public interface StudentMapper {
    //多条件查询
    public abstract List<Student> selectCondition(Student stu);

    //根据多个id查询
    public abstract List<Student> selectByIds(List<Integer> ids);
}

public class Test01 {

    @Test
    public void selectCondition() 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);

        Student stu = new Student();
        stu.setId(2);
        stu.setName("李四");
        //stu.setAge(24);

        //5.调用实现类的方法，接收结果
        List<Student> list = mapper.selectCondition(stu);

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

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

	@Test
    public void selectByIds() 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);

        List<Integer> ids = new ArrayList<>();
        ids.add(1);
        ids.add(2);
        ids.add(3);

        //5.调用实现类的方法，接收结果
        List<Student> list = mapper.selectByIds(ids);

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

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

6、分页插件

导入jar包 jsqlparser、pagehelper

在这里插入图片描述

在核心配置文件中集成分页插件

<configuration>
	<plugins>
		<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
	</plugins>
</configuration>

使用分页助手
PageHelper.startPage(pageNum, pageSize);
mapper.selectAll();

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!--configuration 核心根标签-->
<configuration>

    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <typeAlias type="com.zyk.bean.Student" alias="student"/>
        <!--<package name="com.zyk.bean"/>-->
    </typeAliases>

    <!--集成分页助手插件-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
    </plugins>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}" />
                <property name="url" value="${url}" />
                <property name="username" value="${username}" />
                <property name="password" value="${password}" />
            </dataSource>
        </environment>
    </environments>

    <!-- mappers引入映射配置文件 -->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

代码演示

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zyk.bean.Student;
import com.zyk.mapper.StudentMapper;
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 selectPaging() 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);

        //通过分页助手来实现分页功能
        // 第一页：显示3条数据
        //PageHelper.startPage(1,3);
        // 第二页：显示3条数据
        //PageHelper.startPage(2,3);
        // 第三页：显示3条数据
        PageHelper.startPage(3,3);

        //5.调用实现类的方法，接收结果
        List<Student> list = mapper.selectAll();

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

        //获取分页相关参数
        PageInfo<Student> info = new PageInfo<>(list);
        System.out.println("总条数：" + info.getTotal());
        System.out.println("总页数：" + info.getPages());
        System.out.println("当前页：" + info.getPageNum());
        System.out.println("每页显示条数：" + info.getPageSize());
        System.out.println("上一页：" + info.getPrePage());
        System.out.println("下一页：" + info.getNextPage());
        System.out.println("是否是第一页：" + info.isIsFirstPage());
        System.out.println("是否是最后一页：" + info.isIsLastPage());

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

7、多表操作

多表操作一对一
人和身份证、学生和学号、员工和员工号都属于一对一的多表操作。

step：

数据准备

数据库表
实体类对象

package com.zyk.bean;

public class Person {
    private Integer 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 +
                '}';
    }
}

package com.zyk.bean;

public class Card {
    private Integer 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 +
                '}';
    }
}

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db2
username=root
password=root

MybatisConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

    <!--配置log4j-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <package name="com.zyk.bean"/>
    </typeAliases>

    <!--配置数据库环境-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入映射配置文件-->
    <mappers>

    </mappers>

</configuration>

功能实现

引入配置文件

<!--引入映射配置文件-->
    <mappers>
        <mapper resource="com/zyk/one_to_one/OneToOneMapper.xml"/>
    </mappers>

编写接口

package com.zyk.table01;

import com.zyk.bean.Card;

import java.util.List;

public interface OneToOneMapper {
    // 查询全部
    public abstract List<Card> selectAll();
}

编写映射配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zyk.table01.OneToOneMapper">
    <!--配置字段和实体类对象熟悉的映射关系-->
    <resultMap id="oneToOne" type="Card">
        <id column="cid" property="id"/>
        <result column="number" property="number"/>
        <!--
            association：配置被包含对象的映射关系
            property：被包含对象的变量名
            javaType：被包含对象的数据类型
        -->
        <association property="p" javaType="Person">
            <id column="pid" property="id"/>
            <result column="name" property="name"/>
            <result column="age" property="age"/>
        </association>
    </resultMap>
    <select id="selectAll" resultMap="oneToOne">
        select c.id cid, number, pid, NAME, age FROM card c, person p where c.pid=p.id
    </select>
</mapper>

编写测试类

package com.zyk.table01;

import com.zyk.bean.Card;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;


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. 获取接口的实现类对象
        OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);

        // 5. 调用接口类的方法，结束结果
        List<Card> list = mapper.selectAll();

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

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

多表操作一对多
一个班级可以有多个学生，一个老师可以有多个学生，一个班级可以有多个老师。

step：

数据准备

数据库表

在这里插入图片描述

实体类对象

package com.zyk.bean;

import java.util.List;

public class Classes {
    private Integer id;
    private String name;

    private List<Student> students;

    public Classes() {}

    public Classes(Integer id, String name, List<Student> students) {
        this.id = id;
        this.name = name;
        this.students = students;
    }

    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 List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }

    @Override
    public String toString() {
        return "Classes{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", students=" + students +
                '}';
    }
}

package com.zyk.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 +
                '}';
    }
}

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db2
username=root
password=root

MybatisConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>

    <!--配置log4j-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <package name="com.zyk.bean"/>
    </typeAliases>

    <!--配置数据库环境-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <!--引入映射配置文件-->
    <mappers>

    </mappers>

</configuration>

功能实现

引入配置文件

<!--引入映射配置文件-->
    <mappers>
        <mapper resource="com/zyk/one_to_many/OneToManyMapper.xml"/>
    </mappers>

编写接口

package com.zyk.table02;

import com.zyk.bean.Classes;

import java.util.List;

public interface OneToManyMapper {
    // 查询全部
    public abstract List<Classes> selectAll();
}

编写编写映射配置文件

<?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE mapper
                PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zyk.table02.OneToManyMapper">
<resultMap id="oneToMany" type="Classes">
    <id column="cid" property="id"/>
    <result column="cname" property="name"/>

    <!--
        collection：配置被包含的集合对象映射关系
        property：被包含对象的变量名
        ofType：被包含对象的实际数据类型
    -->
    <collection property="students" ofType="com.zyk.bean.Student">
        <id column="sid" property="id"/>
        <result column="sname" property="name"/>
        <result column="sage" property="age"/>
    </collection>
</resultMap>
<select id="selectAll" resultMap="oneToMany">
        SELECT c.id cid,c.name cname,s.id sid,s.name sname,s.age sage FROM classes c,student s WHERE c.id=s.cid
    </select>
</mapper>

编写测试类

package com.zyk.table02;

import com.zyk.bean.Classes;
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 Test02 {
    @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. 获取接口的实现类对象
        OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);

        // 5. 调用接口类的方法，结束结果
        List<Classes> list = mapper.selectAll();

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

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

多表操作多对多

学生和课程，一个学生可以选多门课程，一个课程也可以被多个学生选择。

step：

数据准备

数据库表

在这里插入图片描述

实体类对象

package com.zyk.bean;

public class Course {
    private Integer id;
    private String name;
	
	/*
		空参构造、全参构造
		get、set方法
		重写toString
	*/
}

package com.zyk.bean;

public class Student {
    private Integer id;
    private String name;
    private Integer age;
	
	// 添加约束条件
	private List<Course> courses;
	/*
		空参构造、全参构造
		get、set方法
		重写toString
	*/
}

同上（一对一和一对多）
同上（一对一和一对多）

功能实现

Mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.zyk.table03.ManyToManyMapper">
    <resultMap id="manyToMany" type="com.zyk.bean.Student">
        <id column="sid" property="id"/>
        <result column="sname" property="name"/>
        <result column="sage" property="age"/>
        <collection property="courses" ofType="Course">
            <id column="cid" property="id"/>
            <result column="cname" property="name"/>
        </collection>
    </resultMap>
    <select id="selectAll" resultMap="manyToMany">
        select sc.sid, s.name sname, s.age sage, sc.cid, c.name cname from student s, course c, stu_cr sc where sc.sid=s.id and sc.cid=c.id
    </select>
</mapper>

接口类

package com.zyk.table03;

import com.zyk.bean.Student;

import java.util.List;

public interface ManyToManyMapper {
    // 查询全部
    public abstract List<Student> selectAll();
}

实现类

package com.zyk.table03;


import com.zyk.bean.Course;
import com.zyk.bean.Student;
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 Test03 {

    @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. 获取接口的实现类对象
        ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.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();
    }
}