IBatis 简易框架搭建

 ibatis主要dll介绍

IBatisNet.Common.dll 由DataAccess和DataMapper组成的共享程序集
IBatisNet.Common.Logging.Log4Net.dll Log4Net集成记录器,和Log4Net配合使用
IBatisNet.DataMapper.dll DataMapper主要框架
IBatisNet.DataAccess.dll

DataAccess框架

2、IBatisDao 

1、DaoBase.cs Ibatis接口的封装

namespace IBatisDao
{
    public class DaoBase<T> : MarshalByRefObject where T : EntityBase
    {
        private static ISqlMapper SqlMap;
        /// <summary>
        /// 构造函数
        /// </summary>         
        /// 
        static DaoBase()
        {
            if (SqlMap == null)
            {
                SqlMap = SqlMapperCreater.SqlMap;
            }
        }

        /// <summary>
        ///  开始事务
        /// </summary>
        protected void BeginTransaction()
        {
            try
            {
                SqlMap.BeginTransaction();
            }
            catch
            {
                SqlMap.RollBackTransaction();
                SqlMap.BeginTransaction();
            }
        }

        /// <summary>
        /// 提交事务
        /// </summary> 
        protected void CommitTransaction()
        {
            SqlMap.CommitTransaction();
        }

        /// <summary>
        /// 回滚事务
        /// </summary>
        protected void RollBackTransaction()
        {
            SqlMap.RollBackTransaction();
        }

        /// <summary>
        /// 批量保存多个实体.
        /// </summary>
        /// <param name="list">实体列表</param>
        /// <param name="insertCmdId">insert语句的id</param>
        /// <param name="updateCmdId">update语句的id</param>
        /// <param name="deleteCmdId">delete语句的id</param>
        protected void Save(IList<T> list, string insertCmdId, string updateCmdId, string deleteCmdId)
        {
            //删除
            foreach (T t in list)
            {
                if (t.EntityState == EntityStateEnum.Deleted && !string.IsNullOrEmpty(deleteCmdId))
                {
                    this.Delete(deleteCmdId, t);
                }
            }
            //更新
            foreach (T t in list)
            {
                if (t.EntityState == EntityStateEnum.Modified && !string.IsNullOrEmpty(updateCmdId))
                {
                    this.Update(updateCmdId, t);
                }
            }
            //新增
            foreach (T t in list)
            {
                if (t.EntityState == EntityStateEnum.Added && !string.IsNullOrEmpty(insertCmdId))
                {
                    this.Insert(insertCmdId, t);
                }
            }
        }
        /// <summary>
        /// 保单个实体
        /// </summary>
        /// <param name="list">实体列表</param>
        /// <param name="insertCmdId">insert语句的id</param>
        /// <param name="updateCmdId">update语句的id</param>
        /// <param name="deleteCmdId">delete语句的id</param>
        protected void Save(T obj, string insertCmdId, string updateCmdId, string deleteCmdId)
        {
            //删除
            if (obj.EntityState == EntityStateEnum.Deleted && !string.IsNullOrEmpty(deleteCmdId))
            {
                this.Delete(deleteCmdId, obj);
            }
            //更新
            if (obj.EntityState == EntityStateEnum.Modified && !string.IsNullOrEmpty(updateCmdId))
            {
                this.Update(updateCmdId, obj);
            }
            //新增
            if (obj.EntityState == EntityStateEnum.Added && !string.IsNullOrEmpty(insertCmdId))
            {
                this.Insert(insertCmdId, obj);
            }
        }


        /// <summary>
        /// 通用执行Select语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>结果集合</returns>
        protected IList<T> Select(string tag, object paramObject)
        {
            return SqlMap.QueryForList<T>(tag, paramObject);
        }

        /// <summary>
        /// 通用执行skip Select语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <param name="skipResults">忽略个数</param>
        /// <param name="maxResults">最大个数</param>
        /// <returns>结果集合</returns>
        protected IList<T> Select(string tag, object paramObject, int skipResults, int maxResults)
        {
            return SqlMap.QueryForList<T>(tag, paramObject, skipResults, maxResults);
        }

        /// <summary>
        /// 通用执行Select语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>单个结果</returns>
        protected T SelectOne(string tag, object paramObject)
        {
            return SqlMap.QueryForObject<T>(tag, paramObject);
        }

