mybatis关系映射之一对多和多对一

create database test; 

   use test;

   create table person(

    personid varchar( 36 ) primary key,

    personname varchar( 64 ),

    personaddress varchar( 128 ),

    persontel varchar( 11 )

   );

   create table orders(

    orderid varchar( 36 ) primary key,

    ordernumber varchar( 20 ),

    orderprice int ,

    pid varchar( 36 )

   );

insert into person values( '1' , '木子' , '湖北' , '110' );

insert into person values( '2' , '木子大大' , '武汉' , '120' );

insert into person values( '1' , '木子苗苗' , '天门' , '119' );

   insert into orders values( '1' , '001' , 100 , '1' );

   insert into orders values( '2' , '002' , 200 , '1' );

   insert into orders values( '3' , '003' , 300 , '2' );

   insert into orders values( '4' , '004' , 400 , '2' );

   insert into orders values( '5' , '005' , 500 , '3' );

select p.*, o.* from person p join orders o on (p.personid=o.pid) where p.personid = '1' ;

*指显示所有字段

package com.mybatis.domain;

import java.util.list;

import lombok.data;

@data //注释（person为单方）

public class person {

   private string personid;

   private string personname;

   private string personaddress;

   private string persontel;

   //这个代表多方里面的内容（orders）

   private list<orders> orders;

  @override

  public string tostring() {

  return "person [personid=" + personid + ", personname=" + personname

   + ", personaddress=" + personaddress + ", persontel="

   + persontel + ", orders=" + orders + "]" ;

  }

}

package com.mybatis.domain;

import lombok.data;

@data //（orders为多方）

public class orders {

   private string orderid;

   private string ordernumber;

   private integer orderprice;

   //对象（单方person）与外键进行关联

   private person person;

}

package com.mybatis.dao.mapper;

import com.mybatis.domain.orders;

import com.mybatis.domain.person;

import java.util.list;

public interface personmapper {

   int deletebyprimarykey(string personid);

   int insert(person record);

   person selectbyprimarykey(string personid);

   list<person> selectall();

   int updatebyprimarykey(person record);

   //一对多查询(根据id查询)

   public list<orders> findpersonandorders(string pid);

   //一对多查询返回一个对象

   public person selectpersonbyid(string id);

}

<?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.mybatis.dao.mapper.personmapper" >

  <resultmap id= "personresultmap" type= "com.mybatis.domain.person" >

   <id column= "personid" property= "personid" jdbctype= "varchar" />

   <result column= "personname" property= "personname" jdbctype= "varchar" />

   <result column= "personaddress" property= "personaddress" jdbctype= "varchar" />

   <result column= "persontel" property= "persontel" jdbctype= "varchar" />

  <!-- 一对多的关系（这个是关联集合）这个是orders里面的多方 -->

     <!-- property: 指的是集合属性的名, oftype：指的是集合中元素的类型的路径 （实现类）-->

     <collection property= "orders" oftype= "com.mybatis.domain.orders" >

      <!-- id有一个单独标签 -->

       <id column= "orderid" property= "orderid" />

       <!--column指sql中字段的名字  property指java中对应sql中属性的名 -->

       <result column= "ordernumber" property= "ordernumber" />

       <result column= "orderprice" property= "orderprice" />

     </collection>

  </resultmap>

   <!-- 根据id查询person, 关联将orders查询出来（注意放置的位置） -->

   <select id= "findpersonandorders" parametertype= "string" resultmap= "personresultmap" >

     select p.*,o.* from person o,orders b where o.personid=#{pid};

   </select>

    <select id= "selectpersonbyid" parametertype= "string" resultmap= "personresultmap" >

     select p.*, o.* from person p, orders o where p.personid = o.pid and p.personid = #{id}

   </select>

  </mapper>

package com.mybatis.dao.mapper;

import com.mybatis.domain.orders;

import java.util.list;

public interface ordersmapper {

