/// <summary>
/// 获取消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="routingKey"></param>
/// <param name="handler">消费处理</param>
private void Pull <T>(string exchange, string queue, string routingKey, Action <T> handler) where T : class
{
var channel = GetModel(exchange, queue, routingKey);
var result = channel.BasicGet(queue, false);
if (result.IsNullOrEmpty())
{
return;
}
var msg = SerializerJson.DeserializeObject <T>(result.Body.StreamToStr());
try
{
handler(msg);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
channel.BasicAck(result.DeliveryTag, false);
}
}
/// <summary>
/// 接收消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void Subscribe <T>(Action <T> handler) where T : class
{
//每次消费的消息数
_channel.BasicQos(0, 1, false);
RabbitMessageQueueOptions queueOptions = RabbitQueueOptionsUtil.ReaderByQueue(_queueName);
_channel.ExchangeDeclare(queueOptions.ExchangeName, ExchangeType.Direct);
_channel.QueueDeclare(_queueName, true, false, false, null);
_channel.QueueBind(_queueName, queueOptions.ExchangeName, queueOptions.RoutingKeys);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
string messageId = ea.BasicProperties.MessageId;//消息Id
try
{
handler(msg);
}
catch (Exception ex)
{
Console.WriteLine($"队列：{_queueName}，MessageId：{messageId}", ex);
}
finally
{
_channel.BasicAck(ea.DeliveryTag, false);
}
};
_channel.BasicConsume(_queueName, false, consumer);
}
/// <summary>
/// RPC服务端
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="exchange"></param>
/// <param name="queue"></param>
/// <param name="isProperties"></param>
/// <param name="handler"></param>
/// <param name="isDeadLetter"></param>
public void RpcService <T>(string exchange, string queue, bool isProperties, Func <T, T> handler, bool isDeadLetter)
{
//队列声明
var channel = GetModel(queue, isProperties);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
var props = ea.BasicProperties;
var replyProps = channel.CreateBasicProperties();
replyProps.CorrelationId = props.CorrelationId;
try
{
msg = handler(msg);
}
catch (Exception ex)
{
//ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
}
finally
{
channel.BasicPublish(exchange, props.ReplyTo, replyProps, SerializerJson.SerializeObject(msg).StrToByte());
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queue, false, consumer);
}
/// <summary>
/// 接收消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void Subscribe <T>(string queue, bool isProperties, Action <T> handler, bool isDeadLetter) where T : class
{
//队列声明
var channel = GetModel(queue, isProperties);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (model, ea) =>
{
var body = ea.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
try
{
handler(msg);
}
catch (Exception ex)
{
//ex.GetInnestException().WriteToFile("队列接收消息", "RabbitMq");
if (!isDeadLetter)
{
PublishToDead <DeadLetterQueue>(queue, msgStr, ex);
}
}
finally
{
channel.BasicAck(ea.DeliveryTag, false);
}
};
channel.BasicConsume(queue, false, consumer);
}
private T ConvertObj <T>(RedisValue value)
{
if (value.HasValue)
{
return(SerializerJson.DeserializeObject <T>(value));
}
return(default(T));
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="Message"></param>
/// <returns></returns>
private static bool SendMessage <T>(MessageParam <T> param) where T : class
{
AccessToken token = WUserHelp.GetAccessToken();
RestClient client = new RestClient(string.Format("{0}?access_token={1}", Host.Message, token.access_token));
IRestRequest request = new RestRequest(Method.POST);
request.AddJsonBody(param);
IRestResponse response = client.Execute(request);
JsApiBase jsApiBase = SerializerJson.DeserializeObject <JsApiBase>(response.Content);;
return(jsApiBase.errcode == 0);
}
/// <summary>
/// 获到Ticket
/// </summary>
/// <param name="Code"></param>
/// <returns></returns>
public static Ticket GetTicket(string Code)
{
AccessToken token = GetAccessToken(Code);
RestClient client = new RestClient(Host.Ticket);
IRestRequest request = new RestRequest(Method.GET);
request.AddParameter("access_token", token.access_token);
request.AddParameter("type", "jsapi");
IRestResponse response1 = client.Execute(request);
Ticket ticket = SerializerJson.DeserializeObject <Ticket>(response1.Content);
return(ticket);
}
/// <summary>
/// 普通获取Token
/// </summary>
/// <returns></returns>
public static AccessToken GetAccessToken()
{
RestClient client = new RestClient(Host.BaseAccessToken);
IRestRequest request = new RestRequest(Method.GET);
request.AddParameter("appid", JsApiConfig.AppId);
request.AddParameter("secret", JsApiConfig.AppSecret);
request.AddParameter("grant_type", "client_credential");
IRestResponse response = client.Execute(request);
AccessToken token = SerializerJson.DeserializeObject <AccessToken>(response.Content);;
return(token);
}
/// <summary>
/// 订阅
/// </summary>
/// <param name="Topic"></param>
public static async Task Subscribe <F>(string Topic, Action <F> action) where F : class
{
using (IMqttClient client = GetMqttClient())
{
await Subscribe(Topic);
if (action != null)
{
client.ApplicationMessageReceived += (o, s) =>
{
string json = Encoding.UTF8.GetString(s.ApplicationMessage.Payload);
action(SerializerJson.DeserializeObject <F>(json));
};
}
}
}
/// <summary>
/// 获到用户信息
/// </summary>
public static UserInfo GetUser(string Code)
{
AccessToken token = GetAccessToken(Code);
RestClient userclient = new RestClient(Host.UserInfo);
IRestRequest userrequest = new RestRequest(Method.GET);
userrequest.AddParameter("access_token", token.access_token);
userrequest.AddParameter("openid", token.openid);
userrequest.AddParameter("lang", "zh_CN");
IRestResponse userresponse = userclient.Execute(userrequest);
UserInfo userInfo = SerializerJson.DeserializeObject <UserInfo>(userresponse.Content);
string openid = userInfo.openid;
if (userInfo.errcode == 40029)
{
return(null);
}
return(userInfo);
}
/// <summary>
/// 拉取指定队列的消息
/// </summary>
/// <param name="queueName">队列名称</param>
/// <param name="autoAck">是否自动应答（true表示自动应答；false则需要手动应答）</param>
/// <returns></returns>
public void Pull <T>(Action <T> handler) where T : class
{
BasicGetResult result = _channel.BasicGet(_queueName, false);
if (result != null)
{
var body = result.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
string messageId = result.BasicProperties.MessageId;//消息Id
try
{
handler(msg);
}
catch (Exception ex)
{
Console.WriteLine($"队列：{_queueName}，MessageId：{messageId}", ex);
}
finally
{
_channel.BasicAck(result.DeliveryTag, false);
}
}
}
/// <summary>
/// 接收消息
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="queue">队列名称</param>
/// <param name="isProperties"></param>
/// <param name="handler">消费处理</param>
/// <param name="isDeadLetter"></param>
public void SubscribeRetry <T>(Action <T> handler) where T : class
{
//每次消费的消息数
_channel.BasicQos(0, 1, false);
RabbitMessageQueueOptions queueOptions = RabbitQueueOptionsUtil.ReaderByQueue(_queueName);
_channel.ExchangeDeclare(queueOptions.ExchangeName, queueOptions.ExchangeType, queueOptions.Persistent);
_channel.QueueDeclare(_queueName, true, false, false, null);
_channel.QueueBind(_queueName, queueOptions.ExchangeName, queueOptions.RoutingKeys);
var retryDic = new Dictionary <string, object>
{
{ "x-dead-letter-exchange", queueOptions.ExchangeName },
{ "x-dead-letter-routing-key", queueOptions.RoutingKeys }
};
_channel.ExchangeDeclare(queueOptions.ExchangeName.GetRetrySuffixName(), queueOptions.ExchangeType);
_channel.QueueDeclare(_queueName.GetRetrySuffixName(), true, false, false, retryDic);
_channel.QueueBind(_queueName.GetRetrySuffixName(), queueOptions.ExchangeName.GetRetrySuffixName(), queueOptions.RoutingKeys.GetRetrySuffixName());
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += (model, ea) =>
{
bool canAck = false; //应答结果
int retryCount = 0; //第几次重试
string messageId = ea.BasicProperties.MessageId;
IDictionary <string, object> headers = ea.BasicProperties.Headers;
if (headers != null && headers.ContainsKey(RetryCountKeyName))
{
retryCount = (int)headers[RetryCountKeyName]; retryCount++;
Console.WriteLine($"队列：{_queueName}，MessageId：{messageId}，第：{retryCount}次重试开始！！！");
//Logger.Info($"队列：{_queueName}，MessageId：{messageId}，第：{retryCount}次重试开始！！！");
}
try
{
var body = ea.Body;
var msgStr = body.StreamToStr();
var msg = SerializerJson.DeserializeObject <T>(msgStr);
handler(msg);
canAck = true;
}
catch (Exception ex)
{
Console.WriteLine($"队列：{_queueName}，MessageId：{messageId}，第：{retryCount}次消费发生异常：", ex);
//Logger.Error($"队列：{_queueName}，MessageId：{messageId}，第：{retryCount}次消费发生异常：", ex);
if (CanRetry(retryCount))
{
RetryHandler(retryCount, queueOptions.ExchangeName.GetRetrySuffixName(), queueOptions.RoutingKeys.GetRetrySuffixName(), ea);
canAck = true;
}
else
{
canAck = false;
}
}
//处理应答
AnswerHandler(canAck, ea);
};
_channel.BasicConsume(_queueName, false, consumer);
}
/// <summary>
/// 获取一个key的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T StringGet <T>(string key)
{
return(SerializerJson.DeserializeObject <T>(StringGet(key)));
}
private static void InitRedis(RedisEntityConfig redisconfig)
{
CSRedisClient client = null;
if (redisconfig.RedisMode == "Single")
{
client = new CSRedisClient(redisconfig.RedisConnectionSingle);
}
else if (redisconfig.RedisMode == "Multiple")
{
client = new CSRedisClient(null, redisconfig.RedisConnectionMultiple.ToArray());
}
else
{
throw new Exception("Redis初始化异常!,请检查配置文件");
}
RedisHelper.Initialization(client, value => SerializerJson.SerializeObject(value), deserialize: (data, type) => SerializerJson.DeserializeObject(data, type));
}
private static void InitRedis(ref IServiceCollection services, RedisEntityConfig redisconfig)
{
CSRedisClient client = null;
if (redisconfig.RedisMode == "Single")
{
client = new CSRedisClient(redisconfig.RedisConnectionSingle);
}
else if (redisconfig.RedisMode == "Multiple")
{
client = new CSRedisClient(null, redisconfig.RedisConnectionMultiple.ToArray());
}
else
{
throw new Exception("Redis初始化异常!,请检查配置文件");
}
RedisHelper.Initialization(client, value => SerializerJson.SerializeObject(value), deserialize: (data, type) => SerializerJson.DeserializeObject(data, type));
services.AddSingleton <IDistributedCache>(new TKBase.Framework.Redis.CSRedisCache(RedisHelper.Instance));
}