mybatis简单一对多

一、包结构以及所需jar

二、数据库表

#建表tbl_user
drop table if exists tbl_user;
create table if not exists tbl_user(
user_id int(36) not null primary key auto_increment,
user_name varchar(20) not null unique,
user_pwd varchar(20) not null
)engine = InnoDB default charset = utf8;

#建表，tbl_privilege
drop table if exists tbl_privilege;
create table if not exists tbl_privilege(
pri_id int(36) not null primary key auto_increment,
pri_name varchar(20) not null unique,
pri_desc varchar(10000),
user_id int(36),
foreign key (user_id) references tbl_user(user_id)
)engine = InnoDB default charset = utf8;

三、工具类

DomainToMapUtil.java

package cn.com.beanandmap;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class DomainToMapUtil {
	
	public static Map domainToMap(Class clazz,Object obj) throws Exception{
		Map map = new HashMap();
		Field[] fields = clazz.getDeclaredFields();
		for(int i=0;i<fields.length;i++){
			Field f = fields[i];
			f.setAccessible(true);
			String key = f.getName();
			char[] chs = key.toCharArray();
			StringBuilder strMethod = new StringBuilder("get");
			strMethod.append((chs[0]+"").toUpperCase());
				for(int j=1;j<chs.length;j++){
					strMethod.append(chs[j]);
				}
			Method method = clazz.getDeclaredMethod(strMethod.toString(), null);
			
			map.put(key, method.invoke(obj, null));
		}
		return map;
	}	
}

MyBatisUtil.java

package cn.com.util;

import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisUtil {
	private static final ThreadLocal<SqlSession> tl = new ThreadLocal<SqlSession>();
	
	public static SqlSession getSqlSession() throws Exception {
		String resource = "config/sqlMapConfig.xml";
		Reader reader = Resources.getResourceAsReader(resource);
		return new SqlSessionFactoryBuilder().build(reader).openSession();
	}
	
	public static SqlSession getSameSession() throws Exception{
		SqlSession session = tl.get();
		if(session==null){
			session= getSqlSession();
			tl.set(session);
		}
		return session;
	}
}

sql常量

package cn.com.sql;

public interface SQLConstants {
	
	public static final String INSERT_USER ="cn.com.domain.User.insertUser";
	public static final String SELECT_USER_BY_USER_ID = "cn.com.domain.User.selectUserById";
	public static final String SELECT_USER_BY_USER_ID_JOIN = "cn.com.domain.User.selectUserByIdJoin";
	public static final String SELECT_USER_BY_USER_ID_LAZY = "cn.com.domain.User.selectUserByIdLazy";
	public static final String SELECT_USER_BY_USER_NAME = "cn.com.domain.User.selectUserByName";
	public static final String SELECT_ALL_USER = "cn.com.domain.User.selectAllUser";
	public static final String UPDATE_USER ="cn.com.domain.User.updateUser";
	public static final String SELECT_USER_BY_CONDITIONS = "cn.com.domain.User.selectUserByConditions";
	public static final String SELECT_USER_BY_IDS = "cn.com.domain.User.selectUserByIds";
	public static final String DELETE_USER_BY_USER_ID = "cn.com.domain.User.deleteUserById";
	
	
	public static final String INSERT_PRIVILEGE = "cn.com.domain.Privilege.insertPrivilege";
	public static final String SELECT_PRIVILEGE_BY_PRIVILEGE_ID ="cn.com.domain.Privilege.selectPrivilegeById";
	public static final String SELECT_PRIVILEGE_BY_PRIVILEGE_ID_LAZY ="cn.com.domain.Privilege.selectPrivilegeByIdLazy";
	public static final String SELECT_PRIVILEGE_BY_PRIVILEGE_NAME = "cn.com.domain.Privilege.selectPrivilegeByName";
	public static final String SELECT_ALL_PRIVILEGE = "cn.com.domain.Privilege.selectAllPrivilege";
	public static final String UPDATE_PRIVILEGE = "cn.com.domain.Privilege.updatePrivilege";
	public static final String SELECT_PRIVILEGE_BY_CONDITIONS = "cn.com.domain.Privilege.selectPrivilegeByConditions";
	public static final String SELECT_PRIVILEGE_BY_IDS = "cn.com.domain.Privilege.selectPrivilegeByIds";
	public static final String DELETE_PRIVILEGE_BY_PRIVILEGE_ID = "cn.com.domain.Privilege.deletePrivilegeById";
	public static final String SELECT_PRIVILEGE_BY_USER_ID = "cn.com.domain.Privilege.selectPrivilegeByUserId";
	public static final String UPDATE_PRIVILEGE_FOREIGN_KEY = "cn.com.domain.Privilege.updatePrivilegeForeignKey";
	public static final String SELECT_PRIVILEGE_BY_ID_JOIN = "cn.com.domain.Privilege.selectPrivilegeByPriIdJoin";
}

