今天是我们Mybatis框架学习的第3天,今天要求大家整理的内容是,
1.Mybatis的一对一查询
2.Mybatis的一对多查询
3.Mybatis的多对多查询
4.动态sql

今天是我们Mybatis框架学习的第3天,今天要求大家整理的内容是,
1.Mybatis的一对一查询
答：（1）一对一即多对一，在今天的案例中多是Account类，一是User类。需要在Account的实体类中添加User类的对象作为字段。
（2）写一个AccountDao接口，里面定义方法，返回值类型为List<Account>。写一个AccountDao.xml文件，sql语句使用内联连接account表和user表，使用account表中的
uid字段和user的id字段连接。还要定义一个resultMap标签，标签内先写account表的字段，再通过association标签写user表的字段，property属性和javaType属性要写，column属性可以省略。
（3）测试类获得接口代理对象调用接口方法。
2.Mybatis的一对多查询。
答：（1）在今天的案例中，一的一方是User类，多的一方是Account类。需要在User类中添加List<Account>字段。
（2）写一个UserDao接口，里面定义方法，返回值类型为List<User>。写一个UserDao.xml文件，sql语句使用左外连接user表和account表，使用user表的id字段和account表中的
uid字段连接。需要定义一个resultMap标签，标签内先写User表的字段，再通过collection标签写account表的字段，property属性为User类中定义的集合名字，ofType属性为集合的泛型。
3.Mybatis的多对多查询
答：（1）多对多的实体类，和xml文件，接口写法都和一对多差不多。今天的案例为role和user，当需要查role表顺便显示用户信息就需要在role实体类中添加List<User>字段。反过来，当需要查
user表顺便显示role信息就需要在role实体类中添加List<Role>字段。
（2）xml中，resultMap写法和一对多完全一样，唯一不同的就是sql语句。查role表顺便显示用户信息时，sql语句就要先用role表和role_user表通过role表的id和role_user表的rid进行左外连接，
结果再通过role_user表的uid和user表的id进行左外连接。
（3）查user表顺便显示role信息，sql语句就要先用user表的user的id和role_user表的的uid进行左外连接，结果再通过role_user表的rid和role表的rid进行左外连接。
4.动态sql
答：动态sql四个便签<if><where><foreach><sql>。
<if><where>作用：搭配<where>判断是否需要添加where关键字和查询条件。
<foreach>作用：搭配前两个判断是否需要添加in（）条件，<foreach>循环遍历添加in（）里的内容。

1.Mybatis的一对一查询
答：
        实现类：
                定义两表的实现类，并在主表内定义一个从表对象；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        association标签：从表和主表实体类的从表对象
                                id：主表内的从表对象名；
                                type：从表对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

2.Mybatis的一对多查询
答：
        实现类：
                定义两表的实现类，并在一的一方内定义多的一方的对象集合；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        collecyion标签：从表和主表实体类的从表对象
                                id：主表内的从表集合名；
                                type：从表集合的对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

        注：主表如果出现重复的信息，会将主表对应的从表信息封装到集合中；

3.Mybatis的多对多查询
答：
        实现类：
                定义两表的实现类，并在其中一方定义另一方的对象集合；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        collecyion标签：从表和主表实体类的从表对象
                                id：主表内的从表集合名；
                                type：从表集合的对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

        注：
                环境参数定义方式和一对对类似，不过主表可以随意指定，其结果会根据主表的不同，导致结果也不同；
                sql语句要有一张中间表进行协助查询；

4.动态sql
答：
        if标签：进行SQL语句的拼接
                前置的基础SQL语句：select * from 表名 where 1=1
                属性：test：拼接条件
                内容：要拼接的SQL语句（and 不可省略）

        where标签：进行SQL语句的拼接
                前置的基础SQL语句：select * from 表名
                属性：test：拼接条件
                内容：if标签（第一个if标签的SQL语句的and可以不写）

        foreach标签：进行元素集合的遍历
                前置的基础SQL语句：select * from 表名
                属性：
                        collection：要遍历的集合元素
                        open：SQL语句的开始部分
                        close：SQL语句的结束部分
                        aeparator：参数之间的分隔符
                        item：每个元素，生成的变量名
                内容：#{item指定的变量名}
               
        sql标签：抽取重复的SQL语句
                属性：id：标识；
                内容：SQL基础语句（结尾不能加 ； ）
                使用：
                        include标签
                                属性：refid：指定SQL标签对应的id；

