iBatis的简单增删改查(CRUD)操作

编程技术  /  houtizong 发布于 3年前   84

iBatis是基于SQL的数据持久层框架，那就是要书写SQL语句进行数据库操作。对比于Hibernate虽然在对象属性的扩展上修改麻烦但是对SQL的集中管理和主动权，也还是不错的。下面我们来探讨iBatis中的简单增删改查(CRUD)操作，这也是数据库应用的基本操作。
    为了简化我们SQL输入参数的配置，我们写一个类来专门负责处理输入参数，把它们封装成一个Map类型，代码如下：
Java代码 
1.package ibatis.util;  
2.import java.util.HashMap;  
3.public class ParameterMap extends HashMap<Object, Object> {  
4.    private static final long serialVersionUID = 1L;  
5.    public ParameterMap(Object... parameters) {  
6.        for (int i = 0; i < parameters.length - 1; i += 2) {  
7.            super.put(parameters[i], parameters[i + 1]);  
8.        }  
9.    }  
10.} 
package ibatis.util;
import java.util.HashMap;
public class ParameterMap extends HashMap<Object, Object> {
private static final long serialVersionUID = 1L;
public ParameterMap(Object... parameters) {
for (int i = 0; i < parameters.length - 1; i += 2) {
super.put(parameters[i], parameters[i + 1]);
}
}
}
    代码很简单，一个扩展了HashMap的类，只有一个显式定义的构造方法，并且使用了可变参数，方法处理是将输入的参数按照一定规则存入HashMap。而这个规则一看就明白了，是按照参数列表中的“名”-“值”对来放置的。使用了可变参数后，那么参数想放几对就放几对，非常方便，为了能在XML中使用这个类型，不要忘了声明它。

Xml代码 
1.<typeAlias alias="parameterMap" type="ibatis.util.ParameterMap" /> 
<typeAlias alias="parameterMap" type="ibatis.util.ParameterMap" />
    首先是查询(select)，这个操作面向的是数据库中的记录，结果称之为结果集(JDBC中的说法)，而iBatis可以对结果集进行指定类型的转换，这也是SqlMap的体现。查询大体可分为两种：带条件的查询和不带条件的查询。
    不带条件的查询非常简单，在XML中我们配置如下的查询：

Xml代码 
1.<select id="getAllUsers" resultClass="java.util.HashMap"> 
2.    select *  
3.    from users  
4.</select> 
<select id="getAllUsers" resultClass="java.util.HashMap">
select *
from users
</select>
    这里我们将据诶过类型设置为HashMap，那么iBatis就会将返回的一条记录封装成Map类型，而我们在取值时使用的是SqlMapClient的queryForList(String sql)方法，那么在返回的List中就是HashMap的集合。我们在程序中可以这样来遍历输出结果：

Java代码 
1.package ibatis;  
2.import java.io.*;  
3.import java.sql.SQLException;  
4.import java.util.*;  
5.import com.ibatis.common.resources.Resources;  
6.import com.ibatis.sqlmap.client.*;  
7.public class IBatisDemo {  
8.    private static String config = "ibatis/SqlMapConfig.xml";  
9.    private static Reader reader;  
10.    private static SqlMapClient sqlMap;  
11.    static {  
12.        try {  
13.            reader = Resources.getResourceAsReader(config);  
14.        } catch (IOException e) {  
15.            e.printStackTrace();  
16.        }  
17.        sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);  
18.    }  
19.    public static void main(String[] args) throws SQLException {  
20.        List<HashMap> list = select();  
21.        for (HashMap user : list) {  
22.            System.out.println(user);  
23.        }  
24.    }  
25.    public static List<HashMap> select() throws SQLException {  
26.        return sqlMap.queryForList("getAllUsers");  
27.    }  
28.} 
package ibatis;
import java.io.*;
import java.sql.SQLException;
import java.util.*;
import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.*;
public class IBatisDemo {
private static String config = "ibatis/SqlMapConfig.xml";
private static Reader reader;
private static SqlMapClient sqlMap;
static {
try {
reader = Resources.getResourceAsReader(config);
} catch (IOException e) {
e.printStackTrace();
}
sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);
}
public static void main(String[] args) throws SQLException {
List<HashMap> list = select();
for (HashMap user : list) {
System.out.println(user);
}
}
public static List<HashMap> select() throws SQLException {
return sqlMap.queryForList("getAllUsers");
}
}
    这样就可以遍历出users表中的全部数据了，在控制台打印，可以看出是根据Map类型的格式来输出的。下面来看看含有参数的查询：

