myBatis应用

最近项目中使用myBatis（iBatis）,所以目前对所遇的一些问题及有些模糊的地方在这里标注一下。

首先mybaits是一个“半自动化”的ORM框架。

需要使用的jar包：mybatis-3.0.2.jar(mybatis核心包)，mybatis-spring-1.0.0.jar(与spring结合jar包)这些jar可以去官网下载。

 

配置文件：

<?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>
		<!-- 对在此配置文件下的所有cache进行全局性开/关设置 true|false true -->
		<setting name="cacheEnabled" value="true"/>
		<!-- 全局性设置懒加载。如果设为‘关',则所有相关联的都会被初始化加载。 -->
		<setting name="lazyLoadingEnabled" value="false"/>
		<!-- 当设置为‘开’的时候，懒加载的对象可能被任何懒属性全部加载。否则，每个属性都按需加载。 -->
		<setting name="aggressiveLazyLoading" value="true"/>
		<!-- 允许和不允许单条语句返回多个数据集（取决于驱动需求） -->
		<setting name="multipleResultSetsEnabled" value="true"/>
		<!-- 使用列标签代替列名称。不用的驱动器有不同的作法。 -->
		<setting name="useColumnLabel" value="true"/>
		<!-- 允许JDBC生成主键。需要驱动器支持.如果设为了true，这个设置将强制使用被生成的主键，
		有一些驱动器不兼容不过仍然可以执行。 -->
		<setting name="useGeneratedKeys" value="true"/>
		<!-- 指定MyBatis是否并且如何来自动映射数据表字段与对象的属性。PARTIAL将只自动映射简单的，NONE没有嵌套的结果。
		FULL将自动映射所有复杂的结果。  -->
		<setting name="autoMappingBehavior" value="PARTIAL"/>
		<!-- 配置和设定执行器，SIMPLE执行器执行其它语句。REUSE执行器可能重复使用preparedstatements语句，BATCH执行器可以重复执行语句和批量更新。 -->
		<setting name="defaultExecutorType" value="SIMPLE"/>
		<!-- 设置一个时限，以决定让驱动器等待数据库回应的多长时间为超时. 正整数 -->
		<setting name="defaultStatementTimeout" value="25000"/>
	</settings>
	
	<!-- 类型别名 -->
	<typeAliases>
		<typeAlias type="com.igit.storage.client.model.ClientRelation" alias="ClientRelation"/>
	</typeAliases>
	
	<!-- 分页查询拦截器 
	<plugins>
		<plugin interceptor="com.igit.storage.util.DiclectStatementHandlerInterceptor"></plugin>
		<plugin interceptor="com.igit.storage.util.DiclectResultSetHandlerInterceptor"></plugin>
	</plugins>
	-->
	<!-- 加载映射文件 -->
	<mappers>
		<mapper resource="com/igit/storage/client/model/ClientRelation.xml"/>
	</mappers>
</configuration> 

 