四、实体类

package cn.com.domain;

public class Privilege {

	private Integer priId;
	private String  priName;
	private String  priDesc;
	private Integer userId;
	
	private User user;

	public Integer getPriId() {
		return priId;
	}

	public void setPriId(Integer priId) {
		this.priId = priId;
	}

	public String getPriName() {
		return priName;
	}

	public void setPriName(String priName) {
		this.priName = priName;
	}

	public String getPriDesc() {
		return priDesc;
	}

	public void setPriDesc(String priDesc) {
		this.priDesc = priDesc;
	}

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}

	public User getUser() {
		return user;
	}

	public void setUser(User user) {
		this.user = user;
	}

	@Override
	public String toString() {
		return "Privilege [priId=" + priId + ", priName=" + priName
				+ ", priDesc=" + priDesc + ", userId=" + userId + "]";
	}
}

package cn.com.domain;

import java.util.Set;

public class User {

	private Integer userId;
	private String userName;
	private String userPwd;
	
	private Set<Privilege> ps;

	public Integer getUserId() {
		return userId;
	}

	public void setUserId(Integer userId) {
		this.userId = userId;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getUserPwd() {
		return userPwd;
	}

	public void setUserPwd(String userPwd) {
		this.userPwd = userPwd;
	}

	public Set<Privilege> getPs() {
		return ps;
	}

	public void setPs(Set<Privilege> ps) {
		this.ps = ps;
	}

	@Override
	public String toString() {
		return "User [userId=" + userId + ", userName=" + userName
				+ ", userPwd=" + userPwd + ", ps=" + ps + "]";
	}
}

五、数据访问DAO 及实现

DAO：

package cn.com.dao;

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

import cn.com.domain.Privilege;

public interface PrivilegeDao {
	int savePrivilege(Privilege privilege);
	int deletePrivilegeByPrivilegeId(Integer priId);
	int updatePrivilege(Map privilege);
	int updatePrivilegeForeignKey(Map map);
	Privilege findPrivilegeByPrivilegeId(Integer priId);
	Privilege findPrivilegeByPrivilegeIdJoin(Integer priId);
	Privilege findPrivilegeByPrivilegeIdLazy(Integer priId);
	Privilege findPrivilegeByPrivilegeName(String priName);
	List<Privilege> findAllPrivilege();
	List<Privilege> findPrivilegeByConditions(Privilege privilege);
	List<Privilege> findPrivilegeByIds(List<Integer> ids);
	List<Privilege> findPrivilegeByUserId(Integer userId);
}

package cn.com.dao;

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

import cn.com.domain.User;

public interface UserDao {
	int saveUser(User user);//保存国家
	int deleteUserByUserId(Integer userId);
	int updateUser(Map user);
	User findUserByUserId(Integer userId);
	User findUserByUserIdLazy(Integer userId);
	User findUserByUserName(String userName);
	List<User> findUserByIdJoin(Integer userId);
	List<User> findAllUser();
	List<User> findUserByConditions(User user);
	List<User> findUserByIds(List<Integer> ids);
}

DAO实现

package cn.com.dao.impl;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.session.SqlSession;

import cn.com.dao.PrivilegeDao;
import cn.com.domain.Privilege;
import cn.com.sql.SQLConstants;
import cn.com.util.MybatisUtil;

public class PrivilegeDaoImpl implements PrivilegeDao {
	private static Log log = LogFactory.getLog(PrivilegeDaoImpl.class);
	private static SqlSession session;
	static {
		try {
			session = MybatisUtil.getSameSession();
		} catch (Exception e) {
			log.debug("session获取失败", e);
		}
	}
	@Override
	public int savePrivilege(Privilege privilege) {
		if(this.findPrivilegeByPrivilegeName(privilege.getPriName())!=null){
			log.info("该权限已存在，请重新输入");
			return 0;
		}
		int ret = session.insert(SQLConstants.INSERT_PRIVILEGE, privilege);
		session.commit();
		log.info("保存权限返回值 ：  "+ret);
		return ret;
	}
	@Override
	public int deletePrivilegeByPrivilegeId(Integer priId) {
		int ret = session.delete(SQLConstants.DELETE_PRIVILEGE_BY_PRIVILEGE_ID, priId);
		session.commit();
		log.info("删除返回值 ： "+ret);
		return ret;
	}
	@Override
	public int updatePrivilege(Map privilege) {
		if(this.findPrivilegeByPrivilegeName((String) privilege.get("priName"))!=null){
			log.info("已存在权限名称，请重新输入。");
			return 0;
		}
		int ret = session.update(SQLConstants.UPDATE_PRIVILEGE, privilege);
		session.commit();
		log.info("修改权限返回值 ： "+ret);
		return ret;
	}
	@Override
	public Privilege findPrivilegeByPrivilegeId(Integer priId) {
		Privilege dbP = session.selectOne(SQLConstants.SELECT_PRIVILEGE_BY_PRIVILEGE_ID, priId);
		log.info("查询的权限信息 ： "+dbP);
		return dbP;
	}
	@Override
	public Privilege findPrivilegeByPrivilegeName(String priName) {
		Privilege p = session.selectOne(SQLConstants.SELECT_PRIVILEGE_BY_PRIVILEGE_NAME, priName);
		log.info("查询的权限信息 ： "+p);
		return p;
	}
	@Override
	public List<Privilege> findAllPrivilege() {
		List<Privilege> ps = session.selectList(SQLConstants.SELECT_ALL_PRIVILEGE);
		log.info("查询出的所有权限信息 ： "+ps);
		return ps;
	}
	@Override
	public List<Privilege> findPrivilegeByConditions(Privilege privilege) {
		List<Privilege> list = session.selectList(SQLConstants.SELECT_PRIVILEGE_BY_CONDITIONS, privilege);
		log.info("查询出的权限信息 ： "+list);
		return list;
	}
	@Override
	public List<Privilege> findPrivilegeByIds(List<Integer> ids) {
		List<Privilege> ps = session.selectList(SQLConstants.SELECT_PRIVILEGE_BY_IDS, ids);
		log.info("查找到的权限信息 ： "+ps);
		return ps;
	}
	@Override
	public Privilege findPrivilegeByPrivilegeIdLazy(Integer priId) {
		Privilege p = session.selectOne(SQLConstants.SELECT_PRIVILEGE_BY_PRIVILEGE_ID_LAZY, priId);
		log.info(p);
		return p;
	}
	@Override
	public List<Privilege> findPrivilegeByUserId(Integer userId) {
		List<Privilege> ps = session.selectList(SQLConstants.SELECT_PRIVILEGE_BY_USER_ID, userId);
		log.info("查询到的权限信息 ： "+ps);
		log.info("查询到的权限数量 ： "+ps.size());
		return ps;
	}
	@Override
	public int updatePrivilegeForeignKey(Map map) {
		int ret = session.update(SQLConstants.UPDATE_PRIVILEGE_FOREIGN_KEY, map);
		session.commit();
		log.info("更改权限外键返回值 ： "+ret);
		return ret;
	}
	@Override
	public Privilege findPrivilegeByPrivilegeIdJoin(Integer priId) {
		Privilege p = session.selectOne(SQLConstants.SELECT_PRIVILEGE_BY_ID_JOIN,priId);
		log.info("查询出的权限信息　：　"+p);
		return p;
	}
}

package cn.com.dao.impl;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ibatis.session.SqlSession;

import cn.com.dao.UserDao;
import cn.com.domain.User;
import cn.com.sql.SQLConstants;
import cn.com.util.MybatisUtil;

public class UserDaoImpl implements UserDao{
	private static Log log = LogFactory.getLog(UserDaoImpl.class);
	private static SqlSession session;
	static{
		try {
			session = MybatisUtil.getSameSession();
		} catch (Exception e) {
			log.debug("session获取失败", e);
		}
	}
	@Override
	public int saveUser(User user) {
		if(this.findUserByUserName(user.getUserName())!=null){
			log.info("该用户名已存在，请重新输入");
			return 0;
		}
		int ret = session.insert(SQLConstants.INSERT_USER, user);
		session.commit();
		log.info("保存信息返回值 ： "+ret);
		return ret;
	}
	@Override
	public int deleteUserByUserId(Integer userId) {
		int ret = session.delete(SQLConstants.DELETE_USER_BY_USER_ID, userId);
		session.commit();
		log.info("删除后返回值 ： "+ret);
		return ret;
	}
	@Override//暂时有问题
	public int updateUser(Map user) {
		if(this.findUserByUserName((String) user.get("userName"))!=null){
			log.info("该用户名已存在，请重新输入");
			return 0;
		}
		int ret = session.update(SQLConstants.UPDATE_USER, user);
		session.commit();
		log.info("修改用户返回值 ： "+ret);
		return ret;
	}
	@Override
	public User findUserByUserId(Integer userId) {
		User user = session.selectOne(SQLConstants.SELECT_USER_BY_USER_ID, userId);
		log.info("查找的用户信息 ： "+user);
		return user;
	}
	@Override
	public User findUserByUserIdLazy(Integer userId) {
		User user = session.selectOne(SQLConstants.SELECT_USER_BY_USER_ID_LAZY, userId);
		log.info("查找的用户信息 ： "+user);
		return user;
	}
	@Override
	public User findUserByUserName(String userName) {
		User user = session.selectOne(SQLConstants.SELECT_USER_BY_USER_NAME, userName);
		log.info("查询到的用户信息 ： "+user);
		return user;
	}
	@Override
	public List<User> findAllUser() {
		List<User> users = session.selectList(SQLConstants.SELECT_ALL_USER);
		log.info("查询出的用户信息 ： "+users);
		log.info("用户数量 ： "+users.size());
		return users;
	}
	@Override
	public List<User> findUserByConditions(User user) {
		List<User> users = session.selectList(SQLConstants.SELECT_USER_BY_CONDITIONS, user);
		log.info("查询出的用户信息 ： "+users);
		log.info("查询出的用户数量 ： "+users.size());
		return users;
	}
	@Override
	public List<User> findUserByIds(List<Integer> ids) {
		List<User> users = session.selectList(SQLConstants.SELECT_USER_BY_IDS, ids);
		log.info("查找到的用户信息 ： "+users);
		log.info("查找到的用户数量 ： "+users.size());
		return users;
	}
	@Override
	public List<User> findUserByIdJoin(Integer userId) {
		List<User> users = session.selectList(SQLConstants.SELECT_USER_BY_USER_ID_JOIN, userId);
		log.info("查询出的用户信息 ： "+users);
		return users;
	}
}

六、XML配置

PrivilegeMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.com.domain.Privilege">

<!--
 建议sql使用链接查询 ，在一对多的一方查询时如果不使用链接查询，则所查询出的集合如果理论上有多个，但是实际上查出的却只有一个
在多的一方可以不使用链接查询	
-->