1.Mybatis的一对一查询方法一:创建一个PO对象实体类,继承主表,把要联查的表的字段作为属性封装进PO对象中,并在ToString方法中,调用父类的ToString方法,进行字符串拼接;


方法二:在主表的实体类中,添加需要联查的表的实体类作为属性值,这样查询出的结果会被封装进主表中;

2.Mybatis的一对多查询
在主表中添加一个属性为多表的对象集合,这样查询的结果会被封装进对象中;
配置文件中需要定义<resultType>标签,定义完主表的属性后用<association>类定义集合对象,并且要指定javaType的类型,用于返回结果封装;
<resultMap id="AccountUser" type="account" >
    <id property="id" column="id" />
    <result property="uid" column="uid" />
    <result property="money" column="money"/>
    <association property="user" javaType="user">
        <id property="id" column="id"/>
        <result property="username" column="username"/>
        <result property="address" column="address"/>
        <result property="sex" column="sex" />
        <result property="birthday" column="birthday"/>
    </association>
</resultMap>
3.Mybatis的多对多查询
多对多查询可以从任意一张表的角度看成是一对多,这样的话,将需要作为主表的实体类中添加需要联查的表的对象集合,但是使用<collection>标签作为连接;
<resultMap id="UserRoleMap" type="user">
    <id property="id" column="id" />
    <result property="username" column="username"/>
    <result property="address" column="address"/>
    <result property="sex" column="sex"/>
    <result property="birthday" column="birthday"/>
    <collection property="roles" ofType="role">
        <id property="id" column="rid"></id>
        <result property="roleName" column="role_name"/>
        <result property="roleDesc" column="role_desc"/>
    </collection>4.动态sql及例子

<if>标签, test属性值跟着表达式,如果表达式成立,那么<if>标签中的内容会被拼接到sql语句中,根据表达式的非空判断,来确定是否要添加查询条件,实现动态sql;
<where>标签, 如果where标签内容被拼接,那么会提前在sql语句中添加上where true ,where标签中的内容要以and 来连接where标签;
<foreach>标签,将类型为集合的参数遍历,一个个的取出集合中的值,与属性定义的字符串一起拼接,<foreach>标签的属性open,close,item,separator属性共同定义了需要拼接的字符串;
<sql>标签,将重复使用的sql语句片段提前出来,放入<sql>标签中,需要用到时使用<include >标签插入;
例子:User表和Account表联查, 在User的实体类中,添加Account属性,sql语句为 select * from user u ,account a where u.id = a.uid;

李伟斌

1.Mybatis的一对一查询
答：a.定义接口中的方法。
       b.设置数据库和实体类的对应关系
        注意：一对一的关系映射，配置封装user的内容为
        <association property="属性" javaType="类型">
        这边和一对多，多对多的配置文件不同。
       c.现在映射配置文件中写入sql语句。       
       d.写测试类，创建接口对象，调用接口中的方法，然后输出。
2.Mybatis的一对多查询
答：a.定义接口中的方法。
       b.设置数据库和实体类的对应关系
        注意：一对多的关系映射，配置封装user的内容为
        <collection property="属性" ofType="类型">
        这边和一对一的配置文件不同。
       c.现在映射配置文件中写入sql语句。       
       d.写测试类，创建接口对象，调用接口中的方法，然后输出。
3.Mybatis的多对多查询
答：和一对多的布置方法一致。
4.动态sql  
答：有以下几个关键字用于拼接字符串。
       if，用于进行条件判断。
       where：用于根据<if>标签的结果是否拼接where关键字。
       foreach：用于进行遍历。
       sql：抽取公用的sql代码。

今天是我们Mybatis框架学习的第3天,今天要求大家整理的内容是,

1.Mybatis的一对一查询
public class Account implements Serializable {
    private Integer id;
   private Integer uid;
    private Double money;

    //从表实体应该包含一个主表实体的对象引用
    private User user;

IAccountDao.xml：
   <!-- 定义封装account和user的resultMap -->
    <resultMap id="accountUserMap" type="account">
        <id property="id" column="aid"></id>
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!-- 一对一的关系映射：配置封装user的内容-->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </association>
    </resultMap>

