JavaWeb项目架构之Redis分布式日志队列-SpringBoot实例

#配置redis
#在RedisProperties.class有redis的默认配置，默认host为localhost,默认端口为6379
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.maxIdle=3
spring.redis.maxTotal=20

package com.niugang;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.niugang.mq.MessageDelegate;
import com.niugang.mq.MessageDelegateImpl;
import redis.clients.jedis.JedisPoolConfig;


@Configuration
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfig {
        public String host;
public int port;
public int maxIdle;
public int maxTotal;
@Bean
public JedisConnectionFactory jedisConnectionFactory() {
JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
jedisConnectionFactory.setHostName(host);
jedisConnectionFactory.setPort(port);
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxTotal(maxTotal);
jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
return jedisConnectionFactory;
}
  // 默认用的是用JdkSerializationRedisSerializer进行序列化的
@Bean
@SuppressWarnings({ "rawtypes", "unchecked" })
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
// 注入数据源
redisTemplate.setConnectionFactory(jedisConnectionFactory());
// 使用Jackson2JsonRedisSerialize 替换默认序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
               // 设置value的序列化规则和 key的序列化规则
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
     @Bean
public StringRedisTemplate stringRedisTemplate() {
return new StringRedisTemplate(jedisConnectionFactory());
}


// ################发布订阅配置###################################
@Bean
public MessageDelegate messageDelegate() {
return new MessageDelegateImpl();
}
      @Bean
public MessageListenerAdapter messageListener() {
MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(messageDelegate());
return messageListenerAdapter;


}
/**
* RedisMessageListenerContainer充当消息侦听器容器;它用于接收来自Redis通道的消息，
* 并驱动注入到其中的MessageListeners。侦听器容器负责消息接收的所有线程，并将消息分派到侦听器中进行处理。
* 消息侦听器容器是MDP(message-driven POJOs)和消息传递提供程序之间的中介 负责注册接收消息，资源获取和发布，异常。
* 
* 转换等
*/
      @Bean
public RedisMessageListenerContainer redisContainer() {
RedisMessageListenerContainer con = new RedisMessageListenerContainer();
con.setConnectionFactory(jedisConnectionFactory());
ChannelTopic channelTopic = new ChannelTopic("log_queue");
con.addMessageListener(messageListener(), channelTopic);
return con;
}
public String getHost() {
return host;
}
        public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public int getMaxIdle() {
return maxIdle;
}
public void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
}
public int getMaxTotal() {
return maxTotal;
}
public void setMaxTotal(int maxTotal) {
this.maxTotal = maxTotal;
}
}

package com.niugang.annotation;
/**
 * 日志类型常量类
 * @author niugang
 *
 */
public class LogType {
   public static final String OPERATE_LOG="redis:operate:log";
}

package com.niugang.aop;
import java.lang.reflect.Method;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import com.niugang.annotation.LogApi;

@Aspect
@Component
public class LogAscept {

      @Autowired
private RedisTemplate<String, String> redisTemplate;

@Around("@annotation(com.niugang.annotation.LogApi)")
public Object aroundAdvice(ProceedingJoinPoint pjd) throws Throwable {
Object proceed = pjd.proceed();
MethodSignature signature = (MethodSignature)pjd.getSignature();
Method method = signature.getMethod();
LogApi logApi= method.getAnnotation(LogApi.class);
//调用redis发布消息
messageQueue(logApi);
return proceed; // 必须得有返回值，否则不能往下执行
}

private void messageQueue(LogApi logApi) {
String value = logApi.value();
String type = logApi.type();
JSONObject jsonObject = new JSONObject();
jsonObject.put("value", value);
jsonObject.put("type", type);
if(StringUtils.isNotBlank(value)){
redisTemplate.convertAndSend("log_queue", jsonObject.toJSONString());
}

}
}