[펌] Spring - iBatis Integration

Spring - iBatis Integration

스프링 - 아이바티스 연동

[출처]http://www.javabeat.net/articles/52-spring-ibatis-integration-1.html

1) Introduction

iBatisis anobject-relational mapping tool (ORM)that simplifies access to database. This article details the steps needed forintegrating iBatis with Spring. Through such an integration, objects that are specific to iBatis can utilise all the benefits given bySpring's IOC Container. This is not an introductory article for both Spring and iBatis Frameworks. First-time readers are encouraged to read the Introductory article for Spring in javabeatIntroduction to Spring Web Frameworkto know the preliminary concepts related to Spring.

2) Step-by-Step Procedure for Integration

2.1) Introduction

We are going to create a sample table in theMySql Databaseand going to access the data within it usingSpring-iBatis Integration. The required bundles needed to build and run the sample program are listed below.

• Spring Distribution
• MySql Database
• MySql Database Driver

2.2) Creating tables

Create a table calledJsrwhich contains relevant information for holding information likename,id,descriptionandspecification leadfor aJava Specification Request (JSR). Issue the following command in the MySql Client command prompt to create the table,

create table Jsr (JsrId varchar(10), JsrName varchar(50), JsrDescription,  varchar(500), SpecLead varchar(100));

2.3) Creating the Java Equivalent

Now let us create a equivalent Java class for theJsrtable. This class, will contain properties that will map to the column names in theJsrtable. Given here is the complete code listing for theJsrJava class,

Jsr.java

package javabeat.net.articles.spring.ibatis;public class Jsr {    private String id;    private String name;    private String description;    private String specLead;    public String getId()    {        return id;    }    public void setId(String id)    {        this.id = id;    }    public String getName()    {        return name;    }    public void setName(String name)    {        this.name = name;    }    public String getDescription()    {        return description;    }    public void setDescription(String description)    {        this.description = description;    }    public String getSpecLead()    {        return specLead;    }    public void setSpecLead(String specLead)    {        this.specLead = specLead;    }    public String toString()    {        return "Id = " + id + ", Name = " + name +             ", Description = " + description + ", Lead = " + specLead;     }}

2.4) JsrDao Class

Then, we need to get into the client-facing Dao interface design. This is the interface that clients will be depending on, to perform various database operations like selection of rows, insertion, deletion, updating data etc.

JsrDao.java

package javabeat.net.articles.spring.ibatis;import java.util.List;public interface JsrDao {    public List<Jsr> selectAllJsrs();    public Jsr selectJsrById(String jsrID);    public void insertJsr(Jsr insertJsr);    public void deleteJsr(String jsrId);    public void updateJsr(Jsr jsrWithNewValues);}

2.5) iBatis Mapping File

Jsr.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE sqlMap PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN""http://www.ibatis.com/dtd/sql-map-2.dtd"><sqlMap>    <typeAlias type = "javabeat.net.articles.spring.ibatis.Jsr" alias = "jsr"/>    <resultMap class = "jsr" id = "result">        <result property = "id" column = "JsrId"/>        <result property = "name" column = "JsrName"/>        <result property = "description" column = "JsrDescription"/>        <result property = "specLead" column = "SpecLead"/>    </resultMap>      <select id = "selectAllJsrs" resultMap = "result">        select * from Jsr    </select>    <select id = "selectJsrById" resultMap = "result" parameterClass = "string">        select * from Jsr where JsrId = #value#    </select>    <insert id = "insertJsr" parameterClass="jsr">        insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (#id#, #name#, #description#, #specLead#)    </insert>    <delete id = "deleteJsr" parameterClass="string">        delete from Jsr where JsrId = #value#    </delete>    <update id = "updateJsr" parameterClass="jsr">        update Jsr set JsrName = #name#, JsrDescription = #description#, SpecLead = #specLead#         where JsrId = #id#    </update></sqlMap>

iBatis mapping filecontains the mapping information between a Java class and its corresponding table in the database. Not only does it contain this mapping information, but also it contains many definitions forNamed Queries. ANamed Queryis just a query defined with some name so that it can be reused across multiple modules.

