一、映射文件
（一）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 – 使用结果值来决定使用哪个结果映射
<!-- 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">
<!–这个id唯一，访问的标志符–><!–resultType 返回值类型–>
<!–查询总记录
<select id="selectCount" resultType="int">
/*语句后面不要加“;”*/
select count(1) from smbms_user
</select>
<!–全查,resultType可以给别名–>
<select id="selectAllUser" resultType="com.offcn.pojo.User">
select * from smbms_user
</select>
<!–模糊查询–>
<!–parameterType：代表参数的类型；#{}：代表的占位符(?)；模糊查询：一定要加concat–>
<select id="selectLikeUser" resultType="com.offcn.pojo.User" parameterType="String">
select * from smbms_user where userName like concat('%',#{userName},'%')
</select>
<!–根据id查–>
<select id="selectUserById" resultType="com.offcn.pojo.User" parameterType="String">
select * from smbms_user where id = #{id}
</select>
<!–根据id修改,返回值可以不需要–>
<!–userName 对应数据库的列 所对应的是Java实体bean–>
<!–建议数据库与实体类一一对应–>
<update id="updateUserById" parameterType="com.offcn.pojo.User">
update smbms_user set userName = #{userName}, userPassword = #{userPassword} where id = #{id}
</update>
<!–根据id删除–>
<delete id="deleteUserById" parameterType="int">
delete from smbms_user where id = #{id}
</delete>
<!–增加一个对象–>
<insert id="insertUser" parameterType="com.offcn.pojo.User">
insert into smbms_user (userName,userPassword) values (#{userName},#{userPassword})
</insert>–>
</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>
<!–配置一对多，ofType（必须添加）：类型–>
<collection property="addressList" ofType="Address">
<!–<id property="id" column="a_id"></id>–>
<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();
}
}
}