   int deletebyprimarykey(string orderid);

   int insert(orders record);

   orders selectbyprimarykey(string orderid);

   list<orders> selectall();

   int updatebyprimarykey(orders record);

   //多查一 根据id

   public orders selectorderbyid(string oid);

   //多查一 根据ordernumber

   public orders selectordernumber(string number);

}

<?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.mybatis.dao.mapper.ordersmapper" >

  <resultmap id= "ordersresultmap" type= "com.mybatis.domain.orders" >

   <id column= "orderid" property= "orderid" jdbctype= "varchar" />

   <result column= "ordernumber" property= "ordernumber" jdbctype= "varchar" />

   <result column= "orderprice" property= "orderprice" jdbctype= "integer" />

   <!--

   <result column= "pid" property= "pid" jdbctype= "varchar" />

   -->

    <!-- 多对一的关系 这个是person里面的单方 -->

     <!-- property: 指的是属性的值, javatype：指的是属性的类型的路径 （实现类）-->

     <association property= "person" javatype= "com.mybatis.domain.person" >

       <!--注意：在此column和property的值要一样都为person的属性 -->

  <id column= "personid" property= "personid" />

<result column= "personname" property= "personname" />

<result column= "personaddress" property= "personaddress" />

<result column= "persontel" property= "persontel" />

</association>

  </resultmap>

<!-- 根据id查询order, 关联将person查询出来 -->

<select id= "selectorderbyid" parametertype= "string" resultmap= "ordersresultmap" >

  select p.*, o.* from person p, orders o where p.personid = o.pid and o.orderid = #{oid}

</select>

<!-- 根据ordernumber查询order, 关联将person查询出来 -->

<select id= "selectordernumber" parametertype= "string" resultmap= "ordersresultmap" >

select p.*, o.* from person p, orders o where p.personid = o.pid and o.orderid = #{number}

  </select>

</mapper>

db.properties配置（sql语句的基本链接）

db.driver=com.mysql.jdbc.driver

db.url=jdbc:mysql: //localhost:3306/wang1?useunicode=true&characterencoding=utf8

db.username=root

db.password= 123456

    log4j.properties配置（注释）

# global logging configuration

log4j.rootlogger=debug, stdout

# console output...

log4j.appender.stdout=org.apache.log4j.consoleappender

log4j.appender.stdout.layout=org.apache.log4j.patternlayout

log4j.appender.stdout.layout.conversionpattern=%5p [%t] - %m%n

   mybatis.xml（逆向生成domain、dao层）

<?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>

<!-- mybatis核心配置文件 -->

  <!-- 加载java的配置文件或者声明属性信息 -->

  <properties resource= "db.properties" >

  </properties>

  <!-- alias别名 -->

  <typealiases>  <!--这里需要修改 domain层的路径-->

  <typealias type= "com.mybatis.domain.person" alias= "person" />

  <typealias type= "com.mybatis.domain.orders" alias= "orders" />

  </typealiases>

  <!-- 配置mybatis的环境信息，与spring整合，该信息由spring来管理

  如果说我们需要连接数据库,那么必须在mybatis中配置环境 运行环境

  -->

  <environments default = "development" >

  <environment id= "development" >

   <!-- 配置jdbc事务控制，由mybatis进行管理 -->

   <transactionmanager type= "jdbc" ></transactionmanager>

   <!-- 配置数据源，采用mybatis连接池 -->

   <datasource type= "pooled" >

   <property name= "driver" value= "${db.driver}" />

   <property name= "url" value= "${db.url}" />

   <property name= "username" value= "${db.username}" />

   <property name= "password" value= "${db.password}" />

   </datasource>

  </environment>

  </environments>

  <!-- 加载映射文件(注意反\)-->

  <mappers>  <!--这里需要修改 dao层的路径-->

  <mapper resource= "com\mybatis\dao\mapper\personmapper.xml" />

  <mapper resource= "com\mybatis\dao\mapper\ordersmapper.xml" />

  </mappers>

