mybatis 5：SQL映射关系

最新推荐文章于 2024-06-21 19:44:23 发布

编程搬运工

最新推荐文章于 2024-06-21 19:44:23 发布

阅读量555

点赞数

分类专栏： SSM（Mybatis）

本文链接：https://blog.csdn.net/qq_42857603/article/details/83058632

版权

SSM（Mybatis）专栏收录该内容

7 篇文章 0 订阅

订阅专栏

※ 1 一对一映射 association

        Student和Address是一个【一对一】关系
       建表语言:

        drop table students;
        drop table addresses;
        如果需要可以使用 cascade constraints;

        create table addresses(
          addr_id number primary key,
          street varchar2(50) not null,
          city varchar2(50) not null,
          state varchar2(50) not null,
          zip varchar2(10),
          country varchar2(50)
        );

        create table students(
          stud_id number primary key,
          name varchar2(50) not null,
          email varchar2(50),
          phone varchar2(15),  
          dob date ,
          addr_id number references addresses(addr_id)
        );

  java类:
        public class PhoneNumber {
            private String countryCode;
            private String stateCode;
            private String number;
            get/set
        }
        public class Address{
            private Integer addrId;
            private String street;
            private String city;
            private String state;
            private String zip;
            private String country;
            get/set
        }
        public class Student {
            private Integer studId;
            private String name;
            private String email;
            private Date dob;
            private PhoneNumber phone;
            private Address address;
            get/set
        }

 addresses 表的样例输入如下所示：
        addr_id  street        city     state    zip   country
        1     redSt        kunshan   W    12345  china
        2     blueST        kunshan   W     12345  china

        insert into addresses(addr_id,street,city,state,zip,country) values(1,'redSt','kunshan','W','12345','china');
        insert into addresses(addr_id,street,city,state,zip,country) values(2,'blueST','kunshan','W','12345','china');


        students 表的样例数据如下所示：
        stud_id  name    email            phone        addr_id
           1    John  john@gmail.com  123-456-7890   1
           2    Paul  paul@gmail.com  111-222-3333   2
        
        insert into students(stud_id,name,email,phone,addr_id) values(1,'John','john@gmail.com','123-456-7890',1);
        insert into students(stud_id,name,email,phone,addr_id) values(2,'Paul','paul@gmail.com','111-222-3333',2);

        
        mapper XML:
        
        <resultMap type="Student" id="StudentWithAddressResult">
          <id property="studId" column="stud_id" />
          <result property="name" column="name" />
          <result property="email" column="email" />
          <result property="phone" column="phone" />
          <result property="address.addrId" column="addr_id" />
          <result property="address.street" column="street" />
          <result property="address.city" column="city" />
          <result property="address.state" column="state" />
          <result property="address.zip" column="zip" />
          <result property="address.country" column="country" />
        </resultMap>
        <select id="selectStudentWithAddress" parameterType="int" resultMap="StudentWithAddressResult">
            select stud_id, name, email, a.addr_id, street, city, state, zip, country
            from students s left outer join addresses a on  
                s.addr_id=a.addr_id
            where stud_id=#{studid}
        </select>

我们可以使用(对象.属性名)的方式为内嵌的对象的属性赋值。在上述的resultMap中，Student的address属性使用该方式被赋上了 address 对应列的值。同样地，我们可以访问【任意深度】的内嵌对象的属性。

  //接口定义
        public interface Student Mapper{
            Student selectStudentWithAddress(int studId);
        }

        //方法调用
        int studId = 1;
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        Student student = studentMapper.selectStudentWithAddress(studId);
        System.out.println("Student :" + student);
        System.out.println("Address :" + student.getAddress());

       上面展示了一对一关联映射的一种方法。然而，使用这种方式映射，
       如果address结果需要在其他的SELECT映射语句中映射成Address对象，我们需要为每一个
       语句重复这种映射关系。MyBatis提供了更好地实现一对一关联映射的方法：
       【嵌套结果】ResultMap和【嵌套查询】select语句。接下来，我们将讨论这两种方式。

        1.1 使用嵌套结果ResultMap实现一对一关系映射
       我们可以使用一个嵌套结果ResultMap方式来获取Student及其Address信息，代码如下：

          <resultMap type="Address" id="AddressResult">
          <id property="addrId" column="addr_id" />
          <result property="street" column="street" />
          <result property="city" column="city" />
          <result property="state" column="state" />
          <result property="zip" column="zip" />
          <result property="country" column="country" />
        </resultMap>
        <resultMap type="Student" id="StudentWithAddressResult">
          <id property="studId" column="stud_id" />
          <result property="name" column="name" />
          <result property="email" column="email" />
          <association property="address" resultMap="AddressResult" />
        </resultMap>
        <select id="findStudentWithAddress" parameterType="int" resultMap="StudentWithAddressResult">
            select stud_id, name, email, a.addr_id, street, city, state,
            zip, country
            from students s left outer join addresses a on  
            s.addr_id=a.addr_id
            where stud_id=#{studid}
        </select>

       注:association是关联的意思
       元素<association>被用来导入“有一个”(has-one)类型的关联。在上述的例子中，
       我们使用了<association>元素引用了另外的在同一个XML文件中定义的<resultMap>。
       同时我们也可以使用<association> 定义内联的resultMap，代码如下所示：

          <resultMap type="Student" id="StudentWithAddressResult">
          <id property="studId" column="stud_id" />
          <result property="name" column="name" />
          <result property="email" column="email" />
          <association property="address" javaType="Address">
            <id property="addrId" column="addr_id" />
            <result property="street" column="street" />
            <result property="city" column="city" />
            <result property="state" column="state" />
            <result property="zip" column="zip" />
            <result property="country" column="country" />
          </association>
        </resultMap>

        1.2 使用嵌套查询select实现一对一关系映射
       我们可以通过使用嵌套select查询来获取Student及其Address信息，代码如下：

          <resultMap id="AddressResult" type="Address">
          <id property="addrId" column="addr_id" />
          <result property="street" column="street" />
          <result property="city" column="city" />
          <result property="state" column="state" />
          <result property="zip" column="zip" />
          <result property="country" column="country" />
        </resultMap>
        <select id="findAddressById" parameterType="int" resultMap="AddressResult">
            select * from addresses where addr_id=#{id}
        </select>

        <resultMap id="findStudentByIdWithAddress" type="Student">
          <id property="studId" column="stud_id" />
          <result property="name" column="name" />
          <result property="email" column="email" />
          <association property="address" column="addr_id" select="findAddressById" />
        </resultMap>
        <select id="findStudentWithAddress" parameterType="int" resultMap="StudentWithAddressResult">
            select * from students where stud_id=#{id}
        </select>

       在此方式中，<association>元素的select属性被设置成了id为findAddressById的语句。这里，两个分开的SQL语句将会在数据库中分别执行，第一个调用findStudentById加载student信息，而第二个调用findAddressById来加载address信息。
       addr_id列的值将会被作为输入参数传递给selectAddressById语句。

       我们可以如下调用findStudentWithAddress映射语句：

        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        Student student = mapper.selectStudentWithAddress(studId);
        System.out.println(student);
        System.out.println(student.getAddress());

