Mybatis关系映射

最新推荐文章于 2024-06-16 10:23:56 发布

懂你的小叔

最新推荐文章于 2024-06-16 10:23:56 发布

阅读量932

点赞数

分类专栏：第四阶段文章标签：关系映射 MyBatis

本文链接：https://blog.csdn.net/weixin_43278609/article/details/83031603

版权

第四阶段专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、映射文件

（一）Mapper文件

cache 给定命名空间的缓存配置。
cache-ref 其他命名空间缓存配置的引用。
resultMap 最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象
sql 可被其他语句引用的可重用语句块
insert 映射插入语句
update 映射修改(更新)语句
delete 映射删除语句
select 映射查询语句

（1）select

<select
  id=""
  parameterType=""
  parameterMap=""
  resultType=""
  resultMap=""
  flushCache=""
  useCache=""
  timeout=""
  fetchSize=""
  statementType=""
  resultSetType="">
  </select>

属性	描述
id	在命名空间中唯一的标识符，可以被用来引用这条语句。
parameterType	将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用 resultType 或 resultMap，但不能同时使用。
resultMap	外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，对其有一个很好的理解的话，许多复杂映射的情形都能迎刃而解。使用 resultMap 或 resultType，但不能同时使用。
flushCache	将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：false。
useCache	将其设置为 true，将会导致本条语句的结果被二级缓存，默认值：对 select 元素为 true。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。
fetchSize	这是尝试影响驱动程序每次批量返回的结果行数和这个设置值相等。默认值为 unset（依赖驱动）。
statementType	STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
resultSetType	FORWARD_ONLY，SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE 中的一个，默认值为 unset （依赖驱动）。
databaseId	如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。
resultOrdered	这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。
resultSets	这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。

（2）Insert, Update, Delete

<insert
  id=""
  parameterType=""
  flushCache=""
  statementType=""
  keyProperty=""
  keyColumn=""
  useGeneratedKeys=""
  timeout="">
</insert>

<update
  id=""
  parameterType=""
  flushCache=""
  statementType=""
  timeout="">
</update>

<delete
  id=""
  parameterType=""
  flushCache=""
  statementType=""
  timeout="">
</delete>

属性	描述
id	命名空间中的唯一标识符，可被用来代表这条语句。
parameterType	将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。
flushCache	将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：true（对应插入、更新和删除语句）。
timeout	这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。
statementType	STATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。
useGeneratedKeys	（仅对 insert 和 update 有用）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系数据库管理系统的自动递增字段），默认值：false。
keyProperty	（仅对 insert 和 update 有用）唯一标记一个属性，MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，默认：unset。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn	（仅对 insert 和 update 有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
databaseId	如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。

（3）selectKey

<selectKey
  keyProperty=""
  resultType=""
  order=""
  statementType="">
</selectKey>

属性	描述
keyProperty	selectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn	匹配属性的返回结果集中的列名称。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
resultType	结果的类型。MyBatis 通常可以推算出来，但是为了更加确定写上也不会有什么问题。MyBatis 允许任何简单类型用作主键的类型，包括字符串。如果希望作用于多个生成的列，则可以使用一个包含期望属性的 Object 或一个 Map。
order	这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE，那么它会首先选择主键，设置 keyProperty 然后执行插入语句。如果设置为 AFTER，那么先执行插入语句，然后是 selectKey 元素 - 这和像 Oracle 的数据库相似，在插入语句内部可能有嵌入索引调用。
statementType	与前面相同，MyBatis 支持 STATEMENT，PREPARED 和 CALLABLE 语句的映射类型，分别代表 PreparedStatement 和 CallableStatement 类型。

（4）resultMap

constructor - 类在实例化时,用来注入结果到构造方法中
- idArg - ID 参数;标记结果作为 ID 可以帮助提高整体效能
- arg - 注入到构造方法的一个普通结果
id – 一个 ID 结果;标记结果作为 ID 可以帮助提高整体效能
result – 注入到字段或 JavaBean 属性的普通结果
association – 一个复杂的类型关联;许多结果将包成这种类型
collection – 复杂类型的集
discriminator – 使用结果值来决定使用哪个结果映射
- case – 基于某些值的结果映射

