使用Castle扩展Ibatis.Net，面向接口编程-更优雅的代码

使用Ibatis.Net做项目半年了，甚是喜欢，感觉确实是个简单、轻巧的O/R Mapping框架，特别是将Sql配置在Xml文件中，相当于直接将Dao层抽离了出来。

本文假定读者对Ibatis.Net有一定的了解。

最近试用了一下Ibatis.Net的亲兄弟--Java的Mybatis，一对比发现：

执行一个查询，Ibatis.Net是这么写的：IList<UserEntity> list = SqlMapper.QueryForList<UserEntity>(prefix+ ".GetByFilter", parameters);

而Java的Mybatis是这么写的：List<UserEntity> list = dao.GetByFilter(parameters);

发现了没，后者的显然更优雅。

Mybatis之所以能这么调用，是因为Mybatis提供了一种面向接口编程的方法，只要写好接口，接口的方法名与map文件中sql片段的id相同，我们就能够直接通过接口调用。

我想了又想...C#也能够实现这样优雅的调用啊，可是为啥Ibatis.Net不提供呢，想到这，我开始明白Ibatis.Net是后妈生的。。。

---

说到这，进入主题吧，既然Ibatis.Net先天不够强大，那我们后天弥补吧，这里主要使用Castle这个组件来动态实现接口。

接下来我们做个Demo

