spring mvc与Mybatis整合——（三）增删改查

有了上篇文章中的环境基础，这里进一步做一些增删改查的实例。并附带源码下载链接。

一、配置文件的语法约束：

      1、Mybatis的配置文件和接口的定义要有一定的规范约束，也是约定大于配置的一种表现，那就是配置文件中，增删改查的每一个方法的id要和接口中的方法一致，且大小写敏感。

     2、在配置文件中增删改查方法有各自对应的标签：insert、delete、update、select。通常情况下都会有一个parameterType标签表示传入的参数类型。传递多个参数的时候，可以不在配置文件中使用该标签，但需在接口中配合注解。

     3、多个参数的传递，还有两种方法：利用hashMap 、实体封装；mybatis 自身的多个参数传递方式。这里不做重点，后面会有介绍。

    4、参数使用ognl的表达式语法，如：#{userName},#{userAge},#{userAddress}。

    5、对于结果是集合类型的返回值使用resultMap标签标示。

    6、association标签相当于一个component，可以打到复用的目的。

    

二、增删改查实例：

    实例中包含了单表的增删改查和多表的联合查询，针对联合查询和hibernate的对象导航语法查询很类似，这里不用做过多解释，重点是具体语法的体会。

    

    在上篇文章的基础上添加了Article实体，在接口中添加了单表增删改查的方法以及两个实体的联合查询，以及返回集合类型的方法。

    1、接口的定义：

[java]  view plain copy

1. /** 
2.  * 规则：接口中的方法名和参数和配置文件中的id和parameterType分别对应，sql写在配置文件中，参数和调用的类test中的方法一致 
3.  * sql语句中的参数和实体中的字段名一致， 
4.  * @author limin 
5.  * 
6.  */  
7. public interface IUserOperation {  
8.     /* 
9.      * 这里面有一个方法名 selectUserByID 必须与 User.xml 里面配置的 select 的id 对应（<select 
10.      * id="selectUserByID"） 
11.      */  
12.     public User selectUserByID(int id);  
13.     //根据用户名查询用户列表     
14.     public List<User> selectUsers(String userName);     
15.     public void addUser(User user);  
16.     public void updateUser(User user);  
17.     public void deleteUser(int id);  
18.     public List<Article> getUserArticles(int id);   
19.       
20. }  

    2、配置文件：