<!-- Very Complex Result Map -->
<resultMap id="" type="">
  <constructor>
    <idArg column="" javaType=""/>
  </constructor>
  <result property="" column=""/>
  <association property="" javaType="">
    <id property="" column=""/>
    <result property="" column="_username"/>
    <result property="" column=""/>
    <result property="" column=""/>
    <result property="" column=""/>
    <result property="" column=""/>
  </association>
  <collection property="" ofType="">
    <id property="" column=""/>
    <result property="" column=""/>
    <association property="" javaType=""/>
    <collection property="" ofType="">
      <id property="" column=""/>
    </collection>
    <collection property="" ofType="" >
      <id property="" column=""/>
    </collection>
    <discriminator javaType="" column="">
      <case value="" resultType=""/>
    </discriminator>
  </collection>
</resultMap>

Attribute	Description
id
A unique identifier in this namespace that can be used to reference this result map.
type	A fully qualified Java class name, or a type alias (see the table above for the list of built-in type aliases).
autoMapping	If present, MyBatis will enable or disable the automapping for this ResultMap. This attribute overrides the global autoMappingBehavior. Default: unset.

（5）id , result

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

属性	描述
property	映射到列结果的字段或属性。如果匹配的是存在的,和给定名称相同的 JavaBeans 的属性,那么就会使用。否则 MyBatis 将会寻找给定名称 property 的字段。这两种情形你可以使用通常点式的复杂属性导航。比如,你可以这样映射一些东西: “username” ,或者映射到一些复杂的东西: “address.street.number” 。
column	从数据库中得到的列名,或者是列名的重命名标签。这也是通常和会传递给 resultSet.getString(columnName)方法参数中相同的字符串。
javaType	一个 Java 类的完全限定名,或一个类型别名(参考上面内建类型别名的列表) 。如果你映射到一个 JavaBean,MyBatis 通常可以断定类型。然而,如果你映射到的是 HashMap,那么你应该明确地指定 javaType 来保证所需的行为。
jdbcType	在这个表格之后的所支持的 JDBC 类型列表中的类型。JDBC 类型是仅仅需要对插入,更新和删除操作可能为空的列进行处理。这是 JDBC jdbcType 的需要,而不是 MyBatis 的。如果你直接使用 JDBC 编程,你需要指定这个类型-但仅仅对可能为空的值。
typeHandler	我们在前面讨论过默认的类型处理器。使用这个属性,你可以覆盖默认的类型处理器。这个属性值是类的完全限定名或者是一个类型处理器的实现,或者是类型别名。

二、动态SQL

（一）、概述

写sql 语句可以实现复杂的逻辑
所有的框架都是一个半成品，有些特殊要求，需要自己来封装jdbc，一般企业的需求都能满足80%-90%

（二）、元素

if
choose (when, otherwise)
trim (where, set)
foreach

三、关联查询映射

嵌套查询:通过执行另外一个 SQL 映射语句来返回预期的复杂类型。
嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集。首先,然让我们来查看这个元素的属性。所有的你都会看到,它和普通的只由select和resultMap属性的结果映射不同。

（一）关联的嵌套查询

在这里插入图片描述

（二）关联的嵌套结果

在这里插入图片描述

四、完整代码

在这里插入图片描述

（一）pojo

package com.offcn.pojo;

import java.util.Date;
import java.util.List;

public class User {
   private Integer id; //id 
   private String userCode; //用户编码
   private String userName; //用户名称
   private String userPassword; //用户密码
   private Integer gender;  //性别
   private Date birthday;  //出生日期
   private String phone;   //电话
   private String address; //地址
   private Integer userRole;    //用户角色
   private Integer createdBy;   //创建者
   private Date creationDate; //创建时间
   private Integer modifyBy;     //更新者
   private Date modifyDate;   //更新时间
   private Role role;
   private List<Address> addressList1;