        /// <summary>
        /// 通用执行Update语句(强制检查数据并发)
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>更新的行数</returns>
        protected int Update(string tag, T paramObject)
        {
            return this.Update(tag, paramObject, true);
        }

        /// <summary>
        /// 通用执行Update语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>更新的行数</returns>
        protected int Update(string tag, object paramObject)
        {
            int iReturn = SqlMap.Update(tag, paramObject);

            // 若更新出现并发且要检查并发,则抛出对应的异常
            if (iReturn <= 0)
            {
                throw new Exception("数据已被修改,请重新加载.");
            }
            // 改变状态为Unchanged
            return iReturn;
        }

        /// <summary>
        /// 通用执行Update语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <param name="checkConcurrency">是否要检查数据并发</param>
        /// <returns>更新的行数</returns>
        protected int Update(string tag, T paramObject, bool checkConcurrency)
        {
            int iReturn = SqlMap.Update(tag, paramObject);

            // 若更新出现并发且要检查并发,则抛出对应的异常
            if (iReturn <= 0 && checkConcurrency)
            {
                throw new Exception("数据已被修改,请重新加载.");
            }
            // 改变状态为Unchanged
            paramObject.EntityState = EntityStateEnum.Unchanged;
            return iReturn;
        }
        /// <summary>
        /// 通用执行Update语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <param name="checkConcurrency">是否要检查数据并发</param>
        /// <returns>更新的行数</returns>
        protected int Update(string tag, object paramObject, bool checkConcurrency)
        {
            int iReturn = SqlMap.Update(tag, paramObject);

            // 若更新出现并发且要检查并发,则抛出对应的异常
            if (iReturn <= 0 && checkConcurrency)
            {
                throw new Exception("数据已被修改,请重新加载.");
            }
            return iReturn;
        }


        /// <summary>
        /// 通用执行Deelte语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>删除的行数</returns>
        protected int Delete(string tag, T paramObject)
        {
            return SqlMap.Delete(tag, paramObject);
        }

        /// <summary>
        /// 通用执行Insert语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>插入行的PK对象</returns>
        protected object Insert(string tag, T paramObject)
        {
            object result = SqlMap.Insert(tag, paramObject);
            paramObject.EntityState = EntityStateEnum.Unchanged;
            return result;
        }

        /// <summary>
        /// 通用执行Insert语句
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>插入行的PK对象</returns>
        protected object Insert(string tag, object paramObject)
        {
            object result = SqlMap.Insert(tag, paramObject);

            return result;
        }

        #region GetSql/GetDataTable

        /// <summary>
        /// 通用得到参数化后的SQL(xml文件中参数要使用$标记的占位参数)
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>获得的SQL</returns>
        protected string GetSql(string tag, object paramObject)
        {
            string sql = GetPreparedSql(tag, paramObject);
            //ServiceObject.Log.Logs.DebugLog(tag + ": " + sql);

            return sql;
        }

        /// <summary>
        /// 返回结果集中的第一行的第一列
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>结果集中的第一行的第一列</returns>
        protected object QueryScalar(string tag, object paramObject)
        {
            bool isSessionLocal = false;
            object result;

            if (SqlMap.LocalSession == null)
            {
                isSessionLocal = true;
                SqlMap.OpenConnection();
            }

            //记录SQL语句
            GetSql(tag, paramObject);

            try
            {
                IDbCommand cmd = GetDbCommand(tag, paramObject);
                result = cmd.ExecuteScalar();
            }
            catch (Exception ex)
            {
                throw new Exception("Can't QueryScalar, tag = " + tag, ex);
            }
            finally
            {
                if (isSessionLocal)
                {
                    SqlMap.CloseConnection();
                }
            }

            return result;
        }

        /// <summary>
        /// 通用的以DataSet的方式得到Select的结果(xml文件中参数要使用$标记的占位参数)
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>得到的DataSet</returns>
        protected DataSet GetDataSet(string tag, object paramObject)
        {
            bool isSessionLocal = false;
            DataSet result = new DataSet(); ;

            if (SqlMap.LocalSession == null)
            {
                isSessionLocal = true;
                SqlMap.OpenConnection();
            }
            try
            {
                IDbCommand cmd = GetDbCommand(tag, paramObject);
                IDbDataAdapter adapter = SqlMap.LocalSession.CreateDataAdapter(cmd);
                adapter.Fill(result);
            }
            catch (Exception ex)
            {
                throw new Exception("Can't GetDataSet, tag = " + tag, ex);
            }
            finally
            {
                if (isSessionLocal)
                {
                    SqlMap.CloseConnection();
                }
            }

            return result;
        }

