题外：在博文索引中暂时列出了开源的计划一览，虫子开源的目的是希望能有更多的交流，部分软件可能小得连开源协议的认证价值都没有。不管程序有多小多简单，用心把一个完整的设计思路、实现过程以及测试结果展现给大家。欢迎大牛拍砖，小牛问路。
虫子的博文索引 http://www.cnblogs.com/dubing/archive/2011/11/03/2234599.html
软件背景
拿本次高性能数据同步工具来说，目前还处于开发阶段，大概是1/4的样子。为了避免模糊，就先把这1/4分享给大家。
数据作为系统的核心价值，因为其流动性所以经常会有载体的变更。如何高性能、安全的将数据搬移是一个大家经常接触也一直在用的课题。如果只是sql to sql可能作为程序员而言，DBA更适合这个内容，例如dts导入等。但是更多的实际场景下，可能会有文件、服务、甚至其他类型的数据流来源。所以作为码农，我们不妨多了解一下这方面的内容。
设计思路
暂时开源程序中只做了sql to sql的一部分。直接就以这个开始来讲吧。
首先是入参和返参的设计
/// <summary>
/// 入参接口
/// </summary>
public interface IAOPParam
{
/// <summary>
/// 目标地址
/// </summary>
string T_ConnectionString { get; }
/// <summary>
/// 请求行数
/// </summary>
long MaxSize { get; }
/// <summary>
/// 表名
/// </summary>
string TableName { get; }
/// <summary>
/// 当前行数
/// </summary>
long CurrentSize { get; }
/// <summary>
/// 域名
/// </summary>
string p_Domain { get; }
/// <summary>
/// 断点文件地址
/// </summary>
string p_InitPath { get; }
/// <summary>
/// 断点时间
/// </summary>
DateTime p_Previous { get; }
/// <summary>
/// 是否结束
/// </summary>
bool p_IsEnd { get; }
/// <summary>
/// 排序方式
/// </summary>
string SortName { get; set; }
/// <summary>
/// 单次请求大小
/// </summary>
long SingleSize { get; }
/// <summary>
/// 排序主键
/// </summary>
string Sortkey { get; }
/// <summary>
/// 是否支持事务
/// </summary>
bool IsTransaction { get; }
/// <summary>
/// true为支持断点 发生断点或异常后程序终止 false为不支持断点 遇到断点或异常继续填充直到此次请求完成
/// </summary>
bool IsBreakPoints { get; }
/// <summary>
/// guid
/// </summary>
string T_Guid { get; }
}
/// <summary>
/// 对象处理返回的入参接口（泛型）
/// </summary>
public interface IAOPParam<T> : IAOPParam
{
/// <summary>
/// 泛型附加对象
/// </summary>
T ParamAttachObjectEx { get; }
}
这样设计的目的是考虑到服务器的内存与资源占用问题，如果数据来源的体积过大，我们将会对请求的来源进行分块处理。另外通过排序字段或者自定义的sql语句或者存储过程(暂未补充)可以对数据源进行高级过滤，断点续传的设计目前比较简单，web程序的话植入cookie、控制台或者cs程序通过文本媒介json格式来控制。
#region IAOPResult
/// <summary>
/// 对象处理返回的结果接口
/// </summary>
/// <remarks>
/// 建议在代码调用返回值中都采用此类实例为返回值<br />
/// 一般ResultNo小于0表示异常，0表示成功，大于0表示其它一般提示信息
/// </remarks>
public interface IAOPResult
{
/// <summary>
/// 返回代码
/// </summary>
int ResultNo { get; }
/// <summary>
/// 对应的描述信息
/// </summary>
string ResultDescription { get; }
/// <summary>
/// 相应的附加信息
/// </summary>
object ResultAttachObject { get; }
/// <summary>
/// 内部AOPResult
/// </summary>
IAOPResult InnerAOPResult { get; }
/// <summary>
/// 处理结果是否成功（ResultNo == 0）
/// </summary>
bool IsSuccess { get; }
/// <summary>
/// 处理结果是否失败（ResultNo != 0 ）
/// </summary>
bool IsNotSuccess { get; }
/// <summary>
/// 处理结果是否失败（ResultNo < 0 ）
/// </summary>
bool IsFailed { get; }
/// <summary>
/// 已处理，但有不致命的错误（ResultNo > 0）
/// </summary>
bool IsPassedButFailed { get; }
/// <summary>
/// 如果处理失败，则抛出异常
/// </summary>
/// <returns>返回本身</returns>
IAOPResult ThrowErrorOnFailed();
}
#endregion IAOPResult
#region IAOPResult<T>
/// <summary>
/// 对象处理返回的结果接口（泛型）
/// </summary>
public interface IAOPResult<T> : IAOPResult
{
/// <summary>
/// 泛型附加对象
/// </summary>
T ResultAttachObjectEx { get; }
}
#endregion
返参的设计比较通用化，大家可以自己摸索下。自己也可以补充添加。
/// <summary>
/// 异常模块异常，框架的基础异常类，所有的异常请从本类派生
/// </summary>
[Serializable]
public class BaseException : ApplicationException
{
/// <summary>
/// 构造函数
/// </summary>
public BaseException()
: this(0, null, null)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="message">异常消息</param>
/// <param name="innerException">内部异常</param>
public BaseException(string message, Exception innerException)
: this(0, message, innerException)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="message">异常消息</param>
public BaseException(string message)
: this(0, message)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="errorNo">异常编号</param>
/// <param name="message">异常消息</param>
public BaseException(int errorNo, string message)
: this(errorNo, message, null)
{
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="errorNo">异常编号</param>
/// <param name="message">异常消息</param>
/// <param name="innerException">内部异常</param>
public BaseException(int errorNo, string message, Exception innerException)
: base(message, innerException)
{
this.errorNo = errorNo;
}
/// <summary>
/// 异常编号
/// </summary>
protected int errorNo;
/// <summary>
/// 异常编号
/// </summary>
public int ErrorNo
{
get { return errorNo; }
}
/// <summary>
/// 查找原始的异常
/// </summary>
/// <param name="e">异常</param>
/// <returns>原始的异常</returns>
public static Exception FindSourceException(Exception e)
{
Exception e1 = e;
while (e1 != null)
{
e = e1;
e1 = e1.InnerException;
}
return e;
}
/// <summary>
/// 从异常树种查找指定类型的异常
/// </summary>
/// <param name="e">异常</param>
/// <param name="expectedExceptionType">期待的异常类型</param>
/// <returns>所要求的异常，如果找不到，返回null</returns>
public static Exception FindSourceException(Exception e, Type expectedExceptionType)
{
while (e != null)
{
if (e.GetType() == expectedExceptionType)
{
return e;
}
e = e.InnerException;
}
return null;
}
}
异常基类。
public class Log4N
{
public static void WarnLog(string msg)
{
string dateTimeStr = DateTime.Now.ToString();
log4net.LogManager.GetLogger("WarnLog").Warn(dateTimeStr + "$$" + msg + "\r\n----------------------------------------------------------------------------");
}
public static void WarnLog(string msg, Exception ex)
{
string dateTimeStr = DateTime.Now.ToString();
log4net.LogManager.GetLogger("WarnLog").Warn(dateTimeStr + "$$" + msg+"\r\n----------------------------------------------------------------------------", ex);
}
public static void DebugLog(string msg)
{
string dateTimeStr = DateTime.Now.ToString();
log4net.LogManager.GetLogger("DebugLog").Debug(dateTimeStr + "$$" + msg + "\r\n----------------------------------------------------------------------------");
}
public static void DebugLog(string msg, Exception ex)
{
string dateTimeStr = DateTime.Now.ToString();
log4net.LogManager.GetLogger("DebugLog").Debug(dateTimeStr + "$$" + msg + "\r\n----------------------------------------------------------------------------", ex);
}
public static void InfoLog(string msg)
{
string dateTimeStr = DateTime.Now.ToString();
log4net.LogManager.GetLogger("InfoLog").Info(dateTimeStr + "$$" + msg + "\r\n----------------------------------------------------------------------------");
}
public static void InfoLog(string msg,IAOPParam app)
{
string dateTimeStr = DateTime.Now.ToString();
var s = new StringBuilder();
s.Append(dateTimeStr+"\r\n");
s.Append(msg + "\r\n");
s.AppendFormat("目标地址:" + app.T_ConnectionString + "\r\n");
s.AppendFormat("请求行数:" + app.MaxSize + "\r\n");
s.AppendFormat("当前行数:" + app.CurrentSize + "\r\n");
s.AppendFormat("域名信息:" + app.p_Domain + "\r\n");
s.AppendFormat("断点信息地址:" + app.p_InitPath + "\r\n");
s.AppendFormat("是否完成:" + app.p_IsEnd.ToString() + "\r\n");
s.AppendFormat("断点时间:" + app.p_Previous.ToString() + "\r\n");
s.AppendFormat("单次行数:" + app.SingleSize.ToString() + "\r\n");
s.AppendFormat("排序主键:" + app.Sortkey + "\r\n");
s.AppendFormat("排序方式:" + app.SortName + "\r\n");
s.AppendFormat("表名:" + app.TableName + "\r\n");
log4net.LogManager.GetLogger("InfoLog").Info("$$" + s + "\r\n----------------------------------------------------------------------------");
}
public static void WarnLog(string msg, IAOPParam app)
{
string dateTimeStr = DateTime.Now.ToString();
var s = new StringBuilder();
s.Append(dateTimeStr+"\r\n");
s.Append(msg + "\r\n");
s.AppendFormat("目标地址:" + app.T_ConnectionString + "\r\n");
s.AppendFormat("请求行数:" + app.MaxSize + "\r\n");
s.AppendFormat("当前行数:" + app.CurrentSize + "\r\n");
s.AppendFormat("域名信息:" + app.p_Domain + "\r\n");
s.AppendFormat("断点信息地址:" + app.p_InitPath + "\r\n");
s.AppendFormat("是否完成:" + app.p_IsEnd.ToString() + "\r\n");
s.AppendFormat("断点时间:" + app.p_Previous.ToString() + "\r\n");
s.AppendFormat("单次行数:" + app.SingleSize.ToString() + "\r\n");
s.AppendFormat("排序主键:" + app.Sortkey + "\r\n");
s.AppendFormat("排序方式:" + app.SortName + "\r\n");
s.AppendFormat("表名:" + app.TableName + "\r\n");
log4net.LogManager.GetLogger("WarnLog").Info("$$" + s + "\r\n----------------------------------------------------------------------------");
}
}
日志采取lognet 不赘述
public static class Singleton<T> where T : class, new()
{
private static readonly object LockKey = new object();
public static T GetInstance()
{
return GetInstance(null);
}
public static T GetInstance(Func<T> onCreateInstance)
{
if (_instance == null)
{
lock (LockKey)
{
if (_instance == null)
{
try
{
return _instance = onCreateInstance == null ? new T() : onCreateInstance();
}
catch
{
_instance = default(T);
}
}
}
}
return _instance;
}
private static T _instance;
public static T GetInstance(object lockKey, T instance, Func<T> onCreateInstance)
{
if (instance == null)
{
if (lockKey == null)
lockKey = LockKey;
lock (lockKey)
{
try
{
instance = onCreateInstance == null ? new T() : onCreateInstance();
}
catch
{
instance = default(T);
}
}
}
return instance;
}
public static void ReleaseInstance()
{
lock (LockKey)
{
var id = _instance as IDisposable;
if (id != null)
id.Dispose();
_instance = default(T);
}
}
public static void TakeAction(Func<bool> lockCondition, object lockObject, Action action)
{
if (lockCondition())
{
lock (lockObject)
{
if (lockCondition())
{
action();
}
}
}
}
}
单例通用类 关于作用可以参考虫子设计模式随笔中的相关博文
public class Status : IDisposable
{
private readonly HttpContext _mHttpContext;
public enum CopyStatus { Initialization, Doing, Finished }
public string MGuid;
public DateTime MStartTime;
public long MTotalSize;
public long MCurrentSize;
public CopyStatus Statusflag;
public Status()
{
MGuid = Guid.NewGuid().ToString();
MStartTime = DateTime.Now;
_mHttpContext = HttpContext.Current;
Statusflag = CopyStatus.Initialization;
MCurrentSize = 0;
}
public void Dispose()
{
if (_mHttpContext.Session[MGuid] != null)
{
_mHttpContext.Session.Remove(MGuid);
}
}
}
状态类，通过这个类可以反映出当前数据同步的进度。
边缘化的准备工作大体如此，下面是主要的实现过程。过程中有几个注意点，同步读写还是异步读写、是否存在线程安全甚至进程的资源安全（例如我在读写前5000条的时候突然在另外一个客户端CRUD了N条数据）,另外，我们读写的时候是用连接的方式还是使用非连接的方式，如何解决服务器端内存占用问题，如何实现excel、txt、sql、oracle等不同数据来源的多态性。
实现过程
这里就先介绍下已经解决的一些问题
public class AnalyseDataManager
{
public Status MStatus { get; set; }
public static int SingleSize = 5000;
public static int StatusSize = 1000;
readonly Sqlhelper _sh = new Sqlhelper();
public AnalyseDataManager()
{
}
public AnalyseDataManager(Status st)
: this()
{
MStatus = st;
}
public IAsyncResult OutMethod(AopParam app)
{
MStatus.MTotalSize = app.MaxSize;
var func = new Func<AopParam, bool>(ServerMethod);
return func.BeginInvoke(app, CallbackMethod, func);
}
/// <summary>
/// 复制数据
/// </summary>
/// <returns>是否成功</returns>
public bool ServerMethod(AopParam app)
{
try
{
_sh.App = app;
if (_sh.OpenConn().IsSuccess)
{
while (app.MaxSize > MStatus.MCurrentSize)
{
app.CurrentSize = MStatus.MCurrentSize;
if (!AsyncDataToServer(app) && app.IsBreakPoints)
{
break;
}
}
}
}
catch (Exception ex)
{
Log4N.WarnLog("ServerMethod出错", ex);
if (app.IsBreakPoints)
{
return false;
}
}
finally
{
_sh.Dispose();
}
return true;
}
private bool AsyncDataToServer(AopParam app)
{
Log4N.InfoLog(string.Format("数据同步开始\r\n来源数据{0}\r\n表的名字{1}\r\n一次性提交的行数{2}\r\n当前行数{3}", app.T_ConnectionString, app.TableName, app.MaxSize, app.CurrentSize));
using (var bcp = new SqlBulkCopy(_sh.TconnSql))
{
MStatus.Statusflag = Status.CopyStatus.Doing;
bcp.BatchSize = SingleSize;
bcp.DestinationTableName = app.TableName;
bcp.SqlRowsCopied +=
OnSqlRowsCopied;
bcp.NotifyAfter = StatusSize;
try
{
bcp.WriteToServer(_sh.GetDtResultImp());
}
catch (Exception ex)
{
Log4N.WarnLog("AsyncDataToServer出错", ex);
return false;
}
finally
{
_sh.IreaderSql.Close();
}
return true;
}
}
private void OnSqlRowsCopied(object sender, SqlRowsCopiedEventArgs e)
{
Thread.Sleep(1000);
MStatus.MCurrentSize += StatusSize;
}
public void CallbackMethod(IAsyncResult ar)
{
var caller = (Func<AopParam,bool >)ar.AsyncState;
if (caller.EndInvoke(ar))
{
MStatus.Statusflag = Status.CopyStatus.Finished;
}
}
}
Microsoft SQL Server 提供一个称为 bcp 的流行的命令提示符实用工具，用于将数据从一个表移动到另一个表（表既可以在同一个服务器上，也可以在不同服务器上）。SqlBulkCopy 类允许编写提供类似功能的托管代码解决方案。还有其他将数据加载到 SQL Server 表的方法（例如 INSERT 语句），但相比之下 SqlBulkCopy 提供明显的性能优势。使用 SqlBulkCopy 类只能向 SQL Server 表写入数据。但是，数据源不限于 SQL Server；可以使用任何数据源，只要数据可加载到 DataTable 实例或可使用 IDataReader 实例读取数据。其中 SqlRowsCopied 在每次处理完 NotifyAfter 属性指定的行数时发生。
ServerMethod为主方法提供单次客户端请求的逻辑。
OutMethod对外开放以bpm异步编程模型形式进行处理、sqlhelper之所以不设计成单列，为了保证可以多个客户端请求状态不干扰。
public class Sqlhelper : IDisposable
{
private readonly string _sqlconn = ConfigurationSettings.AppSettings["BaseConn"];
public bool IblnTransBegin { get; set; }
public SqlTransaction ItransSql { get; set; }
public SqlConnection IconnSql { get; set; }
public SqlConnection TconnSql { get; set; }
public SqlDataReader IreaderSql { get; set; }
public IAOPParam App { get; set; }
public DataTable GetDtResult(string sqlcommand)
{
var ds = new DataSet();
var da = new SqlDataAdapter(sqlcommand, new SqlConnection(_sqlconn));
da.Fill(ds);
if (ds.Tables[0] != null)
{
return ds.Tables[0];
}
return null;
}
public DataTable GetDtResult()
{
//string sqlstr = string.Format("Select Top {0} * From {1} Where {2} not in (select Top {4} {2} From {1} order by {2} {3} ) order by {2} {3} ", app.SingleSize.ToString(), app.TableName, app.Sortkey, app.SortName, app.CurrentSize.ToString());
string sqlstr = GetCommandByApp();
var ds = new DataSet();
var da = new SqlDataAdapter(sqlstr, new SqlConnection(_sqlconn));
da.Fill(ds);
if (ds.Tables[0] != null)
{
return ds.Tables[0];
}
return null;
}
public SqlDataReader GetDtResultImp()
{
var sqlstr = GetCommandByApp();
var command = new SqlCommand(
sqlstr, IconnSql);
IreaderSql =
command.ExecuteReader();
return IreaderSql;
}
public IAOPResult OpenConn()
{
var ar = new AOPResult(0);
IconnSql = new SqlConnection(_sqlconn);
TconnSql = new SqlConnection(App.T_ConnectionString);
try
{
IconnSql.Open();
TconnSql.Open();
}
catch (SqlException ex)
{
ar.ResultNo = 1;
Log4N.InfoLog(string.Format("OpenConn失败,详细消息为{0},源表", ex.Message), App);
}
return ar;
}
public IAOPResult CloseConn()
{
var ar = new AOPResult(0);
try
{
IconnSql.Close();
TconnSql.Close();
}
catch (SqlException ex)
{
ar.ResultNo = 1;
Log4N.InfoLog(string.Format("CloseConn失败,详细消息为{0},源表", ex.Message), App);
}
return ar;
}
public IAOPResult BeginTran()
{
ItransSql = IconnSql.BeginTransaction();
return null;
}
public void Dispose()
{
CloseConn();
}
public string GetCommandByApp()
{
string sqlstr = string.Empty;
if(App.CurrentSize == 0)
{
switch (App.SortName.ToLower())
{
case "asc":
sqlstr = string.Format("Select Top {0} * From {1} order by {2} asc", App.SingleSize.ToString(), App.TableName, App.Sortkey);
break;
case "desc":
sqlstr = string.Format("Select Top {0} * From {1} order by {2} desc", App.SingleSize.ToString(), App.TableName, App.Sortkey);
break;
}
}
else
{
switch (App.SortName.ToLower())
{
case "asc":
sqlstr = string.Format("Select Top {0} * From {1} Where {2} >(select max ({2}) From (select Top {3} {2} From {1} order by {2} asc ) as temp_chongzi) order by {2} asc", App.SingleSize.ToString(), App.TableName, App.Sortkey, App.CurrentSize.ToString());
break;
case "desc":
sqlstr = string.Format("Select Top {0} * From {1} Where {2} <(select min ({2}) From (select Top {3} {2} From {1}) order by {2} desc )as temp_chongzi) order by {2} desc", App.SingleSize.ToString(), App.TableName, App.Sortkey, App.CurrentSize.ToString());
break;
}
}
return sqlstr;
}
数据库访问层中首先是一个类似分页sql的设计，来优化单次请求的效率。bcp的来源可以选择连接式的SqlDataReader 或者非连接式的Dataset，2者各有优缺。前者需要打开SqlConnection，但是是逐条读取，后者非连接但是占用内存大。至于具体的性能比，虫子在下一章节再和大家讨论。至于源程序目前还是草稿版，很多功能还未实现，细节处理也不够细腻，因为异步目前只设置了一个线程，还未涉及到并行框架，性能方面还有相当大的提高空间。先放出来让大家讨论，细节方面可以暂时先略过，大家可以说说在设计方面如何才能更高效、稳定。
源码地址：点击此处下载
扫一扫
9499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