    <select id="findAll" resultMap="accountUserMap">
        select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
    </select>

2.Mybatis的一对多查询
public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

   //一对多关系映射：主表实体应该包含从表实体的集合引用
    private List<Account> accounts;

IUserDao.xml：
<!-- 定义User的resultMap-->
    <resultMap id="userAccountMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
       <!-- 配置user对象中accounts集合的映射 -->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"></id>
            <result column="uid" property="uid"></result>
            <result column="money" property="money"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userAccountMap">
        select u.*,a.id as aid,a.uid,a.money from user u left outer join account a on u.id = a.uid
    </select>

3.Mybatis的多对多查询
public class Role implements Serializable {
    private Integer roleId;
    private String roleName;
    private String roleDesc;

   //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;

IRoleDao.xml：
<!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user" >
            <id column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </collection>
    </resultMap>

<select id="findAll" resultMap="roleMap">
       select u.*,r.id as rid,r.role_name,r.role_desc from role r
        left outer join user_role ur  on r.id = ur.rid
        left outer join user u on u.id = ur.uid
    </select>

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

  //多对多的关系映射：一个用户可以具备多个角色
    private List<Role> roles;

IUserDao.xml：
<!-- 定义User的resultMap-->
   <resultMap id="userMap" type="user">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!-- 配置角色集合的映射 -->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>

<select id="findAll" resultMap="userMap">
      select u.*,r.id as rid,r.role_name,r.role_desc from user u
        left outer join user_role ur  on u.id = ur.uid
         left outer join role r on r.id = ur.rid
   </select>

4.动态sql
<if>标签
<if test="username!=null and username != '' ">
        and username like #{username}
</if>

<where> 标签
<where>
        <if test="username!=null and username != '' ">
                and username like #{username}
        </if>
        <if test="address != null">
                and address like #{address}
        </if>
</where>

<foreach>标签
<if test="ids != null and ids.size() > 0">
        <foreach collection="ids" open="id in ( " close=")" item="uid"  separator=",">
                #{uid}
        </foreach>
</if>

SQL 片段
<sql id="defaultSql">
        select * from user
</sql>

1.Mybatis的一对一查询
答：
        实现类：
                定义两表的实现类，并在主表内定义一个从表对象；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        association标签：从表和主表实体类的从表对象
                                id：主表内的从表对象名；
                                type：从表对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

2.Mybatis的一对多查询
答：
        实现类：
                定义两表的实现类，并在一的一方内定义多的一方的对象集合；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        collecyion标签：从表和主表实体类的从表对象
                                id：主表内的从表集合名；
                                type：从表集合的对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

        注：主表如果出现重复的信息，会将主表对应的从表信息封装到集合中；

3.Mybatis的多对多查询
答：
        实现类：
                定义两表的实现类，并在其中一方定义另一方的对象集合；
        映射配置文件：
                指定数据库表和实体类的对应关系：
                        resultMap标签：主表和主表实体类
                                id：标识；
                                type：实体类类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：实体类的属性名；
                                        column：数据库表的列名；
                        collecyion标签：从表和主表实体类的从表对象
                                id：主表内的从表集合名；
                                type：从表集合的对象类型；
                                内容：id标签（主键）和result标签（非主键）
                                        property：从表实体类的属性名；
                                        column：数据库表的列名；
                select标签：设置查询操作：
                        id：dao层的方法名；
                        resultMap：resultMap标签的id；
                        内容：sql语句；

        注：
                环境参数定义方式和一对对类似，不过主表可以随意指定，其结果会根据主表的不同，导致结果也不同；
                sql语句要有一张中间表进行协助查询；

4.动态sql
答：
        if标签：进行SQL语句的拼接
                前置的基础SQL语句：select * from 表名 where 1=1
                属性：test：拼接条件
                内容：要拼接的SQL语句（and 不可省略）

        where标签：进行SQL语句的拼接
                前置的基础SQL语句：select * from 表名
                属性：test：拼接条件
                内容：if标签（第一个if标签的SQL语句的and可以不写）

        foreach标签：进行元素集合的遍历
                前置的基础SQL语句：select * from 表名
                属性：
                        collection：要遍历的集合元素
                        open：SQL语句的开始部分
                        close：SQL语句的结束部分
                        aeparator：参数之间的分隔符
                        item：每个元素，生成的变量名
                内容：#{item指定的变量名}
               
