ibatis开发环境搭建

时间：2014-06-08 04:55:29 阅读：241 评论：0 收藏：0 [点我收藏+]

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的版本进行说明。首先看下项目结构。

bubuko.com,布布扣

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开发环境搭建,布布扣,bubuko.com

ibatis开发环境搭建

标签：ibatis 框架

原文地址：http://blog.csdn.net/jirongzi_cs2011/article/details/29198869

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行