[html]  view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
3.   
4. <mapper namespace="com.tgb.mybatis.inter.IUserOperation">  
5.   
6. <!-- com.yihaomen.mybatis.model.UserMapper -->  
7.   
8.     <!-- resultType的值要和Configuration.xml中的实体User的别名相同 -->  
9.     <select id="selectUserByID" parameterType="int" resultType="User">  
10.         select * from user where id = #{id}  
11.     </select>  
12.   
13.     <!-- 为了返回list 类型而定义的returnMap -->  
14.     <resultMap type="User" id="resultListUser">  
15.         <id column="id" property="id" />  
16.         <result column="userName" property="userName" />  
17.         <result column="userAge" property="userAge" />  
18.         <result column="userAddress" property="userAddress" />  
19.     </resultMap>  
20.   
21.       
22.     <!-- 返回list 的select 语句，注意 resultMap 的值是指向前面定义好的 -->  
23.     <select id="selectUsers" parameterType="string" resultMap="resultListUser">  
24.         select * from user where userName like #{userName}  
25.     </select>  
26.   
27.   
28.     <!-- 执行增加操作的SQL语句。id和parameterType分别与IUserOperation接口中的addUser方法的名字和 参数类型一致。以#{name}的形式引用Student参数的name属性，MyBatis将使用反射读取Student参数   
29.         的此属性。#{name}中name大小写敏感。引用其他的gender等属性与此一致。useGeneratedKeys设置 为"true"表明要MyBatis获取由数据库自动生成的主   
30.         键；keyProperty="id"指定把获取到的主键值注入 到Student的id属性 -->  
31.     <insert id="addUser" parameterType="User" useGeneratedKeys="true"  
32.         keyProperty="id">  
33.         insert into user(userName,userAge,userAddress)    
34.         values(#{userName},#{userAge},#{userAddress})  
35.     </insert>  
36.   
37.   
38. <!-- 更新的配置 -->  
39.     <update id="updateUser" parameterType="User">  
40.         update user set  
41.         userName=#{userName},userAge=#{userAge},userAddress=#{userAddress}  
42.         where id=#{id}  
43.     </update>  
44.       
45.     <!-- 删除配置 -->  
46.     <delete id="deleteUser" parameterType="int">  
47.         delete from user where id=#{id}  
48.     </delete>  
49.           
50.     <!-- 多对一方法二：将 association 中对应的映射独立抽取出来，可以达到复用的目的。 -->  
51.         <!-- User 联合文章进行查询 方法之二的配置 (多对一的方式) -->  
52.     <resultMap id="resultUserArticleList" type="Article">  
53.         <id property="id" column="aid" />  
54.         <result property="title" column="title" />  
55.         <result property="content" column="content" />  
56.         <association property="user" javaType="User" resultMap="resultListUser" />  
57.     </resultMap>  
58.       
59.           
60.     <!-- 多对一的配置方法一： 根据用户id查询多个Article -->  
61. <!--     <resultMap id="resultUserArticleList" type="Article">  
62.         <id property="id" column="aid" />  
63.         <result property="title" column="title" />  
64.         <result property="content" column="content" />  
65.   
66.         <association property="user" javaType="User">  
67.             <id property="id" column="id" />  
68.             <result property="userName" column="userName" />  
69.             <result property="userAddress" column="userAddress" />  
70.         </association>  
71.     </resultMap>  
72.  -->  
73.    
74.     <select id="getUserArticles" parameterType="int"  
75.         resultMap="resultUserArticleList">  
76.           
77.         select user.id,user.username,user.useraddress,article.id aid,article.title,article.content  
78.         from user,article  
79.         where user.id=article.userid and user.id=#{id}  
80.     </select>  
81.       
82.   
83.       
84. </mapper>  

同时需要在Configuration.xml中，增加了Article的部分，参照user即可。

对多对一的配置有两种方法，区别在于是否在association标签中复用resultMap标签，resultMap标签配置了一个list集合。

     3、最后再给出测试文件：

[java]  view plain copy

1. package com.tgb.test;  
2.   
3. import java.io.Reader;  
4. import java.util.List;  
5.   
6. import org.apache.ibatis.io.Resources;  
7. import org.apache.ibatis.session.SqlSession;  
8. import org.apache.ibatis.session.SqlSessionFactory;  
9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
10.   
11. import com.tgb.mybatis.inter.IUserOperation;  
12. import com.tgb.mybatis.model.Article;  
13. import com.tgb.mybatis.model.User;  
14.   
15.   
16. /** 
17.  * 增加：天机后，必须提交事务，否则不会写入到数据库 
18.  * 更新：类似hibernate，要先查出后，之后再更新 
19.  * 也有类似的session.commit() 
20.  * @author limin 
21.  * 
22.  */  
23. public class Test {  
24.   
25.     private static SqlSessionFactory sqlSessionFactory;  
26.     private static Reader reader;  
27.   
28.     static {  
29.         try {  
30.             // 最终实现了从配置文件中配置工厂的初始化  
31.             reader = Resources.getResourceAsReader("Configuration.xml");  
32.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);  
33.         } catch (Exception e) {  
34.             e.printStackTrace();  
35.         }  
36.     }  
37.   
38.     public static SqlSessionFactory getSession() {  
39.         return sqlSessionFactory;  
40.     }  
41.   
42.     public void getUserList(String userName){  
43.         SqlSession session = sqlSessionFactory.openSession();  
44.         try {  
45.             IUserOperation userOperation=session.getMapper(IUserOperation.class);            
46.             List<User> users = userOperation.selectUsers(userName);  
47.             for(User user:users){  
48.                 System.out.println(user.getId()+":"+user.getUserName()+":"+user.getUserAddress());  
49.             }  
50.               
51.         } finally {  
52.             session.close();  
53.         }  
54.     }  
55.       
56.       
57.       
58.     //增加后，必须提交事务，否则不会写入到数据库.  
59.     public void addUser(){  
60.         User user=new User();  
61.         user.setUserAddress("万达广场");  
62.         user.setUserName("陆逊");  
63.         user.setUserAge(80);  
64.         SqlSession session = sqlSessionFactory.openSession();  
65.         try {  
66.             IUserOperation userOperation=session.getMapper(IUserOperation.class);  
67.             userOperation.addUser(user);  
68.             session.commit();  
69.             System.out.println("当前增加的用户 id为:"+user.getId());  
70.         } finally {  
71.             session.close();  
72.         }  
73.     }  
74.       
75.     //类似hibernate，要先查出后，之后再更新  
76.     public void updateUser(){  
77.         //先得到用户,然后修改，提交。  
78.         SqlSession session = sqlSessionFactory.openSession();  
79.         try {  
80.             IUserOperation userOperation=session.getMapper(IUserOperation.class);  
81.             User user = userOperation.selectUserByID(2);              
82.             user.setUserAddress("上海东方明珠宝塔");  
83.             userOperation.updateUser(user);  
84.             session.commit();  
85.               
86.         } finally {  
87.             session.close();  
88.         }  
89.     }  
90.       
91.       
92.     /** 
93.      * 删除数据，删除一定要 commit. 
94.      * @param id 
95.      */  
96.     public void deleteUser(int id){  
97.         SqlSession session = sqlSessionFactory.openSession();  
98.         try {  
99.             IUserOperation userOperation=session.getMapper(IUserOperation.class);            
100.             userOperation.deleteUser(id);  
101.             session.commit();              
102.         } finally {  
103.             session.close();  
104.         }  
105.     }  
106.       
107.     public void getUserArticles(int userid){  
108.         SqlSession session = sqlSessionFactory.openSession();  
109.         try {  
110.             IUserOperation userOperation=session.getMapper(IUserOperation.class);            
111.             List<Article> articles = userOperation.getUserArticles(userid);  
112.             for(Article article:articles){  
113.                 System.out.println(article.getTitle()+":"+article.getContent()+  
114.                         ":作者是:"+article.getUser().getUserName()+":地址:"+  
115.                          article.getUser().getUserAddress());  
116.             }  
117.         } finally {  
118.             session.close();  
119.         }  
120.     }  
121.   
122.       
123.       
124.       
125.     public static void main(String[] args) {          
126.   
127.         //测试接口返回用户list列表  
128.          Test testUser=new Test();         
129.         testUser.getUserList("%");            
130.          testUser.addUser();          
131.          testUser.updateUser();            
132.          testUser.deleteUser(2);              
133.          testUser.getUserArticles(1);  
134.            
135. /* 
136.         SqlSession session = sqlSessionFactory.openSession(); 
137.         try { 
138.  
139.             // 1、没有使用接口的测试 
140.             // 这里传入的参数是从User.xml文件中配置的 
141.             //User user = (User) session.selectOne("com.yihaomen.mybatis.model.UserMapper.selectUserByID", 1); 
142.  
143.             // 2、基于接口的测试:在接口的定义中，selectUserByID方法和配置文件中的方法名要一致，这里传入的是参数 
144.             IUserOperation userOperation = session.getMapper(IUserOperation.class); 
145.             User user = userOperation.selectUserByID(1); 
146.  
147.             System.out.println(user.getUserAddress()); 
148.             System.out.println(user.getUserName()); 
149.              
150.              
151.         } finally { 
152.             session.close(); 
153.         }       */  
154.           
155.   
156.           
157.     }  
158.   
159. }  

     结果如图：

三、总结：

    这篇文章主要是增删改查的一个实例，也包含了联合查询，重点是几种xml标签的使用，在使用的时候，可以从照猫画虎开始，有hibernate基础，理解Mybatis是很容易的。

    相关源码可以从这里下载，自行测试。

版权声明：本文为博主原创文章，未经博主允许不得转载。