iBATIS Framework

1.What is iBATIS?

• The iBATIS Data Mapper framework makes it easier to use a database with Java and .NET applications. iBATIS couples objects with stored procedures or SQL statements using a XML descriptor. Simplicity is the biggest advantage of the iBATIS Data Mapper over object relational mapping tools.
• To use the iBATIS Data Mapper, you rely on your own objects, XML, and SQL. There is little to learn that you don't already know. With the iBATIS Data Mapper, you have the full power of both SQL and stored procedures at your fingertips.

2.iBatis Two BasicComponents
2.1 iBATIS Data Mapper

• The iBATIS Data Mapper provides a very simple and flexible means of moving data between your Java and .NET objects and a relationaldatabase. Use the full power of real SQL without a single line of JDBC or ADO.NET code!
• This framework maps classes to SQL statements using a very simple XML descriptor.Using iBATIS you have the full power of real SQL at your fingertips.

2.2 iBATIS Data Access Objects

• iBATIS Data Access Objects is an abstraction layer that hides the details of your persistence solution and provides a common API to therest of your application.
• Data Access Objects allow you to create simple components that provide access to your data without revealing the specifics of the implementation to the rest of your application.
• Using DAOs you can allow your application tobe dynamically configured to use different persistence mechanisms.
• If you have a complex application with a number of differentdatabases and persistence approaches involved, DAOs can help you create a consistent API for the rest of your application.

3. iBATIS Downloads

• C# DataAccess Developer Guide
• C# DataMapper Developer Guide
• Download for NET Developers
  

4.Quick Start Guide to iBATIS DataMapper
This sample takes an "over-the-shoulder" Cookbook approach. We'll define a simple data access problem and use iBATIS to solve it for us. Let's say our client has a database and one of the tables in the database is a list of people. The client tells us:"We would like to use a web application to display the people in this table and to add, edit, and delete individual records."
Step 1 : The SQL
Let's start with the people table client mentioned. Since we're keeping it simple, we'll say it's a table in an Access database. The table definition is shown as
Name Type Size
PER_ID Long Integer 4
PER_FIRST_NAME Text 40
PER_LAST_NAME Text 40
PER_BIRTH_DATE DateTime 8
PER_WEIGHT_KG Double 8
PER_HEIGHT_M Double 8
Step 2 :The.NET Class
Person.cs
using System;
namespace iBatisTutorial.Model
{
public class Person
{
private int _id;
private string _firstName;
private string _lastName;
private DateTime _birthDate;
private double _weightInKilograms;
private double _heightInMeters;

public int Id
{
get{ return _id; }
set{ _id = value; }
}

// Other public properties for the private fields ...

}
}
Step 3 :The Nunit test
The first thing our story says is that client would like to display a list of people.
using System.Collections;
using IBatisNet.DataMapper;
using NUnit.Framework;
namespace iBatisTutorial.Model
{
[TestFixture]
public class PersonTest
{
[Test]
public void PersonList ()
{
// try it
IList people = Mapper.Instance().QueryForList("SelectAll",null);

// test it
Assert.IsNotNull(people,"Person list not returned");
Assert.IsTrue(people.Count>0,"Person list is empty");
Person person = (Person) people[0];
Assert.IsNotNull(person,"Person not returned");
}
}
}

OK, that was fun! The Assert class is built into NUnit, so to compile, we just need the Mapper object and QueryForList method. The Mapper is built into the iBATIS framework, so we don't need to write that either. The iBATIS QueryForList method executes our SQL statement (or stored procedure) and returns the result as a list.
Each row in the result becomes an entry in the list. Along with QueryForList, there is also Delete, Insert, Select, QueryForObject, and a couple of other methods in the iBATIS API. (See the Developers Guide for details.)
Looking at PersonTest class, we see that the QueryForList method takes the name of the statement we want to run and any runtime values the statement may need. Since a "SelectAll" statement wouldn't need any runtime values, we pass null in our test.
OK. Easy enough. But where does iBATIS get the "SelectAll" statement?
Some systems try to generate SQL statements for you, but iBATIS specializes in data mapping, not code generation. It's our job (or the job of our database administrator) to craft the SQL or provide a stored procedure. We then describe the statement in an XML element, like the one shown below.
Step 4 :The mapping file
Person.xml
"Person" type="iBatisTutorial.Model.Person, iBatisTutorial.Model" />
"SelectAllResult" class="Person">
"Id" column="PER_ID" />
"FirstName" column="PER_FIRST_NAME" />
"LastName" column="PER_LAST_NAME" />
"BirthDate" column="PER_BIRTH_DATE" />
"WeightInKilograms" column="PER_WEIGHT_KG" />
"HeightInMeters" column="PER_HEIGHT_M" />

The iBATIS mapping documents can hold several sets of related elements, like those shown. We can also have as many mapping documents as we need. Having multiple mapping documents is handy when several developers are working on the project at once.
So, the framework gets the SQL code for the query from the mapping, and plugs it into a prepared statement. But, how does iBATIS know where to find the table's datasource?
Surprise! More XML! You can define a configuration file for each datasource your application uses. The example below shows a configuration file for our Access database.
Step 5 :The configuration file
SqlMap.Config - A configuration file for our Access database

