private DbTypeConverter()
{
_logger = CurrentIocManager.CreateLogger <DbTypeConverter>();
var path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "config", "DbTypeMaps.xml");
_typeMap = XmlHelper.XmlDeserializeFromPath(path, new DbTypeMap());
}
/// <summary> 通知配置更新 </summary>
/// <param name="module"></param>
/// <param name="env"></param>
/// <param name="config"></param>
/// <returns></returns>
private void NotifyConfig(string module, string env, object config)
{
Task.Factory.StartNew <Task>(async() =>
{
using var scope = CurrentIocManager.BeginLifetimeScope();
var hub = scope.Resolve <IHubContext <ConfigHub> >();
if (string.IsNullOrWhiteSpace(env))
{
var contract = scope.Resolve <IConfigContract>();
//default
var existsEnvs = (await contract.GetEnvsAsync(Project.Id, module)).ToList();
foreach (ConfigEnv configEnv in Enum.GetValues(typeof(ConfigEnv)))
{
var item = configEnv.ToString().ToLower();
if (existsEnvs.Contains(item))
{
continue;
}
await hub.UpdateAsync(Project.Code, module, item, config);
}
}
else
{
await hub.UpdateAsync(Project.Code, module, env, config);
}
});
}
/// <summary> 构造函数 </summary>
/// <param name="baseUri"></param>
/// <param name="timeout">超时时间(秒)</param>
public RestHelper(string baseUri = null, int timeout = -1)
{
_baseUri = baseUri;
_httpHelper = HttpHelper.Instance;
_timeout = timeout;
_logger = CurrentIocManager.CreateLogger <RestHelper>();
}
/// <summary> Ioc注册 </summary>
protected override void IocRegisters()
{
Builder = Builder ?? new ContainerBuilder();
//注入程序集查找器
var finder = new DefaultAssemblyFinder();
Builder.RegisterInstance(finder).As <IAssemblyFinder>().SingleInstance();
var assemblies = finder.FindAll().ToArray();
Builder.RegisterAssemblyTypes(assemblies)
.Where(type => typeof(IScopedDependency).IsAssignableFrom(type) && !type.IsAbstract)
.AsSelf() //自身服务，用于没有接口的类
.AsImplementedInterfaces() //接口服务
.PropertiesAutowired() //属性注入
.InstancePerLifetimeScope(); //保证生命周期基于请求
Builder.RegisterAssemblyTypes(assemblies)
.Where(type => typeof(IDependency).IsAssignableFrom(type) && !type.IsAbstract)
.AsSelf() //自身服务，用于没有接口的类
.AsImplementedInterfaces() //接口服务
.PropertiesAutowired(); //属性注入
Builder.RegisterAssemblyTypes(assemblies)
.Where(type => typeof(ISingleDependency).IsAssignableFrom(type) && !type.IsAbstract)
.AsSelf() //自身服务，用于没有接口的类
.AsImplementedInterfaces() //接口服务
.PropertiesAutowired() //属性注入
.SingleInstance(); //保证单例注入
IocManager = new IocManager(this);
CurrentIocManager.SetIocManager(IocManager);
Builder.RegisterInstance(IocManager).AsSelf().As <IIocManager>().SingleInstance();
}
public static void Start(params string[] args)
{
var builder = new MicroBuilder();
builder.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Information);
builder.AddConsole();
});
var services = builder
.AddMicroClient(builder =>
{
builder
.AddJsonCodec()
//.AddMessagePackCodec()
//.AddProtoBufCodec()
.AddSession()
//.AddHttpProtocol()
.AddTcpProtocol()
//.AddWebSocketProtocol()
//.AddGrpcProtocol()
//.AddNacos(opt =>
//{
// opt.Host = "http://192.168.0.231:8848/";
// opt.Tenant = "ef950bae-865b-409b-9c3b-bc113cf7bf37";
//})
//.AddConsul("http://192.168.0.231:8500")
.AddDefaultRouter(r =>
{
r.Regist("Spear.Tests.Contracts_v1", new ServiceAddress("127.0.0.1", 5003)
{
Service = "192.168.10.217",
Protocol = ServiceProtocol.Tcp,
Codec = ServiceCodec.Json,
Gzip = false
});
})
;
});
services.AddSingleton <IService, ServieA>();
services.AddSingleton <IService, ServieB>();
var provider = services.BuildServiceProvider();
CurrentIocManager.CreateLogger <Client>().LogInformation("test");
var logger = provider.GetService <ILogger <Client> >();
logger.LogInformation("请输入消息");
while (true)
{
var message = Console.ReadLine();
if (string.IsNullOrWhiteSpace(message))
{
continue;
}
//SingleTest(provider, message, logger);
CodeTimerTest(provider, message, logger);
}
}
/// <summary> 添加本地Json配置 </summary>
/// <param name="builder"></param>
/// <param name="dirPath"></param>
/// <returns></returns>
public static ISpearConfigBuilder AddLocal(this ISpearConfigBuilder builder, string dirPath = null)
{
var configPath = string.IsNullOrWhiteSpace(dirPath) ? "configPath".Config <string>() : dirPath;
if (string.IsNullOrWhiteSpace(configPath))
{
return(builder);
}
configPath = Path.Combine(Directory.GetCurrentDirectory(), configPath);
if (!Directory.Exists(configPath))
{
return(builder);
}
CurrentIocManager.CreateLogger(typeof(ConfigBuilderExtensions)).LogInformation($"正在加载本地配置[{configPath}]");
var jsons = Directory.GetFiles(configPath, "*.json");
if (jsons.Any())
{
foreach (var json in jsons)
{
builder.AddJsonFile(json, false, true);
}
}
return(builder);
}
public object Get(string key, Type type)
{
if (_config == null)
{
SetConfig(CreateDefaultBuilder().Build());
}
if (type.IsSimpleType() || type.IsEnum)
{
var str = _config.GetValue <string>(key);
return(GetEnvOrValue(str, type));
}
////枚举类型处理
//if (type.IsEnum)
// return _config.GetValue<string>(key).CastTo(defaultValue);
try
{
//区分大小写
return(_config.GetSection(key).Get(type));
}
catch (Exception ex)
{
CurrentIocManager.CreateLogger <ConfigHelper>().LogError(ex, ex.Message);
return(null);
}
}
/// <summary> 路由处理 </summary>
/// <param name="context"></param>
/// <returns></returns>
public Task RouteAsync(RouteContext context)
{
var requestedUrl = context.HttpContext.Request.Path.Value.Trim('/');
if (string.IsNullOrWhiteSpace(requestedUrl))
{
context.Handler = async ctx => await WriteJsonAsync(ctx, Methods.Keys);
return(Task.CompletedTask);
}
requestedUrl = requestedUrl.ToLower();
//健康状态
if (requestedUrl == "healthy")
{
context.Handler = async ctx => await ctx.Response.WriteAsync("ok");
return(Task.CompletedTask);
}
if (!Methods.TryGetValue(requestedUrl, out var method))
{
context.Handler = async ctx =>
await WriteJsonAsync(ctx, DResult.Error($"{requestedUrl} not found"), (int)HttpStatusCode.NotFound);
return(Task.CompletedTask);
}
var instance = CurrentIocManager.Resolve(method.DeclaringType);
context.Handler = async ctx => await Runner(ctx, instance, method);
return(Task.CompletedTask);
}
public MicroEntryFactory()
{
_logger = LogManager.Logger <MicroEntryFactory>();
_methods = new ConcurrentDictionary <string, MethodInfo>();
_typeFinder = CurrentIocManager.Resolve <ITypeFinder>();
InitServices();
}
/// <summary> 订阅配置 </summary>
/// <param name="modules">模块</param>
/// <param name="env">环境模式</param>
/// <returns></returns>
public async Task Subscript(string[] modules, string env)
{
if (string.IsNullOrWhiteSpace(Code))
{
return;
}
Logger.LogInformation($"hub:{Context.ConnectionId} Subscript {env} - {string.Join(',', modules)}");
foreach (var mode in modules)
{
await Groups.AddToGroupAsync(Context.ConnectionId, $"{Code}_{mode}_{env}");
}
if (ProjectId.IsNotNullOrEmpty())
{
using var scope = CurrentIocManager.BeginLifetimeScope();
var contract = scope.Resolve <IConfigContract>();
var dict = new Dictionary <string, object>();
foreach (var module in modules)
{
var config = await contract.GetAsync(ProjectId, module, env);
dict.Add(module, config);
}
await Clients.Caller.SendAsync("UPDATE", dict);
}
}
/// <summary> RabbitMQ事件总线 </summary>
/// <param name="connection"></param>
/// <param name="subsManager"></param>
/// <param name="messageCodec"></param>
public EventBusRabbitMq(IRabbitMqConnection connection, ISubscribeManager subsManager, IMessageCodec messageCodec)
: base(subsManager, messageCodec, connection?.Name)
{
_connection =
connection ?? throw new ArgumentNullException(nameof(connection));
_brokerName = connection.Broker;
_logger = CurrentIocManager.CreateLogger <EventBusRabbitMq>();
SubscriptionManager.OnEventRemoved += SubsManager_OnEventRemoved;
}
protected DRepository(IUnitOfWork unitOfWork)
{
UnitOfWork = unitOfWork;
_connProvider = CurrentIocManager.Resolve <IDbConnectionProvider>();
Logger = CurrentIocManager.CreateLogger(GetType());
if (Logger.IsEnabled(LogLevel.Debug))
{
Logger.LogDebug($"{GetType().Name} Create");
}
}
public RabbitMessageQueue(IRabbitMqConnection connection, string queue)
{
_connection = connection;
_encoding = Encoding.UTF8;
_logger = CurrentIocManager.CreateLogger <RabbitMessageQueue>();
_queue = queue;
Channel.ExchangeDeclare(_connection.Broker, ExchangeType.Direct, false, true);
Channel.QueueDeclare(_queue, true, false, false);
Channel.QueueBind(_queue, _connection.Broker, _queue);
}
protected void ConsumerTo <TEvent, TConsumer>()
where TConsumer : IEventHandler <TEvent>
where TEvent : class
{
var consumer = CurrentIocManager.Resolve <TConsumer>();
var name = consumer.GetType().GetCustomAttribute <NamingAttribute>();
var eventBus = _provider.GetEventBus(name?.Name);
eventBus.Subscribe <TEvent, TConsumer>(() => consumer);
}
//private static readonly object SyncObj = new object();
private UnitOfWork()
{
Id = Guid.NewGuid();
_connProvider = CurrentIocManager.Resolve <IDbConnectionProvider>();
_connections = new ConcurrentDictionary <int, Lazy <IDbConnection> >();
_logger = CurrentIocManager.CreateLogger(GetType());
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"{GetType().Name}:{Id} Create");
}
}
public static List <Type> GetServices()
{
if (_services != null)
{
return(_services);
}
_services = CurrentIocManager.Resolve <ITypeFinder>()
.Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService))
.ToList();
return(_services);
}
/// <summary> 根据编码获取项目 </summary>
/// <param name="context"></param>
/// <returns></returns>
public static ProjectDto GetProjectByToken(this HttpContext context)
{
var ticket = context.GetTicket();
if (ticket?.ProjectId == null)
{
return(null);
}
using var scope = CurrentIocManager.BeginLifetimeScope();
var contract = scope.Resolve <IProjectContract>();
return(contract.DetailAsync(ticket.ProjectId).SyncRun());
}
/// <summary> 根据编码获取项目 </summary>
/// <param name="context"></param>
/// <returns></returns>
public static ProjectDto GetProjectByCode(this HttpContext context)
{
var code = context.GetProjectCode();
if (string.IsNullOrWhiteSpace(code))
{
return(null);
}
using var scope = CurrentIocManager.BeginLifetimeScope();
var contract = scope.Resolve <IProjectContract>();
return(contract.DetailByCodeAsync(code).SyncRun());
}
/// <summary> 开启微服务 </summary>
/// <param name="provider"></param>
/// <param name="addressAction"></param>
/// <returns></returns>
public static void UseMicroService(this IServiceProvider provider, Action <ServiceAddress> addressAction = null)
{
if (CurrentIocManager.IocManager == null)
{
CurrentIocManager.SetIocManager(new DefaultIocManager(provider));
}
var address = SpearConfig.GetConfig().Service;
addressAction?.Invoke(address);
var host = provider.GetService <IMicroHost>();
Task.Factory.StartNew(async() => await host.Start(address));
}
/// <summary> 建立连接 </summary>
/// <returns></returns>
public override async Task OnConnectedAsync()
{
Logger.LogInformation($"hub:{Context.ConnectionId} Connected,{RemoteAddress()}");
var context = CurrentIocManager.Resolve <IHttpContextFeature>()?.HttpContext;
var code = context.GetProject();
if (code == null)
{
return;
}
Context.Items.Add(ProjectKey, code);
await Connected();
await base.OnConnectedAsync();
}
public Task RouteAsync(RouteContext context)
{
var requestedUrl = context.HttpContext.Request.Path.Value.Trim('/');
var arrs = requestedUrl.Split('/');
if (arrs == null || arrs.Length != 2)
{
return(Task.CompletedTask);
}
var service = arrs[0];
var method = arrs[1];
var type = GetServices().FirstOrDefault(t =>
string.Equals(t.Name, service, StringComparison.CurrentCultureIgnoreCase));
if (type == null)
{
return(Task.CompletedTask);
}
var instance = CurrentIocManager.Resolve(type);
var m = instance.GetType().GetMethod(method, BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);
if (m == null)
{
return(Task.CompletedTask);
}
context.Handler = async ctx =>
{
var input = ctx.Request.Body;
string html;
using (var stream = new StreamReader(input))
{
html = stream.ReadToEnd();
}
var arg = JsonConvert.DeserializeObject(html, m.GetParameters()[0].ParameterType);
var result = m.Invoke(instance, new[] { arg });
var response = ctx.Response;
response.ContentType = "application/json";
var bytes = Encoding.ASCII.GetBytes(JsonHelper.ToJson(result));
await response.Body.WriteAsync(bytes, 0, bytes.Length);
};
return(Task.CompletedTask);
}
/// <summary> 初始化服务 </summary>
internal static void InitServices()
{
var services = CurrentIocManager.Resolve <ITypeFinder>()
.Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService))
.ToList();
foreach (var service in services)
{
var assKey = service.Assembly.AssemblyKey();
if (!ServiceAssemblies.Contains(assKey))
{
ServiceAssemblies.Add(assKey);
}
var methods = service.GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var method in methods)
{
Methods.TryAdd($"{service.Name}/{method.Name}".ToLower(), method);
}
}
}
private async Task LocalExecute(InvokeMessage invokeMessage, ResultMessage result)
{
try
{
var service = _entryFactory.Find(invokeMessage.ServiceId);
var args = new List <object>();
var parameters = invokeMessage.Parameters ?? new Dictionary <string, object>();
foreach (var parameter in service.GetParameters())
{
if (parameters.ContainsKey(parameter.Name))
{
var parameterType = parameter.ParameterType;
args.Add(parameters[parameter.Name].CastTo(parameterType));
}
else
{
args.Add(parameter.DefaultValue);
}
}
var instance = CurrentIocManager.Resolve(service.DeclaringType);
var data = service.Invoke(instance, args.ToArray());
if (!(data is Task task))
{
result.Data = data;
}
else
{
await task;
var taskType = task.GetType().GetTypeInfo();
if (taskType.IsGenericType)
{
var prop = taskType.GetProperty("Result");
if (prop != null)
{
result.Data = prop.GetValue(task);
}
}
}
}
public DefaultRabbitMqConnection(RabbitMqConfig config = null)
{
config = config ?? RabbitMqConfig.Config();
if (string.IsNullOrWhiteSpace(config?.Host))
{
throw new ArgumentException(nameof(config));
}
_connectionFactory = new ConnectionFactory {
HostName = config.Host, Port = config.Port
};
if (!string.IsNullOrWhiteSpace(config.VirtualHost))
{
_connectionFactory.VirtualHost = config.VirtualHost;
}
if (!string.IsNullOrWhiteSpace(config.User))
{
_connectionFactory.UserName = config.User;
_connectionFactory.Password = config.Password;
}
_logger = CurrentIocManager.CreateLogger <DefaultRabbitMqConnection>();
Broker = config.Broker;
}
/// <summary> 自动创建数据库(自动备份) </summary>
/// <param name="path">路径</param>
/// <param name="password">密码(可选)</param>
public static void AutoCreateDb(this string path, string password = null)
{
if (File.Exists(path))
{
//备份
var dir = Path.GetDirectoryName(path);
var name = Path.GetFileNameWithoutExtension(path);
var ext = Path.GetExtension(path);
var backupPath = $"{dir}/__old_{name}_{DateTime.Now:yyyyMMddHHmm}{ext}";
var fi = new FileInfo(path);
fi.MoveTo(backupPath);
}
var finder = CurrentIocManager.Resolve <ITypeFinder>();
var tableTypes = finder.Find(t => t.BaseType == typeof(BaseEntity <string>)).Take(1);
var sql = new StringBuilder();
foreach (var tableType in tableTypes)
{
sql.AppendLine(tableType.CreateTableSql());
}
using (var conn = path.CreateConnection())
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
if (!string.IsNullOrWhiteSpace(password))
{
//设置密码
cmd.CommandText = $"PRAGMA key = {password};";
cmd.ExecuteNonQuery();
}
cmd.CommandText = sql.ToString();
cmd.ExecuteNonQuery();
}
}
}
/// <summary> 添加任务日志 </summary>
/// <param name="record"></param>
/// <returns></returns>
public async Task <int> InsertAsync(TJobRecord record)
{
const string sql =
"UPDATE [t_job_trigger] SET [prev_time]=@start WHERE [id] = @id;" +
"UPDATE [t_job_trigger] SET [times]=[times]-1 WHERE [id] = @id AND [type]=2 AND [times]>0;";
var fmtSql = Connection.FormatSql(sql);
return(await Transaction(async (conn, trans) =>
{
try
{
var count = await conn.ExecuteAsync(fmtSql, new { id = record.TriggerId, start = record.StartTime },
trans);
count += await conn.InsertAsync(record, trans: trans);
return count;
}
catch (Exception ex)
{
CurrentIocManager.CreateLogger <JobRecordRepository>().LogError(ex, "添加任务日志异常");
throw;
}
}));
}
/// <summary> 执行事务 </summary>
/// <param name="manager"></param>
/// <param name="eventName"></param>
/// <param name="data"></param>
/// <returns></returns>
public static async Task ProcessEvent(this ISubscribeManager manager, string eventName, byte[] data)
{
var codec = CurrentIocManager.Resolve <IMessageCodec>();
if (manager.HasSubscriptionsForEvent(eventName))
{
var eventType = manager.GetEventTypeByName(eventName);
var @event = codec.Decode(data, eventType);
var handlers = manager.GetHandlersForEvent(eventName);
foreach (var handlerfactory in handlers)
{
var handler = handlerfactory.DynamicInvoke();
var concreteType = typeof(IEventHandler <>).MakeGenericType(eventType);
var method = concreteType.GetMethod("Handle");
if (method == null)
{
continue;
}
await(Task) method.Invoke(handler, new[] { @event });
}
}
}
public async Task Execute(IJobExecutionContext context)
{
var record = new JobRecordDto
{
Id = IdentityHelper.Guid32,
StartTime = Clock.Now,
TriggerId = context.Trigger.Key.Name
};
try
{
var data = context.JobDetail.JobDataMap.Get(Constants.JobData).CastTo <T>();
if (data == null)
{
throw new BusiException("任务数据异常");
}
record.JobId = data.Id;
await ExecuteJob(data, record);
record.Status = RecordStatus.Success;
}
catch (Exception ex)
{
record.Remark = ex.Message;
if (!(ex is BusiException))
{
Logger.LogError(ex, ex.Message);
}
record.Status = RecordStatus.Fail;
}
finally
{
record.CompleteTime = Clock.Now;
var repository = CurrentIocManager.Resolve <IJobContract>();
var result = await repository.AddRecordAsync(record);
}
}
/// <summary> 初始化服务 </summary>
private void InitServices()
{
if (_typeFinder == null)
{
return;
}
var services = _typeFinder
.Find(t => typeof(IMicroService).IsAssignableFrom(t) && t.IsInterface && t != typeof(IMicroService))
.ToList();
foreach (var service in services)
{
if (!CurrentIocManager.IsRegisted(service))
{
continue;
}
var methods = service.GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var method in methods)
{
var serviceId = GenerateServiceId(method);
_methods.TryAdd(serviceId, method);
}
}
}
///// <summary> 从body中读取对象 </summary>
///// <typeparam name="T"></typeparam>
///// <returns></returns>
//[NonAction]
//protected async Task<T> FromBody<T>()
//{
// return await AcbHttpContext.FromBody<T>();
//}
/// <summary> 获取IOC注入 </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
protected T Resolve <T>()
{
return(Current?.RequestServices != null
? Current.RequestServices.GetService <T>()
: CurrentIocManager.Resolve <T>());
}