	<sql id="allCols">
		pri_id,pri_name,pri_desc,user_id
	</sql>
	<sql id="someCols">
		pri_name,pri_desc,user_id
	</sql>
	
	<parameterMap type="Privilege" id="PriMap">
		<parameter property="priId" resultMap="pri_id"/>
		<parameter property="priName" resultMap="pri_name"/>
		<parameter property="priDesc" resultMap="pri_desc"/>
		<parameter property="userId" resultMap="user_id"/>
	</parameterMap>
	<!--懒加载配置  -->
	<resultMap type="Privilege" id="PriResultLazy">
		<id column="pri_id" property="priId"/>
		<result column="pri_name" property="priName"/>
		<result column="pri_desc" property="priDesc"/>
		<result column="user_id" property="userId"/>
		<association property="user" column="user_id" javaType="User">
			<id column="user_id" property="userId"/>
			<result column="user_name" property="userName"/>
			<result column="user_pwd" property="userPwd"/>
		</association>
	</resultMap>
	
	<!-- 立即加载配置 -->
	<resultMap type="Privilege" id="PriResult">
		<id column="pri_id" property="priId"/>
		<result column="pri_name" property="priName"/>
		<result column="pri_desc" property="priDesc"/>
		<result column="user_id" property="userId"/>
		<association property="user" column="user_id" javaType="User" select="cn.com.domain.User.selectUserById">
		</association>
	</resultMap>
	