        sql标签：抽取重复的SQL语句
                属性：id：标识；
                内容：SQL基础语句（结尾不能加 ； ）
                使用：
                        include标签
                                属性：refid：指定SQL标签对应的id；

今天是我们Mybatis框架学习的第3天,今天要求大家整理的内容是,
1.Mybatis的一对一查询
答：在主表中添加要关联的表的实体类对象，并在xml配置文件中配置以下信息
<!-- 它是用于指定从表方的引用实体属性的 -->
    <association property="user" javaType="user">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <result column="address" property="address"/>
    </association>
2.Mybatis的一对多查询
答：在主表中添加要关联的表的实体类对象的集合，并在xml配置文件中配置以下信息
<!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型-->
    <collection property="accounts" ofType="account">
    //collection：部分定义了用户关联的账户信息。表示关联查询结果集
    //property="accList"：关联查询的结果集存储在 User 对象的上哪个属性。
    //ofType="account"：指定关联查询的结果集中的对象类型即 List中的对象类型。此处可以使用别名，也可以使用全限定名。
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
    </collection>
3.Mybatis的多对多查询
答：多对多配置方式与一对多类似，在主表中添加要关联的表的实体类对象的集合，并在xml配置文件中配置以下信息
<!-- collection 是用于建立一对多中集合属性的对应关系 ofType 用于指定集合元素的数据类型-->
    <collection property="accounts" ofType="account">
    //collection：部分定义了用户关联的账户信息。表示关联查询结果集
    //property="accList"：关联查询的结果集存储在 User 对象的上哪个属性。
    //ofType="account"：指定关联查询的结果集中的对象类型即 List中的对象类型。此处可以使用别名，也可以使用全限定名。
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
    </collection>
4.动态sql
答：<if>标签, test属性值跟着表达式,如果表达式成立,那么<if>标签中的内容会被拼接到sql语句中,根据表达式的非空判断,来确定是否要添加查询条件,实现动态sql;
<where>标签, 如果where标签内容被拼接,那么会提前在sql语句中添加上where true ,where标签中的内容要以and 来连接where标签;
<foreach>标签,将类型为集合的参数遍历,一个个的取出集合中的值,与属性定义的字符串一起拼接,<foreach>标签的属性open,close,item,separator属性共同定义了需要拼接的字符串;
<sql>标签,将重复使用的sql语句片段提前出来,放入<sql>标签中,需要用到时使用<include >标签插入;
例子:User表和Account表联查, 在User的实体类中,添加Account属性,sql语句为 select * from user u ,account a where u.id = a.uid;

今天是我们Mybatis框架学习的第3天,今天要求大家整理的内容是,
1.Mybatis的一对一查询
        今天所讲的一对一查询是账户类Account查询用户类,其中类接口xml配置文件的标签<association>是一对一使用。
        有两种配置方式:
                方式一:定义一个专门的类AccountUser其类继承账户类,在类中定义User中需要用到的属性，
                重写toString方法的时候返回其父类的toString，在账户类xml配置文件中修改其返回值类型为accountuser。
                方式二:在账户实体类中添加用户User属性，修改账户接口中方法的返回值为Account，在账户xml配置文件中建立对应关系
       
2.Mybatis的一对多查询
        查询用户信息及用户关联的账户信息是一对多查询:首先sql语句可以使用左外连接拼接，
        在User类中加入List<Account>属性,用户持久层Dao接口中加入查询方法,
        在Dao映射配置文件中使用<resultMap>和<collection>标签建立一对多中集合属性的对应关系
3.Mybatis的多对多查询
        多对多关系我们看成双向一对多关系,在role角色实体类中添加多对多关系映射,
        一个角色赋予多个用户 private List<User> users，
        编写Role持久层接口，编写映射文件RoleDao.xml建立多对多对应关系

4.动态sql
        <if>标签:属性test=“”进行条件判断true就追加条件false就不添加
        <where>标签:包裹if标签，if标签里的条件成立时候追加where和if标签中的sql语句
        <froeach>标签遍历集合:属性collection:代表要遍历的集合元素,注意编写时不要写#{}
                open:代表语句的开始部分  close:代表结束部分 item:生成的变量名与#{}中相同
                sperator:分隔符  
        <sql id="defaultSql">抽取sql共性语句 在用到的只要写
        <include refid="defaultSql">