"1.0" encoding="UTF-8" ?>
"http://ibatis.apache.org/dataMapper"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" >

"OleDb1.1"/>
"iBatisTutorial"
connectionString="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=./Resources/iBatisTutorial.mdb"/>
"Resources/Person.xml" />

Of course, besides Access, other ADO.NET providers are supported, including SqlServer, Oracle, MySQL, PostgreSQL, DB2 and generic OLEDB, ODBC providers. (See the Developers Guide for details.)
The last part of the configuration file ("sqlMaps") is where we list our mapping documents, like the one shown back in Step 4. We can list as many documents as we need here, and they will all be read when the configuration is parsed.

OK, so how does the configuration get parsed?

Look back at PersonTest class in step 3. The heart of the code is the call to the "Mapper" object (under the remark "try it"). The Mapper object is a singleton. The first time it's called, it reads in the configuration documents to create the Mapper object. On subsequent calls, it reuses the Mapper object, so that the configuration is re-read only if the file changes.
The framework comes bundled with a default Mapper class. If you want to use a different name for the configuration file, or need to use more than one database, you can also use your own class, by copying and modifying the standard version.
The following example shows the code for the standard Mapper class that comes with the framework.

Mapper.cs

using IBatisNet.Common.Utilities;
using IBatisNet.DataMapper;

namespace IBatisNet.DataMapper
{
public class Mapper
{
private static volatile SqlMapper _mapper = null;

protected static void Configure (object obj)
{
_mapper = (SqlMapper) obj;
}
protected static void InitMapper()
{
ConfigureHandler handler = new ConfigureHandler (Configure);
_mapper = SqlMapper.ConfigureAndWatch (handler);
}

public static SqlMapper Instance()
{
if (_mapper == null)
{
lock (typeof (SqlMapper))
{
if (_mapper == null) // double-check
InitMapper();
}
}
return _mapper;
}

public static SqlMapper Get()
{
return Instance();
}
}
}

You can access as many different database configurations as you need, just by setting up additional Mapper classes. Each Mapper configuration is a facade for a database. As far as our application knows, the "Mapper" is the database. Behind the Mapper facade, you can change the location of the database, or switch between SQL statements and stored procedures, with zero-changes to your application code.

5 Comments

• It's a apache project/license
• It's very power and flexible framework. It saves me alot of time and you have total control over the generate SQL. It also help you validate your SQL statements too. Best of all, with some benifits belows.
  * You add a XML file for SQLserver and adjust an app config file.
  * And later you want to migrate the app to Oracle. Make a new XML file with all the Oracle info and you change config and you are running against Oracle now.
  * Even if the XML file is ad-hoc SQL later you can change to Stored Procedures or Packages with merely adding an XML file and changing the config to point to it.
  * The DBAs can write efficient Sprocs or packages and change your code to sue them without touching the code just adding some new XML and a config file change.
  * It is possible to change databases by merely adding XML files and changing confuigs without recompiling the code. In fact the person making up the XML files need know little about the code, just needs to know the DB well. For example, someone who knows mySQL or DB2 can change an app written by another coder, that was running in another DB quickly transformed to be running DB2 or mySQL in no time.
  
• The data mapper API has proven itself as very good. But I do not recommend using it yet for the following reasons:
  1) There is no support for your custom data types, structs like money, Nullables and others cannot be mapped from database to your entity objects. At least until you dig into iBatis source code.
  2) You still have to write lots of SQL, every bussiness entity needs CRUD operations.
  3) Initialization of the framework is very slow, as the number of mapped statements grows, iBatis really slows down the web application startup, this problem is caused by heavy use of XML serialization.
  
  On my next projects I use NHibernate O/R mapper, which is still in beta, but much more mature than iBatis.NET. There is a large community supporting NHibernate on its web forum.
  The problems with iBatis as I wrote above are solved here:
  1) Custom datatypes are fully supported
  2) You have to write no simple SQL statements by hand, all trial SQL is autogenerated. This really saves you a couple of hours.
  3) The initialization is much faster, because it uses XmlReaders instead of serialization.
  

6 List of Other ORM for more considerations

* .NET Persistence
* BBADataObjects
* DataObjects.NET
* Data Tier Modeler for .NET
* DotNorm
* Eldorado.NET
* Enterprise Core Objects (ECO™)
* Entity Broker
* eXpress Persistent Objects for .NET
* FastObjects.NET
* JC Persistent Framework
* LLBLGen Pro
* ModelWorks
* Nhibernate
* Nolics.NET
* Norm
* Norpheme
* ObjectBroker
* ObjectSpaces
* ObjectSpark
* Objectz.NET
* OJB.NET
* OPF.Net (Object Persistent Framework)
* ORM.NET
* Pragmatier Data Tier Builder
* RapTier
* Sisyphus Persistence Framework
* TierDeveloper
* Bob.NET
* ObjectPersistor.NET
* Genome

TrungNEMO 3:42 AM Tags : 4.NET Frameworks

Subscribe by Email

Follow Updates Articles from This Blog via Email