ibatis开发环境搭建

IBatis是一款使用方便的数据访问工具，也可作为数据持久层的框架。和ORM框架(如Hibernate)将数据库表直接映射为Java对象相比，iBatis是将SQL语句映射为Java对象。相对于全自动SQL的Hibernate，iBatis允许你对SQL有完全控制权，可以视为半自动的数据访问工具。

iBatis的最大优点是简便，轻量级，仅需iBatis的一个jar和数据库的驱动即可运行，而且使用iBatis仅需掌握SQL和XML的用法即可，而不像Hibernate那样需要配置对象间的关系。学习iBatis的过程要比Hibernate快很多，在项目中，若人员水平不大一致时，使用iBatis代替Hibernate作为数据访问工具可以有效提升开发效率。

不管是iBatis还是Hibernate，都作为访问数据库的工具，它们必然基于JDBC而来，目的解决是JDBC程序开发的繁琐性和代码的冗余性(如加载驱动，建立连接，初始化语句对象，执行数据库操作，返回结果，关闭各个对象这一重复且无技术含量的过程)。在 JDBC应用程序中，所有操作必须人为显式完成，如有遗漏可能就会对程序造成影响，比如连接不释放，数据更新操作时使用事务。不可否认的是，JDBC直接操作数据库的效率是最高的，一旦使用了持久层的框架，会在效率上造成一定影响。这点要权衡利弊，做出决定。

下面我们进入iBatis的配置。使用iBatis首先要获取开发包，现在iBatis版本分为2和3，二者在使用上稍有差别，这里我们使用2的版本进行说明。首先看下项目结构。

iBatis的配置文件是SqlMapConfig.xml，这里面需要声明数据库连接的属性信息，数据源配置信息，映射文件等信息，先看个例子：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
    "http://ibatis.apache.org/dtd/sql-map-config-2.dtd">  

<sqlMapConfig>
    <!-- 使用JDBC的事务管理 -->
		<transactionManager type="JDBC">
			<dataSource type="SIMPLE">
				<property name="JDBC.Driver" value="com.mysql.jdbc.Driver" />
				<property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost:3306/ibatistest" />
				<property name="JDBC.Username" value="root" />
				<property name="JDBC.Password" value="123456" />
			 </dataSource>
		</transactionManager>
    <!-- 这里可以写多个实体的映射文件 -->
    <sqlMap resource="sqlmap_student.xml" />
</sqlMapConfig>  

配置好iBatis后，我们就要进行数据库操作了，当然iBatis本身的SQL语句也是写在映射文件中的，那么就要看sqlmap_student.xml了。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-2.dtd">  