</configuration>

   generatorconfig.xml配置（对mysql进行操作）下面标红部分根据自己建立的进行修改

<?xml version= "1.0" encoding= "utf-8" ?>

<!doctype generatorconfiguration

  public "-//mybatis.org//dtd mybatis generator configuration 1.0//en"

"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >

<!-- 配置生成器 -->

<generatorconfiguration>  d盘中要有此包mysql-connector-java- 5.1 . 7 -bin.jar

<classpathentry location= "d:\mysql-connector-java-5.1.7-bin.jar" />

  <context id= "mysql" defaultmodeltype= "hierarchical" targetruntime= "mybatis3simple" >

  <!-- 自动识别数据库关键字，默认 false ，如果设置为 true ，根据sqlreservedwords中定义的关键字列表；

          一般保留默认值，遇到数据库关键字（java关键字），使用columnoverride覆盖 -->

  <property name= "autodelimitkeywords" value= "false" />

  <!-- 生成的java文件的编码 -->

  <property name= "javafileencoding" value= "utf-8" />

  <!-- beginningdelimiter和endingdelimiter：指明数据库的用于标记数据库对象名的符号，比如oracle就是双引号，mysql默认是`反引号； -->

  <property name= "beginningdelimiter" value= "`" />

  <property name= "endingdelimiter" value= "`" />

  <!-- 注释生成器 -->

  <commentgenerator>

   <property name= "suppressdate" value= "true" />

   <property name= "suppressallcomments" value= "true" />

  </commentgenerator>

  <!-- 必须要有的，使用这个配置链接数据库 @todo :是否可以扩展 -->

  <jdbcconnection driverclass= "com.mysql.jdbc.driver"

   connectionurl= "jdbc:mysql://localhost:3306/wang1" userid= "root" password= "123456" >

   <!-- 这里面可以设置property属性，每一个property属性都设置到配置的driver上 -->

  </jdbcconnection>

  <!-- java模型创建器，是必须要的元素 负责： 1 ，key类（见context的defaultmodeltype）； 2 ，java类； 3 ，查询类

   targetpackage：生成的类要放的包，真实的包受enablesubpackages属性控制；

          targetproject：目标项目，指定一个存在的目录下，生成的内容会放到指定目录中，如果目录不存在，mbg不会自动建目录 -->

  <javamodelgenerator targetpackage= "com.mybatis.domain" targetproject= "mybatis03/src" >

   <!-- for mybatis3/mybatis3simple 自动为每一个生成的类创建一个构造方法，构造方法包含了所有的field；而不是使用setter； -->

   <property name= "constructorbased" value= "false" />

   <!-- for mybatis3 / mybatis3simple 是否创建一个不可变的类，如果为 true ， 那么mbg会创建一个没有setter方法的类，

           取而代之的是类似constructorbased的类 -->

   <property name= "immutable" value= "false" />

  </javamodelgenerator>

  <!-- 生成sql map的xml文件生成器， 注意，在mybatis3之后，我们可以使用mapper.xml文件+mapper接口（或者不用mapper接口），

   或者只使用mapper接口+annotation，所以，如果 javaclientgenerator配置中配置了需要生成xml的话，这个元素就必须配置

   targetpackage/targetproject:同javamodelgenerator -->

  <sqlmapgenerator targetpackage= "com.mybatis.dao.mapper" targetproject= "mybatis03/src" >

   <!-- 在targetpackage的基础上，根据数据库的schema再生成一层 package ，最终生成的类放在这个 package 下，默认为 false -->

   <property name= "enablesubpackages" value= "true" />

  </sqlmapgenerator>

    <!-- 对于mybatis来说，即生成mapper接口，注意，如果没有配置该元素，那么默认不会生成mapper接口 targetpackage/targetproject:同javamodelgenerator

   type：选择怎么生成mapper接口（在mybatis3/mybatis3simple下）：

    1 ，annotatedmapper：会生成使用mapper接口+annotation的方式创建（sql生成在annotation中），不会生成对应的xml；

   2 ，mixedmapper：使用混合配置，会生成mapper接口，并适当添加合适的annotation，但是xml会生成在xml中；

   3 ，xmlmapper：会生成mapper接口，接口完全依赖xml；

   注意，如果context是mybatis3simple：只支持annotatedmapper和xmlmapper -->

  <javaclientgenerator targetpackage= "com.mybatis.dao.mapper" type= "xmlmapper" targetproject= "mybatis03/src" >

   <!-- 在targetpackage的基础上，根据数据库的schema再生成一层 package ，最终生成的类放在这个 package 下，默认为 false -->

   <property name= "enablesubpackages" value= "true" />

   <!-- 可以为所有生成的接口添加一个父接口，但是mbg只负责生成，不负责检查 <property name= "rootinterface"

   value= "" /> -->

  </javaclientgenerator>

             <!--逆向生成的文件-->

  <table tablename= "person" delimitidentifiers= "true" >

