第一章问候 MyBatis

第一节：MyBatis 简介

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

MyBatis [2] 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。
每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。
用xml文件构建SqlSessionFactory实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但你可以使用任何Reader实例，包括用文件路径或file://开头的url创建的实例。MyBatis有一个实用类----Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。

(1)加载配置并初始化
触发条件：加载配置文件
处理过程：将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。
(2)接收调用请求
触发条件：调用Mybatis提供的API
传入参数：为SQL的ID和传入参数对象
处理过程：将请求传递给下层的请求处理层进行处理。
(3)处理操作请求
触发条件：API接口层传递请求过来
传入参数：为SQL的ID和传入参数对象
处理过程：
(A)根据SQL的ID查找对应的MappedStatement对象。
(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。
©获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。
(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。
(E)释放连接资源。
(4)返回处理结果将最终的处理结果返回。

我们把Mybatis的功能架构分为三层：
(1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。
(2)数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
(3)基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

框架架构讲解：
(1)加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个
mybatis结构
mybatis结构
个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。
(2)SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。
(3)SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。
(4)结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。

第二节：MyBatis 版 HelloWorld 实现

新建项目MyBatiesPro01
->创建数据库db_mybatis,创建数据表t_student
id,name,age
1 张三 10
->jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
jdbc.username=root
jdbc.password=123456

->mybaties-config

<?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"/>
	<typeAliases>
		<typeAlias alias="Student" type="com.java1234.model.Student"/>
	</typeAliases>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	//映射器
	<mappers>
		<mapper resource="com/java1234/mappers/StudentMapper.xml" />
	</mappers>
</configuration>

->引入驱动mybatis-3.2.8
在这里插入图片描述
这是它lib里面的
->新建com.java1234.model
Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, Integer age) {
		super();
		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;
	}	
}

->新建com.java1234.util
SqlSessionFactoryUtil .java

package com.java1234.util;

import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class SqlSessionFactoryUtil {

	private static SqlSessionFactory sqlSessionFactory;
	
	public static SqlSessionFactory getSqlSessionFactory(){
		if(sqlSessionFactory==null){
			InputStream inputStream=null;
			try{
				inputStream=Resources.getResourceAsStream("mybatis-config.xml");
				sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return sqlSessionFactory;
	}
	
	public static SqlSession openSession(){
		return getSqlSessionFactory().openSession();
	}
}

->新建com.java1234.mappers
StudentMapper.java 有的公司用DAO

package com.java1234.mappers;

import com.java1234.model.Student;

public interface StudentMapper {

	public int add(Student student);
}

->StudentMapper.xml

扫描二维码关注公众号，回复： 3674360 查看本文章

<?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.java1234.mappers.StudentMapper">

	<insert id="add" parameterType="Student"  >
		insert into t_student values(null,#{name},#{age})
	</insert>

</mapper>

->com.java1234.service我们主要用来测试
StudentTest.java

package com.java1234.service;

import org.apache.ibatis.session.SqlSession;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest {

	public static void main(String[] args) {
		SqlSession sqlSession=SqlSessionFactoryUtil.openSession();
		StudentMapper studentMapper=sqlSession.getMapper(StudentMapper.class);
		Student student=new Student("李四",11);
		int result=studentMapper.add(student);
		sqlSession.commit();
		if(result>0){
			System.out.println("添加成功！");
		}
	}
}

->运行结果
添加成功

第二章 MyBatis 项目配置

第一节：environments

MyBatis 支持多个环境，可以任意配置；
接着项目MyBatisPro01
->mybatis-config.xml

<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
		<environment id="test">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>

第二节：transactionManager

MyBatis 支持两种类型的事务管理器：JDBC 和 MANAGED(托管)；
JDBC：应用程序负责管理数据库连接的生命周期；
MANAGED：由应用服务器负责管理数据库连接的生命周期；(一般商业服务器才有此功能，如 JBOSS,WebLogic)

第三节：dataSource

用来配置数据源；类型有：UNPOOLED，POOLED，JNDI；
UNPOOLED，没有连接池，每次数据库操作，MyBatis 都会创建一个新的连接，用完后，关闭；适合小并发项目；
POOLED，用上了连接池；
JNDI，使用应用服务器配置 JNDI 数据源获取数据库连接；

第四节：properties

配置属性
->mybatis-config.xml

<!-- <properties resource="jdbc.properties"/> -->
//不用properties文件的话，你就自己定义吧
	<properties>
		<property name="jdbc.driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="jdbc.url" value="jdbc:mysql://localhost:3306/db_mybatis"/>
		<property name="jdbc.username" value="root"/>
		<property name="jdbc.password" value="123456"/>
	</properties>

第五节：typeAliases

给类的完成限定名取别名，方便使用；
->mybatis-config.xml

<!-- <typeAliases>
		<typeAlias alias="Student" type="com.java1234.model.Student"/>
	</typeAliases> -->
	//不用每次都写完整路径了，而是只需要写个Student
	//但是有100个类就得写100个吗？
	//有一种方便的方法就是取package，即这个包下面的所有的类都进行扫描，直接取简易别名
	<typeAliases>
		<package name="com.java1234.model"/>
	</typeAliases>

第六节：mappers

引入映射文件
->mybatis-config.xml

<mappers>
		<!-- <mapper resource="com/java1234/mappers/StudentMapper.xml" /> -->
		<!-- <mapper class="com.java1234.mappers.StudentMapper"/> -->
		//可以找配置文件，还可以找类
		//有100个映射文件，难道要写100个mapper
		//可以用package，此包下面的所有映射文件都进行了扫描
		<package name="com.java1234.mappers"/>
	</mappers>

第七节：配置 Log4j 日志

->log4j.properties

log4j.rootLogger=info,appender1,appender2//输出目标

log4j.appender.appender1=org.apache.log4j.ConsoleAppender //控制台输出

log4j.appender.appender2=org.apache.log4j.FileAppender //向文件输出
log4j.appender.appender2.File=C:/logFile.txt
 
log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout
log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout

->贴log4j的jar包log4j-1.2.17
->StudentTest .java

package com.java1234.service;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	
	public static void main(String[] args) {
		SqlSession sqlSession=SqlSessionFactoryUtil.openSession();
		StudentMapper studentMapper=sqlSession.getMapper(StudentMapper.class);
		Student student=new Student("李四",11);
		int result=studentMapper.add(student);
		sqlSession.commit();
		if(result>0){
			logger.info("添加成功！");
		}
	}
}

->运行结果
在这里插入图片描述

第三章使用 XML 配置 SQL 映射器

第一节：INSERT 映射语句

第二节：UPDATE 映射语句

第三节：DELETE 映射语句

第四节：SELECT 映射语句

继续项目MyBatiesPro01
->添加junit的jar包 junit4.4
->StudentMapper.java

package com.java1234.mappers;

import java.util.List;

import com.java1234.model.Student;

public interface StudentMapper {

	public int add(Student student);
	
	public int update(Student student);
	
	public int delete(Integer id);
	
	public Student findById(Integer id);
	
	public List<Student> find();
}

->StudentMapper.xml

<?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.java1234.mappers.StudentMapper">

//返回是集合的话，要先定义一个resultMap
	<resultMap type="Student" id="StudentResult">
	//和实体、列里面的要一一对应
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
	</resultMap>

	<insert id="add" parameterType="Student"  >
		insert into t_student values(null,#{name},#{age})
	</insert>

	<update id="update" parameterType="Student">
		update t_student set name=#{name},age=#{age} where id=#{id}
	</update>
	
	<delete id="delete" parameterType="Integer">
		delete from t_student where id=#{id}
	</delete>
	
	<select id="findById" parameterType="Integer" resultType="Student">
		select * from t_student where id=#{id}
	</select>
	
	<select id="find" resultMap="StudentResult">
		select * from t_student
	</select>
</mapper>

->Student.java中增加重载的构造器

public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

->新建junit测试方法 StudentTest2,java

package com.java1234.service;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest2 {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testAdd() {
		logger.info("添加学生");
		Student student=new Student("王五",12);
		studentMapper.add(student);
		sqlSession.commit();
	}
	
	@Test
	public void testUpdate(){
		logger.info("修改学生");
		Student student=new Student(8,"王五2",13);
		studentMapper.update(student);
		sqlSession.commit();
	}
	
	@Test
	public void testDelete(){
		logger.info("删除学生");
		studentMapper.delete(8);
		sqlSession.commit();
	}
	
	@Test
	public void testFindById(){
		logger.info("通过ID查找学生");
		Student student=studentMapper.findById(1);
		System.out.println(student);
	}

	@Test
	public void testFind(){
		logger.info("查找所有学生");
		List<Student> studentList=studentMapper.find();
		for(Student s:studentList){
			System.out.println(s);
		}
	}
}

->运行结果
在这里插入图片描述

在这里插入图片描述

在Student.java中写上toString方法

在这里插入图片描述

第四章 MyBatis 关系映射

第一节：一对一关系实现

继续项目MyBatisPro01
->新建表t_address
id sheng shi qu
江苏省苏州市姑苏区
江苏省南京市鼓楼区
要实现一对多的话
在t_student中加一个字段address，外键关联表t_address主键
->Address.java

package com.java1234.model;

public class Address {

	private Integer id;
	private String sheng;
	private String shi;
	private String qu;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getSheng() {
		return sheng;
	}
	public void setSheng(String sheng) {
		this.sheng = sheng;
	}
	public String getShi() {
		return shi;
	}
	public void setShi(String shi) {
		this.shi = shi;
	}
	public String getQu() {
		return qu;
	}
	public void setQu(String qu) {
		this.qu = qu;
	}
	@Override
	public String toString() {
		return "Address [id=" + id + ", sheng=" + sheng + ", shi=" + shi
				+ ", qu=" + qu + "]";
	}
}

->Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;
	private Address address;
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	} 
	public Student(String name, Integer age) {
		super();
		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;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", address=" + address + "]";
	}

}

->如何实现一对一呢
StudentTest3.java

package com.java1234.service;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest3 {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

}
->StudentMapper.java中加一个方法

public Student findStudentWithAddress(Integer id);

->StudentMapper.xml

<?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.java1234.mappers.StudentMapper">

	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		
		<result property="address.id" column="addressId"/>//这里要写外键的名字
		<result property="address.sheng" column="sheng"/>
		<result property="address.shi" column="shi"/>
		<result property="address.qu" column="qu"/>
	</resultMap>
	
	
	<select id="findStudentWithAddress" resultMap="StudentResult" parameterType="Integer">
		select * from t_student t1,t_address t2 where t1.addressId=t2.id and t1.id=#{id}
	</select>

	<insert id="add" parameterType="Student"  >
		insert into t_student values(null,#{name},#{age})
	</insert>

	<update id="update" parameterType="Student">
		update t_student set name=#{name},age=#{age} where id=#{id}
	</update>
	
	<delete id="delete" parameterType="Integer">
		delete from t_student where id=#{id}
	</delete>
	
	<select id="findById" parameterType="Integer" resultType="Student">
		select * from t_student where id=#{id}
	</select>
	
	<select id="find" resultMap="StudentResult">
		select * from t_student
	</select>
</mapper>

->StudentTest3.java

	@Test
	public void testFindStudentWithAddress() {
		logger.info("查询学生(带地址)");
		Student student=studentMapper.findStudentWithAddress(1);
		System.out.println(student);
	}

->运行结果
在这里插入图片描述

在这里插入图片描述
查出了张三的信息和地址
但是这种方式不好，看下面的方式
->StudentMapper.xml

	<resultMap type="Address" id="AddressResult">
		<result property="id" column="id"/>
		<result property="sheng" column="sheng"/>
		<result property="shi" column="shi"/>
		<result property="qu" column="qu"/>
	</resultMap>
	
	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<association property="address" resultMap="AddressResult"/>
	</resultMap>

把地址独立成一个模块，这样直接引用它就比较方便
->运行结果
在这里插入图片描述

另一种方式
->StudentMapper.xml

	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<association property="address" javaType="Address">
			<result property="id" column="id"/>
			<result property="sheng" column="sheng"/>
			<result property="shi" column="shi"/>
			<result property="qu" column="qu"/>
		</association>
	</resultMap>

最后一种方式才能高度重用
->AddressMapper .java

package com.java1234.mappers;

import com.java1234.model.Address;

public interface AddressMapper {

	public Address findById(Integer id);

}

->AddressMapper .xml

<?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.java1234.mappers.AddressMapper">

	<resultMap type="Address" id="AddressResult">
		<result property="id" column="id"/>
		<result property="sheng" column="sheng"/>
		<result property="shi" column="shi"/>
		<result property="qu" column="qu"/>
	</resultMap>
	
	<select id="findById" parameterType="Integer" resultType="Address">
		select * from t_address where id=#{id}
	</select>

</mapper>

->StudentMapper.xml

<?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.java1234.mappers.StudentMapper">
	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		//这里的column对应于student表的外键
		<association property="address" column="addressId" select="com.java1234.mappers.AddressMapper.findById"></association>
	</resultMap>
	
	<select id="findStudentWithAddress" resultMap="StudentResult" parameterType="Integer">
		select * from t_student t1,t_address t2 where t1.addressId=t2.id and t1.id=#{id}
	</select>

	<insert id="add" parameterType="Student"  >
		insert into t_student values(null,#{name},#{age})
	</insert>

	<update id="update" parameterType="Student">
		update t_student set name=#{name},age=#{age} where id=#{id}
	</update>
	
	<delete id="delete" parameterType="Integer">
		delete from t_student where id=#{id}
	</delete>
	
	<select id="findById" parameterType="Integer" resultType="Student">
		select * from t_student where id=#{id}
	</select>
	
	<select id="find" resultMap="StudentResult">
		select * from t_student
	</select>
</mapper>

->运行结果
过程是在student表首先传了2进去，主键是2，查到addressid为几，再回到address的表

第二节：一对多关系实现

一个年级里面有很多学生
接上个项目
->先建表t_grade
id gradeName
1 大学一年级
2 大学二年级
表t_student
id name age addressId gradeId
通过年级来查询学生
->Grade.java

package com.java1234.model;

import java.util.List;

public class Grade {

	private Integer id;
	private String gradeName;
	private List<Student> students;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getGradeName() {
		return gradeName;
	}
	public void setGradeName(String gradeName) {
		this.gradeName = gradeName;
	}
	public List<Student> getStudents() {
		return students;
	}
	public void setStudents(List<Student> students) {
		this.students = students;
	}
	@Override
	public String toString() {
		return "Grade [id=" + id + ", gradeName=" + gradeName +"]";
	}	
}

->GradeMapper .java

package com.java1234.mappers;

import com.java1234.model.Grade;

public interface GradeMapper {

	public Grade findById(Integer id);

}

->GradeMapper .xml

<?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.java1234.mappers.GradeMapper">

	<resultMap type="Grade" id="GradeResult">
		<result property="id" column="id"/>
		<result property="gradeName" column="gradeName"/>
		//这里的column才是student的主键
		<collection property="students" column="id" select="com.java1234.mappers.StudentMapper.findByGradeId"></collection>
	</resultMap>
	
	<select id="findById" parameterType="Integer" resultMap="GradeResult">
		select * from t_grade where id=#{id}
	</select>

</mapper>

->StudentMapper.java

 public Student findByGradeId(Integer gradeId);

->StudentMapper.xml

<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<association property="address" column="addressId" select="com.java1234.mappers.AddressMapper.findById"></association>
		<association property="grade" column="gradeId" select="com.java1234.mappers.GradeMapper.findById"></association>
	</resultMap>

	<select id="findByGradeId" resultMap="StudentResult" parameterType="Integer">
		select * from t_student where gradeId=#{gradeId}
	</select>

->GradeTest .java

package com.java1234.service;


import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.GradeMapper;
import com.java1234.model.Grade;
import com.java1234.util.SqlSessionFactoryUtil;

public class GradeTest {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private GradeMapper gradeMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		gradeMapper=sqlSession.getMapper(GradeMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testFindGradeWithStudents() {
		logger.info("查询年级(带学生)");
		Grade grade=gradeMapper.findById(2);
		System.out.println(grade);
	}
	
}

->查询结果
在这里插入图片描述

address也级联打印了

如果我们查学生时也想要查到他的年级
->Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;
	private Address address;
	private Grade grade;
	
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public Student(String name, Integer age) {
		super();
		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;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}

	public Grade getGrade() {
		return grade;
	}

	public void setGrade(Grade grade) {
		this.grade = grade;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", address=" + address + ", grade=" + grade + "]";
	}
}

->StudentMapper.xml

<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<association property="address" column="addressId" select="com.java1234.mappers.AddressMapper.findById"></association>
		<association property="grade" column="gradeId" select="com.java1234.mappers.GradeMapper.findById"></association>
	</resultMap>

->其实相当于双向的一对一
StudentTest3.java

@Test
	public void testFindStudentWithGrade(){
		logger.info("查询学生(带年级)");
		Student student=studentMapper.findStudentWithAddress(1);
		System.out.println(student);
	}

->查询结果
在这里插入图片描述

多对多用两个一对多实现

第五章动态 SQL

第一节：if 条件

第二节：choose，when 和 otherwise 条件

新建项目MyBatisPro02
->log4j.properties

log4j.rootLogger=info,appender1,appender2

log4j.appender.appender1=org.apache.log4j.ConsoleAppender 

log4j.appender.appender2=org.apache.log4j.FileAppender 
log4j.appender.appender2.File=C:/logFile.txt
 
log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout
log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout

->jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
jdbc.username=root
jdbc.password=123456

->mybatis-config.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"/>
	<typeAliases>
		<package name="com.java1234.model"/>
	</typeAliases>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
		<environment id="test">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverClassName}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<package name="com.java1234.mappers"/>
	</mappers>
</configuration>

->Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public Student(String name, Integer age) {
		super();
		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 + "]";
	}
}

->StudentMapper.java

package com.java1234.mappers;

import java.util.List;
import java.util.Map;

import com.java1234.model.Student;


public interface StudentMapper {

	public List<Student> searchStudents(Map<String,Object> map);
	
	public List<Student> searchStudents2(Map<String,Object> map);
}

->StudentMapper.xml

<?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.java1234.mappers.StudentMapper">

	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
	</resultMap>
	//id对应方法，
	<select id="searchStudents" parameterType="Map" resultMap="StudentResult">
		select * from t_student 
		 where gradeId=#{gradeId}
		 <if test="name!=null">
		 	and name like #{name}
		 </if>
		 <if test="age!=nulll">
		 	and age=#{age}
		 </if>
	</select>
	
	<select id="searchStudents2" parameterType="Map" resultMap="StudentResult">
		select * from t_student 
		 <choose>
		 	<when test="searchBy=='gradeId'">
		 		where gradeId=#{gradeId}
		 	</when>
		 	<when test="searchBy=='name'">
		 		where name like #{name}
		 	</when>
		 	<otherwise>
		 		where age=#{age}
		 	</otherwise>
		 </choose>
		 
	</select>
</mapper>

->StudentTest.java

package com.java1234.service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testSearchStudents() {
		logger.info("添加学生(带条件)");
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("gradeId", 2);
		map.put("name", "%李%");
		map.put("age", 11);
		List<Student> studentList=studentMapper.searchStudents(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}
	
	@Test
	public void testSearchStudents2() {
		logger.info("添加学生(带条件)");
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("searchBy", "age");
		map.put("gradeId", 2);
		map.put("name", "%李%");
		map.put("age", 11);
		List<Student> studentList=studentMapper.searchStudents2(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

}

->运行结果
testSearchStudents
不加两个条件
在这里插入图片描述
加上两个条件

testSearchStudents2
grageid

name和age

第三节：where 条件

1，自动加上 where；
2，如果 where 子句以 and 或者 or 开头，则自动删除第一个 and 或者 or；
->StudentMapper.xml

<select id="searchStudents3" parameterType="Map" resultMap="StudentResult">
		select * from t_student 
		 <where>
			 <if test="gradeId!=null">
			 	gradeId=#{gradeId}
			 </if>
			 <if test="name!=null">
			 	and name like #{name}
			 </if>
			 <if test="age!=nulll">
			 	and age=#{age}
			 </if>
		 </where>
	</select>

->StudentTest.java

@Test
	public void testSearchStudents3() {
		logger.info("添加学生(带条件)");
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("gradeId", 2);
		map.put("name", "%李%");
		map.put("age", 11);
		List<Student> studentList=studentMapper.searchStudents3(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

->运行结果
gradeId
在这里插入图片描述
name

age

三条都有

第四节：trim 条件

功能和 where 元素类似，提供了前缀，后缀功能，更加灵活；
->StudentMapper.xml

<select id="searchStudents4" parameterType="Map" resultMap="StudentResult">
		select * from t_student 
		 <trim prefix="where" prefixOverrides="and|or">
			 <if test="gradeId!=null">
			 	gradeId=#{gradeId}
			 </if>
			 <if test="name!=null">
			 	and name like #{name}
			 </if>
			 <if test="age!=nulll">
			 	and age=#{age}
			 </if>
		 </trim>
	</select>

->StudentTest.java

@Test
	public void testSearchStudents4() {
		logger.info("添加学生(带条件)");
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("gradeId", 2);
		// map.put("name", "%李%");
		// map.put("age", 11);
		List<Student> studentList=studentMapper.searchStudents4(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

在这里插入图片描述

第五节：foreach 循环

->StudentMapper.xml

<select id="searchStudents5" parameterType="Map" resultMap="StudentResult"> 		
select * from t_student  		 
<if test="gradeIds!=null">
		 	<where>
		 		gradeId in 
		 		<foreach item="gradeId" collection="gradeIds" open="(" separator="," close=")">
		 		 #{gradeId}
		 		</foreach>
		 	</where> 		 
</if> 	
</select>

->StudentTest.java

@Test
	public void testSearchStudents5() {
		logger.info("添加学生(带条件)");
		Map<String,Object> map=new HashMap<String,Object>();
		List<Integer> gradeIds=new ArrayList<Integer>();
		gradeIds.add(1);
		gradeIds.add(2);
		map.put("gradeIds", gradeIds);
		List<Student> studentList=studentMapper.searchStudents5(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

在这里插入图片描述

第六节：set 条件

1，自动加上 set；
2，自动剔除最后一个逗号“，”；
->StudentMapper.xml

<update id="updateStudent" parameterType="Student">
		update t_student
		<set>
		 <if test="name!=null">
		 	name=#{name},
		 </if>
		 <if test="age!=null">
		 	age=#{age},
		 </if>
		</set>
		where id=#{id}
	</update>

->StudentTest.java

@Test
	public void testUpdateStudent(){
		logger.info("更新学生(带条件)");
		Student student=new Student();
		student.setId(1);
		student.setName("张三3");
		student.setAge(13);
		studentMapper.updateStudent(student);
		sqlSession.commit();
	}

第六章 Mybatis 杂项

第一节：处理 CLOB、BLOB 类型数据

第二节：传入多个输入参数

->t_student
id name age pic remark
->Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;
	private byte[] pic;
	private String remark;
	
	
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public Student(String name, Integer age) {
		super();
		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;
	}

	public byte[] getPic() {
		return pic;
	}
	public void setPic(byte[] pic) {
		this.pic = pic;
	}


	public String getRemark() {
		return remark;
	}

	public void setRemark(String remark) {
		this.remark = remark;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", remark=" + remark + "]";
	}
}

->StudentMapper.java

package com.java1234.mappers;

import java.util.List;
import java.util.Map;

import com.java1234.model.Student;


public interface StudentMapper {

	public List<Student> searchStudents(Map<String,Object> map);
	
	public List<Student> searchStudents2(Map<String,Object> map);
	
	public List<Student> searchStudents3(Map<String,Object> map);
	
	public List<Student> searchStudents4(Map<String,Object> map);
	
	public List<Student> searchStudents5(Map<String,Object> map);
	
	public List<Student> searchStudents6(String name,int age);//输入多个参数来查询
	
	public int updateStudent(Student student);
	
	public int insertStudent(Student student);//插入clob blob
	
	public Student getStudentById(Integer id);//取出clob blob
}

->StudentMapper.java

	<resultMap type="Student" id="StudentResult">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
	</resultMap>
	
	<insert id="insertStudent" parameterType="Student">
		insert into t_student values(null,#{name},#{age},#{pic},#{remark});
	</insert>
	
	<select id="getStudentById" parameterType="Integer" resultType="Student">
		select * from t_student where id=#{id}
	</select>
	
	<select id="searchStudents6" resultMap="StudentResult">
		select * from t_student where name like #{param1} and age=#{param2}
	</select>

->StudentTest2.java

@Test
	public void testInsertStudent(){
		logger.info("添加学生");
		Student student=new Student();
		student.setName("张三4");
		student.setAge(14);
		student.setRemark("很长的本文...");
		byte []pic=null;
		try{
			File file=new File("c://boy.jpg");
			InputStream inputStream=new FileInputStream(file);
			pic=new byte[inputStream.available()];
			inputStream.read(pic);
			inputStream.close();
		}catch(Exception e){
			e.printStackTrace();
		}
		student.setPic(pic);
		studentMapper.insertStudent(student);
		sqlSession.commit();
	}
	
	@Test
	public void testGetStudentById(){
		logger.info("通过ID查找学生");
		Student student=studentMapper.getStudentById(4);
		System.out.println(student);
		byte []pic=student.getPic();
		try{
			File file=new File("d://boy2.jpg");
			OutputStream outputStream=new FileOutputStream(file);
			outputStream.write(pic);
			outputStream.close();
		}catch(Exception e){
			e.printStackTrace();
		}
	}
	
	@Test
	public void testSearchStudents6() {
		logger.info("添加学生(带条件)");
		List<Student> studentList=studentMapper.searchStudents6("%3%",12);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

->运行结果
1插入成功
2
在这里插入图片描述
3

第三节：Mybatis 分页

1，逻辑分页；
->StudentMapper.java

public List<Student> findStudents(RowBounds rowBounds);

->->StudentMapper.xml

<select id="findStudents" resultMap="StudentResult">
		select * from t_student
	</select>

->StudentTest3.java

@Test
	public void testFindStudent(){
		logger.info("查询学生");
		int offset=0,limit=3;//起始页，每页大小
		RowBounds rowBounds=new RowBounds(offset,limit);
		List<Student> studentList=studentMapper.findStudents(rowBounds);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

<select id="findStudents" resultMap="StudentResult" flushCache="false" useCache="true">
	select * from t_student
</select>

->查询结果
把所有数据取出来都放到内存中
在这里插入图片描述
2，物理分页；
->StudentMapper.java

public List<Student> findStudents2(Map<String,Object> map);

->StudentMapper.xml

<select id="findStudents2" parameterType="Map" resultMap="StudentResult">
	select * from t_student
	<if test="start!=null and size!=null">
		limit #{start},#{size}//真正的物理分页
	</if>
</select>

->StudentTest3.java

@Test
	public void testFindStudent2(){
		logger.info("查询学生");
		Map<String,Object> map=new HashMap<String,Object>();
		map.put("start", 3);
		map.put("size", 3);
		List<Student> studentList=studentMapper.findStudents2(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

在这里插入图片描述

第四节：Mybatis 缓存

Mybatis 默认情况下，MyBatis 启用一级缓存，即同一个 SqlSession 接口对象调用了相同的 select 语句，则直接会从缓存中返回结果，而不是再查询一次数据库；开发者可以自己配置二级缓存，二级缓存是全局的；
默认情况下，select 使用缓存的，insertupdatedelete 是不使用缓存的；

并发量很大，且都是在查询的情况下。
->StudentMapper.xml

<!--
    	1，size:表示缓存cache中能容纳的最大元素数。默认是1024；
    	2，flushInterval:定义缓存刷新周期，以毫秒计；
     	3，eviction:定义缓存的移除机制；默认是LRU(least recently userd，最近最少使用),还有FIFO(first in first out，先进先出)
     	4，readOnly:默认值是false，假如是true的话，缓存只能读。
     -->
	<cache size="1024" flushInterval="60000" eviction="LRU" readOnly="false"/>
	<select id="findStudents" resultMap="StudentResult" flushCache="false" useCache="true">
		select * from t_student
	</select>
	<insert id="insertStudent" parameterType="Student" flushCache="true">
	insert into t_student values(null,#{name},#{age},#{pic},#{remark});
	</insert>

第七章使用注解配置 SQL 映射器

第一节：基本映射语句

1，@Insert 2，@Update 3，@Delete 4，@Select
新建项目MyBatisPro03
->t_student
id name age
->Student.java
->StudentMapper.java 没有StudentMapper.xml了

package com.java1234.mappers;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.java1234.model.Student;


public interface StudentMapper {

	@Insert("insert into t_student values(null,#{name},#{age})")
	public int insertStudent(Student student);
	
	@Update("update t_student set name=#{name},age=#{age} where id=#{id}")
	public int updateStudent(Student student);
	
	@Delete("delete from t_student where id=#{id}")
	public int deleteStudent(int id);
	
	@Select("select * from t_student where id=#{id}")
	public Student getStudentById(Integer id);
	
	@Select("select * from t_student")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="name",property="name"),
				@Result(column="age",property="age")
			}
	)
	public List<Student> findStudents();
	
}

->StudentTest.java

package com.java1234.service;


import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testInsert() {
		logger.info("添加学生");
		Student student=new Student("琪琪",11);
		studentMapper.insertStudent(student);
		sqlSession.commit();
	}
	
	@Test
	public void testUpdate() {
		logger.info("更新学生");
		Student student=new Student(6,"琪琪2",12);
		studentMapper.updateStudent(student);
		sqlSession.commit();
	}
	
	@Test
	public void testDelete() {
		logger.info("删除学生");
		studentMapper.deleteStudent(6);
		sqlSession.commit();
	}
	
	@Test
	public void testGetById() {
		logger.info("通过ID查找学生");
		Student student=studentMapper.getStudentById(1);
		System.out.println(student);
	}
	
	@Test
	public void testFindStudents() {
		logger.info("查找所有学生");
		List<Student> studentList=studentMapper.findStudents();
		for(Student student:studentList){
			System.out.println(student);
		}
	}

}

第二节：结果集映射语句

第三节：关系映射

1，一对一映射； 2，一对多映射；
->t_student
id name age addressid
t_address
t_grade
->Student.java

package com.java1234.model;

public class Student {

	private Integer id;
	private String name;
	private Integer age;
	private Address address;
	private Grade grade;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(Integer id, String name, Integer age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public Student(String name, Integer age) {
		super();
		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;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	public Grade getGrade() {
		return grade;
	}
	public void setGrade(Grade grade) {
		this.grade = grade;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", address=" + address + ", grade=" + grade + "]";
	}
}

->Address.java

package com.java1234.model;

public class Address {

	private Integer id;
	private String sheng;
	private String shi;
	private String qu;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getSheng() {
		return sheng;
	}
	public void setSheng(String sheng) {
		this.sheng = sheng;
	}
	public String getShi() {
		return shi;
	}
	public void setShi(String shi) {
		this.shi = shi;
	}
	public String getQu() {
		return qu;
	}
	public void setQu(String qu) {
		this.qu = qu;
	}
	@Override
	public String toString() {
		return "Address [id=" + id + ", sheng=" + sheng + ", shi=" + shi
				+ ", qu=" + qu + "]";
	}
	
	
}

->Grade.java

package com.java1234.model;

import java.util.List;

public class Grade {

	private Integer id;
	private String gradeName;
	private List<Student> students;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getGradeName() {
		return gradeName;
	}
	public void setGradeName(String gradeName) {
		this.gradeName = gradeName;
	}
	public List<Student> getStudents() {
		return students;
	}
	public void setStudents(List<Student> students) {
		this.students = students;
	}
	@Override
	public String toString() {
		return "Grade [id=" + id + ", gradeName=" + gradeName +"]";
	}
	
	
}

->StudentMapper.java

package com.java1234.mappers;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.java1234.model.Student;


public interface StudentMapper {

	@Insert("insert into t_student values(null,#{name},#{age})")
	public int insertStudent(Student student);
	
	@Update("update t_student set name=#{name},age=#{age} where id=#{id}")
	public int updateStudent(Student student);
	
	@Delete("delete from t_student where id=#{id}")
	public int deleteStudent(int id);
	
	@Select("select * from t_student where id=#{id}")
	public Student getStudentById(Integer id);
	
	@Select("select * from t_student")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="name",property="name"),
				@Result(column="age",property="age")
			}
	)
	public List<Student> findStudents();
	
	@Select("select * from t_student where id=#{id}")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="name",property="name"),
				@Result(column="age",property="age"),
				//column外键property对应于address对象//one=@One  addressid与address中的id一一对应
				@Result(column="addressId",property="address",one=@One(select="com.java1234.mappers.AddressMapper.findById"))
			}
	)
	public Student selectStudentWithAddress(int id);//用学生查地址
	
	@Select("select * from t_student where gradeId=#{gradeId}")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="name",property="name"),
				@Result(column="age",property="age"),
				@Result(column="addressId",property="address",one=@One(select="com.java1234.mappers.AddressMapper.findById"))
			}
	)
	public Student selectStudentByGradeId(int gradeId);//用年级查学生
	
	@Select("select * from t_student where id=#{id}")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="name",property="name"),
				@Result(column="age",property="age"),
				@Result(column="addressId",property="address",one=@One(select="com.java1234.mappers.AddressMapper.findById")),
				@Result(column="gradeId",property="grade",one=@One(select="com.java1234.mappers.GradeMapper.findById"))
			}
	)
	public Student selectStudentWithAddressAndGrade(int id);//查学生的时候把年级也带上
}

->AddressMapper.java

package com.java1234.mappers;

import org.apache.ibatis.annotations.Select;

import com.java1234.model.Address;

public interface AddressMapper {

	@Select("select * from t_address where id=#{id}")
	public Address findById(Integer id);

}

->GradeMapper.java

package com.java1234.mappers;

import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

import com.java1234.model.Grade;

public interface GradeMapper {

	@Select("select * from t_grade where id=#{id}")
	@Results(
			{
				@Result(id=true,column="id",property="id"),
				@Result(column="gradeName",property="gradeName"),
				@Result(column="id",property="students",many=@Many(select="com.java1234.mappers.StudentMapper.selectStudentByGradeId"))
			}
	)
	public Grade findById(Integer id);

}

->StudentTest2.java

package com.java1234.service;


import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.GradeMapper;
import com.java1234.mappers.StudentMapper;
import com.java1234.model.Grade;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest2 {

	private static Logger logger=Logger.getLogger(StudentTest2.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	private GradeMapper gradeMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
		gradeMapper=sqlSession.getMapper(GradeMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testSelectStudentWithAddress() {
		logger.info("查找学生(带地址)");
		Student student=studentMapper.selectStudentWithAddress(1);
		System.out.println(student);
	}
	
	@Test
	public void testSelectGradeWithStudents() {
		logger.info("查找年级(带学生)");
		Grade grade=gradeMapper.findById(2);
		System.out.println(grade);
		List<Student> studentList=grade.getStudents();
		for(Student student:studentList){
			System.out.println(student);
		}
	}
	
	@Test
	public void testSelectStudentWithAddressAndGrade() {
		logger.info("查找学生(带年级，带地址)");
		Student student=studentMapper.selectStudentWithAddressAndGrade(1);
		System.out.println(student);
	}
	
}

->
testSelectStudentWithAddress
在这里插入图片描述
testSelectGradeWithStudents

testSelectStudentWithAddressAndGrade

第四节：动态 SQL

@InsertProvider @UpdateProvider @DeleteProvider @SelectProvider
新建项目MyBatisPro04
->StudentMapper.java

package com.java1234.mappers;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;

import com.java1234.model.Student;

public interface StudentMapper {

@InsertProvider(type=StudentDynaSqlProvider.class,method="insertStudent")
public int insertStudent(Student student);

@UpdateProvider(type=StudentDynaSqlProvider.class,method="updateStudent")
public int updateStudent(Student student);

@DeleteProvider(type=StudentDynaSqlProvider.class,method="deleteStudent")
public int deleteStudent(int id);

@SelectProvider(type=StudentDynaSqlProvider.class,method="getStudentById")
public Student getStudentById(Integer id);

@SelectProvider(type=StudentDynaSqlProvider.class,method="findStudents")
public List<Student> findStudents(Map<String,Object> map);

}

->StudentDynaSqlProvider.java

 package com.java1234.mappers;
    
    import java.util.Map;
    
    import org.apache.ibatis.jdbc.SQL;
    
    import com.java1234.model.Student;
    
    public class StudentDynaSqlProvider {
    
    	public String insertStudent(final Student student){
    		return new SQL(){
    			{
    				INSERT_INTO("t_student");
    				if(student.getName()!=null){
    					VALUES("name", "#{name}");
    				}
    				if(student.getAge()!=null){
    					VALUES("age", "#{age}");
    				}
    			}
    		}.toString();
    	}
    	
    	public String updateStudent(final Student student){
    		return new SQL(){
    			{
    				UPDATE("t_student");
    				if(student.getName()!=null){
    					SET("name=#{name}");
    				}
    				if(student.getAge()!=null){
    					SET("age=#{age}");
    				}
    				WHERE("id=#{id}");
    			}
    		}.toString();
    	}
    	
    	public String deleteStudent(){
    		return new SQL(){
    			{
    				DELETE_FROM("t_student");
    				WHERE("id=#{id}");
    			}
    		}.toString();
    	}
    	
    	public String getStudentById(){
    		return new SQL(){
    			{
    				SELECT("*");
    				FROM("t_student");
    				WHERE("id=#{id}");
    			}
    		}.toString();
    	}
    	
    	public String findStudents(final Map<String,Object> map){
    		return new SQL(){
    			{
    				SELECT("*");
    				FROM("t_student");
    				StringBuffer sb=new StringBuffer();
    				if(map.get("name")!=null){
    					sb.append(" and name like '"+map.get("name")+"'");
    				}
    				if(map.get("age")!=null){
    					sb.append(" and age="+map.get("age"));
    				}
    				if(!sb.toString().equals("")){
    					WHERE(sb.toString().replaceFirst("and", ""));					
    				}
    			}
    		}.toString();
    	}
    }

->StudentTest.java
package com.java1234.service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.java1234.mappers.StudentMapper;
import com.java1234.model.Student;
import com.java1234.util.SqlSessionFactoryUtil;

public class StudentTest {

	private static Logger logger=Logger.getLogger(StudentTest.class);
	private SqlSession sqlSession=null;
	private StudentMapper studentMapper=null;
	
	/**
	 * 测试方法前调用
	 * @throws Exception
	 */
	@Before
	public void setUp() throws Exception {
		sqlSession=SqlSessionFactoryUtil.openSession();
		studentMapper=sqlSession.getMapper(StudentMapper.class);
	}

	/**
	 * 测试方法后调用
	 * @throws Exception
	 */
	@After
	public void tearDown() throws Exception {
		sqlSession.close();
	}

	@Test
	public void testInsert() {
		logger.info("添加学生");
		Student student=new Student("琪琪",11);
		studentMapper.insertStudent(student);
		sqlSession.commit();
	}
	
	@Test
	public void testUpdate() {
		logger.info("更新学生");
		Student student=new Student(6,"琪琪2",12);
		studentMapper.updateStudent(student);
		sqlSession.commit();
	}
	
	@Test
	public void testDelete() {
		logger.info("删除学生");
		studentMapper.deleteStudent(6);
		sqlSession.commit();
	}
	
	@Test
	public void testGetById() {
		logger.info("通过ID查找学生");
		Student student=studentMapper.getStudentById(1);
		System.out.println(student);
	}
	
	@Test
	public void testFindStudents() {
		logger.info("查找所有学生");
		Map<String,Object> map=new HashMap<String,Object>();
		// map.put("name", "%张%");
		map.put("age", 12);
		List<Student> studentList=studentMapper.findStudents(map);
		for(Student student:studentList){
			System.out.println(student);
		}
	}

}

Java第三阶段之MyBaties3

第一章问候 MyBatis

第一节：MyBatis 简介

第二节：MyBatis 版 HelloWorld 实现

第二章 MyBatis 项目配置

第一节：environments

第二节：transactionManager

第三节：dataSource

第四节：properties

第五节：typeAliases

第六节：mappers

第七节：配置 Log4j 日志

第三章使用 XML 配置 SQL 映射器

第一节：INSERT 映射语句

第二节：UPDATE 映射语句

第三节：DELETE 映射语句

第四节：SELECT 映射语句

第四章 MyBatis 关系映射

第一节：一对一关系实现

第二节：一对多关系实现

第五章动态 SQL

第一节：if 条件

第二节：choose，when 和 otherwise 条件

第三节：where 条件

第四节：trim 条件

第五节：foreach 循环

第六节：set 条件

第六章 Mybatis 杂项

第一节：处理 CLOB、BLOB 类型数据

第二节：传入多个输入参数

第三节：Mybatis 分页

第四节：Mybatis 缓存

第七章使用注解配置 SQL 映射器

第一节：基本映射语句

第二节：结果集映射语句

第三节：关系映射

第四节：动态 SQL

猜你喜欢

Java第三阶段之MyBaties3

第一章 问候 MyBatis

第一节：MyBatis 简介

第二节：MyBatis 版 HelloWorld 实现

第二章 MyBatis 项目配置

第一节：environments

第二节：transactionManager

第三节：dataSource

第四节：properties

第五节：typeAliases

第六节：mappers

第七节：配置 Log4j 日志

第三章 使用 XML 配置 SQL 映射器

第一节：INSERT 映射语句

第二节：UPDATE 映射语句

第三节：DELETE 映射语句

第四节：SELECT 映射语句

第四章 MyBatis 关系映射

第一节：一对一关系实现

第二节：一对多关系实现

第五章 动态 SQL

第一节：if 条件

第二节：choose，when 和 otherwise 条件

第三节：where 条件

第四节：trim 条件

第五节：foreach 循环

第六节：set 条件

第六章 Mybatis 杂项

第一节：处理 CLOB、BLOB 类型数据

第二节：传入多个输入参数

第三节：Mybatis 分页

第四节：Mybatis 缓存

第七章 使用注解配置 SQL 映射器

第一节：基本映射语句

第二节：结果集映射语句

第三节：关系映射

第四节：动态 SQL

猜你喜欢

第一章问候 MyBatis

第三章使用 XML 配置 SQL 映射器

第五章动态 SQL

第七章使用注解配置 SQL 映射器