myBatis应用

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

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

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

配置文件：

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
3. "http://mybatis.org/dtd/mybatis-3-config.dtd">
4. <configuration>
5. <settings>
6. <!-- 对在此配置文件下的所有cache进行全局性开/关设置 true|false true -->
7. <setting name="cacheEnabled" value="true"/>
8. <!-- 全局性设置懒加载。如果设为‘关',则所有相关联的都会被初始化加载。 -->
9. <setting name="lazyLoadingEnabled" value="false"/>
10. <!-- 当设置为‘开’的时候，懒加载的对象可能被任何懒属性全部加载。否则，每个属性都按需加载。 -->
11. <setting name="aggressiveLazyLoading" value="true"/>
12. <!-- 允许和不允许单条语句返回多个数据集（取决于驱动需求） -->
13. <setting name="multipleResultSetsEnabled" value="true"/>
14. <!-- 使用列标签代替列名称。不用的驱动器有不同的作法。 -->
15. <setting name="useColumnLabel" value="true"/>
16. <!-- 允许JDBC生成主键。需要驱动器支持.如果设为了true，这个设置将强制使用被生成的主键，
17. 有一些驱动器不兼容不过仍然可以执行。 -->
18. <setting name="useGeneratedKeys" value="true"/>
19. <!-- 指定MyBatis是否并且如何来自动映射数据表字段与对象的属性。PARTIAL将只自动映射简单的，NONE没有嵌套的结果。
20. FULL将自动映射所有复杂的结果。  -->
21. <setting name="autoMappingBehavior" value="PARTIAL"/>
22. <!-- 配置和设定执行器，SIMPLE执行器执行其它语句。REUSE执行器可能重复使用preparedstatements语句，BATCH执行器可以重复执行语句和批量更新。 -->
23. <setting name="defaultExecutorType" value="SIMPLE"/>
24. <!-- 设置一个时限，以决定让驱动器等待数据库回应的多长时间为超时. 正整数 -->
25. <setting name="defaultStatementTimeout" value="25000"/>
26. </settings>
27. <!-- 类型别名 -->
28. <typeAliases>
29. <typeAlias type="com.igit.storage.client.model.ClientRelation" alias="ClientRelation"/>
30. </typeAliases>
31. <!-- 分页查询拦截器
32. <plugins>
33. <plugin interceptor="com.igit.storage.util.DiclectStatementHandlerInterceptor"></plugin>
34. <plugin interceptor="com.igit.storage.util.DiclectResultSetHandlerInterceptor"></plugin>
35. </plugins>
36. -->
37. <!-- 加载映射文件 -->
38. <mappers>
39. <mapper resource="com/igit/storage/client/model/ClientRelation.xml"/>
40. </mappers>
41. </configuration>