实例一：一对一

1.实例类 hus和wife

 package com.briup.bean;
/*
 * create table hus(
 * id number primary key,
 * name varchar2(20),
 * age number
 * );
 * create sequence s_hus;
 */
public class Hus implements Comparable<Hus>{
	private long id;
	private String name;
	private int age;
	private Wife wife;
	
	@Override
	public String toString() {
		return "Hus [id=" + id + ", name=" + name + ", age=" + age + ", wife=" + wife + "]";
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Hus(long id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public Hus(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Hus() {
		super();
	}
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
	@Override
	public int compareTo(Hus o) {
		return (int) (this.getId()-o.getId());
	}
	
}




package com.briup.bean;
/*
 * create table wife(
 * id number primary key,
 * name varchar2(20),
 * age number,
 * hus_id number  references hus(id)
 * );
 */
public class Wife {
	private long id;
	private String name;
	private int age;
	private Hus hus;
	@Override
	public String toString() {
		return "Wife [id=" + id + ", name=" + name + ", age=" + age + ", hus=" + hus + "]";
	}
	public Wife() {
		super();
	}
	public Wife(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Wife(long id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Hus getHus() {
		return hus;
	}
	public void setHus(Hus hus) {
		this.hus = hus;
	}
}



2.接口Mapper

package com.briup.One2One;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;

import org.apache.ibatis.annotations.Param;

import com.briup.bean.Hus;
import com.briup.bean.Wife;

public interface One2OneMapper {
		void saveHus(Hus hus);
		/*
		 * @Param("id")     sql->#{id}
		 */
		void updateHus(
				@Param("id") long id,
				@Param("names")String name,
				@Param("age")int age);
		
		void deleteHus(long id);
		
		Hus findhus(long id);
		//ArrayList
		List<Hus> findhuss();
		//HashSet
		Set<Hus> findhuss_set();
		//treeset
		SortedSet<Hus> findhuss_sortset();
		/*
		 * 一个Map集合对应结果集中的一行
		 * 数据,结果集的列名为key，列名对应
		 * 的值为value
		 * select * from hus where id =7
		 * id  name age
		 * 7   tom  33
		 * -->map.put("id",7)
		 */
		Map<String, Object> findhus_map(long id);
		
		List<Map<String, Object>> findhus_maps();
		
		int findhus_count();
		
		List<String> fingHus_Name();
		
		void saveWife(Wife wife);
		/*
		 * 查询出来hus的同时通过Hus可以直接
		 * 取到Wife对象
		 * 
		 * 参数hus的id值
		 */
		Hus findHus_Wife(long id);
		
		List<Hus> findHus_Wifes();
		
		List<Hus> findHus_Wifes1();
		
		List<Hus> findHus_Wifes2();
		
		List<Hus> findHus_Wifes3();
		
}


3.响应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.briup.One2One.One2OneMapper">
	<!-- <insert id="saveHus" parameterType="hus">
		insert into hus values(#{id},#{name},#{age})
	</insert> -->
	<!-- -让序列维护主键 -->
	<insert id="saveHus" parameterType="hus">
		<!-- keyProperty指向对象中的属性（和表中主键对应的
		属性）
		resultType返回的结果为java中的什么类型（
			指向对象中的属性类型一致） 
			order生产主键的顺序
				BEFORE	 先执行序列，把返回的值设置
				给传入的对象Hus的id属性,在执行insert语句
				AFTER 先执行insert语句，在执行序列查询
				把查询的值赋给对象的id属性，不对
				插入的数据生效
				注意：oracle中用BEFORE
					mysql支持after，执行insert，在执行序列查询
				把查询的值赋给对象的id属性，同时修改数据库
				该插入数据的id属性
			-->
		<selectKey keyProperty="id" resultType="long"
			order="BEFORE">
			select s_hus.nextval from dual
		</selectKey>
		insert into hus values(#{id},#{name},#{age})
	</insert>
	<!-- mysql 主键auto_increment字段修饰 
	mysql策略:useGeneratedKeys="true"开启主键直接
	让mysql数据库维护，keyProperty指向作为参数传入的
	对象属性（和表中主键对应的属性），
	插入数据成功，自动生产主键，主键会返回给mybatis
	mybatis基于keyProperty设置给对象的指定属性
	-->
	<!-- <insert id="saveHus" parameterType="hus"
		useGeneratedKeys="true" keyProperty="id">
		insert into hus(name,age) values(#{name},#{age})
	</insert> -->
	 <update id="updateHus">
		update hus set name=#{names},age=#{age}
		where id=#{id}
	</update> 
	<!-- 在传入多个参数的时候
	直接基于参数位置角标获取值  
		#{0} 获取第一个参数的值 #{1}获取第二个参数的值
		param1 param2 ..param?
		param1获取第一个参数的值
		param2获取第二个参数的值
		
		第三种方式，给接口中方法参数加注解
		@Param("key") ，在映射文件中直接#{key}取值
	 -->
	<!-- <update id="updateHus">
		update hus set name=#{param2},age=#{param3}
		where id=#{param1}
	</update> --> 
	<delete id="deleteHus" parameterType="long">
		delete from hus
		where id=#{id}
	</delete>
	<!-- resultType表示查询的结构封装的对象类型
	如果数据库表中的列名和对象中的属性名不一致
	，select后面查询的列名起别名，别名是封装对象的
	属性名，
	如果数据库表中的列名和对象中的属性名一致，
	不起别名
	id  name 	age
	
	Hus h=new Hus();
	h.setId(xx)
		
	 -->
	<select id="findhus" parameterType="long"
		resultType="hus">
		select * from hus
		where id=#{id}
	</select>
	<!-- <select id="findhuss"
		resultType="hus">
		select * from hus
	</select> -->
	<resultMap type="hus" id="hus_model">
		<id property="id" column="id"></id>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
	</resultMap>
	<select id="findhuss"
		resultMap="hus_model">
		select * from hus
	</select> 
	<select id="findhuss_set"
		resultMap="hus_model">
		select * from hus
	</select> 
	<select id="findhuss_sortset"
		resultMap="hus_model">
		select * from hus
	</select> 
	<!-- 当返回类型是map的时候resultType="map" -->
	<select id="findhus_map"
		resultType="map" parameterType="long">
		select * from hus
		where id=#{id}
	</select> 
	<select id="findhus_maps"
		resultType="map" >
		select * from hus
	</select> 
	<select id="findhus_count" resultType="int">
		select count(*) from hus
	</select>
	<select id="fingHus_Name" resultType="java.lang.String">
		select name from hus
	</select>
	<!-- 
	Hus  -hus_id
	 -->
	<insert id="saveWife" parameterType="wife">
		<selectKey resultType="long" keyProperty="id"
		order="BEFORE"
		>
		select s_hus.nextval from dual
		</selectKey>
		insert into wife(id,name,age,hus_id) 
		values(#{id},#{name},#{age},#{hus.id})
	</insert>
	<!-- 第一种配置 -->
	<resultMap type="hus" id="hus_modl1">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<result property="wife.id" column="ids"/>
		<result property="wife.name" column="names"/>
		<result property="wife.age" column="ages"/>
	</resultMap>
	<!-- （对象级联查询）多表查询 ，多个表中列名
	相同，要起别名区分-->
	<select id="findHus_Wife" resultMap="hus_modl1" 
	parameterType="long">
		select h.id,h.name,h.age,w.id ids,w.name names,w.age ages
		from hus h,wife w
		where h.id=w.hus_id and h.id=#{id}
	</select>
	<select id="findHus_Wifes" resultMap="hus_modl1" 
	>
		select h.id,h.name,h.age,w.id ids,w.name names,w.age ages
		from hus h,wife w
		where h.id=w.hus_id 
	</select>
	<!-- 第二种方法 -->
	<resultMap type="wife" id="wife_mod1">
		<id property="id" column="ids"/>
		<result property="name" column="names"/>
		<result property="age" column="ages"/>
	</resultMap>
	<resultMap type="hus" id="hus_modl2">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<result property="age" column="age"/>
		<!-- 专门处理一对一映射关系的标签
		property属性指向引用变量wife
		 -->
		<association property="wife"  resultMap="wife_mod1"></association>
	</resultMap>
	<select id="findHus_Wifes1" resultMap="hus_modl2" 
	>
		select h.id,h.name,h.age,w.id ids,w.name names,w.age ages
		from hus h,wife w
		where h.id=w.hus_id 
	</select>
	<!-- 第三种形式 -->
	<resultMap type="hus" id="mod1_hus">
	<id property="id" column="id"/>
	<result property="name" column="name"/>
	<result property="age" column="age"/>
	<association property="wife" column="wife">
	   <id property="id" column="ids"/>
	   <result property="name" column="names"/>
	   <result property="age" column="ages"/>
	   </association>
	</resultMap>
	<select id="findHus_Wifes2" resultMap="hus_modl3">
	
	</select>
	<!-- 基于wife表的hus_id查询一行记录 -->
	<select id="selectWifeByHus_id" parameterType="long"
	resultType="wife">
	select id,name,age
	from wife
	where hus_id=#{id}
	</select>
	<!-- 查询hus表中的记录，通过id到wife表查询 -->
	<resultMap type="hus" id="mod2_hus">
	<id property="id" column="id"/>
	<result property="name" column="name"/>
	<result property="age" column="age"/>
	<!-- column="id"基于该属性查询 -->
	<association property="wife" column="id" select="selectWifeByHus_id">
	</association>
	</resultMap>
	<select id="findHus_Wifes3" resultMap="">
	select id,name,age
	from hus
	</select>
</mapper>


4.测试类
package com.briup.One2One;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedSet;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.briup.bean.Hus;
import com.briup.bean.Wife;
import com.briup.util.MyBatisSqlSessionFactory;

public class One2OneTest {
	@Test
	public void select_hus_wifes2(){
		try {
		SqlSession session=
				MyBatisSqlSessionFactory.openSession(true);
		One2OneMapper oom=
				session.getMapper(One2OneMapper.class);
		List<Hus> hus=oom.findHus_Wifes2();
		for(Hus h:hus){
			System.out.println(h);
		}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_hus_wifes1(){
		try {
		SqlSession session=
				MyBatisSqlSessionFactory.openSession(true);
		One2OneMapper oom=
				session.getMapper(One2OneMapper.class);
		List<Hus> hus=oom.findHus_Wifes1();
		for(Hus h:hus){
			System.out.println(h);
		}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_hus_wifes(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			List<Hus> hus=oom.findHus_Wifes();
			for(Hus h:hus){
				System.out.println(h);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_hus_wife(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			Hus hus=oom.findHus_Wife(11);
			System.out.println(hus);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void save_hus_wife(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			Hus hus=new Hus("jake2", 33);
			Wife wife=new Wife("rose2", 22);
			wife.setHus(hus);
			oom.saveHus(hus);
			oom.saveWife(wife);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_hus_name(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			List<String> list=oom.fingHus_Name();
			for(String n:list){
				System.out.println(n);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_hus_count(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			int count=oom.findhus_count();
			System.out.println(count);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_huss_maps(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			List<Map<String, Object>> list=oom.findhus_maps();
			for(Map<String, Object> map:list){
				for(Entry<String, Object> en:map.entrySet()){
					System.out.println(en.getKey()+"-"+en.getValue());
				}
				System.out.println("********");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_huss_map(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			Map<String, Object> map=oom.findhus_map(7);
			System.out.println(map.getClass());
			for(Entry<String, Object> en:map.entrySet()){
				System.out.println(en.getKey()+"-"+en.getValue());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_huss_sortedset(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			SortedSet<Hus> hus=oom.findhuss_sortset();
			System.out.println(hus.getClass());
			System.out.println(hus);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_huss_set(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			Set<Hus> hus=oom.findhuss_set();
			System.out.println(hus.getClass());
			System.out.println(hus);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void select_huss(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			List<Hus> hus=session.selectList("com.briup.One2One.One2OneMapper.findhuss");
			System.out.println(hus.getClass());
			//		One2OneMapper oom=
//				session.getMapper(One2OneMapper.class);
//		List<Hus> hus=oom.findhuss();
			System.out.println(hus);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
		@Test
		public void select_hus(){
			try {
				SqlSession session=
						MyBatisSqlSessionFactory.openSession(true);
				//Hus hus=session.selectOne("com.briup.One2One.One2OneMapper.findhus", 2L);
				One2OneMapper oom=
						session.getMapper(One2OneMapper.class);
				Hus hus=oom.findhus(2);
				System.out.println(hus);
			} catch (Exception e) {
				e.printStackTrace();
			}
	}
	@Test
	public void delete_hus(){
		try {
			SqlSession session=
					MyBatisSqlSessionFactory.openSession(true);
			//session.delete("com.briup.One2One.One2OneMapper.deleteHus", 0L);
			One2OneMapper oom=
					session.getMapper(One2OneMapper.class);
			oom.deleteHus(1);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
		@Test
		public void update_hus(){
			try {
				SqlSession session=
						MyBatisSqlSessionFactory.openSession(true);
//		session
//		.update("com.briup.One2One.One2OneMapper.updateHus",hus);
				One2OneMapper oom=
						session.getMapper(One2OneMapper.class);
				oom.updateHus(2, "oooo", 30);
			} catch (Exception e) {
				e.printStackTrace();
			}
	}
	@Test
	public void insert_hus(){
		SqlSession session=
				MyBatisSqlSessionFactory.openSession(true);
		Hus hus=new Hus( "tom", 33);
		System.out.println(hus);
		//第一种方式（可以不构建实现类）
		//第一个参数表示接口中方法的全限定名
		//第二个参数是接口中方法的参数，如果有参数
		//写在第二个位置，没有忽略
		//session.insert("com.briup.One2One.One2OneMapper.saveHus",hus);
		//第二种方式
		One2OneMapper oom=
				session.getMapper(One2OneMapper.class);
		oom.saveHus(hus);
		System.out.println(hus);
	}
}

※ 2 一对多映射 collection

        一个讲师tutors可以教授一个或者多个课程course。这意味着讲师和课程之间存在一对多的映射关系。
       注意:在一对多关系中,数据库建表的时候外键一定是在多的那一方建立.

建表语句:
        drop table tutors;
        drop table courses;
        如果需要可以使用 cascade constraints;

        create table tutors(
          tutor_id number primary key,
          name varchar2(50) not null,
          email varchar2(50) ,
          phone varchar2(15) ,  
          addr_id number(11) references addresses (addr_id)
        );

        create table courses(
          course_id number primary key,
          name varchar2(100) not null,
          description varchar2(512),
          start_date date ,
          end_date date ,
          tutor_id number references tutors (tutor_id)
        );

 tutors 表的样例数据如下：
        tutor_id   name     email          phone        addr_id
            1        zs  zs@briup.com   123-456-7890    1
            2        ls  ls@briup.com   111-222-3333    2
        
        insert into tutors(tutor_id,name,email,phone,addr_id)
        values(1,'zs','zs@briup.com','123-456-7890',1);
        insert into tutors(tutor_id,name,email,phone,addr_id)
        values(2,'ls','ls@briup.com','111-222-3333',2);

 course 表的样例数据如下：
        course_id  name  description  start_date   end_date  tutor_id
            1     JavaSE    JavaSE      2015-09-10  2016-02-10   1
            2     JavaEE    JavaEE      2015-09-10  2016-03-10   2
            3     MyBatis   MyBatis     2015-09-10  2016-02-20   2
        
        insert into
        courses(course_id,name,description,start_date,end_date,tutor_id)
        values(1,'JavaSE','JavaSE',to_date('2015-09-10','yyyy-mm-dd'),to_date('2016-02-10','yyyy-mm-dd'),1);

        insert into
        courses(course_id,name,description,start_date,end_date,tutor_id)
        values(2,'JavaEE','JavaEE',to_date('2015-09-10','yyyy-mm-dd'),to_date('2016-03-10','yyyy-mm-dd'),2);

        insert into
        courses(course_id,name,description,start_date,end_date,tutor_id)
        values(3,'MyBatis','MyBatis',to_date('2015-09-10','yyyy-mm-dd'),to_date('2016-02-20','yyyy-mm-dd'),1);

在上述的表数据中，zs 讲师教授一个课程，而 ls 讲师教授两个课程

 java代码:
        public class Tutor{
            private Integer tutorId;
            private String name;
            private String email;
            private PhoneNumber phone;
            private Address address;
            private List<Course> courses;

            get/set
        }

        public class Course{
            private Integer courseId;
            private String name;
            private String description;
            private Date startDate;
            private Date endDate;

            get/set
        }

       <collection>元素被用来将多行课程结果映射成一个课程Course对象的一个集合。和一对一映射一样，我们可以使用【嵌套结果ResultMap】和【嵌套查询Select】语句两种方式映射实现一对多映射。


        2.1 使用内嵌结果 ResultMap 实现一对多映射
       我们可以使用嵌套结果resultMap方式获得讲师及其课程信息，代码如下：

          <resultMap type="Address" id="AddressResult">
          <id property="addrId" column="addr_id" />
          <result property="street" column="street" />
          <result property="city" column="city" />
          <result property="state" column="state" />
          <result property="zip" column="zip" />
          <result property="country" column="country" />
        </resultMap>
        <resultMap type="Course" id="CourseResult">
          <id column="course_id" property="courseId" />
          <result column="name" property="name" />
          <result column="description" property="description" />
          <result column="start_date" property="startDate" />
          <result column="end_date" property="endDate" />
        </resultMap>
        <resultMap type="Tutor" id="TutorResult">
          <id column="tutor_id" property="tutorId" />
          <result column="name" property="name" />
          <result column="email" property="email" />
          <result column="phone" property="phone" />
          <association property="address" resultMap="AddressResult" />
          <collection property="courses" resultMap="CourseResult" />
        </resultMap>
        
        <select id="findTutorById" parameterType="int" resultMap="TutorResult">
            select t.tutor_id, t.name, t.email, c.course_id, c.name, description, start_date, end_date
            from tutors t left outer join addresses a on t.addr_id=a.addr_id
            left outer join courses c on t.tutor_id=c.tutor_id
            where t.tutor_id=#{tutorid}
        </select>

       这里我们使用了一个简单的使用了JOINS连接的Select语句获取讲师及其所教课程信息。<collection>元素的resultMap属性设置成了CourseResult，CourseResult包含了Course对象属性与表列名之间的映射。
       如果同时也要查询到Address相关信息,可以按照上面一对一的方式,在配置中加入<association>即可

        2.2 使用嵌套Select语句实现一对多映射
       我们可以使用嵌套Select语句方式获得讲师及其课程信息，代码如下：

          <resultMap type="Address" id="AddressResult">
          <id property="addrId" column="addr_id" />
          <result property="street" column="street" />
          <result property="city" column="city" />
          <result property="state" column="state" />
          <result property="zip" column="zip" />
          <result property="country" column="country" />
        </resultMap>
        <resultMap type="Course" id="CourseResult">
          <id column="course_id" property="courseId" />
          <result column="name" property="name" />
          <result column="description" property="description" />
          <result column="start_date" property="startDate" />
          <result column="end_date" property="endDate" />
        </resultMap>

        <resultMap type="Tutor" id="TutorResult">
          <id column="tutor_id" property="tutorId" />
          <result column="tutor_name" property="name" />
          <result column="email" property="email" />
          <association property="address" column="addr_id" select="findAddressById"></association>
          <!-- 这里要注意:是把当前tutor_id表中列的值当做参数去执行findCoursesByTutor这个查询语句,最后把查询结果封装到Tutor类中的courses属性中 -->
          <collection property="courses" column="tutor_id" select="findCoursesByTutor" />
        </resultMap>
        <select id="findTutorById" parameterType="int" resultMap="TutorResult">
            select *  
            from tutors
            where tutor_id=#{tutor_id}
        </select>
        <select id="findAddressById" parameterType="int" resultMap="AddressResult">
            select *
            from addresses
            where addr_id = #{addr_id}
        </select>
        <select id="findCoursesByTutor" parameterType="int" resultMap="CourseResult">
           select *
           from courses
           where tutor_id=#{tutor_id}
        </select>

       在这种方式中，<aossication>元素的select属性被设置为id为findCourseByTutor的语句，
       用来触发单独的SQL查询加载课程信息。tutor_id这一列值将会作为输入参数传递给 findCouresByTutor语句。

  mapper接口代码:
        public interface TutorMapper{
            Tutor findTutorById(int tutorId);
        }
        
        //方法调用
        TutorMapper mapper = sqlSession.getMapper(TutorMapper.class);
        Tutor tutor = mapper.findTutorById(tutor Id);
        System.out.println(tutor);
        List<Course> courses = tutor.getCourses();
        for (Course course : courses){
            System.out.println(course);
        }

【注意】嵌套查询Select语句查询会导致1+N选择问题。首先，主查询将会执行（1 次），
对于主查询返回的每一行，另外一个查询将会被执行（主查询 N 行，则此查询 N 次）。对于大量数据而言，这会导致很差的性能问题。

实例二：一对多 

1.实例类User和Order

package com.briup.bean;

import java.util.Set;
/*
 * create table s_user(
 * id number primary key,
 * name varchar2(20)
 * )
 * create sequence u_seq;
 */
public class User {
	private long id;
	private String name;
	private Set<Order> orders;
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}
	public User(long id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
	public User() {
	}
	public User(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", orders=" + orders + "]";
	}
	
}


package com.briup.bean;
/*
 * create table s_order(
 * id number primary key,
 * name varchar2(20),
 * price number,
 * user_id number references s_user(id)
 * )
 */
public class Order {
	private long id;
	private String name;
	private double price;
	public User user;
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public Order(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}
	public Order() {
		super();
	}
	@Override
	public String toString() {
		return "Order [id=" + id + ", name=" + name + ", price=" + price + ", user=" + user + "]";
	}
	
}


2.接口mapper

package com.briup.One2Many;

import java.util.List;
import java.util.Set;

import com.briup.bean.Order;
import com.briup.bean.User;

public interface One2ManyMapper {
	void saveUser(User user);
	void saveOrder(Order order);
	//基于用户的id查询用户信息（
	//级联的查询出所有的订单）
	User findUserAndOrders(long id);
	/*
	 * 基于用户的id查询所有的order
	 */
	Set<Order> selectOrderByUser_id(long id);
	/*
	 * 查询所有的用户及订单
	 */
	List<User> selectUserandOrder();
}

3.映射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.briup.One2Many.One2ManyMapper">
	<insert id="saveUser" parameterType="user">
		<selectKey keyProperty="id" resultType="long"
		order="BEFORE"
		>
			select u_seq.nextval from dual
		</selectKey>
		insert into s_user values(#{id},#{name})
	</insert>
	<insert id="saveOrder" parameterType="order">
		<selectKey keyProperty="id"
		resultType="long" order="BEFORE"
		>
		select u_seq.nextval from dual
		</selectKey>
		insert into s_order(id,name,price,user_id)
		values(#{id},#{name},#{price},#{user.id})
	</insert>
	<resultMap type="order" id="order_model">
		<id property="id" column="ids"/>
		<result property="name" column="names"/>
		<result property="price" column="price"/>
	</resultMap>
	<resultMap type="user" id="user_model">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<!-- 表示集合的封装  property指向
		单前封装对象中的集合引用对象-->
		<collection property="orders" 
				resultMap="order_model"></collection>
	</resultMap>
	<select id="findUserAndOrders"
	parameterType="long" resultMap="user_model">
		select s.id,s.name,d.id ids,d.name names,d.price
		from s_user s,s_order d
		where s.id=d.user_id
		 and s.id=#{id}
	</select>
	<!-- 基于用户的id查找订单对象 -->
	<select id="selectOrderByUser_id" parameterType="long"
		resultMap="order_model"
	>
	select id ids,name names,price
	from s_order
	where user_id=#{id}
	</select>
	<resultMap type="user" id="mod_user">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<!-- 基于单前查询的用户id去order表找
		订单 -->
		<collection property="orders" column="id" 
			select="selectOrderByUser_id"></collection>
	</resultMap>
	<select id="selectUserandOrder"
	 resultMap="mod_user"
	 >
		select id,name
		from s_user
	 </select>
</mapper>


4.测试类

package com.briup.One2Many;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.briup.bean.Order;
import com.briup.bean.User;
import com.briup.util.MyBatisSqlSessionFactory;

public class One2ManyTest {
	@Test
	public void find_user_order(){
		SqlSession session=
				MyBatisSqlSessionFactory
					.openSession(true);
		One2ManyMapper omm=
		session.getMapper(One2ManyMapper.class);
		List<User> user=omm.selectUserandOrder();
		System.out.println(user);
	}
	@Test
	public void select_user_order(){
		SqlSession session=
				MyBatisSqlSessionFactory
				.openSession(true);
		One2ManyMapper omm=
				session.getMapper(One2ManyMapper.class);
		User user=omm.findUserAndOrders(1L);
		System.out.println(user);
	}
	@Test
	public void save_user_order(){
		SqlSession session=
				MyBatisSqlSessionFactory
				.openSession(true);
		One2ManyMapper omm=
				session.getMapper(One2ManyMapper.class);
		User user=new User("lisi");
		Order order1=new Order("orde1", 34.55);
		order1.setUser(user);
		Order order2=new Order("orde2", 14.55);
		order2.setUser(user);
		Order order3=new Order("orde3", 24.55);
		order3.setUser(user);
		omm.saveUser(user);//id
		
		omm.saveOrder(order1);
		omm.saveOrder(order2);
		omm.saveOrder(order3);
	}
}

※ 3 多对多映射

        对于在mybatis中的多对多的处理,其实我们可以参照一对多来解决
       【注意】在这个例子中有三个字段都是一样的:id,这种情况一定要小心,要给列起别名的(上面的一对一和一对多中如果出现这种情况也是一样的处理方式)

建表语句:
        drop table student_course;
        drop table course;
        drop table student;
        如果需要可以使用 cascade constraints;

        create table course (
          id number primary key,
          course_code varchar2(30) not null,
          course_name varchar2(30) not null
        );
        create table student (
          id number primary key,
          name varchar2(10) not null,
          gender varchar2(10) ,
          major varchar2(10) ,
          grade varchar2(10)
        );
        create table student_course (
          id number primary key,
          student_id number references student(id),
          course_id number references course(id)
        );

  java代码:
        public class Course {
            private Integer id;
            private String courseCode; // 课程编号
            private String courseName;// 课程名称
            private List<Student> students;// 选课学生
            get/set
        }
        public class Student {
            private Integer id;
            private String name; // 姓名
            private String gender; // 性别
            private String major; // 专业
            private String grade; // 年级
            private List<Course> courses;// 所选的课程
            get/set
        }
        
        Many2ManyMapper.java:
        public interface Many2ManyMapper {
            //插入student数据
            public void insertStudent(Student student);
            //插入course数据
            public void insertCourse(Course course);
            //通过id查询学生
            public Student getStudentById(Integer id);
            //通过id查询课程
            public Course getCourseById(Integer id);
            
            //学生x选课y
            public void studentSelectCourse(Student student, Course course);
            //查询比指定id值小的学生信息
            public List<Student> getStudentByIdOnCondition(Integer id);
            //查询student级联查询出所选的course并且组装成完整的对象
            public Student getStudentByIdWithCourses(Integer id);
        }


        Many2ManyMapper.xml:
        <insert id="insertStudent" parameterType="Student">
            <selectKey keyProperty="id" resultType="int" order="BEFORE">
                select my_seq.nextval from dual
            </selectKey>
            insert into
                student(id,name,gender,major,grade)
            values
                (#{id},#{name},#{gender},#{major},#{grade})
        </insert>
        
        <insert id="insertCourse" parameterType="Course">
            <selectKey keyProperty="id" resultType="int" order="BEFORE">
                select my_seq.nextval from dual
            </selectKey>
            insert into
                course(id,course_code,course_name)
            values
                (#{id},#{courseCode},#{courseName})
        </insert>

        <select id="getStudentById" parameterType="int" resultType="Student">
            select id,name,gender,major,grade
            from student
            where id=#{id}
        </select>
        
        <select id="getCourseById" parameterType="int" resultType="Course">
            select id,course_code as courseCode,course_name as courseName
            from course
            where id=#{id}
        </select>

        <!-- param1代表方法中第一个参数 以此类推 -->
        <insert id="studentSelectCourse">
            insert into
                student_course(id,student_id,course_id)
            values
                (my_seq.nextval,#{param1.id},#{param2.id})
        </insert>
        
        <!-- 如果有特殊符号的话 需要用 <![CDATA[ 特殊符号 ]]>  例如 < & 等等 -->
        <select id="getStudentByIdOnCondition" parameterType="int" resultType="Student">
            select *
            from student
            where id <![CDATA[ < ]]> #{id}
        </select>

        <!--
             这里使用了嵌套结果ResultMap的方式进行级联查询
             当然也可以使用嵌套查询select
        -->
        <!-- 映射一个基本的Student查询结果 -->
        <resultMap id="StudentResult" type="Student">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="gender" column="gender"/>
            <result property="major" column="major"/>
            <result property="grade" column="grade"/>
        </resultMap>
        <!-- 继承上面那个基本的映射,再扩展出级联查询 -->
        <resultMap id="StudentResultWithCourses" type="Student" extends="StudentResult">
            <collection property="courses" resultMap="CourseResult"></collection>
        </resultMap>
        <!-- 这里特别要是的是column="cid" 这是和select语句中的 c.id as cid对应的 一定一定一定要对应起来 -->
        <resultMap id="CourseResult" type="Course">
            <id property="id" column="cid"/>
            <result property="courseCode" column="course_code"/>
            <result property="courseName" column="course_name"/>
        </resultMap>
        <!--
            注意:查询语句的中的c.id as cid这个地方,避免名字相同出现查询结果不正确的情况
            同时在id="CourseResult"的resultMap中也有与这里对应的设置要特别特别注意
        -->
        <select id="getStudentByIdWithCourses" parameterType="int" resultMap="StudentResultWithCourses">
            select s.id,s.name,s.gender,s.major,s.grade,c.id as cid,c.course_code,c.course_name,sc.id,sc.student_id,sc.course_id
            from student s,course c,student_course sc
            where
            s.id=#{id}
            and
            s.id=sc.student_id
            and
            sc.course_id=c.id
        </select>
        
        测试代码:
        @Test
        public void test_insertStudent(){
            
            SqlSession session = null;
            try {
                session = MyBatisSqlSessionFactory.openSession();
                
                Many2ManyMapper mapper = session.getMapper(Many2ManyMapper.class);
                    
                mapper.insertStudent(new Student("张三","男","计算机","大四"));
                
                session.commit();
                
            } catch (Exception e) {
                e.printStackTrace();
                session.rollback();
            }finally {
                if(session!=null)session.close();
            }
            
        }
        
        @Test
        public void test_insertCourse(){
            
            SqlSession session = null;
            try {
                session = MyBatisSqlSessionFactory.openSession();
                
                Many2ManyMapper mapper = session.getMapper(Many2ManyMapper.class);
                    
                mapper.insertCourse(new Course("001","corejava"));
                mapper.insertCourse(new Course("002","oracle"));
                
                session.commit();
                
            } catch (Exception e) {
                e.printStackTrace();
                session.rollback();
            }finally {
                if(session!=null)session.close();
            }
            
        }
        
        @Test
        public void test_studentSelectCourse(){
            
            SqlSession session = null;
            try {
                session = MyBatisSqlSessionFactory.openSession();
                
                Many2ManyMapper mapper = session.getMapper(Many2ManyMapper.class);
                    
                Student student = mapper.getStudentById(58);
                Course course = mapper.getCourseById(59);
                
                mapper.studentSelectCourse(student, course);
                
                session.commit();
                
            } catch (Exception e) {
                e.printStackTrace();
                session.rollback();
            }finally {
                if(session!=null)session.close();
            }
            
        }
        
        @Test
        public void test_getStudentByIdOnCondition(){
            
            SqlSession session = null;
            try {
                session = MyBatisSqlSessionFactory.openSession();
                
                Many2ManyMapper mapper = session.getMapper(Many2ManyMapper.class);
                
                List<Student> list = mapper.getStudentByIdOnCondition(100);
                
                for(Student s:list){
                    System.out.println(s);
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(session!=null)session.close();
            }
            
        }
        
        @Test
        public void test_getStudentByIdWithCourses(){
            
            SqlSession session = null;
            try {
                session = MyBatisSqlSessionFactory.openSession();
                
                Many2ManyMapper mapper = session.getMapper(Many2ManyMapper.class);
                
                Student student = mapper.getStudentByIdWithCourses(58);
                
                System.out.println(student);
                
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(session!=null)session.close();
            }
            
        }

注:这是从student这边出发所做的一些操作,从course一边开始操作是一样的,因为俩者的关系是多对多(对称的).
同时不论是一对一还是一对多还是多对多,都不能在mybatis中进行级联保存、更新、删除,我们需要使用sql语句控制每一步操作

实例3：多对多

1.实例类：student和course

package com.briup.bean;
/*
 * 学生
 * 
 * create table  s_stu(
 * id number primary key,
 * name varchar2(20)
 * )
 * create table  s_course(
 * id number primary key,
 * name varchar2(20)
 * )
 * create table stu_cou(
 * stu_id number references s_stu(id),
 * cou_id number references s_course(id),
 * primary key(stu_id,cou_id)
 * )
 * create sequence sc_seq;
 */

import java.util.Set;

import org.apache.ibatis.type.Alias;
@Alias("stud")
public class Stu {
	private int id;
	private String name;
	private Set<Course> courses;
	
	@Override
	public String toString() {
		return "Stu [id=" + id + ", name=" + name + ", courses=" + courses + "]";
	}
	public Stu() {
		super();
	}
	public Stu(String name) {
		super();
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Course> getCourses() {
		return courses;
	}
	public void setCourses(Set<Course> courses) {
		this.courses = courses;
	}
}


package com.briup.bean;
/*
 * 课程
 */

import java.util.Set;

public class Course {
	private long id;
	private String name;
	
	public Course() {
	}
	@Override
	public String toString() {
		return "Course [id=" + id + ", name=" + name + ", stus=" + stus + "]";
	}
	public Course(String name) {
		this.name = name;
	}
	private Set<Stu> stus;
	
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Stu> getStus() {
		return stus;
	}
	public void setStus(Set<Stu> stus) {
		this.stus = stus;
	}
	
}


2.接口mapper

package com.briup.Many2Many;

import java.util.List;
import java.util.Set;

import org.apache.ibatis.annotations.Param;

import com.briup.bean.Course;
import com.briup.bean.Stu;

public interface Many2ManyMapper {
	void saveStu(Stu stu);
	void saveCourse(Course cours);
	Stu findStuByid(int id);
	Course findCourseById(long id);
	/*
	 * 学生选课
	 */
	void saveStu_Course(@Param("stu")Stu stu,@Param("course")Course course);
	/*
	 * 查询学生信息及选择的所有课程
	 */
	Stu findStuAndCourse(int id);
	/*
	 * 查询选择某门课程的所有学生
	 */
	List<Course> findCourseAndStu(long id);
	Set<Stu> findStuByids(int id);
}


3.映射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.briup.Many2Many.Many2ManyMapper">
	<insert id="saveStu" parameterType="stud">
		<selectKey keyProperty="id" resultType="int"
		order="BEFORE">
		select sc_seq.nextval from dual
		</selectKey>
		insert into s_stu values(#{id},#{name})
	</insert>
	<insert id="saveCourse" parameterType="course">
		<selectKey keyProperty="id" resultType="long"
		order="BEFORE">
		select sc_seq.nextval from dual
		</selectKey>
		insert into s_course values(#{id},#{name})
	</insert>
	<select id="findStuByid" parameterType="int"
	resultType="stud"
	>
		select id,name
		from s_stu
		where id=#{id}
	</select>
	<select id="findCourseById" parameterType="long"
	resultType="course"
	>
		select id,name
		from s_course
		where id=#{id}
	</select>
	
	<!-- 传入多参数
	#{0} #{1}...
	#{param1} #{param2}
	在接口方法中使用注解@param("key")
	在映射文件中直接#{key}
	 -->
	<!-- <insert id="saveStu_Course">
		insert into stu_cou values(#{param1.id},#{param2.id})
	</insert> -->
	<insert id="saveStu_Course">
		insert into stu_cou values(#{stu.id},#{course.id})
	</insert>
	<resultMap type="course" id="course_mod">
		<id property="id" column="ids"></id>
		<result property="name" column="names"/>
	</resultMap>
	<resultMap type="stud" id="stud_mod">
		<id property="id" column="id"></id>
		<result property="name" column="name"/>
		<collection property="courses" resultMap="course_mod"></collection>
	</resultMap>
	<select id="findStuAndCourse" parameterType="int"
	resultMap="stud_mod">
	select s.id,s.name,c.id ids,c.name names
	from s_stu s,s_course c,stu_cou sc
	where s.id=sc.stu_id and sc.cou_id=c.id
		and s.id=#{id}
	</select>
	
	<!-- <resultMap type="stud" id="stud1_mod">
		<id property="id" column="id"></id>
		<result property="name" column="name"/>
	</resultMap>
	<resultMap type="course" id="course1_mod">
		<id property="id" column="ids"></id>
		<result property="name" column="names"/>
		<collection property="stus" resultMap="stud1_mod"></collection>
	</resultMap>
	<select id="findCourseAndStu" parameterType="long"
	resultMap="course1_mod"
	>
	select s.id,s.name,c.id ids,c.name names
	from s_stu s,s_course c,stu_cou sc
	where s.id=sc.stu_id and sc.cou_id=c.id
	and c.id=#{id}
	</select> -->
	<select id="findStuByids" parameterType="int"
	resultType="stud"
	>
		select s.id,s.name
		from s_stu s,stu_cou sc
		where s.id=sc.stu_id 
			and sc.cou_id=#{id}
	</select>
	<resultMap type="course" id="course2_mod">
		<id property="id" column="id"/>
		<result property="name" column="name"/>
		<collection property="stus" column="id"
		select="findStuByids"
		></collection>
	</resultMap>
	<select id="findCourseAndStu" parameterType="long"
	resultMap="course2_mod"
	> 
	select id,name
	from s_course
	where id=#{id}
	</select> 
</mapper>

4.测试类

package com.briup.Many2Many;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.briup.bean.Course;
import com.briup.bean.Stu;
import com.briup.util.MyBatisSqlSessionFactory;

public class Many2ManyTest {
	@Test
	public void findStu_and_courses1(){
		try{
		SqlSession session=
				MyBatisSqlSessionFactory
					.openSession(true);
		Many2ManyMapper mm=
		session.getMapper(Many2ManyMapper.class);
		List<Course> c=mm.findCourseAndStu(5L);
		System.out.println(c);
		session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void findStu_and_courses(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Stu s=mm.findStuAndCourse(3);
			System.out.println(s);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void saveStu_course(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Stu s=mm.findStuByid(3);
			Course c=mm.findCourseById(4L);
			//Course c1=mm.findCourseById(5L);
			mm.saveStu_Course(s, c);
			//mm.saveStu_Course(s, c1);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void selectCourse_id(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Course c=mm.findCourseById(4L);
			System.out.println(c);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void selectStudent_id(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Stu s=mm.findStuByid(1);
			System.out.println(s);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void saveStudent(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Stu stu=new Stu("lisi");
			Stu stu1=new Stu("jake");
			Stu stu2=new Stu("tom");
			mm.saveStu(stu);
			mm.saveStu(stu1);
			mm.saveStu(stu2);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
	@Test
	public void saveCourse(){
		try{
			SqlSession session=
					MyBatisSqlSessionFactory
					.openSession(true);
			Many2ManyMapper mm=
					session.getMapper(Many2ManyMapper.class);
			Course c=new Course("java");
			Course c1=new Course("oracle");
			mm.saveCourse(c);
			mm.saveCourse(c1);
			session.close();
		}catch (Exception e) {
			e.printStackTrace();
		}
	}
}

编程搬运工

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
mybatis 5：SQL映射关系

※ 1 一对一映射 association Student和Address是一个【一对一】关系建表语言: drop table students; drop table addresses; 如果需要可以使用 cascade constraints; create table a...
复制链接

扫一扫

专栏目录