private NHibernate.Cfg.Configuration BuildConfiguration(IDbProviderConfig config)
{
Logger.Debug("Building configuration");
//TODO 缓存配置实现
var providerService = _dataServicesProviderFactory.CreateProvider(config);
var result = providerService.BuildConfiguration(config);
Logger.Debug("Done Building configuration");
return(result);
}
private ISessionFactory BuildSessionFactory(IDbProviderConfig providerConfig)
{
Logger.Debug("Building session factory");
if (!Utils.IsFullTrust)
{
NHibernate.Cfg.Environment.UseReflectionOptimizer = false;
}
NHibernate.Cfg.Configuration config = GetConfiguration(providerConfig);
var result = config.BuildSessionFactory();
Logger.Debug("Done building session factory");
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public NHibernate.Cfg.Configuration GetConfiguration(IDbProviderConfig config)
{
NHibernate.Cfg.Configuration configuration;
lock (configLock)
{
_configDictonary.TryGetValue(config.CustomerId, out configuration);
if (configuration == null)
{
configuration = BuildConfiguration(config);
_configDictonary.AddOrUpdate(config.CustomerId, x => configuration,
(x, y) => { return(configuration); });
}
}
return(configuration);
}
/// <summary>
///
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public ISessionFactory GetSessionFactory(IDbProviderConfig config)
{
ISessionFactory sessionFactory;
lock (this)
{
_sessionFactories.TryGetValue(config.CustomerId, out sessionFactory);
if (sessionFactory == null)
{
sessionFactory = BuildSessionFactory(config);
_sessionFactories.AddOrUpdate(config.CustomerId, x => sessionFactory,
(x, y) => { return(sessionFactory); });
}
}
return(sessionFactory);
}
static AutoPersistenceModel CreateAutomappings(List <Type> typeList, IDbProviderConfig config)
{
// This is the actual automapping - use AutoMap to start automapping,
// then pick one of the static methods to specify what to map (in this case
// all the classes in the assembly that contains Employee), and then either
// use the Setup and Where methods to restrict that behaviour, or (preferably)
// supply a configuration instance of your definition to control the automapper.
return(AutoMap
.Source(new TypeSource(typeList))
.Conventions.Add <RecordTableNameConvention>(new RecordTableNameConvention(typeList))
.Conventions.Add <EnumConvention>()
.Conventions.Add <StringLengthConvention>()
.Conventions.Add <PropertyConvertion>(new PropertyConvertion(config))
.Conventions.Add <CacheConvention>(new CacheConvention(typeList))
);
}
/// <summary>
/// 创建工厂提供器并且
/// </summary>
public static IDbConnection DbService(IDbProviderConfig config)
{
if (_df == null)
{
_df = DbProviderFactories.GetFactory(config.ProviderFactoryString);
}
var connection = _df.CreateConnection();
if (connection == null)
{
throw new Exception("创建IDbConnection异常");
}
connection.ConnectionString = config.DbConnectionString;
//if (connection.State != ConnectionState.Open) connection.Open();
return(connection);
}
public IDataServicesProvider CreateProvider(IDbProviderConfig parameters)
{
var providerName = parameters.DbProvider.ToString();
if (parameters.DbProvider == DbProvider.MySql)
{
return(new MySqlDataServicesProvider(parameters.DataFolder, parameters.DbConnectionString));
}
else if (parameters.DbProvider == DbProvider.SqlServer)
{
return(new SqlServerDataServicesProvider(parameters.DataFolder, parameters.DbConnectionString));
}
if (providerName == "SqlCe")
{
return(new SqlCeDataServicesProvider(parameters.DataFolder, parameters.DbConnectionString));
}
return(null);
}
/// <summary>
/// 要求所有表都要手动添加映射类
/// </summary>
/// <returns></returns>
public NHibernate.Cfg.Configuration BuildConfiguration(IDbProviderConfig config)
{
try
{
List <Type> typeList = new List <Type>();
foreach (var provider in _typeProviders)
{
typeList.AddRange(provider.GetTypes());
}
var database = GetPersistenceConfigurer(false);
return(Fluently.Configure()
.Database(database)
.Mappings(m => m.AutoMappings.Add(CreateAutomappings(typeList, config)))
.ExposeConfiguration(x => { ExposeConfig(config.CustomerId, x); })
.BuildConfiguration());
}
catch (Exception e)
{
Logger.Error(e, this.GetType().Name + "BuildConfiguration");
}
return(null);
}
public DeviceAccess(IDbProviderConfig providerConfig)
: base(providerConfig)
{
}
public AppBasicInfoAccess(IDbProviderConfig providerConfig)
: base(providerConfig)
{
_logger = LoggerFactory.GetLog();
}
public PropertyConvertion(IDbProviderConfig config)
{
_config = config;
}
/// <summary>
///
/// </summary>
public RawSqlSearchService(IDbProviderConfig providerConfig)
{
_providerConfig = providerConfig;
Logger = LoggerFactory.GetLog();
}
public ConfigCenterRedisCacheKeyAccess(IDbProviderConfig providerConfig)
: base(providerConfig)
{
}
/// <summary>
///
/// </summary>
/// <param name="providerConfig"></param>
protected BusinessService(IDbProviderConfig providerConfig)
{
_searchService = new RawSqlSearchService(providerConfig);
_primatyKeyIsInt = null;
}
/// <summary>
///
/// </summary>
/// <param name="providerConfig"></param>
public DatabaseInitialise(IDbProviderConfig providerConfig)
{
_providerConfig = providerConfig;
_searchService = new RawSqlSearchService(_providerConfig);
}
public ConfigCenterClusterComputerAccess(IDbProviderConfig providerConfig)
: base(providerConfig)
{
}
public NhRepository(IDbProviderConfig config)
{
_config = config;
Logger = LoggerFactory.GetLog();
_sessionFactory = null; //.Current.Resolve<ISessionFactoryHolder>();
}
public UnitOfWork(IDbProviderConfig dbProviderConfig)
{
this._connection = Database.DbService(dbProviderConfig);
DbProviderConfig = dbProviderConfig;
}