Xml代码 
1.<select id="getUserByName" parameterClass="java.lang.String" 
2.        resultClass="java.util.HashMap"> 
3.    select *  
4.    from users  
5.    where USERNAME=#VARCHAR#  
6.</select> 
<select id="getUserByName" parameterClass="java.lang.String"
resultClass="java.util.HashMap">
select *
from users
where USERNAME=#VARCHAR#
</select>
    和上面相比，多了一个parameterClass，就是参数类型，就一个参数USERNAME，我们使用String类型就可以了。方法中这样写就可以：

Java代码 
1.public static void main(String[] args) throws SQLException {  
2.    System.out.println(select("sarin"));  
3.}  
4.    public static HashMap select(String parameter) throws SQLException {        return (HashMap) sqlMap.queryForObject("getUserByName", parameter);  
5.} 
public static void main(String[] args) throws SQLException {
System.out.println(select("sarin"));
}
public static HashMap select(String parameter) throws SQLException { return (HashMap) sqlMap.queryForObject("getUserByName", parameter);
}
    有一个参数时我们在XML中配置parameterClass写这种参数的类型就可以了，但是多个参数时却不能在parameterClass中写一串类型，那么就需要抽象出一种数据结构来传递参数，很自然想到了HashMap，这种键值对形式的结构非常适合同名参数的传递。因为直接操作HashMap在参数存储时很不方便，我们就设计了前面提到的parameterMap类型。

Xml代码 
1.<select id="getUserByRealNameAndMobile" parameterClass="parameterMap" 
2.        resultClass="java.util.HashMap"> 
3.    select *  
4.    from users  
5.    where REALNAME=#realName:VARCHAR# and MOBILE=#mobile:VARCHAR#  
6.</select> 
<select id="getUserByRealNameAndMobile" parameterClass="parameterMap"
resultClass="java.util.HashMap">
select *
from users
where REALNAME=#realName:VARCHAR# and MOBILE=#mobile:VARCHAR#
</select>
    为了区别，数据库字段名全部大写，而传递的变量名采用小写方式，这样可以很清楚地辨别对应关系。那么程序中，这样进行就可以了。

Java代码 
1.public static void main(String[] args) throws SQLException {  
2.        ParameterMap parameterMap = new ParameterMap("realName", "sarin","mobile", "15940990000");  
3.        System.out.println(select(parameterMap));  
4.}  
5.    public static HashMap select(Map parameterMap) throws SQLException {return (HashMap) sqlMap.queryForObject("getUserByRealNameAndMobile",  
6.                parameterMap);  
7.} 
public static void main(String[] args) throws SQLException {
ParameterMap parameterMap = new ParameterMap("realName", "sarin","mobile", "15940990000");
System.out.println(select(parameterMap));
}
public static HashMap select(Map parameterMap) throws SQLException {return (HashMap) sqlMap.queryForObject("getUserByRealNameAndMobile",
parameterMap);
}
    数据操作中查询是难度最大的，但是在iBatis中只涉及到了参数传递和结果的获取，SQL的书写那就是具体问题具体分析了。简单查询知道这么多就够用了，下面我们来说插入(insert)操作。

