private static void LoadCtor(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap)
{
var ctorNode = xmlNode.SelectSingleNode("//ns:Constructor", xmlNsM);
if (ctorNode != null)
{
var argNodes = ctorNode.SelectNodes("//ns:Arg", xmlNsM);
if (argNodes.Count > 0)
{
var ctorMap = new Constructor
{
Args = new List <Arg>()
};
foreach (XmlNode argNode in argNodes)
{
var arg = new Arg
{
Column = argNode.Attributes["Column"].Value,
Type = argNode.Attributes["Type"].Value,
TypeHandler = argNode.Attributes["TypeHandler"]?.Value
};
arg.ArgType = ArgTypeConvert(arg.Type);
if (!String.IsNullOrEmpty(arg.TypeHandler))
{
arg.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == arg.TypeHandler).Handler;
}
ctorMap.Args.Add(arg);
}
resultMap.Constructor = ctorMap;
}
}
}
public static ResultMap LoadResultMap(XElement xmlNode, SmartSqlMapConfig sqlMapConfig)
{
ResultMap resultMap = new ResultMap
{
Id = xmlNode.Attribute("Id").Value,
Results = new List <Result> {
}
};
var type = xmlNode.Attribute("ResultType")?.Value;
if (string.IsNullOrWhiteSpace(type) == false)
{
resultMap.ResultType = Type.GetType(type);
}
if (resultMap.ResultType == null)
{
throw new SmartSqlException($"Entity map {resultMap.Id} 找不到类型{resultMap.ResultType}!");
}
foreach (XElement childNode in xmlNode.Elements())
{
var result = new Result
{
Property = childNode.Attribute("Property").Value,
Column = (childNode.Attribute("Column") ?? childNode.Attribute("Property")).Value,
TypeHandler = childNode.Attribute("TypeHandler")?.Value
};
result.Handler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == result.TypeHandler)?.Handler;
resultMap.Results.Add(result);
}
return(resultMap);
}
public static ParameterMap LoadParameterMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig)
{
ParameterMap parameterMap = new ParameterMap
{
Id = xmlNode.Attributes["Id"].Value,
Parameters = new List <Parameter> {
}
};
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
var parameter = new Parameter
{
Property = childNode.Attributes["Property"].Value,
Name = (childNode.Attributes["Name"] ?? childNode.Attributes["Property"]).Value,
TypeHandler = childNode.Attributes["TypeHandler"].Value
};
if (!String.IsNullOrEmpty(parameter.TypeHandler))
{
TypeHandler typeHandler = TypeHanderNotNull(sqlMapConfig, parameter.TypeHandler);
parameter.Handler = typeHandler.Handler;
}
parameterMap.Parameters.Add(parameter);
}
return(parameterMap);
}
public override async Task process(WatchedEvent @event)
{
string path = @event.getPath();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher process : {path} .");
var eventType = @event.get_Type();
if (eventType == Event.EventType.NodeDataChanged)
{
if (!SmartSqlMapConfig.Settings.IsWatchConfigFile)
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap,dot not watch: {path} .");
}
else
{
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} Starting");
var sqlmap = SmartSqlMapConfig.SmartSqlMaps.FirstOrDefault(m => m.Path == path);
var newSqlmap = await ConfigLoader.LoadSmartSqlMapAsync(path, SmartSqlMapConfig);
sqlmap.Scope = newSqlmap.Scope;
sqlmap.Statements = newSqlmap.Statements;
sqlmap.Caches = newSqlmap.Caches;
SmartSqlMapConfig.ResetMappedStatements();
SmartSqlMapConfig.SmartSqlMapper.CacheManager.ResetMappedCaches();
_logger.LogDebug($"ZooKeeperConfigLoader.SmartSqlMapWatcher Changed Reload SmartSqlMap: {path} End");
}
}
}
private void LoadSmartSqlMap(SmartSqlMapConfig config, String sqlmapSourcePath)
{
_logger.LogDebug($"LoadSmartSqlMap Load: {sqlmapSourcePath}");
var sqlmapStream = LoadConfigStream(sqlmapSourcePath);
var sqlmap = LoadSmartSqlMap(sqlmapStream, config);
config.SmartSqlMaps.Add(sqlmap);
}
public SmartSqlContext(
ILogger <SmartSqlContext> logger
, SmartSqlMapConfig sqlMapConfig
)
{
_logger = logger;
SqlMapConfig = sqlMapConfig;
Setup();
}
private static TypeHandler TypeHanderNotNull(SmartSqlMapConfig sqlMapConfig, string typeHandlerName)
{
var typeHandler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == typeHandlerName);
if (typeHandler == null)
{
throw new SmartSqlException($"Can not find TypeHandler.Name:{typeHandlerName}");
}
return(typeHandler);
}
public SmartSqlMapWatcher(ILoggerFactory loggerFactory
, SmartSqlMapConfig smartSqlMapConfig
, ZooKeeperConfigLoader configLoader
, Func <WatchedEvent, Task> onWatch = null
) : base(loggerFactory, onWatch)
{
_logger = loggerFactory.CreateLogger <SmartSqlMapWatcher>();
SmartSqlMapConfig = smartSqlMapConfig;
ConfigLoader = configLoader;
}
/// <summary>
/// 监控配置文件-热更新
/// </summary>
private void WatchConfig(SmartSqlMapConfig config)
{
#region SmartSqlMaps File Watch
foreach (var sqlmapKV in SqlMapConfig.SmartSqlMaps)
{
var sqlmap = sqlmapKV.Value;
#region SqlMap File Watch
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Watch SmartSqlMap: {sqlmap.Path} .");
}
var sqlMapFileInfo = FileLoader.GetInfo(sqlmap.Path);
_fileWatcherLoader.Watch(sqlMapFileInfo, () =>
{
Thread.Sleep(DELAYED_LOAD_FILE);
lock (this)
{
try
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Changed Reload SmartSqlMap: {sqlmap.Path} Starting");
}
var newSqlMap = LoadSmartSqlMap(config, sqlmap.Path);
var oldSqlMap = SqlMapConfig.SmartSqlMaps.Values.First(s => s.Path == sqlmap.Path);
oldSqlMap.Caches = newSqlMap.Caches;
oldSqlMap.Scope = newSqlMap.Scope;
oldSqlMap.Statements = newSqlMap.Statements;
InitDependency();
OnChanged?.Invoke(this, new OnChangedEventArgs
{
SqlMapConfig = SqlMapConfig,
SqlMap = oldSqlMap,
EventType = EventType.SqlMapChangeed
});
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Changed Reload SmartSqlMap: {sqlmap.Path} End");
}
}
catch (Exception ex)
{
_logger.LogError(new EventId(ex.HResult), ex, ex.Message);
}
}
});
#endregion SqlMap File Watch
}
#endregion SmartSqlMaps File Watch
}
private void LoadManifestSmartSqlMap(SmartSqlMapConfig config, string name)
{
var configStream = new ConfigStream
{
Path = name,
Stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(name)
};
var sqlmap = LoadSmartSqlMap(configStream, config);
config.SmartSqlMaps.Add(sqlmap);
}
public SmartSqlMapConfig LoadConfig(ConfigStream configStream)
{
using (configStream.Stream)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig));
SqlMapConfig = xmlSerializer.Deserialize(configStream.Stream) as SmartSqlMapConfig;
SqlMapConfig.Path = configStream.Path;
SqlMapConfig.SmartSqlMaps = new List <SmartSqlMap> {
};
return(SqlMapConfig);
}
}
public static ResultMap LoadResultMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM)
{
ResultMap resultMap = new ResultMap
{
Id = xmlNode.Attributes["Id"].Value,
Results = new List <Result> {
}
};
LoadCtor(xmlNode, sqlMapConfig, xmlNsM, resultMap);
LoadResult(xmlNode, sqlMapConfig, xmlNsM, resultMap);
return(resultMap);
}
public async Task <SmartSqlMap> LoadSmartSqlMapAsync(String path, SmartSqlMapConfig config)
{
_logger.LogDebug($"SmartSql.LoadSmartSqlMapAsync Load: {path}");
var sqlmapResult = await ZooClient.getDataAsync(path, new SmartSqlMapWatcher(_loggerFactory, config, this));
var sqlmapStream = new ConfigStream
{
Path = path,
Stream = new MemoryStream(sqlmapResult.Data)
};
return(LoadSmartSqlMap(sqlmapStream, config));
}
private SmartSqlMap LoadSmartSqlMap(SmartSqlMapConfig config, string sqlMapPath)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LoadSmartSqlMap Load: {sqlMapPath}");
}
var sqlmapStream = LoadConfigStream(sqlMapPath);
var sqlmap = LoadSmartSqlMap(sqlmapStream);
config.SmartSqlMaps.Add(sqlmap);
return(sqlmap);
}
public SmartSqlMapConfig LoadConfig(ConfigStream configStream)
{
using (configStream.Stream)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig));
SqlMapConfig = xmlSerializer.Deserialize(configStream.Stream) as SmartSqlMapConfig;
SqlMapConfig.Path = configStream.Path;
SqlMapConfig.SmartSqlMaps = new Dictionary <String, SmartSqlMap> {
};
if (SqlMapConfig.TypeHandlers != null)
{
foreach (var typeHandler in SqlMapConfig.TypeHandlers)
{
typeHandler.Handler = TypeHandlerFactory.Create(typeHandler.Type);
}
}
return(SqlMapConfig);
}
}
private static void LoadResult(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap)
{
var resultNodes = xmlNode.SelectNodes("//ns:Result", xmlNsM);
foreach (XmlNode resultNode in resultNodes)
{
var result = new Result
{
Property = resultNode.Attributes["Property"].Value,
Column = (resultNode.Attributes["Column"] ?? resultNode.Attributes["Property"]).Value,
TypeHandler = resultNode.Attributes["TypeHandler"]?.Value
};
if (!String.IsNullOrEmpty(result.TypeHandler))
{
result.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == result.TypeHandler).Handler;
}
resultMap.Results.Add(result);
}
}
private static void LoadProperty(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig, XmlNamespaceManager xmlNsM, ResultMap resultMap)
{
var resultNodes = xmlNode.SelectNodes("./ns:Result", xmlNsM);
foreach (XmlNode resultNode in resultNodes)
{
var property = new Property
{
Name = resultNode.Attributes["Property"].Value,
Column = (resultNode.Attributes["Column"] ?? resultNode.Attributes["Property"]).Value,
TypeHandler = resultNode.Attributes["TypeHandler"]?.Value
};
if (!String.IsNullOrEmpty(property.TypeHandler))
{
TypeHandler typeHandler = TypeHanderNotNull(sqlMapConfig, property.TypeHandler);
property.Handler = typeHandler.Handler;
}
resultMap.Properties.Add(property);
}
}
private SmartSqlMapConfig LoadConfig(String path, ISmartSqlMapper smartSqlMapper)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig));
SmartSqlMapConfig config = null;
using (var configStream = FileLoader.Load(path))
{
config = xmlSerializer.Deserialize(configStream) as SmartSqlMapConfig;
config.Path = path;
config.SmartSqlMapper = smartSqlMapper;
}
config.SmartSqlMaps = new List <SmartSqlMap> {
};
foreach (var sqlmapSource in config.SmartSqlMapSources)
{
var sqlmap = LoadSmartSqlMap(sqlmapSource.Path, config);
config.SmartSqlMaps.Add(sqlmap);
}
return(config);
}
public async Task <SmartSqlMap> LoadSmartSqlMapAsync(string path, SmartSqlMapConfig smartSqlMapConfig)
{
var sqlMap = new SmartSqlMap
{
SmartSqlMapConfig = smartSqlMapConfig,
Path = path,
Statements = new List <Statement> {
},
Caches = new List <SqlMap.Cache> {
}
};
var configResult = await ZooClient.getDataAsync(path, new SmartSqlMapWatcher(smartSqlMapConfig, this));
using (MemoryStream configStream = new MemoryStream(configResult.Data))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(configStream);
XmlNamespaceManager xmlNsM = new XmlNamespaceManager(xmlDoc.NameTable);
xmlNsM.AddNamespace("ns", "http://SmartSql.net/schemas/SmartSqlMap.xsd");
sqlMap.Scope = xmlDoc.SelectSingleNode("//ns:SmartSqlMap", xmlNsM)
.Attributes["Scope"].Value;
#region Init Caches
var cacheNodes = xmlDoc.SelectNodes("//ns:Cache", xmlNsM);
foreach (XmlElement cacheNode in cacheNodes)
{
var cache = SqlMap.Cache.Load(cacheNode);
sqlMap.Caches.Add(cache);
}
#endregion
#region Init Statement
var statementNodes = xmlDoc.SelectNodes("//ns:Statement", xmlNsM);
foreach (XmlElement statementNode in statementNodes)
{
var statement = Statement.Load(statementNode, sqlMap);
sqlMap.Statements.Add(statement);
}
#endregion
return(sqlMap);
}
}
private SmartSqlMap LoadSmartSqlMap(string path, SmartSqlMapConfig smartSqlMapConfig)
{
var sqlMap = new SmartSqlMap
{
SmartSqlMapConfig = smartSqlMapConfig,
Path = path,
Statements = new List <Statement> {
},
Caches = new List <SqlMap.Cache> {
}
};
using (var configStream = FileLoader.Load(path))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(configStream);
XmlNamespaceManager xmlNsM = new XmlNamespaceManager(xmlDoc.NameTable);
xmlNsM.AddNamespace("ns", "http://SmartSql.net/schemas/SmartSqlMap.xsd");
sqlMap.Scope = xmlDoc.SelectSingleNode("//ns:SmartSqlMap", xmlNsM)
.Attributes["Scope"].Value;
#region Init Caches
var cacheNodes = xmlDoc.SelectNodes("//ns:Cache", xmlNsM);
foreach (XmlElement cacheNode in cacheNodes)
{
var cache = SqlMap.Cache.Load(cacheNode);
sqlMap.Caches.Add(cache);
}
#endregion
#region Init Statement
var statementNodes = xmlDoc.SelectNodes("//ns:Statement", xmlNsM);
foreach (XmlElement statementNode in statementNodes)
{
var statement = Statement.Load(statementNode, sqlMap);
sqlMap.Statements.Add(statement);
}
#endregion
return(sqlMap);
}
}
public async Task <SmartSqlMapConfig> LoadConfigAsync(String path, ISmartSqlMapper smartSqlMapper)
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(SmartSqlMapConfig));
SmartSqlMapConfig config = null;
var configResult = await ZooClient.getDataAsync(path, new SmartSqlMapConfigWatcher(smartSqlMapper, this));
using (MemoryStream configStream = new MemoryStream(configResult.Data))
{
config = xmlSerializer.Deserialize(configStream) as SmartSqlMapConfig;
config.Path = path;
config.SmartSqlMapper = smartSqlMapper;
}
config.SmartSqlMaps = new List <SmartSqlMap> {
};
foreach (var sqlmapSource in config.SmartSqlMapSources)
{
var sqlmap = await LoadSmartSqlMapAsync(sqlmapSource.Path, config);
config.SmartSqlMaps.Add(sqlmap);
}
return(config);
}
public static ParameterMap LoadParameterMap(XmlElement xmlNode, SmartSqlMapConfig sqlMapConfig)
{
ParameterMap parameterMap = new ParameterMap
{
Id = xmlNode.Attributes["Id"].Value,
Parameters = new List <Parameter> {
}
};
foreach (XmlNode childNode in xmlNode.ChildNodes)
{
var parameter = new Parameter
{
Property = childNode.Attributes["Property"].Value,
Name = (childNode.Attributes["Name"] ?? childNode.Attributes["Property"]).Value,
TypeHandler = childNode.Attributes["TypeHandler"].Value
};
parameter.Handler = sqlMapConfig.TypeHandlers.First(th => th.Name == parameter.TypeHandler).Handler;
parameterMap.Parameters.Add(parameter);
}
return(parameterMap);
}
public static ParameterMap LoadParameterMap(XElement xmlNode, SmartSqlMapConfig sqlMapConfig)
{
ParameterMap parameterMap = new ParameterMap
{
Id = xmlNode.Attribute("Id").Value,
Parameters = new List <Parameter> {
}
};
foreach (XElement childNode in xmlNode.Elements())
{
var parameter = new Parameter
{
Property = childNode.Attribute("Property").Value,
Name = (childNode.Attribute("Name") ?? childNode.Attribute("Property")).Value,
TypeHandler = childNode.Attribute("TypeHandler")?.Value
};
parameter.Handler = sqlMapConfig.TypeHandlers.FirstOrDefault(th => th.Name == parameter.TypeHandler)?.Handler;
parameterMap.Parameters.Add(parameter);
}
return(parameterMap);
}
public SmartSqlMapWatcher(SmartSqlMapConfig smartSqlMapConfig, ZooKeeperConfigLoader configLoader)
{
SmartSqlMapConfig = smartSqlMapConfig;
ConfigLoader = configLoader;
}
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig)
{
SqlMapper.LoadConfig(smartSqlMapConfig);
}
public SmartSqlMapWatcher(ILoggerFactory loggerFactory, SmartSqlMapConfig smartSqlMapConfig, ZooKeeperConfigLoader configLoader)
{
_logger = loggerFactory.CreateLogger <SmartSqlMapWatcher>();
SmartSqlMapConfig = smartSqlMapConfig;
ConfigLoader = configLoader;
}
public override SmartSqlMapConfig Load()
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Load: {_sqlMapConfigFilePath} Starting");
}
//读取xml文件
var smartSqlConfig = LoadSmartSqlConfig();
SqlMapConfig = new SmartSqlMapConfig()
{
Database = new SmartSql.Configuration.Database()
{
DbProvider = _options.Database.DbProvider,
ReadDataSources = _options.Database.Read,
WriteDataSource = _options.Database.Write
},
SmartSqlMaps = new Dictionary <String, SmartSqlMap>(),
SmartSqlMapSources = smartSqlConfig.SmartSqlMaps,
Settings = smartSqlConfig.Settings,
TypeHandlers = smartSqlConfig.TypeHandlers,
};
foreach (var sqlMapSource in SqlMapConfig.SmartSqlMapSources)
{
switch (sqlMapSource.Type)
{
case SmartSqlMapSource.ResourceType.File:
{
LoadSmartSqlMapAndInConfig(sqlMapSource.Path);
break;
}
case SmartSqlMapSource.ResourceType.Directory:
case SmartSqlMapSource.ResourceType.DirectoryWithAllSub:
{
SearchOption searchOption = SearchOption.TopDirectoryOnly;
if (sqlMapSource.Type == SmartSqlMapSource.ResourceType.DirectoryWithAllSub)
{
searchOption = SearchOption.AllDirectories;
}
var dicPath = Path.Combine(AppContext.BaseDirectory, sqlMapSource.Path);
var childSqlmapSources = Directory.EnumerateFiles(dicPath, "*.xml", searchOption);
foreach (var childSqlmapSource in childSqlmapSources)
{
LoadSmartSqlMapAndInConfig(childSqlmapSource);
}
break;
}
default:
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader unknow SmartSqlMapSource.ResourceType:{sqlMapSource.Type}.");
}
break;
}
}
}
InitDependency();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Load: {_sqlMapConfigFilePath} End");
}
if (SqlMapConfig.Settings.IsWatchConfigFile)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Load Add WatchConfig: {_sqlMapConfigFilePath} Starting.");
}
WatchConfig();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"LocalFileConfigLoader Load Add WatchConfig: {_sqlMapConfigFilePath} End.");
}
}
return(SqlMapConfig);
}
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig)
{
SqlMapConfig = smartSqlMapConfig;
SqlMapConfig.SetLogger(_loggerFactory.CreateLogger <SmartSqlMapConfig>());
}
public void LoadConfig(SmartSqlMapConfig smartSqlMapConfig)
{
MapperInstance.LoadConfig(smartSqlMapConfig);
}
public override SmartSqlMapConfig Load()
{
SqlMapConfig = new SmartSqlMapConfig()
{
SmartSqlMaps = new List <SmartSqlMap>(),
SmartSqlMapSources = _options.SmartSqlMaps,
Database = new Configuration.Database()
{
DbProvider = _options.Database.DbProvider,
WriteDataSource = _options.Database.Write,
ReadDataSources = _options.Database.Read
},
Settings = _options.Settings,
TypeHandlers = _options.TypeHandlers,
};
foreach (var sqlMapSource in SqlMapConfig.SmartSqlMapSources)
{
switch (sqlMapSource.Type)
{
case SmartSqlMapSource.ResourceType.File:
{
LoadSmartSqlMap(SqlMapConfig, sqlMapSource.Path);
break;
}
case SmartSqlMapSource.ResourceType.Directory:
case SmartSqlMapSource.ResourceType.DirectoryWithAllSub:
{
SearchOption searchOption = SearchOption.TopDirectoryOnly;
if (sqlMapSource.Type == SmartSqlMapSource.ResourceType.DirectoryWithAllSub)
{
searchOption = SearchOption.AllDirectories;
}
var dicPath = Path.Combine(AppContext.BaseDirectory, sqlMapSource.Path);
var childSqlmapSources = Directory.EnumerateFiles(dicPath, "*.xml", searchOption);
foreach (var childSqlmapSource in childSqlmapSources)
{
LoadSmartSqlMap(SqlMapConfig, childSqlmapSource);
}
break;
}
default:
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"OptionConfigLoader unknow SmartSqlMapSource.ResourceType:{sqlMapSource.Type}.");
}
break;
}
}
}
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"OptionConfigLoader Load End");
}
if (SqlMapConfig.Settings.IsWatchConfigFile)
{
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"OptionConfigLoader Load Add WatchConfig Starting.");
}
WatchConfig(SqlMapConfig);
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"OptionConfigLoader Load Add WatchConfig End.");
}
}
return(SqlMapConfig);
}