The above Xml file starts with an element called'typeAlias'which is just a short-name for'javabeat.net.articles.spring.ibatis.Jsr'. Instead of referencing the fully-qualified name of the Jsr class, now it can be shortly referred as'jsr'in the other sections of the Xml file. Next comes the mapping information specified in the form of'resultMap'element where the associations between the Java properties for the corresponding column names are made.

Then, theNamed Queriessection follows. A query called'selectAllJsrs'has been defined which is actually a select query. The query string value is manifested in the form of'select * from Jsr'. By having such a query definition, it can be used elsewhere in the Application just by referring the query identifier. Now, let us choose a query definition that illustrates passing parameters to it. The query identifier'selectJsrById'needs theJsrIdas a parameter using which it can filter the number of rows fetched. This can be represented by using the attribute'parameterClass'. Here'string'stands forjava.lang.Stringwhich means that the parameter is of type String. Similarly there are values like'int','float', etc forjava.lang.Integerandjava.lang.Floatrespectively. Inside the query definition, we have the following query string,

select * from Jsr where JsrId = #value#

In the above query string, we have defined a new symbol called'value'. This is the default symbol name for the parameter and since we have only one parameter it would not cause any problem. The expression'#value#'will be substituted with the values specified at the run-time. (Later we will see how the value gets substituted to the above expression).

Now, let us see a query definition that accepts multiple parameters. In the query definition'insertJsr', we want thejsr id,jsr name,jsr descriptionandspec leadvalues to get inserted and we have defined the query string as follows,

insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (    #id#, #name#, #description#, #specLead#)

In the query definition, the value of the parameter value is pointing to 'jsr', which means that during run-time the query string will get translated as follows,

insert into Jsr (JsrId, JsrName, JsrDescription, SpecLead) values (    jsr.getId(), jsr.getName(),jsr.getDescription(), jsr.getSpecLead())

2.6) iBatis Configuration File
The Configuration file for iBatis contains references to various mapping files as well as to the dataSource. But in our case, we would not define any dataSource related information in the Configuration file, but instead we will have it in the Spring Configuration file. 
SqlMapConfig.xml 
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE sqlMapConfigPUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN""http://www.ibatis.com/dtd/sql-map-config-2.dtd"><sqlMapConfig>    <sqlMap resource="./spring/ibatis/Jsr.xml" /></sqlMapConfig>
2.7) Implementation for JsrDao
We have designed only the client-facing interface in section 2.4. In this section, we shall see the implementation for the same. The following class extends SqlMapClientDaoSupport for getting reference to SqlMapClientTemplate object which simplifies the access to most of the database related operations. 
JsrDaoImpl.java 
package javabeat.net.articles.spring.ibatis;import java.util.List;import org.springframework.orm.ibatis.SqlMapClientTemplate;import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;public class JsrDaoImpl extends SqlMapClientDaoSupport implements JsrDao {    @Override    public List<Jsr> selectAllJsrs()     {        SqlMapClientTemplate template = getSqlMapClientTemplate();        return (List<Jsr>)template.queryForList("selectAllJsrs");    }    @Override    public Jsr selectJsrById(String jsrID)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        Object objectJsr = template.queryForObject("selectJsrById", jsrID);        return objectJsr instanceof Jsr ? ((Jsr)objectJsr) : null;    }    @Override    public void insertJsr(Jsr insertJsr)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.insert("insertJsr", insertJsr);	    }    @Override    public void deleteJsr(String jsrId)     {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.delete("deleteJsr", jsrId);    }    @Override    public void updateJsr(Jsr jsrWithNewValues)    {        SqlMapClientTemplate template = getSqlMapClientTemplate();        template.update("updateJsr", jsrWithNewValues);    }}
All the CRUD operations like select(), delete(), insert(), update() will take the named query object which was previously defined in the Configuration file. 
2.8) Spring Configuration File
The Spring configuration that we are going to see has 3 sections. The first section configures a Spring Bean for database access like the data source, the driver class name and username/password information etc. Next we have defined a Factory Bean for reading all the mapping definitions and the named query information in the iBatis Configuration file. This Bean is the 'SqlMapClientFactoryBean' and it references the configuration file 'SqlMapConfig.xml'. The final section is the definition of the JsrDaoImpl bean for client access and it contains references to both the data-source and the sqlMapClientFactoryBean that were declared previously. 
spring-ibatis.xml 
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""http://www.springframework.org/dtd/spring-beans.dtd">    <beans>        <bean id="dataSource"         class="org.apache.commons.dbcp.BasicDataSource"         destroy-method="close">            <property name="driverClassName">                <value>com.mysql.jdbc.Driver</value>            </property>            <property name="url">                <value>jdbc:mysql://localhost/test</value></property>            <property name="username"><value>root</value></property>            <property name="password"><value>rootPassword</value></property>    </bean>     <bean id="sqlMapClient"     class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">        <property name="configLocation">            <value>./spring/ibatis/SqlMapConfig.xml</value>        </property>    </bean>    <bean id="jsrDao"     class="javabeat.net.articles.spring.ibatis.JsrDaoImpl">        <property name="dataSource"><ref local="dataSource"/></property>        <property name="sqlMapClient"><ref local="sqlMapClient"/></property>    </bean></beans>
2.9) Client Application
JsrClientApplication.java 
package javabeat.net.articles.spring.ibatis;import java.util.List;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.xml.XmlBeanFactory;import org.springframework.core.io.FileSystemResource;import org.springframework.core.io.Resource;public class JsrClientApplication{    public static void main(String[] args)    {        Resource resource = new FileSystemResource(            "./src/spring/ibatis/spring-ibatis.xml");        BeanFactory beanFactory = new XmlBeanFactory(resource);        JsrDaoImpl jsrDao = (JsrDaoImpl)beanFactory.getBean("jsrDao");        System.out.println("Inserting JSR's");        insertJsrs(jsrDao);        System.out.println("Listing all JSR's");        List<Jsr> allJsrs = jsrDao.selectAllJsrs();        for (Jsr aJsr : allJsrs)        {            System.out.println(aJsr);        }        System.out.println("Selecting a JSR by Id 'JSR002'");        Jsr aJsr = jsrDao.selectJsrById("JSR002");        System.out.println(aJsr);        System.out.println("Updating a JSR");        Jsr fourthJsr = allJsrs.get(3);        fourthJsr.setName("Servlets-Updated");        fourthJsr.setDescription("Java Servlets and JSP-Updated");        fourthJsr.setSpecLead("Belkin-Updated");        jsrDao.updateJsr(fourthJsr);        System.out.println("Deleting a JSR");        jsrDao.deleteJsr("JSR004");    }    static void insertJsrs(JsrDaoImpl jsrDao)    {        Jsr newJsr = createJsr("JSR001", "JMX",             "Java Management Extension", "McManus");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR002", "XML",             "XML Parsing Spec", "Rajiv");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR003", "JDO",             "Java Data Objects", "Russell");        jsrDao.insertJsr(newJsr);        newJsr = createJsr("JSR004", "Servlets",             "Java Servlets and JSP", "Belkin");        jsrDao.insertJsr(newJsr);    }    static Jsr createJsr(String id, String name, String description, String specLead)    {        Jsr newJsr = new Jsr();        newJsr.setId(id);        newJsr.setName(name);        newJsr.setDescription(description);        newJsr.setSpecLead(specLead);        return newJsr;    }}
The Client Application in the above case gets a reference to the JsrDao object defined in the Spring Configuration file and makes use of it by testing the various available CRUD operations. 
3) Conclusion
This article provided the various introductory details for integrating iBatis with Spring Framework. The procedure for this integration has been explained in depth. This would help the readers to integrate iBatis with Spring framework and thereby allow the objects specific to iBatis to make optimum use of the features available in the Spring framework. 

<script> function hrefMark(){ } function hrefPageGo(mark){ try{ if(mark == 'top'){ parent.window.scrollTo(0,0); }else{ 　document.location.href="this.location.href+"#comment"; } }catch(e){} } //포스트 글로딩후 top포커수 주기 setTimeout('hrefPageGo("top")',300); </script>