   public List<Address> getAddressList1() {
      return addressList1;
   }

   public void setAddressList1(List<Address> addressList1) {
      this.addressList1 = addressList1;
   }

   public Role getRole() {
      return role;
   }

   public void setRole(Role role) {
      this.role = role;
   }

   public Integer getId() {
      return id;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public String getUserCode() {
      return userCode;
   }
   public void setUserCode(String userCode) {
      this.userCode = userCode;
   }
   public String getUserName() {
      return userName;
   }
   public void setUserName(String userName) {
      this.userName = userName;
   }
   public String getUserPassword() {
      return userPassword;
   }
   public void setUserPassword(String userPassword) {
      this.userPassword = userPassword;
   }
   public Integer getGender() {
      return gender;
   }
   public void setGender(Integer gender) {
      this.gender = gender;
   }
   public Date getBirthday() {
      return birthday;
   }
   public void setBirthday(Date birthday) {
      this.birthday = birthday;
   }
   public String getPhone() {
      return phone;
   }
   public void setPhone(String phone) {
      this.phone = phone;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String address) {
      this.address = address;
   }
   public Integer getUserRole() {
      return userRole;
   }
   public void setUserRole(Integer userRole) {
      this.userRole = userRole;
   }
   public Integer getCreatedBy() {
      return createdBy;
   }
   public void setCreatedBy(Integer createdBy) {
      this.createdBy = createdBy;
   }
   public Date getCreationDate() {
      return creationDate;
   }
   public void setCreationDate(Date creationDate) {
      this.creationDate = creationDate;
   }
   public Integer getModifyBy() {
      return modifyBy;
   }
   public void setModifyBy(Integer modifyBy) {
      this.modifyBy = modifyBy;
   }
   public Date getModifyDate() {
      return modifyDate;
   }
   public void setModifyDate(Date modifyDate) {
      this.modifyDate = modifyDate;
   }
}

（二）Mapper

package com.offcn.dao;

import com.offcn.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

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

//@Mapper
public interface UserMapper {
   /* //全查
    @Select("select * from smbms_user")
    List<User> selectAllUser();*/
    //查询总记录数
    //这个id必须匹配相对应的方法名
    int selectCount();
    //增加
    int insertUser(User user);
    //模糊查询
    List<User> selectLikeUser(String userName);
    //查询全部
    List<User> selectAllUser();
    //根据用户角色和名字来进行模糊查询
    //使用注解的方式来注入参数
    List<User> getLikeUser(@Param("userName")String userName,@Param("userRole")Integer userRole);
    //根据map查询
    List<User> selectByMap(Map<String,String> map);
    //复杂查询
    List<User> selectByRole(User user);
    /*++++++++++++++++++++++++++++++*/
    //根据用户名查询当前用户名地址
    List<User> selectByUserName(String userName);
    /*++++++++++++++++++++++++++++++++++++++++++*/
    //增加
    int addUser(User user);
    //修改
    int updateUser(User user);
    //查询userRole为2或者3的用户
    List<User> selectArrayUser(Integer[] integers);
    //查询userRole为2或者3的用户
    List<User> selectListUser(List<Integer> integers);
    //

}

mapper对应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">

<!--namespace：包管理器-->
<!--
<mapper namespace="com.offcn.dao.UserMapper">
 &lt;!&ndash;这个id唯一，访问的标志符&ndash;&gt;&lt;!&ndash;resultType 返回值类型&ndash;&gt;
    &lt;!&ndash;查询总记录
    <select id="selectCount" resultType="int">
        /*语句后面不要加“;”*/
        select count(1) from smbms_user
    </select>
    &lt;!&ndash;全查,resultType可以给别名&ndash;&gt;
    <select id="selectAllUser" resultType="com.offcn.pojo.User">
        select * from smbms_user
    </select>
    &lt;!&ndash;模糊查询&ndash;&gt;
    &lt;!&ndash;parameterType：代表参数的类型；#{}：代表的占位符(?)；模糊查询：一定要加concat&ndash;&gt;
    <select id="selectLikeUser" resultType="com.offcn.pojo.User" parameterType="String">
        select * from smbms_user where userName like concat('%',#{userName},'%')
    </select>
    &lt;!&ndash;根据id查&ndash;&gt;
    <select id="selectUserById" resultType="com.offcn.pojo.User" parameterType="String">
        select * from smbms_user where id = #{id}
    </select>
    &lt;!&ndash;根据id修改,返回值可以不需要&ndash;&gt;
    &lt;!&ndash;userName 对应数据库的列 所对应的是Java实体bean&ndash;&gt;
    &lt;!&ndash;建议数据库与实体类一一对应&ndash;&gt;
    <update id="updateUserById"  parameterType="com.offcn.pojo.User">
        update smbms_user set userName = #{userName}, userPassword = #{userPassword} where id = #{id}
    </update>
    &lt;!&ndash;根据id删除&ndash;&gt;
    <delete id="deleteUserById" parameterType="int">
        delete from smbms_user where id = #{id}
    </delete>
    &lt;!&ndash;增加一个对象&ndash;&gt;
    <insert id="insertUser" parameterType="com.offcn.pojo.User">
        insert into smbms_user (userName,userPassword) values (#{userName},#{userPassword})
    </insert>&ndash;&gt;
</mapper>-->
<!--找到关联的接口类：包名+类名-->
<mapper namespace="com.offcn.dao.UserMapper">
    <!--id必须和接口类的方法名一样-->
    <select id="selectAllUser" resultType="user">
        select * from smbms_user
    </select>
    <!--prefix：加前缀；prefixOverrides：去除第一个不需要的关键字；suffix：加后缀；suffixOverrides：去除最后一个不需要的后缀，比如（符号、关键字）；-->
    <select id="getLikeUser" resultType="User">
        select u.*,r.roleName from smbms_user u,smbms_role r
        <trim prefix="where" prefixOverrides="and" suffix="and u.userRole = r.id">
            <if test="userRole !=null">
                and userRole =#{userRole}
            </if>
            <if test="userName !=null and userName !=''">
                and userName like concat('%',#{userName},'%')
            </if>
        </trim>
    </select>
    <!--resultMap 也相当于结果集-->
    <!--其中resultMap中的id必须对应resultMap的值;type：返回值类型（可以给别名）-->
    <resultMap id="selectByMapResult" type="User">
        <!--id:代表标签实体类的属性名；column：代表的时数据库的列名
        其它的不是id属性就用result-->
        <!--Mybatis的封装：数据库列名必须和实体bean的属性名一致-->
        <!--用resultMap的情况：1.当数据库列名和属性名不匹配的时候
                               2.复杂查询（一对一的关系，一对多的关系）
        -->
        <id property="id" column="id"></id>
        <result property="userName" column="userName"></result>
        <result property="userRole" column="userRole"></result>
        <result property="uPwd" column="userPassword"></result>
    </resultMap>
    <select id="selectByMap" parameterType="Map" resultMap="selectByMapResult">
        select u.*,r.roleName from smbms_user u,smbms_role r
        where userName like concat('%',#{uName},'%') and
        userRole =#{uRole} and u.userRole = r.id
    </select>
    <!--<select id="selectByMap" parameterType="Map" resultType="User">
        select u.*,r.roleName from smbms_user u,smbms_role r
        where userName like concat('%',#{uName},'%') and
        userRole =#{uRole} and u.userRole = r.id
    </select>-->

    <resultMap id="selectByRoleResult" type="User">
        <id property="id" column="id"></id>
        <result property="userName" column="userName"></result>
        <result property="userRole" column="userRole"></result>
        <!--association：配置一对一的关系，第一个值为属性名；javaType：代表返回的类型,可以给别名，也可以给完整路径-->
        <association property="role" javaType="Role">
            <id property="id" column="r_id"></id>
            <result property="roleName" column="roleName"></result>
            <result property="roleCode" column="roleCode"></result>
        </association>
    </resultMap>
    <select id="selectByRole" parameterType="User" resultMap="selectByRoleResult">
        select u.*,r.id as r_id,r.roleName,r.roleCode from smbms_user u,smbms_role r
        where userName like concat('%',#{userName},'%') and
        userRole =#{userRole} and u.userRole = r.id
    </select>
    <!--++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
    <!--<resultMap id="selectByUserNameResult" type="User">
        <id property="id" column="id"></id>
        <result property="userName" column="userName"></result>
        <result property="userRole" column="userRole"></result>
        &lt;!&ndash;配置一对多，ofType（必须添加）：类型&ndash;&gt;
        <collection property="addressList" ofType="Address">
            &lt;!&ndash;<id property="id" column="a_id"></id>&ndash;&gt;
            <result property="addressDesc" column="addressDesc"></result>
            <result property="contact" column="contact"></result>
        </collection>
    </resultMap>
    <select id="selectByUserName" parameterType="User" resultMap="selectByUserNameResult">
        select u.userName,a.contact,a.addressDesc from smbms_user u,smbms_address a where u.id = a.userid and u.userName = #{userName}
    </select>-->
    <resultMap id="selectByUserNameResult" type="User">
        <id property="id" column="id"></id>
        <result property="userName" column="userName"></result>
        <result property="userRole" column="userRole"></result>
        <collection property="addressList1" ofType="Address">
            <result property="addressDesc" column="addressDesc"></result>
            <result property="contact" column="contact"></result>
        </collection>
    </resultMap>
    <select id="selectByUserName" parameterType="User" resultMap="selectByUserNameResult">
        select u.userName,a.contact,a.addressDesc from smbms_user u,smbms_address a where u.id = a.userid and u.userName =#{userName}
    </select>
    <!--++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-->
    <insert id="addUser" parameterType="User">
        insert into smbms_user (userCode,userName,userPassword,gender,birthday)
        values (#{userCode},#{userName},#{uPwd},#{gender},#{birthday})
    </insert>
    <!--prefix:加上前缀-->
    <!--suffixOverrides：去除,-->
    <update id="updateUser" parameterType="User">
        update smbms_user
        <trim prefix="set" suffixOverrides="," suffix="where id =#{id}">
            <if test="userCode !=null">userCode =#{userCode},</if>
            <if test="userName !=null">userName =#{userName},</if>
            <if test="userPassword !=null">userPassword =#{userPassword},</if>
            <if test="gender !=null">gender =#{gender},</if>
            <if test="birthday !=null">birthday =#{birthday},</if>
        </trim>
    </update>

    <!--collection：为遍历的类型；item：每次遍历的条目；open：以xxx开始；separator：以xxx分割；close：以xxx结束-->
    <!--item 必须与foreach里面的一样-->
    <select id="selectArrayUser" resultType="User">
        SELECT * FROM smbms_user u WHERE u.userRole IN
        <foreach collection="array" item="uRole" open="(" separator="," close=")">
            #{uRole}
        </foreach>
    </select>
    <select id="selectListUser" resultType="User">
        SELECT * FROM smbms_user u WHERE u.userRole IN
        <foreach collection="list" item="uRole" open="(" separator="," close=")">
            #{uRole}
        </foreach>
    </select>
</mapper>

（三）xml配置文件`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">

<!-- 通过这个配置文件完成mybatis与数据库的连接 -->
<configuration>
    <!--引入配置文件-->
    <properties resource="database.properties"></properties>
    <typeAliases>
        <!--1.给当前包下面所有类取别名，别名与类名一致-->
        <package name="com.offcn.pojo"></package>
        <!--2.给具体的类加别名 type：要加别名的类的包名+类名；alias：别名的名称-->
        <!--<typeAlias type="com.offcn.pojo.User" alias="user"></typeAlias>-->
    </typeAliases>
    <!--配置环境-->
    <!--environments 可以配置多个环境：mysql、Oracle-->
        <environments default="development">
            <environment id="development">
                <!--事务，用jdbc的事务进行管理-->
                <transactionManager type="JDBC"></transactionManager>
                <!--配置数据源-->
                <!--1.jndi：由tomcat容器分配的数据源
                    2.pooled：mybatis自带的数据源-->
                <dataSource type="POOLED">
                    <!--JDBC的name不能为driverClassName，只能为driver-->
                    <property name="url" value="${url}"></property>
                    <property name="driver" value="${driver}"></property>
                    <property name="username" value="${username}"></property>
                    <property name="password" value="${password}"></property>
                </dataSource>
            </environment>
        </environments>
    <!--关联UserMapper.xml，mappers：可以配置多个；resource：代表路径，这里的.都要换成/-->
    <mappers>
        <mapper resource="com/offcn/dao/UserMapper.xml"></mapper>
        <!--<mapper class="com.offcn.dao.UserMapper"></mapper>-->
        <mapper resource="com/offcn/dao/AddressMapper.xml"></mapper>
    </mappers>

</configuration>

（四）测试

package com.offcn.text;

import com.offcn.dao.AddressMapper;
import com.offcn.dao.UserMapper;
import com.offcn.pojo.Address;
import com.offcn.pojo.Role;
import com.offcn.pojo.User;
import com.offcn.utils.SqlSessionUtils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.InputStream;
import java.util.*;

public class Text {
    @Test
    public  void test(){
        try {
            //得到核心配置文件
            String path = "mybatis-config.xml";
            //得到一个输入流对象
            InputStream is = Resources.getResourceAsStream(path);
            //得到工厂SqlSessionFactory
            SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(is);
            //通过工厂得到SqlSession
            SqlSession sqlSession = ssf.openSession();
            //返回一列，就用selectOne
            int num = sqlSession.selectOne("com.offcn.dao.UserMapper.selectCount");
            System.out.println(num);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test1(){
        try {
            //得到核心配置文件
            String path = "mybatis-config.xml";
            //得到一个输入流对象
            InputStream is = Resources.getResourceAsStream(path);
            //得到工厂SqlSessionFactory
            SqlSessionFactory ssf = new SqlSessionFactoryBuilder().build(is);
            //通过工厂得到SqlSession
            SqlSession sqlSession = ssf.openSession();
            //返回一列，就用selectOne
            List<User> list = sqlSession.selectList("com.offcn.dao.UserMapper.selectAllUser");
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserPassword());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test2(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            List<User> list = sqlSession.selectList("com.offcn.dao.UserMapper.selectLikeUser","李");
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserPassword());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test3(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            User user = new User();
            user.setUserName("小古");
            user.setUserPassword("11111111");
            user.setId(1);
            int u = sqlSession.update("com.offcn.dao.UserMapper.updateUserById",user);
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test4(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            User u = sqlSession.selectOne("com.offcn.dao.UserMapper.selectUserById","1");
            System.out.println(u.getUserName());
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test5(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            int u = sqlSession.delete("com.offcn.dao.UserMapper.deleteUserById","1");
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test6(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            User user = new User();
            user.setUserName("小古");
            user.setUserPassword("11111111");
            int u = sqlSession.insert("com.offcn.dao.UserMapper.insertUser",user);
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /*@Test
    public  void test7(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            int num = sqlSession.getMapper(UserMapper.class).selectCount();
            System.out.println(num);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test8(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            User user = new User();
            user.setUserName("小古");
            user.setUserPassword("11111111");
            int num = sqlSession.getMapper(UserMapper.class).insertUser(user);
            System.out.println(num);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test9(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            List<User> list = sqlSession.getMapper(UserMapper.class).selectLikeUser("李");
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserPassword());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }*/
    @Test
    public  void test10(){
        //全查
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            List<User> list = sqlSession.getMapper(UserMapper.class).selectAllUser();
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserPassword());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test11(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> list = userMapper.selectAllUser();
            for (User u:list) {
                System.out.println(u.getUserName());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /*@Test
    public  void test12(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            AddressMapper addressMapper = sqlSession.getMapper(AddressMapper.class);
            Address address = new Address();
            address.setContact("小古");
            address.setAddressDesc("重庆市沙坪坝区");
            address.setId(1);
            int num = addressMapper.updateAddress(address);
            System.out.println(num);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test13(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            int num = sqlSession.delete("com.offcn.dao.AddressMapper.deleteAddressById","1");
            System.out.println(num);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test14(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            List<Address> list = sqlSession.getMapper(AddressMapper.class).selectLikeAddress("王");
            for (Address a:list) {
                System.out.println(a);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test15(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            List<Address> list = sqlSession.getMapper(AddressMapper.class).selectAllAddress();
            for (Address a:list) {
                System.out.println(a);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }*/
    @Test
    public  void test16(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<User> list = userMapper.getLikeUser("孙",null);
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserRole());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test17(){
        //用map来进行传参，键名必须和xml里面对应方法里的所对应占位符名称一致
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            Map<String,String> map = new HashMap<String, String>();
            map.put("uName","孙");
            map.put("uRole","3");
            List<User> list = userMapper.selectByMap(map);
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserRole()+"\t"+u.getUserPassword());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test18(){
        //用map来进行传参，键名必须和xml里面对应方法里的所对应占位符名称一致
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = new User();
            user.setUserRole(3);
            user.setUserName("孙");
            List<User> list = userMapper.selectByRole(user);
            for (User u:list) {
                System.out.println(u.getUserName()+"\t"+u.getUserRole());
                Role role = u.getRole();
                System.out.println(role.getRoleName()+"\t"+role.getRoleCode());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    @Test
    public  void test19(){
        //用map来进行传参，键名必须和xml里面对应方法里的所对应占位符名称一致
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

            List<User> userList = userMapper.selectByUserName("李明");
            for (User u:userList) {
                System.out.println(u.getUserName()+"\t"+u.getUserRole());
                List<Address> addressList = u.getAddressList1();
                for (Address a:addressList) {
                    System.out.println(a.getContact()+"\t"+a.getAddressDesc());
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
    @Test
    public  void test20(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = new User();
            user.setUserCode("xiaogu");
            user.setUserName("小古");
            user.setUserPassword("222222222222");
            user.setGender(222);
            user.setBirthday(new Date());
            int u = userMapper.addUser(user);
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test21(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            User user = new User();
            user.setUserCode("asdasd");
            user.setUserName("fff");
            user.setUserPassword("3333333");
            user.setGender(3);
            user.setId(13);
            int u = userMapper.updateUser(user);
            System.out.println(u);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test22(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            Integer[] ints ={2,3};
            List<User> list = userMapper.selectArrayUser(ints);
            for (User u:list) {
                System.out.println(u.getUserName());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    @Test
    public  void test23(){
        try {
            //封装工具类
            SqlSession sqlSession = SqlSessionUtils.getSqlSessionUtils().sqlSession;
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            List<Integer> integerList = new ArrayList<Integer>();
            integerList.add(2);
            integerList.add(3);
            List<User> list = userMapper.selectListUser(integerList);
            for (User u:list) {
                System.out.println(u.getUserName());
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

懂你的小叔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis关系映射

一、映射文件（一）Mapper文件cache 给定命名空间的缓存配置。cache-ref 其他命名空间缓存配置的引用。resultMap 最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象sql 可被其他语句引用的可重用语句块insert 映射插入语句update 映射修改(更新)语句delete 映射删除语句select 映射查询语句二、动态SQL三、关联查...
复制链接

扫一扫