映射文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC 
 "-//mybatis.org//DTD Mapper 3.0//EN" 
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 定义命名空间 --> 
<mapper namespace="com.igit.storage.client.model.ClientRelation">
 <resultMap type="ClientRelation" id="relationResult"><!-- 对象应用关联查询 -->
  <association property="client" column="clientId" javaType="Client" select="com.igit.storage.client.model.Client.selectById">
  </association>
 </resultMap>
 <insert id="insert" parameterType="ClientRelation" useGeneratedKeys="true" keyProperty="id">
   insert into S_ClientRelation(relation,clientId)
    values(#{relation},#{client.clientId})
 </insert>
 
 <delete id="delete" parameterType="long" flushCache="true">
   delete from S_ClientRelation where relation=#{value}
 </delete>
 <!-- flushCache="true" 清空缓存 -->
 <delete id="remove"  parameterType="long" flushCache="true">
   delete from S_ClientRelation where id=#{id}
 </delete>
 <!-- 批量删除多个，参数是数组  key为array  map-->
 <delete id="removeMore"  parameterType="map" flushCache="true">
   delete from S_ClientRelation 
   where id in 
   <foreach collection="array" index="index" item="ids" open="(" separator="," close=")">
   #{ids}
   </foreach>
 </delete>

 <select id="selectById" resultMap="relationResult" parameterType="long">
   select * from S_ClientRelation where id=#{value}
 </select>
 
 <select id="selectByRelation" resultMap="relationResult" parameterType="long">
   select * from S_ClientRelation where relation=#{value}
 </select>
 
 <select id="selectByPage" resultMap="relationResult">
  select * from S_ClientRelation 
 </select>
 
 <select id="selectByCount" resultType="long">
  select count(*) from S_ClientRelation 
 </select>
 
 <select id="selectMaxRelation" resultType="long">
  select max(relation) from s_clientRelation
 </select>
</mapper>

 

 

修改application.xml文件

 

<!-- 因为Hibernate的TransactionManager可以向下兼容JdbcTransactionManager，所以 mybatis事务处理仍和hibernate共用-->
 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory" />
  </property>
 </bean>

 <!-- 用注解来实现事务管理 -->   
 <tx:annotation-driven transaction-manager="transactionManager"/> 
 
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
   <tx:method name="*" />
  </tx:attributes>
 </tx:advice>

 

<!-- mybatis  sqlSessionFactory 注入datasource和配置文件-->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
	    <property name="configLocation" value="classpath:mybatisconfig.xml" />  
	    <property name="dataSource" ref="dataSource" />  
	</bean>
	<!-- 定义mybatis操作模板类似hibernateTemplate -->
	<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
		<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
	</bean>

 

代码实现

package com.igit.storage.client.service.imp;

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

import org.apache.ibatis.session.RowBounds;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.util.Assert;
import org.springside.core.dao.Page;

import com.igit.exception.BusinessException;
import com.igit.storage.client.model.Client;
import com.igit.storage.client.model.ClientRelation;
import com.igit.storage.client.service.ClientRelationService;

public class ClientRelationServiceImp implements ClientRelationService {
	
	private SqlSessionTemplate sqlSessionTemplate;
	/**
	 * 新增关联客户
	 */
	public void addRelationByClients(Long relation, List<Client> clients) {
		//判断该关联id是否存在
		if(!isValidRelation(relation)){
			throw new BusinessException("该关联关系不存在！");
		}
		//新增关联客户
		for(Client client : clients){
			ClientRelation cr = new ClientRelation();
			cr.setRelation(relation);
			cr.setClient(client);
			Assert.notNull(client, "客户不能为Null");
			sqlSessionTemplate.insert(ClientRelation.class.getName()+".insert", cr);
		}
	}
	/**
	 * 取消关联客户
	 */
	public void cancelRelation(Long relation) {
		sqlSessionTemplate.delete(ClientRelation.class.getName()+".delete", relation);
	}

	/**
	 * 创建关联客户
	 */
	public void createRelation(List<Client> clients) {
		// 客户是否可以创建关联
		if(clients.size()<=1){
			throw new BusinessException("无法创建关联,关联客户不能低于2个！");
		}
		ClientRelation cr = new ClientRelation();
		cr.setRelation(getMaxRelation());
		//创建关联客户
		for(Client client : clients){
			cr.setClient(client);
			Assert.notNull(client, "客户不能为Null");
			sqlSessionTemplate.insert(ClientRelation.class.getName()+".insert", cr);
		}

	}
	/**
	 * 获取最大关联ID
	 * @return
	 */
	private Long getMaxRelation(){
		Long relation = 1L;
		Long maxRelation = (Long) sqlSessionTemplate.selectOne(ClientRelation.class.getName()+".selectMaxRelation");
		if(maxRelation==null){
			return relation;
		}
		return maxRelation+1;
	}

	/**
	 * 分页获取关联客户
	 */
	public Page getClientRelationByPage(int startIndex, int pageSize) {
		List<ClientRelation> list = sqlSessionTemplate.selectList(ClientRelation.class.getName()+".selectByPage", new RowBounds(startIndex,pageSize));
		Long totalCount = (Long) sqlSessionTemplate.selectOne(ClientRelation.class.getName()+".selectByCount");
		return new Page(list,totalCount,pageSize,startIndex);
	}

	/**
	 *  获取没有关联的客户列表
	 */
	public Page getNoRelationClients(int startIndex,int pageSize) {
		List<Client> list = sqlSessionTemplate.selectList(Client.class.getName()+".selectSingleClient", new RowBounds(startIndex,pageSize));
		Long totalCount = (Long) sqlSessionTemplate.selectOne(Client.class.getName()+".selectSingleCount");
		return new Page(list,totalCount,pageSize,startIndex);
	}

	/**
	 * 删除关联客户
	 */
	public void removeRelationByClients(Long relation, List<Client> clients) {
		//1.该客户是否可以从关联中移除
		List<ClientRelation> list = getRelationClients(relation);
		if((list.size()-clients.size())<=1){
			throw new BusinessException("不允许删除，关联客户至少存在2个！");
		}
		//2.移除客户
		for(Client c : clients){
			Map<String,Long> params = new HashMap<String,Long>();
			params.put("relation", relation);
			params.put("clientId", c.getClientId());
			sqlSessionTemplate.delete(ClientRelation.class.getName()+".remove", params);
		}
	}

	
	private boolean isValidRelation(Long relation) {
		List<ClientRelation> list = getRelationClients(relation);
		if(list.size()<=1){
			return false;
		}
		return true;
	}

	private List<ClientRelation> getRelationClients(Long relation) {
		List<ClientRelation> list = sqlSessionTemplate.selectList(ClientRelation.class.getName()+".selectByRelation", relation);
		return list;
	}

	public SqlSessionTemplate getSqlSessionTemplate() {
		return sqlSessionTemplate;
	}

	public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
		this.sqlSessionTemplate = sqlSessionTemplate;
	}
}

  

 

单元测试请看上一篇文章

 

 

评论

2 楼 lzh166 2011-07-11  

我这里的insert当然单条插入了，如果批量插入的话就传入的list集合：

tangpengtao 写道

您好，我想咨询您，batch insert是怎么处理的，SqlSessionTemplate有两个构造方法.一个batch,一个是insert 我想问一下你如何动态控制 是单条插入，和批量插入

我这里的insert当然单条插入了，如果批量插入的话就传入的list集合：

<insert id="insertBatch" > insert into student ( <include refid="Base_Column_List" /> )   values   <foreach collection="list" item="item" index="index" separator=",">        (null,#{item.name},#{item.sex},#{item.address},#{item.telephone},#{item.tId})    </foreach></insert>

1 楼 tangpengtao 2011-07-08  

您好，我想咨询您，batch insert是怎么处理的，SqlSessionTemplate有两个构造方法.一个batch,一个是insert 我想问一下你如何动态控制 是单条插入，和批量插入