	<!-- 保存权限 -->
	<insert id="insertPrivilege" parameterMap="PriMap">
		insert into tbl_privilege (<include refid="someCols"/>) values(#{priName},#{priDesc},#{userId})
	</insert>
	<!-- 根据名称查询权限 -->
	<select id="selectPrivilegeByName" resultMap="PriResult">
		select <include refid="allCols"/> from tbl_privilege where pri_name = #{priName}
	</select>
	<!-- 根据id查询权限，立即加载user,这种方式主要是看 resultMap-->
	<select id="selectPrivilegeById" resultMap="PriResult">
		select <include refid="allCols"/> from tbl_privilege where pri_id = #{priId}
	</select>
	<!-- 根据id查询权限，懒加载user ，这种方式主要是看 resultMap-->
	<select id="selectPrivilegeByIdLazy" resultMap="PriResultLazy">
		select <include refid="allCols"/> from tbl_privilege where pri_id = #{priId}
	</select>
	<!-- 查询所有权限信息，立即加载user，这种方式主要是看 resultMap-->
	<select id="selectAllPrivilege" resultMap="PriResult">
		select <include refid="allCols"/> from tbl_privilege 
	</select>
	<!-- 此处可以为parameterMap="PriMap" 也可以是parameterType="Privilege"-->
	<select id="selectPrivilegeByConditions" parameterMap="PriMap" resultMap="PriResult">
		select <include refid="allCols"/> from tbl_privilege 
		<where> 1=1
			<if test="priName!=null">
			       and pri_name like concat('%',#{priName},'%')
			</if>
			<if test="priDesc!=null">
				and pri_desc like concat('%',#{priDesc},'%')
			</if>
		</where>
	</select>
	<!-- 更新权限，此时的userid不能为null -->
	<update id="updatePrivilege" parameterType="map">
		update tbl_privilege 
			<set>
				<if test="priName!=null">
					pri_name = #{priName},
				</if>
				<if test="priDesc!=null">
					pri_desc = #{priDesc},
				</if>
				<if test="userId!=null">
					user_id = #{userId}
				</if>
			</set>
			<where>
				pri_id=#{priId}
			</where>
	</update>
	<!-- 主要用于更新权限的外键user_id -->
	<update id="updatePrivilegeForeignKey" parameterType="map">
		update tbl_privilege set user_id = #{userId} where pri_id = #{priId}
		<!-- <set>
			user_id = #{userId}
		</set>
		<where>
			pri_id = #{priId}
		</where> -->
	</update>
	
	
	<select id="selectPrivilegeByIds"  resultMap="PriResult">
	select <include refid="allCols"/> from tbl_privilege 
		<where>
			pri_id in 
			<foreach collection="list" item="priId" open="(" separator="," close=")">
				#{priId}
			</foreach>
		</where>
	</select>
	<delete id="deletePrivilegeById" >
		delete from tbl_privilege 
		<where>
			pri_id = #{priId}
		</where>
	</delete>
	<select id="selectPrivilegeByUserId" resultMap="PriResult">
		select <include refid="allCols"/> from tbl_privilege where user_id = #{userId}
	</select>
	
	<select id="selectPrivilegeByPriIdJoin" resultMap="PriResult">
		 select u.*,p.* from tbl_user u inner join tbl_privilege p on u.user_id = p.user_id where p.pri_id = #{priId}
	</select>
	
</mapper>

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="cn.com.domain.User">
	<sql id="allCols">
		user_id,user_name,user_pwd
	</sql>
	<sql id="someCols">
		user_name,user_pwd
	</sql>
	
	<parameterMap type="User" id="UserMap">
		<parameter property="userId" resultMap="user_id"/>
		<parameter property="userName" resultMap="user_name"/>
		<parameter property="userPwd" resultMap="user_pwd"/>
	</parameterMap>
	<!-- 懒加载返回map -->
	<resultMap type="User" id="UserResultLazy">
		<id column="user_id" property="userId"/>
		<result column="user_name" property="userName"/>
		<result column="user_pwd" property="userPwd"/>
		<collection property="ps" column="user_id" ofType="Privilege">
			<id column="pri_id" property="priId"/>
			<result column="pri_name" property="priName"/>
			<result column="pri_desc" property="priDesc"/>
			<result column="user_id" property="userId"/>
		</collection>
	</resultMap>
	<!-- 立即加载返回map -->
	<resultMap type="User" id="UserResult">
		<id column="user_id" property="userId"/>
		<result column="user_name" property="userName"/>
		<result column="user_pwd" property="userPwd"/>
		<collection property="ps" column="user_id" ofType="Privilege" select="cn.com.domain.Privilege.selectPrivilegeById">
		</collection>
	</resultMap>
	
	<insert id="insertUser" parameterMap="UserMap">
		insert into tbl_user (<include refid="someCols"/>) values (#{userName},#{userPwd})
	</insert>
	<select id="selectUserByName" resultMap="UserResult">
		select <include refid="allCols"/> from tbl_user where user_name = #{userName}
	</select>
	<!-- 此种方式只能查出来与user相关的一个privilege，不切合实际 ，建议使用链接查询-->
	<select id="selectUserByIdLazy" resultMap="UserResultLazy">
		select <include refid="allCols"/> from tbl_user where user_id = #{userId}
	</select>
	<!-- 此种方式只能查出来与user相关的一个privilege，不切合实际，建议使用链接查询 -->
	<select id="selectUserById" resultMap="UserResult">
		select <include refid="allCols"/> from tbl_user where user_id = #{userId}
	</select>
	<!-- 链接查询,可以查询出与user相关的所有数据，如果存在的话>=1 -->
	<select id="selectUserByIdJoin" resultMap="UserResult">
		select u.*,p.* from tbl_user u inner join tbl_privilege p on u.user_id = p.user_id where u.user_id = #{userId};
	</select>
	
	<select id="selectAllUser" resultMap="UserResult">
		select <include refid="allCols"/> from tbl_user 
	</select>
	<update id="updateUser" parameterType="map">
		update tbl_user 
		<set>
			<if test="#{userName!=null}">
				user_name = #{userName},
			</if>
			<if test="#{userPwd!=null}">
				user_pwd = #{userPwd}
			</if>
		</set>
		<where>
			user_id = #{userId}
		</where>
	</update>
	
	<select id="selectUserByConditions" resultMap="UserResult">
		select <include refid="allCols"/> from tbl_user
		<where>1=1
			<if test="userName!=null">
			   and	user_name like concat('%',#{userName},'%') 
			</if>
			<if test="userPwd!=null">
				and user_pwd like concat('%',#{userPwd},'%')
			</if>
		</where>
	</select>
	
	<select id="selectUserByIds" resultMap="UserResult">
		select <include refid="allCols"/> from tbl_user
		<where>
			user_id in
			<foreach collection="list" item="userId" open="(" separator="," close=")">
				#{userId}
			</foreach>
		</where>
	</select>
	
	<delete id="deleteUserById" >
		delete from tbl_user 
		<where>
			user_id = #{userId}
		</where>
	</delete>
	
</mapper>

sqlMapConfig.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">
<configuration>
	<!-- 是否使用懒加载 ,但是测试中并未生效,始终显示懒加载,没有使用链接查询情况 -->
	<!-- <settings>
		<setting name="lazyLoadingEnabled" value="false"/>
        <setting name="aggressiveLazyLoading" value="true"/> 
	</settings> -->
	<!-- 定义别名 -->
	<typeAliases>
		<typeAlias type="cn.com.domain.User" alias="User"/>
		<typeAlias type="cn.com.domain.Privilege" alias="Privilege"/>
	</typeAliases>
	
	<environments default="development">
		<environment id="development">
			<!-- 事务管理器类型 -->
			<transactionManager type="JDBC" />
			<!-- 数据源信息 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.jdbc.Driver" />
				<property name="url" value="jdbc:mysql://localhost:3306/mybatisdb" />
				<property name="username" value="root" />
				<property name="password" value="root" />
			</dataSource>
		</environment>
	</environments>
	<!-- 注册SQL映射文件 -->
	<mappers>
	    <mapper resource="cn/com/domain/UserMapper.xml"/>
		<mapper resource="cn/com/domain/PrivilegeMapper.xml"/>
	</mappers>
</configuration>

log4j.properties

log4j.rootLogger=debug,my

### direct log messages to my ###
log4j.appender.my=org.apache.log4j.ConsoleAppender
log4j.appender.my.Target=System.out
log4j.appender.my.layout=org.apache.log4j.PatternLayout
log4j.appender.my.layout.ConversionPattern=%d %5p %c{1}:%L - %m%n

七、测试

package test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;

import cn.com.beanandmap.DomainToMapUtil;
import cn.com.dao.PrivilegeDao;
import cn.com.dao.UserDao;
import cn.com.dao.impl.PrivilegeDaoImpl;
import cn.com.dao.impl.UserDaoImpl;
import cn.com.domain.Privilege;
import cn.com.domain.User;

public class MyBatisTest {
	private static Log log = LogFactory.getLog(MyBatisTest.class);
	private UserDao ud = new UserDaoImpl();
	private PrivilegeDao pd = new PrivilegeDaoImpl();

	@Test//保存用户信息
	public void testSaveUserAlone() {
		User user = new User();
		user.setUserName("name1");
		user.setUserPwd("password1");
		ud.saveUser(user);
	}
	@Test//保存权限信息
	public void savePrivilegeAlone(){
		Privilege pri = new Privilege();
		pri.setPriName("pri001");
		pri.setPriDesc("This is a test privilege ");
		pd.savePrivilege(pri);
	}
	@Test//根据用户名查找权限信息
	public void testFindPrivilegeByName(){
		pd.findPrivilegeByPrivilegeName("priv001");
	}
	@Test//根据权限id查找权限信息立即加载user
	public void testFindPrivilegeById(){
		Privilege p = pd.findPrivilegeByPrivilegeId(5);
		log.info(p.getUser());
	}
	@Test//根据权限id查找权限信息懒加载user
	public void testFindPrivilegeByIdLazy(){
		Privilege p = pd.findPrivilegeByPrivilegeIdLazy(5);
		log.info(p.getUser());
	}
	@Test//修改权限信息
	/*
	 * 此处需要注意的是，多的一方不能引用一的一方不存在的主键（即多的一方的外键必须在一的一方中必须是存在的），
	 * 否则将会出现异常：Cannot add or update a child row: a foreign key constraint fails
	 */
	public void testUpdatePrivilege() throws Exception{
		Privilege p = pd.findPrivilegeByPrivilegeId(8);
		Map<String, Object> map = DomainToMapUtil.domainToMap(p.getClass(), p);
		map.put("priName", "sad");
		map.put("userId", 7);
		pd.updatePrivilege(map);
		log.info(map);
	}
	
	//类似级联保存
	@Test//先单独保存用户，然后查询保存的用户的id，然后将userid分配给privilege进行保存
	public void testSaveUandP01(){
		//先保存用户
		User u = new User();
		u.setUserName("user001");
		u.setUserPwd("pwd001");
		ud.saveUser(u);
		//用户id自动生成，需要进行一次查询
		User dbUser = ud.findUserByUserName("user001");
		//保存权限
		Privilege p = new Privilege();
		p.setPriName("priv001");
		p.setPriDesc("first save user,then find the saved user just now,at last,save the privilege ,no need update");
		p.setUserId(dbUser.getUserId());
		pd.savePrivilege(p);
	}
	@SuppressWarnings("unchecked")
	//类似级联保存
	@Test//先单独保存用户，然后单独保存权限，
	public void testSaveUandP002() throws Exception{
		User u = new User();
		u.setUserName("user005");
		u.setUserPwd("pwd005");
		ud.saveUser(u);
		
		User dbUser = ud.findUserByUserName("user005");
		System.out.println(dbUser);
		Privilege p = new Privilege();
		p.setPriName("priv005");
		p.setPriDesc("first save user alone,then find the saved user just now,the third step,save the privilege alone,....");
		pd.savePrivilege(p);
		
		Privilege p2 = pd.findPrivilegeByPrivilegeName("priv005");
		
		Map<String, Object> map = DomainToMapUtil.domainToMap(p2.getClass(), p2);
		map.put("userId", dbUser.getUserId());
		log.info(map);
		pd.updatePrivilege(map);
	}
	@Test//根据id查找用户懒加载用户权限
	public void testfindUserByIdLazy(){
		ud.findUserByUserIdLazy(7);
	}
	@Test//根据id查找用户立即加载用户权限
	public void testFindUserById(){
		ud.findUserByUserId(7);
	}
	@Test//查询所有权限信息立即加载user
	public void testFindAllPrivilege(){
		List<Privilege> list = pd.findAllPrivilege();
		User user = list.get(2).getUser();
		log.info(user);
	}
	@Test//根据条件的模糊查询权限信息
	public void testFindPrivilegeByConditions(){
		Privilege p = new Privilege();
		p.setPriName("u");
		p.setPriDesc("is");
		pd.findPrivilegeByConditions(p);
	}
	@Test//根据id集合查询权限
	public void testFindPrivilegeByIds(){
		List ids = new ArrayList();
		ids.add(3);
		ids.add(5);
		ids.add(7);
		pd.findPrivilegeByIds(ids);
	}
	@Test//删除指定权限信息
	public void testDeletePrivilegeById(){
		pd.deletePrivilegeByPrivilegeId(10);
	}
	@Test//查找所有用户
	public void testFindAllUser(){
		ud.findAllUser();
	}
	@Test
	public void testUpdateUser() throws Exception{
		User u = ud.findUserByUserId(8);
		Map<String, Object> map = DomainToMapUtil.domainToMap(u.getClass(), u);System.out.println(map);
		map.put("userName", "000232");
		map.put("userPwd", "00002");
		ud.updateUser(map);
	}
	@Test
	public void testFindUserByConditions(){
		User u = new User();
		u.setUserName("2");
		u.setUserPwd("2");
		ud.findUserByConditions(u);
	}
	@Test
	public void testFindUserByIds(){
		List<Integer> ids = new ArrayList<Integer>();
		ids.add(4);
		ids.add(5);
		ids.add(6);
		ud.findUserByIds(ids);
	}
	@Test
	public void testFindPrivilegeByUserId(){
		pd.findPrivilegeByUserId(2);
	}
	@Test
	public void testUpdatePrivilegeForeignKey(){
		Map map = new HashMap();
		map.put("priId", 9);
		map.put("userId", 4);
		pd.updatePrivilegeForeignKey(map);
	}
	@Test//删除用户，首先查找该用户下是否还有权限，如果有，先删除该用户下权限，或者将该用户下权限的外键设置为null，然后在删除用户
	public void testDeleteUserById(){
		//查找该用户下的权限
		List<Privilege> ps = pd.findPrivilegeByUserId(4);
		//循环遍历，修改查询出的权限的外键user_id,设置为空
		for(Privilege p:ps){
			Map<String, Object> map = new HashMap<String, Object>();
			//数据库中的pri_name是唯一的
			//此处需要注意，因为userId是Integer类型的，此处应该为null，而不能是"".否则将出错
			map.put("userId", null);
			map.put("priId", p.getPriId());
			pd.updatePrivilegeForeignKey(map);
		}
		ud.deleteUserByUserId(4);
	}
	@Test
	public void testFindUserByIdJoin(){
		ud.findUserByIdJoin(7);
	}
	@Test
	public void testFindPrivilegeByIdJoin(){
		Privilege p =pd.findPrivilegeByPrivilegeIdJoin(5);
		log.info(p.getUser());
	}
}

本人是mybatis新手，仅供参考。里面有不合适之处，请大家给予指正