映射文件：

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper PUBLIC
3. "-//mybatis.org//DTD Mapper 3.0//EN"
4. "<a href="http://mybatis.org/dtd/mybatis-3-mapper.dtd">http://mybatis.org/dtd/mybatis-3-mapper.dtd</a>">
5. <!-- 定义命名空间 -->
6. <mapper namespace="com.igit.storage.client.model.ClientRelation">
7. <resultMap type="ClientRelation" id="relationResult"><!-- 对象应用关联查询 -->
8. <association property="client" column="clientId" javaType="Client" select="com.igit.storage.client.model.Client.selectById">
9. </association>
10. </resultMap>
11. <insert id="insert" parameterType="ClientRelation" useGeneratedKeys="true" keyProperty="id">
12. insert into S_ClientRelation(relation,clientId)
13. values(#{relation},#{client.clientId})
14. </insert>
15. <delete id="delete" parameterType="long" flushCache="true">
16. delete from S_ClientRelation where relation=#{value}
17. </delete>
18. <!-- flushCache="true" 清空缓存 -->
19. <delete id="remove"  parameterType="long" flushCache="true">
20. delete from S_ClientRelation where id=#{id}
21. </delete>
22. <!-- 批量删除多个，参数是数组  key为array  map-->
23. <delete id="removeMore"  parameterType="map" flushCache="true">
24. delete from S_ClientRelation
25. where id in
26. <foreach collection="array" index="index" item="ids" open="(" separator="," close=")">
27. #{ids}
28. </foreach>
29. </delete>

1. <select id="selectById" resultMap="relationResult" parameterType="long">
2. select * from S_ClientRelation where id=#{value}
3. </select>
4. <select id="selectByRelation" resultMap="relationResult" parameterType="long">
5. select * from S_ClientRelation where relation=#{value}
6. </select>
7. <select id="selectByPage" resultMap="relationResult">
8. select * from S_ClientRelation
9. </select>
10. <select id="selectByCount" resultType="long">
11. select count(*) from S_ClientRelation
12. </select>
13. <select id="selectMaxRelation" resultType="long">
14. select max(relation) from s_clientRelation
15. </select>
16. </mapper>

修改application.xml文件

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

1. <!-- 用注解来实现事务管理 -->
2. <tx:annotation-driven transaction-manager="transactionManager"/>
3. <tx:advice id="txAdvice" transaction-manager="transactionManager">
4. <tx:attributes>
5. <tx:method name="*" />
6. </tx:attributes>
7. </tx:advice>

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

代码实现

1. package com.igit.storage.client.service.imp;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. import org.apache.ibatis.session.RowBounds;
6. import org.mybatis.spring.SqlSessionTemplate;
7. import org.springframework.util.Assert;
8. import org.springside.core.dao.Page;
9. import com.igit.exception.BusinessException;
10. import com.igit.storage.client.model.Client;
11. import com.igit.storage.client.model.ClientRelation;
12. import com.igit.storage.client.service.ClientRelationService;
13. public class ClientRelationServiceImp implements ClientRelationService {
14. private SqlSessionTemplate sqlSessionTemplate;
15. /**
16. * 新增关联客户
17. */
18. public void addRelationByClients(Long relation, List<Client> clients) {
19. //判断该关联id是否存在
20. if(!isValidRelation(relation)){
21. throw new BusinessException("该关联关系不存在！");
22. }
23. //新增关联客户
24. for(Client client : clients){
25. ClientRelation cr = new ClientRelation();
26. cr.setRelation(relation);
27. cr.setClient(client);
28. Assert.notNull(client, "客户不能为Null");
29. sqlSessionTemplate.insert(ClientRelation.class.getName()+".insert", cr);
30. }
31. }
32. /**
33. * 取消关联客户
34. */
35. public void cancelRelation(Long relation) {
36. sqlSessionTemplate.delete(ClientRelation.class.getName()+".delete", relation);
37. }
38. /**
39. * 创建关联客户
40. */
41. public void createRelation(List<Client> clients) {
42. // 客户是否可以创建关联
43. if(clients.size()<=1){
44. throw new BusinessException("无法创建关联,关联客户不能低于2个！");
45. }
46. ClientRelation cr = new ClientRelation();
47. cr.setRelation(getMaxRelation());
48. //创建关联客户
49. for(Client client : clients){
50. cr.setClient(client);
51. Assert.notNull(client, "客户不能为Null");
52. sqlSessionTemplate.insert(ClientRelation.class.getName()+".insert", cr);
53. }
54. }
55. /**
56. * 获取最大关联ID
57. * @return
58. */
59. private Long getMaxRelation(){
60. Long relation = 1L;
61. Long maxRelation = (Long) sqlSessionTemplate.selectOne(ClientRelation.class.getName()+".selectMaxRelation");
62. if(maxRelation==null){
63. return relation;
64. }
65. return maxRelation+1;
66. }
67. /**
68. * 分页获取关联客户
69. */
70. public Page getClientRelationByPage(int startIndex, int pageSize) {
71. List<ClientRelation> list = sqlSessionTemplate.selectList(ClientRelation.class.getName()+".selectByPage", new RowBounds(startIndex,pageSize));
72. Long totalCount = (Long) sqlSessionTemplate.selectOne(ClientRelation.class.getName()+".selectByCount");
73. return new Page(list,totalCount,pageSize,startIndex);
74. }
75. /**
76. *  获取没有关联的客户列表
77. */
78. public Page getNoRelationClients(int startIndex,int pageSize) {
79. List<Client> list = sqlSessionTemplate.selectList(Client.class.getName()+".selectSingleClient", new RowBounds(startIndex,pageSize));
80. Long totalCount = (Long) sqlSessionTemplate.selectOne(Client.class.getName()+".selectSingleCount");
81. return new Page(list,totalCount,pageSize,startIndex);
82. }
83. /**
84. * 删除关联客户
85. */
86. public void removeRelationByClients(Long relation, List<Client> clients) {
87. //1.该客户是否可以从关联中移除
88. List<ClientRelation> list = getRelationClients(relation);
89. if((list.size()-clients.size())<=1){
90. throw new BusinessException("不允许删除，关联客户至少存在2个！");
91. }
92. //2.移除客户
93. for(Client c : clients){
94. Map<String,Long> params = new HashMap<String,Long>();
95. params.put("relation", relation);
96. params.put("clientId", c.getClientId());
97. sqlSessionTemplate.delete(ClientRelation.class.getName()+".remove", params);
98. }
99. }
100. private boolean isValidRelation(Long relation) {
101. List<ClientRelation> list = getRelationClients(relation);
102. if(list.size()<=1){
103. return false;
104. }
105. return true;
106. }
107. private List<ClientRelation> getRelationClients(Long relation) {
108. List<ClientRelation> list = sqlSessionTemplate.selectList(ClientRelation.class.getName()+".selectByRelation", relation);
109. return list;
110. }
111. public SqlSessionTemplate getSqlSessionTemplate() {
112. return sqlSessionTemplate;
113. }
114. public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
115. this.sqlSessionTemplate = sqlSessionTemplate;
116. }
117. }