<!-- 参考 javamodelgenerator 的 constructorbased属性 -->

<property name= "constructorbased" value= "false" />

<generatedkey column= "id" sqlstatement= "jdbc" />

</table>

<table tablename= "orders" delimitidentifiers= "true" >

<!-- 参考 javamodelgenerator 的 constructorbased属性 -->

<property name= "constructorbased" value= "false" />

<generatedkey column= "id" sqlstatement= "jdbc" />

</table>

</context>

</generatorconfiguration>

package com.mybatis.test;

import java.io.inputstream;

import java.text.parseexception;

import java.text.simpledateformat;

import java.util.date;

import java.util.iterator;

import java.util.list;

import lombok.data;

import org.apache.ibatis.io.resources;

import org.apache.ibatis.session.sqlsession;

import org.apache.ibatis.session.sqlsessionfactory;

import org.apache.ibatis.session.sqlsessionfactorybuilder;

import org.junit.before;

import org.junit.test;

import com.mybatis.dao.mapper.ordersmapper;

import com.mybatis.dao.mapper.personmapper;

import com.mybatis.domain.orders;

import com.mybatis.domain.person;

public class teststudentmapper {

  sqlsessionfactory sessionfactory = null ;

  // 这方法之前

  @before

  public void setup() throws exception {

  string resource = "mybatis.xml" ;

  // 这个是加载配置文件

  inputstream inputstream = resources.getresourceasstream(resource);

  // 得到会话工厂

  sessionfactory = new sqlsessionfactorybuilder().build(inputstream);

  }

  //查询一对多 根据这个person里面的id号就能查询出这个用户有多少个订单记录

// @test

  public void testselectpersonbyid(){

  sqlsession sq = sessionfactory.opensession();

  // 得到dao层的实现类

  personmapper u = sq.getmapper(personmapper. class );

  person person = u.selectpersonbyid( "2" );

  system.out.println(person);

  }

  //多对一 根据多对一id进行查询

// @test//多对一关联查询

    public void testselectorderbyid(){

    sqlsession sq = sessionfactory.opensession();

   // 得到dao层的实现类

    ordersmapper u = sq.getmapper(ordersmapper. class );

   orders od = u.selectorderbyid( "2" );

   system.out.println(od.getperson().getpersonname());

   system.out.println(od.getperson().getpersonaddress());

    }

   @test //多对一关联查询

    public void testselectordernumber(){

    sqlsession sq = sessionfactory.opensession();

   // 得到dao层的实现类

    ordersmapper u = sq.getmapper(ordersmapper. class );

   orders od = u.selectordernumber( "001" );

   system.out.println(od.getperson().getpersonname());

   system.out.println(od.getperson().getpersonaddress());

    }

}