<sqlMap>
    <!-- 通过typeAlias使得我们在下面使用Student实体类的时候不需要写包名 -->
    <typeAlias alias="Student" type="com.cainiao.ibatistest.entity.Student" />  

    <!-- 这样以后改了sql，就不需要去改java代码了 -->
    <!-- id表示select里的sql语句，resultClass表示返回结果的类型 -->
    <select id="selectAllStudent" resultClass="Student">
        select * from
        tb_student
    </select>  

    <!-- parameterClass表示参数的内容 -->
    <!-- #表示这是一个外部调用的需要传进的参数，可以理解为占位符 -->
    <select id="selectStudentById" parameterClass="int" resultClass="Student">
        select * from tb_student where id=#id#
    </select>  

    <!-- 注意这里的resultClass类型，使用Student类型取决于queryForList还是queryForObject -->
    <select id="selectStudentByName" parameterClass="String"
        resultClass="Student">
        select name,birth,score from tb_student where name like
        '%$name$%'
    </select>  

    <insert id="addStudent" parameterClass="Student">
        insert into
        tb_student(name,birth,score) values
        (#name#,#birth#,#score#);
        <selectKey resultClass="int" keyProperty="id">
            select @@identity as inserted
            <!-- 这里需要说明一下不同的数据库主键的生成，对各自的数据库有不同的方式： -->
            <!-- mysql:SELECT LAST_INSERT_ID() AS VALUE -->
            <!-- mssql:select @@IDENTITY as value -->
            <!-- oracle:SELECT STOCKIDSEQUENCE.NEXTVAL AS VALUE FROM DUAL -->
            <!-- 还有一点需要注意的是不同的数据库生产商生成主键的方式不一样，有些是预先生成 (pre-generate)主键的，如Oracle和PostgreSQL。
                有些是事后生成(post-generate)主键的，如MySQL和SQL Server 所以如果是Oracle数据库，则需要将selectKey写在insert之前 -->
        </selectKey>
    </insert>  

    <delete id="deleteStudentById" parameterClass="int">
        <!-- #id#里的id可以随意取，但是上面的insert则会有影响，因为上面的name会从Student里的属性里去查找 -->
        <!-- 我们也可以这样理解，如果有#占位符，则ibatis会调用parameterClass里的属性去赋值 -->
        delete from tb_student where id=#id#
    </delete>  

    <update id="updateStudent" parameterClass="Student">
        update tb_student set
        name=#name#,birth=#birth#,score=#score# where id=#id#
    </update>  

</sqlMap>  

typeAlias标签是设置别名用的，这里我们使用了一个Bean叫做Student，声明别名后，在文件的后续部分可以直接使用别名而不用再给出完整类型了，非常方便，如select标签中的resultClass属性，这个配置我们使用的是Bean作为返回的结果类型，当然也可以使用Map，非常灵活。Select的id是标识该SQL语句的标识符，要在应用程序中使用到，必须唯一。Select标签体内的部分就是SQL语句了，其他标签里面也是一样的。

下面就是具体看一下应用程序的java代码：

Student.java中定义了操作对象，具体代码如下：

package com.cainiao.ibatistest.entity;

import java.sql.Date;
/**
 *
 * @author xxx
 *
 */

public class Student {
    // 注意这里需要保证有一个无参构造方法，因为包括Hibernate在内的映射都是使用反射的，如果没有无参构造可能会出现问题
    private int id;
    private String name;
    private Date birth;
    private float score;  

    public int getId() {
        return id;
    }  

    public void setId(int id) {
        this.id = id;
    }  

    public String getName() {
        return name;
    }  

    public void setName(String name) {
        this.name = name;
    }  

    public Date getBirth() {
        return birth;
    }  

    public void setBirth(Date birth) {
        this.birth = birth;
    }  

    public float getScore() {
        return score;
    }  

    public void setScore(float score) {
        this.score = score;
    }  

    @Override
    public String toString() {
        return "id=" + id + "\tname=" + name + "\tmajor=" + birth + "\tscore="
                + score + "\n";
    }  

}

StudentDao.java中声明了操作Student对象的一些接口：

package com.cainiao.ibatistest.dao;
import java.util.List;
import com.cainiao.ibatistest.entity.Student;
/**
 * @author xxx
 *
 */
public interface StudentDao {  

    /**
     * 添加学生信息
     *
     * @param student 学生实体
     * @return 返回是否添加成功
     */
    public boolean addStudent(Student student);  

    /**
     * 根据学生id删除学生信息
     *
     * @param id 学生id
     * @return 删除是否成功
     */
    public boolean deleteStudentById(int id);  

    /**
     * 更新学生信息
     *
     * @param student 学生实体
     * @return 更新是否成功
     */
    public boolean updateStudent(Student student);  

    /**
     * 查询全部学生信息
     *
     * @return 返回学生列表
     */
    public List<Student> selectAllStudent();  

    /**
     * 根据学生姓名模糊查询学生信息
     *
     * @param name 学生姓名
     * @return 学生信息列表
     */
    public List<Student> selectStudentByName(String name);  

    /**
     * 根据学生id查询学生信息
     *
     * @param id 学生id
     * @return 学生对象
     */
    public Student selectStudentById(int id);  

}  

StudentDaoImp.java实现了StudentDao接口：

package com.cainiao.ibatistest.daoimp;

import java.io.IOException;
import java.io.Reader;
import java.sql.SQLException;
import java.util.List;  

import com.ibatis.common.resources.Resources;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapClientBuilder;
import com.cainiao.ibatistest.dao.StudentDao;
import com.cainiao.ibatistest.entity.Student;

/**
 * @author xxx
 *
 */
public class StudentDaoImp implements StudentDao {  

    private static SqlMapClient sqlMapClient = null;  

    // 读取配置文件
    static {
        try {
            Reader reader = Resources
                    .getResourceAsReader("SqlMapConfig.xml");
            sqlMapClient = SqlMapClientBuilder.buildSqlMapClient(reader);
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }  

    public boolean addStudent(Student student) {
        Object object = null;
        boolean flag = false;
        try {
            object = sqlMapClient.insert("addStudent", student);
            System.out.println("添加学生信息的返回值：" + object);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (object != null) {
            flag = true;
        }
        return flag;
    }  

    public boolean deleteStudentById(int id) {
        boolean flag = false;
        Object object = null;
        try {
            object = sqlMapClient.delete("deleteStudentById", id);
            System.out.println("删除学生信息的返回值：" + object + "，这里返回的是影响的行数");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (object != null) {
            flag = true;  

        }
        return flag;  

    }  

    public boolean updateStudent(Student student) {
        boolean flag = false;
        Object object = false;
        try {
            object = sqlMapClient.update("updateStudent", student);
            System.out.println("更新学生信息的返回值：" + object + "，返回影响的行数");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        if (object != null) {
            flag = true;
        }
        return flag;
    }  

    @SuppressWarnings("unchecked")
	public List<Student> selectAllStudent() {
        List<Student> students = null;
        try {
            students = sqlMapClient.queryForList("selectAllStudent");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return students;
    }  

    @SuppressWarnings("unchecked")
	public List<Student> selectStudentByName(String name) {
        List<Student> students = null;
        try {
            students = sqlMapClient.queryForList("selectStudentByName",name);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return students;
    }  

    public Student selectStudentById(int id) {
        Student student = null;
        try {
            student = (Student) sqlMapClient.queryForObject(
                    "selectStudentById", id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return student;
    }
}

在这里面，首先是加载iBatis的配置文件，然后使用SqlMapClient接口提供的方法进行数据操作。

测试类TestMain.java如下：

package com.cainiao.ibatistest.test;

import java.sql.Date;
import java.util.List;  

import com.cainiao.ibatistest.daoimp.StudentDaoImp;
import com.cainiao.ibatistest.entity.Student;

/**
 * @author xxx
 *
 */
public class TestMain {  

    public static void main(String[] args) {
        StudentDaoImp StudentDaoImp = new StudentDaoImp();  

        System.out.println("测试插入");
        Student addStudent = new Student();
        addStudent.setName("李四");
        addStudent.setBirth(Date.valueOf("2011-09-02"));
        addStudent.setScore(88);
        System.out.println(StudentDaoImp.addStudent(addStudent));  

        System.out.println("测试根据id查询");
        System.out.println(StudentDaoImp.selectStudentById(1));  

        System.out.println("测试模糊查询");
        List<Student> mohuLists = StudentDaoImp.selectStudentByName("李");
        for (Student student : mohuLists) {
            System.out.println(student);
        }  

        System.out.println("测试查询所有");
        List<Student> students = StudentDaoImp.selectAllStudent();
        for (Student student : students) {
            System.out.println(student);
        }  

        System.out.println("根据id删除学生信息");
        System.out.println(StudentDaoImp.deleteStudentById(1));  

        System.out.println("测试更新学生信息");
        Student updateStudent = new Student();
        updateStudent.setId(1);
        updateStudent.setName("李四1");
        updateStudent.setBirth(Date.valueOf("2011-08-07"));
        updateStudent.setScore(21);
        System.out.println(StudentDaoImp.updateStudent(updateStudent));  

    }
}  

至此，一个简单的iBatis应用就写完了，相比于Hibernate，我们对SQL有完全的主动权，对SQL的管理也高度统一，并且配置非常简单。

ibatis开发环境搭建