        /// <summary>
        /// 通用的以DataTable的方式得到Select的结果(xml文件中参数要使用$标记的占位参数)
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <returns>得到的DataTable</returns>
        protected DataTable GetDataTable(string tag, object paramObject)
        {
            return GetDataSet(tag, paramObject).Tables[0];
        }

        /// <summary>
        /// 通用的以DataTable的方式得到skip Select的结果(xml文件中参数要使用$标记的占位参数)
        /// </summary>
        /// <param name="tag">语句ID</param>
        /// <param name="paramObject">语句所需要的参数</param>
        /// <param name="skipResults">忽略个数</param>
        /// <param name="maxResults">最大个数</param>
        /// <returns>得到的DataTable</returns>
        protected DataTable GetDataTable(string tag, object paramObject, int skipResults, int maxResults)
        {
            bool isSessionLocal = false;
            DataSet result = new DataSet();

            if (SqlMap.LocalSession == null)
            {
                isSessionLocal = true;
                SqlMap.OpenConnection();
            }

            //记录SQL语句
            GetSql(tag, paramObject);

            try
            {
                IDbCommand cmd = GetDbCommand(tag, paramObject);
                DbDataAdapter adapter = SqlMap.LocalSession.CreateDataAdapter(cmd) as DbDataAdapter;
                if (adapter == null)
                {
                    throw new NotSupportedException("Not support skip GetDataTable");
                }
                adapter.Fill(result, skipResults, maxResults, "result");
            }
            catch (Exception ex)
            {
                throw new Exception("Can't GetDataTable, tag = " + tag, ex);
            }
            finally
            {
                if (isSessionLocal)
                {
                    SqlMap.CloseConnection();
                }
            }

            return result.Tables["result"];
        }

        private IDbCommand GetDbCommand(string statementName, object paramObject)
        {
            IStatement statement = SqlMap.GetMappedStatement(statementName).Statement;

            IMappedStatement mapStatement = SqlMap.GetMappedStatement(statementName);

            ISqlMapSession session = new SqlMapSession(SqlMap);

            if (SqlMap.LocalSession != null)
            {
                session = SqlMap.LocalSession;
            }
            else
            {
                session = SqlMap.OpenConnection();
            }

            RequestScope request = statement.Sql.GetRequestScope(mapStatement, paramObject, session);
            mapStatement.PreparedCommand.Create(request, session, statement, paramObject);

            IDbCommand command = request.IDbCommand;

            // Ibatis 这里做了个装饰,所以得到的类型不是SqlCommand之类的类型
            // 只能暂时使用反射把它装饰的类型(即真实类型)反射出来
            Type t = command.GetType();
            FieldInfo commandField = t.GetField("_innerDbCommand", BindingFlags.Instance | BindingFlags.NonPublic);
            IDbCommand innerDbCommand = commandField.GetValue(command) as IDbCommand;

            return innerDbCommand; // request.IDbCommand;
        }

        /// <summary>
        /// 获取查询语句
        /// </summary>
        /// <param name="statementName"></param>
        /// <param name="parameterObject"></param>
        /// <returns></returns>
        protected string GetPreparedSql(string statementName, object parameterObject)
        {
            IMappedStatement mappedStatement = SqlMap.GetMappedStatement(statementName);
            ISqlMapSession localSession = SqlMap.LocalSession;
            IStatement statement = mappedStatement.Statement;
            if (localSession == null)
            {
                localSession = new SqlMapSession(SqlMap);
            }
            return statement.Sql.GetRequestScope(mappedStatement, parameterObject, localSession).PreparedStatement.PreparedSql;
        }

        protected IList<TableEntity> QueryWithRowDelegate(string tag, object paramObject, Action<object, object, IList<TableEntity>> action)
        {
            return SqlMap.QueryWithRowDelegate<TableEntity>(tag, paramObject, new RowDelegate<TableEntity>(action));
        }
        #endregion
    }
}
View Code

相关文章:

  • 2021-09-17
  • 2021-12-27
  • 2021-12-09
  • 2021-10-30
  • 2021-12-26
  • 2021-08-13
  • 2021-08-04
  • 2021-09-07
猜你喜欢
  • 2021-12-03
  • 2021-10-23
  • 2022-12-23
  • 2021-11-28
  • 2021-06-16
相关资源
相似解决方案