1.搭建Ibatis.Net环境，这里就不说啦(最新版Ibatis.Net下载地址：http://download.csdn.net/detail/tzjzcy/7829759 )

2.引用Castle.Core.dll，这个dll实际上最新版的Ibatis.Net本身就有用到

3.创建一个测试表，录入数据，本文以mysql为例，代码如下：

 CREATE TABLE `user`(
  `Userid` INT NOT NULL AUTO_INCREMENT,
  `Username` VARCHAR(100),
  `Age` INT,
  `City` VARCHAR(100), PRIMARY KEY (`Userid`)
 ); 

 INSERT INTO `testex`.`user` (`Username`, `Age`, `City`) VALUES ('羊望', '', '厦门');
 INSERT INTO `testex`.`user` (`Userid`, `Username`, `Age`, `City`) VALUES ('', '测试', '', '福州'); 

4.编写对应实体类

     public class UserEntity
     {
         public int? Userid { get; set; }

         public string Username { get; set; }

         public int? Age { get; set; }

         public string City { get; set; }
     }

5.写个简单的map文件：UserMap.xml

 <?xml version="1.0" encoding="utf-8" ?>
 <!--这里的namespace必须对应Dao接口的完整类名-->
 <sqlMap namespace="IbatisExTest.Daos.IUserDao"
         xmlns="http://ibatis.apache.org/mapping"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
   <alias>
     <typeAlias alias="UserEntity" type="IbatisExTest.Entities.UserEntity,IbatisExTest" />
   </alias>

   <statements>

     <select id="GetByUserid" parameterClass="String" resultClass="UserEntity">
       SELECT *
       FROM user
       <dynamic prepend="WHERE">
         Userid =#value#
       </dynamic>
     </select>

     <select id="GetByFilter" parameterClass="Hashtable" resultClass="UserEntity">
       SELECT *
       From user
       <dynamic prepend="WHERE">
         <isNotEmpty prepend="AND" property="Userid">
           Userid =#Userid#
         </isNotEmpty>
         <isNotEmpty prepend="AND" property="Username">
           Username =#Username#
         </isNotEmpty>
       </dynamic>
     </select>

     <insert id="InsertUser" parameterClass="UserEntity">
       INSERT INTO user
       ( Username
       , Age
       , City)
       VALUES (
        #Username#
       , #Age#
       , #City#);
     </insert>

   </statements>
 </sqlMap>

6.写一个接口，接口的全名（命名空间+接口名）必须与map文件的namespace相同，接口的方法与map文件中的sql片段id对应

     public interface IUserDao
     {

         UserEntity GetByUserid(string userid);

         IList<UserEntity> GetByFilter(Hashtable ht);

         object InsertUser(UserEntity user);
     }

7.写一个BaseDao，作为动态创建的Dao实现类的基类，定义一个属性，传入SqlMapper用

    public class BaseDao
    {
        public BaseDao(ISqlMapper sqlMapper)
        {
            this.SqlMapper = sqlMapper;
        }
        public ISqlMapper SqlMapper { get; private set; }
    }

8.重点来了，编写Dao实现类的具体方法实现，通过Castle组件实现的，作用是：在调用接口的方法时，执行map中对应的sql片段

     /// <summary>
     /// Dao接口的方法实现
     /// </summary>
     public class DaoInterceptor : IInterceptor
     {
         public void Intercept(IInvocation invocation)
         {
             BaseDao baseDao = (BaseDao)invocation.Proxy;
             //从基类BaseDao获取sqlMapper实例
             ISqlMapper sqlMapper = baseDao.SqlMapper;
             MethodInfo method = invocation.Method;
             if (method.DeclaringType == null) return;
             //获取接口的全名，即map文件的Namespace
             string mapNamespace = method.DeclaringType.FullName;
             //得到要执行的sql的完整id
             string statementId = mapNamespace + "." + method.Name;
             IMappedStatement ms = sqlMapper.GetMappedStatement(statementId);
             if (ms is SelectMappedStatement)
             {
                 ProcessSelectStatement(invocation, sqlMapper, statementId);
             }
             else if (ms is InsertMappedStatement)
             {
                 ProcessInsertStatement(invocation, sqlMapper, statementId);
             }
             else if (ms is UpdateMappedStatement)
             {
                 ProcessUpdateStatement(invocation, sqlMapper, statementId);
             }
             else if (ms is DeleteMappedStatement)
             {
                 ProcessDeleteStatement(invocation, sqlMapper, statementId);
             }
         }

         private static void ProcessSelectStatement(IInvocation invocation, ISqlMapper sqlMapper, string statementId)
         {
             MethodInfo method = invocation.Method;
             if (method.ReturnType.IsGenericType) //判断方法的返回值，如果是泛型，表示返回值是泛型集合
             {
                 //通过反射调用sqlMapper.QueryForList方法
                 Type t = typeof(List<>).MakeGenericType(method.ReturnType.GetGenericArguments());
                 var list = Activator.CreateInstance(t);
                 MethodInfo miQueryForList = typeof(ISqlMapper).GetMethod("QueryForList",
                     new Type[] { typeof(string), typeof(object), typeof(List<>) });
                 miQueryForList.Invoke(sqlMapper, new object[] { statementId, invocation.Arguments[], list });
                 invocation.ReturnValue = list;
             }
             else //返回单个对象,或int等基本类型
             {
                 //直接调用sqlMapper.QueryForObject方法
                 invocation.ReturnValue = sqlMapper.QueryForObject(statementId, invocation.Arguments[]);
             }
         }

         private static void ProcessInsertStatement(IInvocation invocation, ISqlMapper sqlMapper, string statementId)
         {
             invocation.ReturnValue = sqlMapper.Insert(statementId, invocation.Arguments[]);
         }

         private static void ProcessUpdateStatement(IInvocation invocation, ISqlMapper sqlMapper, string statementId)
         {
             invocation.ReturnValue = sqlMapper.Update(statementId, invocation.Arguments[]);
         }

         private static void ProcessDeleteStatement(IInvocation invocation, ISqlMapper sqlMapper, string statementId)
         {
             invocation.ReturnValue = sqlMapper.Delete(statementId, invocation.Arguments[]);
         }

9.编写SqlMapper的扩展方法，动态实现Dao接口

     public static class SqlMapExtensionMethods
     {
         /// <summary>
         /// 获取Dao的实现
         /// </summary>
         /// <typeparam name="T">Dao接口</typeparam>
         /// <param name="sqlMapper">sqlMapper</param>
         /// <returns>返回Dao的实现</returns>
         public static T GetDao<T>(this ISqlMapper sqlMapper)
         {
             ProxyGenerator generator = new ProxyGenerator();
             DaoInterceptor daoInterceptor = new DaoInterceptor();
             //创建一个BaseDao的代理类，并实现指定Dao接口
             object proxy = generator.CreateClassProxy(typeof(BaseDao), new Type[] { typeof(T) }, ProxyGenerationOptions.Default, new object[] { sqlMapper }, daoInterceptor);
             return (T)proxy;
         }
     }

10.这样就完成了扩展，让我们看看调用实例吧

    class Program
    {
        private const string mapperNamespace = "IbatisExTest.Daos.IUserDao";

        private static ISqlMapper SqlMapper
        {
            get { return Mapper.Get(); }
        }

        private static IUserDao UserDao
        {
            get { return SqlMapper.GetDao<IUserDao>(); }
        }

        static void Main()
        {
            Hashtable ht = new Hashtable();
            ht["Username"] = "羊望";
            //传统用法
            IList<UserEntity> list1 = SqlMapper.QueryForList<UserEntity>(mapperNamespace + ".GetByFilter", ht);

            //新用法（代码更优雅了吧）
            IList<UserEntity> list2 = UserDao.GetByFilter(ht);

            //测试新增
            //UserEntity user = new UserEntity { Username = "新用户", Age = , City = "新城市" };
            //UserDao.InsertUser(user);
        }
    }

最后，我们看到，扩展后我们只需要调用Dao接口的方法，代码更简洁了。

至于要比传统用法多写个Dao接口，这个工作或许我们可以通过代码生成工具来做吧。

源代码下载：http://files.cnblogs.com/lookup/Castle%E6%89%A9%E5%B1%95IbatisNet%E4%BE%8B%E5%AD%90.zip

欢迎拍砖:)