Xml代码 
1.<insert id="addUser" parameterClass="parameterMap"> 
2.    insert into users(USERNAME,PASSWORD,REALNAME,MOBILE,EMAIL)  
3.    values(#userName:VARCHAR#,#password:VARCHAR#,#realName:VARCHAR#,#mobile:VARCHAR#,#email:VARCHAR#)  
4.</insert> 
<insert id="addUser" parameterClass="parameterMap">
insert into users(USERNAME,PASSWORD,REALNAME,MOBILE,EMAIL)
values(#userName:VARCHAR#,#password:VARCHAR#,#realName:VARCHAR#,#mobile:VARCHAR#,#email:VARCHAR#)
</insert>
    我都知道的，JDBC的更新操作返回的是影响的结果条数，那么插入操作就没有特定的结果类型了，我们使用SqlMapClient操作时返回的就是int类型的一个数值。当插入成功返回1，插入失败会报出具体的异常。代码如下：

Java代码 
1.public static void main(String[] args) throws SQLException {  
2.        ParameterMap parameterMap = new ParameterMap("userName", "sarin",  
3.                "password", "123", "realName", "sarin", "mobile", "1","email","@");  
4.        System.out.println(insert(parameterMap));  
5.}  
6.public static int insert(Map parameterMap) throws SQLException {  
7.        return sqlMap.update("addUser", parameterMap);  
8.} 
public static void main(String[] args) throws SQLException {
ParameterMap parameterMap = new ParameterMap("userName", "sarin",
"password", "123", "realName", "sarin", "mobile", "1","email","@");
System.out.println(insert(parameterMap));
}
public static int insert(Map parameterMap) throws SQLException {
return sqlMap.update("addUser", parameterMap);
}
    现在我们已经很直接的看出定义一个ParameterMap的好处了，就是为了更加简便的使用iBatis。下面来看看更新(update)操作：

Xml代码 
1.<update id="updateUser"> 
2.        update users   
3.        set PASSWORD='123456' 
4.</update> 
<update id="updateUser">
update users
set PASSWORD='123456'
</update>
    这个操作没有传递任何参数，就不用写parameterClass属性了，然后在程序中调用就可以执行这个操作了，也很简单。

Java代码 
1.public static void main(String[] args) throws SQLException {  
2.    System.out.println(update());  
3.}  
4.public static int update() throws SQLException {  
5.    return sqlMap.update("updateUser");  
6.} 
public static void main(String[] args) throws SQLException {
System.out.println(update());
}
public static int update() throws SQLException {
return sqlMap.update("updateUser");
}
    当执行更新操作后，结果返回的是影响数据表中的行数。最后一个就是删除(delete)操作了，看了前面那么多示例，这不难猜出删除操作的XML标记了。

Xml代码 
1.<delete id="deleteUser" parameterClass="java.lang.Integer"> 
2.    delete from users  
3.    where ID=#INT#  
4.</delete> 
<delete id="deleteUser" parameterClass="java.lang.Integer">
delete from users
where ID=#INT#
</delete>
    数据库中设计主键类型为INT，那么这里在参数上也设置为#INT#，则parameterClass属性就要设置为java.lang.Integer了，很容易理解，基本类型使用其包装类对象。程序中的写法和上面也大同小异了，只是在执行删除时SqlMapClient对象提供delete()方法，当然也可以继续使用update()方法，代码如下：

Java代码 
1.public static void main(String[] args) throws SQLException {  
2.    System.out.println(delete(4));  
3.}  
4.public static int delete(int userId) throws SQLException {  
5.    return sqlMap.delete("deleteUser", userId);  
6.} 
public static void main(String[] args) throws SQLException {
System.out.println(delete(4));
}
public static int delete(int userId) throws SQLException {
return sqlMap.delete("deleteUser", userId);
}
   这样就把ID为4的记录给删除了。
    至此iBatis简单的增删改查操作就介绍完了，很简单。流程就是在配置文件中写相应的标签，在标签体中写SQL语句，然后在程序中使用SqlMapClient对象中的方法来调用。执行方法的第一个参数都是XML配置标签的id属性值，后面跟的是参数或其他可选参数。这样一个流程就执行完了。
    相比于Hibernate的全自动SQL生成，iBatis需要手写SQL，但是SQL的管理要方便，因为它们都集中在XML文件中。