_muggle
_muggle

log模块配置

logback配置全解析

作者：muggle
Logback是由log4j创始人设计的另一个开源日志组件,分为三个模块：

  1. logback-core：其它两个模块的基础模块

  2. logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging

  3. logback-access：访问模块与Servlet容器集成提供通过Http来访问日志的功能
    在springboot中我们通过xml配置来操作logback

springboot中logback的默认配置文件名称为logback-spring.xml，若需要指定xml名称，需在application.properties（application.yml）中配置logging.config=xxxx.xml
现在贴出一份logback的xml配置，可直接使用，懒得看的小伙伴复制粘贴到你的项目中去体验吧






    

    
    

    
        
            
                %d{yyyy-MM-dd HH:mm:ss.SSS} %highlight([%-5level]) %logger - %msg%n
            
        
    
    
        
            
                ${log_dir}/%d{yyyy-MM-dd}-poseidon.log
            
            ${maxHistory}
        
        
            
                %d{yyyy-MM-dd HH:mm:ss.SSS} %highlight([%-5level]) %logger - %msg%n
            
        
    

    

        
            ${log_dir}/runningTime/%d{yyyy-MM-dd}-poseidon.log
            ${maxHistory}
        
        
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n
        
    
    
        
            
                %d{yyyy-MM-dd HH:mm:ss.SSS} [%-5level] %logger - %msg%n
            
        
    
    
        
        
    

    
        
            
                com.mysql.cj.jdbc.Driver
                jdbc:mysql://xxx/xxxx?characterEncoding=UTF-8
                xx
                xxxx

我们可以看到xml中有四种节点
appender，logger，root,configuration

节点解读

configuration包含三个属性：

  1. scan: 当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
  2. scanPeriod: 设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒。当scan为true时，此属性生效。默认的时间间隔为1分钟。
  3. debug: 当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。

Logger作为日志的记录器，把它关联到应用的对应的context上后，主要用于存放日志对象，也可以定义日志类型、级别。

Appender主要用于指定日志输出的目的地，目的地可以是控制台、文件、远程套接字服务器、 MySQL、PostreSQL、 Oracle和其他数据库、 JMS和远程UNIX Syslog守护进程等。

root 就是最高级别logger,所有不被指定logger的日志都归root管理。

在slf4j框架下我们使用log是这样的:

 private static final Logger logger= LoggerFactory.getLogger(xxx.class);

或者

 private static final Logger logger= LoggerFactory.getLogger("xxxx");

可以理解为代码中的getLogger() 方法就是获取xml配置中的logger,如果没有配置相应的logger则为root
比如我配置了：

那我在获得一个logger时可以这样获得它：

 private static final Logger logger= LoggerFactory.getLogger("hhh");

我所输出的日志将被这个logger所管理
logger 上有三个配置 name level additivity
name就是这个logger的名称，level就是这个日志过滤的级别，低于这个级别的日志不输入到对应的appender中；additivity是否向上级logger传递打印信息，默认是true。logger中可以配置多个appender-ref，也就是可以指定多个输出地点。
而root只是特殊的logger，用法上无差别

appender节点：
appender节点是logback配置的关键，其name属性指定其名称，class属性指定实现类，对应得实现类有

ch.qos.logback.core.ConsoleAppender // 以控制台作为输出
ch.qos.logback.core.rolling.RollingFileAppender//以日志文件作为输出
ch.qos.logback.classic.db.DBAppender//以数据库作为输出
net.logstash.logback.appender.LogstashTcpSocketAppender//以logstash作为输出需要引入如下依赖：
ch.qos.logback.classic.AsyncAppender//异步输出 需要定义appender-ref

// logstash依赖

  net.logstash.logback
  logstash-logback-encoder
  4.11

所有的appender 实现ch.qos.logback.core.Appender接口或者 ch.qos.logback.core.UnsynchronizedAppenderBase接口（异步），我们也可以自定义appender来指定日志输出；

在Appender中可以定义哪些节点我们一个个来看：

第一种： ConsoleAppender
如同它的名字一样，这个Appender将日志输出到console，更准确的说是System.out 或者System.err。
它包含的参数如下：

Property Name Type Description
encoder Encoder 通常在其pattern里指定日志格式 如： %d{yyyy-MM-dd HH:mm:ss.SSS} %highlight([%-5level]) %logger - %msg%n表示 日期格式 日志级别（高亮）logger的名称 logger的message
target String 指定输出目标。可选值：System.out 或 System.err。默认值：System.out
withJansi boolean 是否支持ANSI color codes（类似linux中的shell脚本的输出字符串颜色控制代码）。默认为false。如果设置为true。例如：[31m 代表将前景色设置成红色。在windows中，需要提供"org.fusesource.jansi:jansi:1.9"，而在linux，mac os x中默认支持。

第二种： FileAppender
将日志输出到文件当中，目标文件取决于file属性。是否追加输出，取决于append属性。

Property Name Type Description
append boolean 是否以追加方式输出。默认为true。
encoder Encoder See OutputStreamAppender properties.
file String 指定文件名。注意在windows当中，反斜杠 \ 需要转义，或直接使用 / 也可以。例如 c:/temp/test.logor 或 c:\temp\test.log 都可以。没有默认值，如果上层目录不存在，FileAppender会自动创建。
prudent boolean 是否工作在谨慎模式下。在谨慎模式下，FileAppender将会安全写入日志到指定文件，即时在不同的虚拟机jvm中有另一个相同的FileAppender实例。默认值：fales;设置为true，意味着append会被自动设置成true。prudent依赖于文件排它锁。实验表明，使用文件锁，会增加3倍的日志写入消耗。比如说，当prudent模式为off，写入一条日志到文件只要10毫秒，但是prudent为真，则会接近30毫秒。prudent 模式实际上是将I/O请求序列化，因此在I/O数量较大，比如说100次/s或更多的时候，带来的延迟也会显而易见，所以应该避免。在networked file system（远程文件系统）中，这种消耗将会更大，可能导致死锁。

第三个： RollingFileAppender

RollingFileAppender继承自FileAppender，提供日志目标文件自动切换的功能。例如可以用日期作为日志分割的条件。
RollingFileAppender有两个重要属性，RollingPolicy负责怎么切换日志，TriggeringPolicy负责何时切换。为了使RollingFileAppender起作用，这两个属性必须设置，但是如果RollingPolicy的实现类同样实现了TriggeringPolicy接口，则也可以只设置RollingPolicy这个属性。
下面是它的参数：

Property Name Type Description
file String 指定文件名。注意在windows当中，反斜杠 \ 需要转义，或直接使用 / 也可以。例如 c:/temp/test.logor 或 c:\temp\test.log 都可以。没有默认值，如果上层目录不存在，FileAppender会自动创建。
append boolean 是否以追加方式输出。默认为true。
encoder Encoder See OutputStreamAppender properties.
rollingPolicy RollingPolicy 当发生日志切换时，RollingFileAppender的切换行为。例如日志文件名的修改
triggeringPolicy TriggeringPolicy 决定什么时候发生日志切换，例如日期，日志文件大小到达一定值
prudent boolean FixedWindowRollingPolicy 不支持prudent模式。TimeBasedRollingPolicy 支持prudent模式，但是需要满足一下两条约束：在prudent模式中，日志文件的压缩是不被允许，不被支持的。不能设置file属性。

第四个：SocketAppender及SSLSocketAppender（未尝试过）

到目前为止我们讲的appender都只能将日志输出到本地资源。与之相对的，SocketAppender就是被设计用来输出日志到远程实例中的。SocketAppender输出日志采用明文方式，SSLSocketAppender则采用加密方式传输日志。
被序列化的日志事件的类型是 LoggingEventVO 继承ILoggingEvent接口。远程日志记录并非是侵入式的。在反序列化接收后，日志事件就可以好像在本地生成的日志一样处理了。多个SockerAppender可以向同一台日志服务器发送日志。SocketAppender并不需要关联一个Layout，因为它只是发送序列化的日志事件给远程日志服务器。SocketAppender的发送操作是基于TCP协议的。因此如果远程服务器是可到达的，则日志会被其处理，如果远程服务器宕机或不可到达，那么日志将会被丢弃。等到远程服务器复活，日志发送将会透明的重新开始。这种透明式的重连，是通过一个“连接“线程周期性的尝试连接远程服务器实现的。
Logging events会由TCP协议实现自动缓冲。这意味着，如果网络速度比日志请求产生速度快，则网络速度并不会影响应用。但如果网络速度过慢，则网络速度则会变成限制，在极端情况下，如果远程日志服务器不可到达，则会导致应用最终阻塞。不过，如果服务器可到达，但是服务器宕机了，这种情况，应用不会阻塞，而只是丢失一些日志事件而已。
需要注意的是，即使SocketAppender没有被logger链接，它也不会被gc回收，因为他在connector thread中任然存在引用。一个connector thread 只有在网络不可达的情况下，才会退出。为了防止这个垃圾回收的问题，我们应该显示声明关闭SocketAppender。长久存活并创建/销毁大量的SocketAppender实例的应用，更应该注意这个问题。不过大多数应用可以忽略这个问题。如果JVM在SocketAppender关闭之前将其退出，又或者是被垃圾回收，这样子可能导致丢失一些还未被传输，在管道中等待的日志数据。为了防止避免日志丢失，经常可靠的办法就是调用SocketAppender的close方法，或者调用LoggerContext的stop方法，在退出应用之前。

下面我们来看看SocketAppender的属性：

Property Name Type Description
includeCallerData boolean 是否包含调用者的信息如果为true，则以下日志输出的 ?:? 会替换成调用者的文件名跟行号，为false，则为问号。2019-01-06 17:37:30,968 DEBUG [Thread-0] [?:?] chapters.appenders.socket.SocketClient2 - Hi
port int 端口号
reconnectionDelay Duration 重连延时，如果设置成“10 seconds”，就会在连接u武器失败后，等待10秒，再连接。默认值：“30 seconds”。如果设置成0，则关闭重连功能。
queueSize int 设置缓冲日志数，如果设置成0，日志发送是同步的，如果设置成大于0的值，会将日志放入队列，队列长度到达指定值，在统一发送。可以加大服务吞吐量。
eventDelayLimit Duration 设置日志超时丢弃时间。当设置“10 seconds”类似的值，如果日志队列已满，而服务器长时间来不及接收，当滞留时间超过10 seconds，日志就会被丢弃。默认值： 100 milliseconds
remoteHost String 远程日志服务器的IP
ssl SSLConfiguration 只在SSLSocketAppender包含该属性节点。提供SSL配置，详情见 Using SSL.

标准的Logback Classic包含四个可供使用的Receiver用来接收来自SocketAppender的logging evnets。

第五个： SMTPAppender

SMTPAppender 可以将logging event存放在一个或多个固定大小的缓冲区中，然后在用户指定的event到来之时，将适当的大小的logging event以邮件方式发送给运维人员。
详细属性如下：

Property Name Type Description
smtpHost String SMTP server的地址，必需指定。如网易的SMTP服务器地址是： smtp.163.com
smtpPort int SMTP server的端口地址。默认值：25
to String 指定发送到那个邮箱，可设置多个属性，指定多个目的邮箱
from String 指定发件人名称。如果设置成“muggle ”，则邮件发件人将会是“muggle [email protected] ”
subject String 指定emial的标题，它需要满足PatternLayout中的格式要求。如果设置成“Log: %logger - %msg”，就案例来讲，则发送邮件时，标题为“Log: com.foo.Bar - Hello World ”。 默认值："%logger{20} - %m".
discriminator Discriminator 通过Discriminator, SMTPAppender可以根据Discriminator的返回值，将到来的logging event分发到不同的缓冲区中。默认情况下，总是返回相同的值来达到使用一个缓冲区的目的。
evaluator IEvaluator 指定触发日志发送的条件。通过指定EventEvaluator接口的实现类。默认情况下SMTPAppeender使用的是OnErrorEvaluator，表示当发送ERROR或更高级别的日志请求时，发送邮件。Logback提供了几个evaluators：OnErrorEvaluator、OnMarkerEvaluator、JaninoEventEvaluator、GEventEvaluator（功能强大）
cyclicBufferTracker CyclicBufferTracker 指定一个cyclicBufferTracker跟踪cyclic buffer。它是基于discriminator的实现的。如果你不指定，默认会创建一个CyclicBufferTracker ，默认设置cyclic buffer大小为256。你也可以手动指定使用默认的CyclicBufferTracker，并且通过属性修改默认的缓冲区接收多少条logging event。
username String 发送邮件账号，默认为null
password String 发送邮件密码，默认为null
STARTTLS boolean 如果设置为true，appender会尝试使用STARTTLS命令，如果服务端支持，则会将明文连接转换成加密连接。需要注意的是，与日志服务器连接一开始是未加密的。默认值：false
SSL boolean 如果设置为true，appender将会使用SSL连接到日志服务器。 默认值：false
charsetEncoding String 指定邮件信息的编码格式 默认值：UTF-8
localhost String 如果smtpHost没有正确配置，比如说不是完整的地址。这时候就需要localhost这个属性提供服务器的完整路径（如同java中的完全限定名 ），详情参考com.sun.mail.smtp 中的mail.smtp.localhost属性
asynchronousSending boolean 这个属性决定email的发送是否是异步。默认：true，异步发送但是在某些情况下，需要以同步方式发送错误日志的邮件给管理人员，防止不能及时维护应用。
includeCallerData boolean 默认：false 指定是否包含callerData在日志中
sessionViaJNDI boolean SMTPAppender依赖javax.mail.Session来发送邮件。默认情况下，sessionViaJNDI为false。javax.mail.Session实例的创建依赖于SMTPAppender本身的配置信息。如果设置为true，则Session的创建时通过JNDI获取引用。这样做的好处可以让你的代码复用更好，让配置更简洁。需要注意的是，如果使用JNDI获取Session对象，需要保证移除mail.jar以及activation.jar这两个jar包
jndiLocation String 如果sessionViaJNDI设置为true，则jndiLocation指定JNDI的资源名，默认值为："java:comp/env/mail/Session"

SMTPAppender只保留最近的256条logging events 在循环缓冲区中，当缓冲区慢，就会开始丢弃最老的logging event。因此不管什么时候，SMTPAppender一封邮件最多传递256条日志事件。SMTPAppender依赖于JavaMail API。而JavaMail API又依赖于IOC框架（依赖注入）。

第六个：DBAppender

DBAppender 可以将日志事件插入到3张数据表中。它们分别是logging_event，logging_event_property，logging_event_exception。这三张数据表必须在DBAppender工作之前存在。它们的sql脚本可以在 logback-classic/src/main/java/ch/qos/logback/classic/db/script folder 这个目录下找到。这个脚本对大部分SQL数据库都是有效的，除了少部分，少数语法有差异需要调整。
下面是logback与常见数据库的支持信息：

RDBMS tested version(s) tested JDBC driver version(s) supports getGeneratedKeys() method is a dialect provided by logback
DB2 untested untested unknown NO
H2 -- - unknown YES
HSQL -- - NO YES
Microsoft SQL Server -- -- YES YES
MySQL 5.7 YES YES
PostgreSQL -- -- NO YES
Oracle -- -- YES YES
SQLLite -- - unknown YES
Sybase -- - unknown YES

下面给出三张表的sql语句：

BEGIN;
DROP TABLE IF EXISTS logging_event_property;
DROP TABLE IF EXISTS logging_event_exception;
DROP TABLE IF EXISTS logging_event;
COMMIT;

BEGIN;
CREATE TABLE logging_event
  (
    timestmp         BIGINT NOT NULL,
    formatted_message  TEXT NOT NULL,
    logger_name       VARCHAR(254) NOT NULL,
    level_string      VARCHAR(254) NOT NULL,
    thread_name       VARCHAR(254),
    reference_flag    SMALLINT,
    arg0              VARCHAR(254),
    arg1              VARCHAR(254),
    arg2              VARCHAR(254),
    arg3              VARCHAR(254),
    caller_filename   VARCHAR(254) NOT NULL,
    caller_class      VARCHAR(254) NOT NULL,
    caller_method     VARCHAR(254) NOT NULL,
    caller_line       CHAR(4) NOT NULL,
    event_id          BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY
  );
COMMIT;


BEGIN;
CREATE TABLE logging_event_property
  (
    event_id       BIGINT NOT NULL,
    mapped_key        VARCHAR(254) NOT NULL,
    mapped_value      TEXT,
    PRIMARY KEY(event_id, mapped_key),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;


BEGIN;
CREATE TABLE logging_event_exception
  (
    event_id         BIGINT NOT NULL,
    i                SMALLINT NOT NULL,
    trace_line       VARCHAR(254) NOT NULL,
    PRIMARY KEY(event_id, i),
    FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
  );
COMMIT;

第七个： AsyncAppender

AsyncAppender记录ILoggingEvents的方式是异步的。它仅仅相当于一个event分配器，因此需要配合其他appender才能有所作为。

需要注意的是：AsyncAppender将event缓存在 BlockingQueue ，一个由AsyncAppender创建的工作线程，会一直从这个队列的头部获取events，然后将它们分配给与AsyncAppender唯一关联的Appender中。默认情况下，如果这个队列80%已经被占满，则AsyncAppender会丢弃等级为 TRACE，DEBUG，INFO这三个等级的日志事件。
在应用关闭或重新部署的时候，AsyncAppender一定要被关闭，目的是为了停止，回收再利用worker thread，和刷新缓冲队列中logging events。那如果关闭AsyncAppender呢？可以通过关闭LoggerContext来关闭所有appender，当然也包括AsyncAppender了。AsyncAppender会在maxFlushTime属性设置的时间内等待Worker thread刷新全部日志event。如果你发现缓冲的event在关闭LoggerContext的时候被丢弃，这时候你就也许需要增加等待的时间。将maxFlushTime设置成0，就是AsyncAppender一直等待直到工作线程将所有被缓冲的events全部刷新出去才执行才结束。
根据JVM退出的模式，工作线程worker thread处理被缓冲的events的工作是可以被中断的，这样就导致了剩余未处理的events被搁浅。这种现象通常的原因是当LoggerContext没有完全关闭，或者当JVM终止那些非典型的控制流（不明觉厉）。为了避免工作线程的因为这些情况而发生中断，一个shutdown hook（关闭钩子）可以被插入到JVM运行的时候，这个钩子的作用是在JVM开始shutdown刚开始的时候执行关闭 LoggerContext的任务。

下面是AsyncAppender的属性表

Property Name Type Description
queueSize int 设置blocking queue的最大容量，默认是256条events
discardingThreshold int 默认，当blocking queue被占用80%以上，AsyncAppender就会丢弃level为 TRACE，DEBUG，INFO的日志事件，如果要保留所有等级的日志，需要设置成0
includeCallerData boolean 提取CallerData代价比较昂贵，为了提高性能，caller data默认不提供。只有一些获取代价较低的数据，如线程名称，MDC值才会被保留。如果设置为true，就会包含caller data
maxFlushTime int 设置最大等待刷新事件，单位为miliseconds(毫秒)。当LoggerContext关闭的时候，AsyncAppender会在这个时间内等待工作线程完成events的flush工作，超时未处理的events将会被抛弃。
neverBlock boolean 默认为false，如果队列被填满，为了处理所有日志，就会阻塞的应用。如果为true，为了不阻塞你的应用，也会选择抛弃一些message。

默认情况下，event queue最大的容量是256。如果队列被填充满那么就会阻塞你的应用，直到队列能够容纳新的logging event。所以当AsyncAppender工作在队列满的情况下，可以称作伪同步。
在以下四种情况下容易导致AsyncAppender伪同步状态的出现：

  1. 应用中存在大量线程
  2. 每秒产生大量的logging events
  3. 每一个logging event都存在大量的数据
  4. 子appender中存在很高的延迟

为了避免伪同步的出现，提高queueSizes普遍有效，但是就消耗了应用的可用内存。

下面列出一些 appender配置示例：



  
    myapp.log
    
      %logger{35} - %msg%n
    
  

  
    
  

  
    
  




  
    
      
        com.mysql.jdbc.Driver
        jdbc:mysql://${serverName}:${port}/${dbName}
        ${user}
        ${password}
      
    
  

  
    
  



  
    smtp.gmail.com
    465
    true
    [email protected]
    YOUR_GMAIL_PASSWORD

    EMAIL-DESTINATION
    ANOTHER_EMAIL_DESTINATION 
    [email protected]
    TESTING: %logger{20} - %m
    
      %date %-5level %logger{35} - %message%n
    
  

  
    
  



  
    smtp.gmail.com
    587
    true
    [email protected]
    YOUR_GMAIL_xPASSWORD

    EMAIL-DESTINATION
    ANOTHER_EMAIL_DESTINATION 
    [email protected]
    TESTING: %logger{20} - %m
    
      %date %-5level %logger - %message%n
    
  

  
    
  


SimpleSocketServer需要两个命令行参数，port 和 configFile路径。(该方法待验证)
java ch.qos.logback.classic.net.SimpleSocketServer 6000 \ src/main/java/chapters/appenders/socket/server1.xml

客户端的SocketAppender的简单配置例子：


  
    192.168.0.101
    8888
    10000
    true
  

  
    
  



在服务端使用SimpleSSLSocketServer
java -Djavax.net.ssl.keyStore=src/main/java/chapters/appenders/socket/ssl/keystore.jks \ -Djavax.net.ssl.keyStorePassword=changeit \ ch.qos.logback.classic.net.SimpleSSLSocketServer 6000 \ src/main/java/chapters/appenders/socket/ssl/server.xml

SSLSocketAppender配置


  
    ${host}
    ${port}
    10000
    
      
        ${truststore}
        ${password}
      
    
  

  
    
  





  
    testFile.log
    true
    
    
      %-4relative [%thread] %-5level %logger{35} - %msg%n

参考：https://blog.csdn.net/tianyaleixiaowu/article/details/73327752

下面基于logback配置做一个请求日志的的封装

功能：记录每次请求的参数和用户ID存入数据库或者elk
问题：javaee规范中request输入输出流都只能被读取一次，所以如果用过滤器或者拦截器读取request中的流都会导致后面的controller无法接受到数据。
所以我们要用原生的aop获得请求参数，切点为controller，这就很好的避开了以上问题。

package com.muggle.poseidon.core.aspect;

import com.muggle.poseidon.manager.UserInfoManager;
import com.muggle.poseidon.utils.RequestUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;

/**
 * @program: hiram_erp
 * @description: 日志信息切面
 * @author: muggle
 * @create: 2019-02-21
 **/
@Aspect
@Component
public class LogMessageAspect {

    private final static Logger logger = LoggerFactory.getLogger("requestLog");
//    private final static Logger timeLog = LoggerFactory.getLogger(LogMessageAspect.class);
    private static final ThreadLocal threadLocal = new ThreadLocal<>();
    @Pointcut("execution(public * com.hiram.erp.controller.*.*(..))")
    public void webLog() {}

    /**
     * 在切点之前织入
     * @param joinPoint
     * @throws Throwable
     */
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
//        System.out.println("sssssssssssssssssssssssssssssssssssssssssssssssssssss");
       /* // 开始打印请求日志
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 打印请求相关参数
        // 打印请求 url
        // 请求id
        Long userId=null;
        if (user!=null){
            userId=user.getUserInfo().getUserId();
        }
        logger.info("URL : {}, 登录id: {} ,HTTP Method: {},ip :{},Request Args : {}", request.getRequestURL().toString(),userId, request.getMethod(),request.getRemoteAddr());
*/    }

    /**
     * 在切点之后织入
     * @throws Throwable
     */
    @After("webLog()")
    public void doAfter(JoinPoint joinPoint) throws Throwable {



    }

    /**
     * 环绕
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("webLog()")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        // 打印出参
//        logger.info("Response Args  : {},", JSONObject.toJSONString(result),new Date());
        // 执行耗时
        // 开始打印请求日志
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        HttpServletResponse response = attributes.getResponse();
        String requestURL = request.getRequestURL().toString();
        if (requestURL.contains("/sys/log_info/")){
            return result;
        }
        // 打印请求相关参数
        // 打印请求 url
        // 请求id
        String userId = UserInfoManager.getUserId();

        String url = request.getRequestURL().toString();
        String method = request.getMethod();
        String remoteAddr = RequestUtils.getIpAddr(request);
        Object[] args = joinPoint.getArgs();
//        List objects=new ArrayList<>();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i=0;i 
 
对于数据库存储，如果我们希望log存在另外一个数据库中不存在项目里的数据库中，并且可以通过持久化框架查询数据库内信息。我们则可以配置多数据源，如果将日志放在同一个数据库中则直接配置appender就行了，很方便。
 多数据源配置mybatis版：
 
 
其原理是配置多个sessionfactory,然后根据不同的mapperscan来区分不同mapper对应的数据库
 
 
以druid连接池为例
 
 
application.yml
 
 
log:
  datasource:
    druid:
      url: ${mysql_url}/log?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true
      username:
      password:
      driver-class-name: com.mysql.cj.jdbc.Driver
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      filters: stat,wall
      initialSize: 5
      maxActive: 20
      maxPoolPreparedStatementPerConnectionSize: 20
      maxWait: 60000
      minIdle: 5
      poolPreparedStatements: true
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      validationQuery: SELECT 1


spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      url: ${mysql_url}/hiram_erp?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true
      username:
      password:
      driver-class-name: com.mysql.cj.jdbc.Driver
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      filters: stat,wall
      initialSize: 5
      maxActive: 20
      maxPoolPreparedStatementPerConnectionSize: 20
      maxWait: 60000
      minIdle: 5
      poolPreparedStatements: true
      testOnBorrow: false
      testOnReturn: false
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      validationQuery: SELECT 1

 
 

@Configuration
// 主数据库配置 指定mapper位置
@MapperScan(basePackages = {"com.muggle.poseidon.mapper"}, sqlSessionTemplateRef = "sqlSessionTemplate")
public class ManySourceDBConfig {

    @Bean(name = "dataSource")
    // 读取application的配置信息
   @ConfigurationProperties(prefix = "spring.datasource.druid")
   // 最高优先级，表示系统默认使用该配置
    @Primary
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();

        List filterList = new ArrayList<>();

        filterList.add(wallFilter());

        druidDataSource.setProxyFilters(filterList);

        return druidDataSource;
    }

    @Bean(name = "sqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(this.dataSource());

        Properties props = new Properties();
        props.setProperty("localCacheScope", "true");
        props.setProperty("lazyLoadingEnabled", "true");
        props.setProperty("aggressiveLazyLoading", "false");
        props.setProperty("jdbcTypeForNull", "NULL");
        sqlSessionFactoryBean.setConfigurationProperties(props);
        sqlSessionFactoryBean.setVfs(SpringBootVFS.class);
        //pageHelper
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("params", "count=countSql");
        properties.setProperty("pageSizeZero", "true");
        PageInterceptor interceptor = new PageInterceptor();
        interceptor.setProperties(properties);
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{interceptor});
        sqlSessionFactoryBean.setTypeAliasesPackage("com.muggle.poseidon.model");
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath*:/mapper/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean(name = "transactionManager")
    @Primary
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(this.dataSource());
    }

    @Bean(name = "sqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public ServletRegistrationBean statViewServlet() {
        ServletRegistrationBean druid = new ServletRegistrationBean();
        druid.setServlet(new StatViewServlet());
        druid.setUrlMappings(Collections.singletonList("/druid/*"));
        Map params = new HashMap<>();
        params.put("loginUsername", "");
        params.put("loginPassword", "");
        druid.setInitParameters(params);
        return druid;
    }

    @Bean
    public FilterRegistrationBean webStatFilter() {
        FilterRegistrationBean fitler = new FilterRegistrationBean();
        fitler.setFilter(new WebStatFilter());
        fitler.setUrlPatterns(Collections.singletonList("/*"));
        fitler.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return fitler;
    }

    @Bean
    public WallFilter wallFilter() {

        WallFilter wallFilter = new WallFilter();

        wallFilter.setConfig(wallConfig());

        return wallFilter;

    }

    @Bean
    public WallConfig wallConfig() {

        WallConfig config = new WallConfig();

        config.setMultiStatementAllow(true);//允许一次执行多条语句

        config.setNoneBaseStatementAllow(true);//允许非基本语句的其他语句

        return config;

    }

    @Bean
    public ProcessEngineConfiguration processEngineConfiguration() {
        ProcessEngineConfiguration pec = StandaloneProcessEngineConfiguration.createStandaloneProcessEngineConfiguration();
        pec.setDataSource(dataSource());
        //如果表不存在，自动创建表
        pec.setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);
        //属性asyncExecutorActivate定义为true，工作流引擎在启动时就建立启动async executor线程池
        pec.setAsyncExecutorActivate(false);
        return pec;
    }


    @Bean
    public ProcessEngine processEngine() {
        return processEngineConfiguration().buildProcessEngine();
    }

}


 
 
log数据库配置
 
 



/**
 * @program:
 * @description:
 * @author: muggle
 * @create: 2019-02-23
 **/
@Configuration
// 注意确保主配置无法扫描到这个包
@MapperScan(basePackages = "com.muggle.poseidon.logmapper", sqlSessionTemplateRef  = "test1SqlSessionTemplate")

public class LogDBConfig  {
    @Bean(name = "test1DataSource")
    @ConfigurationProperties(prefix = "log.datasource.druid")
    public DataSource dataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();

        List filterList = new ArrayList<>();

        filterList.add(wallFilter());

        druidDataSource.setProxyFilters(filterList);

        return druidDataSource;
    }

    @Bean(name = "test1SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new
        // mapper位置，不要和主配置的mapper放到一起
         PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/log/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "test1TransactionManager")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public WallFilter wallFilter() {

        WallFilter wallFilter = new WallFilter();

        wallFilter.setConfig(wallConfig());

        return wallFilter;

    }
    @Bean
    public WallConfig wallConfig() {

        WallConfig config = new WallConfig();

        config.setMultiStatementAllow(true);//允许一次执行多条语句

        config.setNoneBaseStatementAllow(true);//允许非基本语句的其他语句

        return config;

    }
}


 
 
多数据源jpa版
 
 
package com.muggle.poseidon.config;


import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    /**
     * 扫描spring.datasource.primary开头的配置信息
     *
     * @return 数据源配置信息
     */
    @Primary
    @Bean(name = "primaryDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取主库数据源对象
     *
     * @param properties 注入名为primaryDataSourceProperties的bean
     * @return 数据源对象
     */
    @Primary
    @Bean(name = "primaryDataSource")
    public DataSource dataSource(@Qualifier("primaryDataSourceProperties") DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder().build();
    }

    /**
     * 该方法仅在需要使用JdbcTemplate对象时选用
     *
     * @param dataSource 注入名为primaryDataSource的bean
     * @return 数据源JdbcTemplate对象
     */
    @Primary
    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }




}


 
 
package com.muggle.poseidon.config;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Map;


@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        // repository包名
        basePackages = "com.muggle.poseidon.repos",
        // 实体管理bean名称
        entityManagerFactoryRef = "primaryEntityManagerFactory",
        // 事务管理bean名称
        transactionManagerRef = "primaryTransactionManager"
)
public class MainDataBaseConfig {

    /**
     * 扫描spring.jpa.primary开头的配置信息
     *
     * @return jpa配置信息
     */
    @Primary
    @Bean(name = "primaryJpaProperties")
    @ConfigurationProperties(prefix = "spring.jpa")
    public JpaProperties jpaProperties() {
        return new JpaProperties();
    }

    /**
     * 获取主库实体管理工厂对象
     *
     * @param primaryDataSource 注入名为primaryDataSource的数据源
     * @param jpaProperties     注入名为primaryJpaProperties的jpa配置信息
     * @param builder           注入EntityManagerFactoryBuilder
     * @return 实体管理工厂对象
     */
    @Primary
    @Bean(name = "primaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("primaryDataSource") DataSource primaryDataSource
            , @Qualifier("primaryJpaProperties") JpaProperties jpaProperties, EntityManagerFactoryBuilder builder) {
        return builder
                // 设置数据源
                .dataSource(primaryDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置hibernate配置
                .properties(jpaProperties.getHibernateProperties(new HibernateSettings()))
                // 设置实体包名
                .packages("com.muggle.poseidon.model")
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }

    /**
     * 获取实体管理对象
     *
     * @param factory 注入名为primaryEntityManagerFactory的bean
     * @return 实体管理对象
     */
    @Primary
    @Bean(name = "primaryEntityManager")
    public EntityManager entityManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
        return factory.createEntityManager();
    }

    /**
     * 获取主库事务管理对象
     *
     * @param factory 注入名为primaryEntityManagerFactory的bean
     * @return 事务管理对象
     */
    @Primary
    @Bean(name = "primaryTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }
}

```java
package com.muggle.poseidon.core.config;


import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        // repository包名
        basePackages = "com.muggle.poseidon.logrep",
        // 实体管理bean名称
        entityManagerFactoryRef = "secondEntityManagerFactory",
        // 事务管理bean名称
        transactionManagerRef = "secondTransactionManager"
)
public class LogDataBaseConfig {

    /**
     * 扫描spring.jpa.second开头的配置信息
     *
     * @return jpa配置信息
     */
    @Bean(name = "secondJpaProperties")
    @ConfigurationProperties(prefix = "spring.aa")
    public JpaProperties jpaProperties() {
        return new JpaProperties();
    }

    /**
     * 获取从库实体管理工厂对象
     *
     * @param secondDataSource 注入名为secondDataSource的数据源
     * @param jpaProperties    注入名为secondJpaProperties的jpa配置信息
     * @param builder          注入EntityManagerFactoryBuilder
     * @return 实体管理工厂对象
     */
    @Bean(name = "secondEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("secondDataSource") DataSource secondDataSource
            , @Qualifier("secondJpaProperties") JpaProperties jpaProperties, EntityManagerFactoryBuilder builder) {
        return builder
                // 设置数据源
                .dataSource(secondDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置hibernate配置
                .properties(jpaProperties.getHibernateProperties(new HibernateSettings()))
                // 设置实体包名
                .packages("com.muggle.poseidon.entity")
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("secondPersistenceUnit")
                .build();
    }

    /**
     * 获取实体管理对象
     *
     * @param factory 注入名为secondEntityManagerFactory的bean
     * @return 实体管理对象
     */
    @Bean(name = "secondEntityManager")
    public EntityManager entityManager(@Qualifier("secondEntityManagerFactory") EntityManagerFactory factory) {
        return factory.createEntityManager();
    }

    /**
     * 获取从库事务管理对象
     *
     * @param factory 注入名为secondEntityManagerFactory的bean
     * @return 事务管理对象
     */
    @Bean(name = "secondTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("secondEntityManagerFactory") EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }
}


 
 

package com.muggle.poseidon.core.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class LogDataConfig {
    /**
     * 扫描spring.datasource.second开头的配置信息
     *
     * @return 数据源配置信息
     */
    @Bean(name = "secondDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.ss")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取从库数据源对象
     *
     * @param properties 注入名为secondDataSourceProperties的beanf
     * @return 数据源对象
     */
    @Bean(name = "secondDataSource")
    public DataSource dataSource(@Qualifier("secondDataSourceProperties") DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder().build();
    }

    /**
     * 该方法仅在需要使用JdbcTemplate对象时选用
     *
     * @param dataSource 注入名为secondDataSource的bean
     * @return 数据源JdbcTemplate对象
     */
    @Bean(name = "secondJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("secondDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}


 
 
application.properties
 
 
server.port=8080
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.datasource.driverClassName = com.mysql.cj.jdbc.Driver
spring.datasource.url = jdbc:mysql://119.23.75.58:3306/poseidon?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true
spring.datasource.username =
spring.datasource.password =
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

spring.jpa.database=mysql
spring.jpa.show-sql = true
#配置方言
spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect

spring.ss.type=com.alibaba.druid.pool.DruidDataSource
#spring.datasource.url = jdbc:mysql://localhost:3306/test
spring.ss.driverClassName = com.mysql.cj.jdbc.Driver
spring.ss.url = jdbc:mysql://zzzzz/log?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowMultiQueries=true
spring.ss.username =
spring.ss.password =
spring.ss.max-active=20
spring.ss.max-idle=8
spring.ss.min-idle=8
spring.ss.initial-size=10


spring.aa.database=mysql
spring.aa.show-sql = true
#配置方言
spring.aa.database-platform=org.hibernate.dialect.MySQL5Dialect

 
 
以数据库作为输出配置就算完成了，接下来整合elk系统到我们日志系统中：
 
 
先整合logstash
 
 
logstash安装和配置：
 https://www.elastic.co/cn/downloads/logstash 选择zip包下载
 
 
解压，进入bin目录 创建logstash.conf 并配置：
 
 
input {
    tcp {
    ##host:port就是上面appender中的 destination，这里其实把logstash作为服务，开启9250端口接收logback发出的消息
    host => "127.0.0.1"
    port => 9100
    mode => "server"
    tags => ["tags"]
    codec => json_lines
    }
}
output {
    stdout { codec => rubydebug }
    #输出到es
    #elasticsearch { hosts => "127.0.0.1:9200" }
        #输出到一个文件中
    file {
       path => "D:\logs\test.log"
       codec => line
    }
}


 
 
我这里先配置输出到文件，后面再修改,创建文件：D:\logs\test.log
 
 
启动：
 
 
打开cmd（不要使用powershell），进入bin:
 
 
D:\exe\logstash-6.6.1\logstash-6.6.1\bin>logstash -f logstash.conf

 
 
然后在我们的项目中进行相应的配置：
 按这个来：https://github.com/logstash/logstash-logback-encoder
 
 
加入pom并指定logback版本：
 
 

1.2.3



  net.logstash.logback
  logstash-logback-encoder
  5.3
  
        
  
    ch.qos.logback
    logback-classic
    1.2.3
  

 
 
配置apppender和logger
 
 

    127.0.0.1:9100
    true

    
        true
    
  
  
      
  

 
 
测试：
 
 
RestController
@RequestMapping("/public/log")
public class LogTestController {
    private static final Logger log = LoggerFactory.getLogger("logstash");
    @Autowired
    LoggingEventRepository repository;

    @GetMapping("/")
    public String test(){
        log.info("sssssssssssssss");
        Iterable all = repository.findAll();

        return "sss";

    }
}

 
 
访问接口，logstash打印信息：
 
 
[2019-03-09T11:32:56,358][INFO ][logstash.outputs.file    ] Opening file {:path=>"D:/logs/test.log"}
{
                  "host" => "www.xmind.net",
                 "level" => "INFO",
     "caller_class_name" => "com.muggle.poseidon.controller.LogTestController",
            "@timestamp" => 2019-03-09T03:33:03.413Z,
           "logger_name" => "logstash",
              "@version" => "1",
           "thread_name" => "http-nio-8080-exec-9",
               "message" => "sssssssssssssss",
    "caller_line_number" => 22,
                  "port" => 58368,
           "level_value" => 20000,
      "caller_file_name" => "LogTestController.java",
                  "tags" => [
        [0] "tags"
    ],
    "caller_method_name" => "test"
}

 
 
test.log输出了文件：
 
 
2019-03-09T03:33:03.413Z www.xmind.net sssssssssssssss

 
 
接下来只要把输出路径换成ES就可以了，这属于logstash和es的整合，这里先不讲解；重新回归到我们的请求模块：
 
 
我希望我的模块，对每次请求都能记录下来（请求日志），并将记录存到数据库或者ES，同时我要对所有接口都进行一个幂等性的保障；保障接口的幂等性有多种方法，比较简单的是数据库做唯一索引或者加拦截器，我这里加了一个拦截器来保障接口幂等和拦截前端数据的重复提交(关于接口幂等性在其他文档中介绍)：
 
 
@Slf4j
public class RequestLockInterceptor implements HandlerInterceptor {
    RedisLock redisTool;
    private int expireTime;

    public RequestLockInterceptor(int expireTime, RedislockImpl redisTool) {
        this.expireTime = expireTime;
        this.redisTool = redisTool;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        if("post".equalsIgnoreCase(request.getMethod())){
            String token = request.getParameter("request_key");
            if (token==null||"".equals(token)){
                log.error("请求非法");
//            throw new PoseidonException("请求太频繁",PoseidonProperties.TOO_NUMBER_REQUEST);
                response.setContentType("application/json;charset=UTF-8");
                PrintWriter writer = response.getWriter();
                writer.write("{\"code\":\"5001\",\"msg\":\"请求非法\"}");
                writer.close();
                return false;
            }
            String ipAddr = RequestUtils.getIpAddr(request);
            String lockKey = request.getRequestURI() + "_"  + "_" + token;
            boolean lock = redisTool.lock(lockKey, ipAddr, expireTime);
            if (!lock) {//
                log.error("拦截表单重复提交");
//            throw new PoseidonException("请求太频繁",PoseidonProperties.TOO_NUMBER_REQUEST);
                response.setContentType("application/json;charset=UTF-8");
                PrintWriter writer = response.getWriter();
                writer.write("{\"code\":\"5001\",\"msg\":\"请求太频繁\"}");
                writer.close();
                return false;
            }
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
//        String requestURI = request.getRequestURI();
//        String lockKey = request.getRequestURI() + "_" + RequestUtils.getIpAddr(request);
//        redisTool.unlock(lockKey,getIpAddr(request));
    }


}


 
 
项目使用了redis锁（redis锁原理和使用在其他文档中介绍）
 
 
对于系统异常，如果是业务的异常，正常处理，如果是系统发生的异常比如空指针，数据库异常等我希望系统能马上通知，以便排查问题，所以我配置邮件异常通知(关于springboot邮件配置其他文档介绍)：
 
 

@RestControllerAdvice
@Slf4j
public class RestExceptionHandlerController {
    @Autowired
    EmailService emailService;
    @Value("${admin.email}")
    private String adminEmail;

    @ExceptionHandler(value = {PoseidonException.class})
    public ResultBean poseidonExceptionHandler(PoseidonException e, HttpServletRequest req) {
        return new ResultBean().setMsg(e.getMsg()).setCode(e.getCode());
    }
    @ExceptionHandler(value = {MethodArgumentNotValidException.class})
    public ResultBean MethodArgumentNotValidException(MethodArgumentNotValidException e, HttpServletRequest req) {
        System.out.println(e.getMessage());
        return new ResultBean().setMsg("数据未通过校验").setCode(PoseidonProperties.COMMIT_DATA_ERROR);
    }

    @ExceptionHandler(value = {Exception.class})
    public ResultBean exceptionHandler(Exception e, HttpServletRequest req) {
        log.error("系统异常：" + req.getMethod() + req.getRequestURI(), e);
        try {
//
            EmailBean emailBean = new EmailBean();
            emailBean.setRecipient(adminEmail);
            emailBean.setSubject("poseidon---系统异常");
            emailBean.setContent("系统异常：" + req.getMethod() + req.getRequestURI()+"----"+e.getMessage());
//            改良
            emailService.sendSimpleMail(emailBean);
        } finally {
            return new ResultBean().setMsg("系统异常，请联系管理员").setCode("500");
        }
    }

    @ExceptionHandler(value = {HttpRequestMethodNotSupportedException.class})
    public ResultBean notsupported(Exception e, HttpServletRequest req) {
        return new ResultBean().setMsg("不支持的请求方式").setCode(PoseidonProperties.NOT_SUPPORT_METHOD);
    }
    @ExceptionHandler(value = {NoHandlerFoundException.class})
    public ResultBean notFoundUrl(Exception e, HttpServletRequest req) {
        return new ResultBean().setMsg("请求路径不存在").setCode("404");
    }
}


 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(log模块配置)

        

            

                
    
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • html 中如何使用 uniapp 的部分方法
                        某公司摸鱼前端
htmluni-app前端
                        
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • python os.environ
                        江湖偌大
python深度学习
                        
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
    
                    
    • 
                    
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    
                    
    • 
                    
  • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • log4j配置
                        yy爱yy

                        
    #log4j.rootLogger配置的是大于等于当前级别的日志信息的输出#log4j.rootLogger用法:（注意appenderName可以是一个或多个）#log4j.rootLogger=日志级别,appenderName1,appenderName2,....#log4j.appender.appenderName2定义的是日志的输出方式，有两种：一种是命令行输出或者叫控制台输出，另一
    
                    
    • 
                    
  • git - Webhook让部署自动化
                        大猪大猪

                        
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
    
                    
    • 
                    
  • MYSQL面试系列-04
                        king01299
面试mysql面试
                        
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • 第六集如何安装CentOS7.0，3分钟学会centos7安装教程
                        date分享

                        
    从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
    
                    
    • 
                    
  • 高级 ECharts 技巧：自定义图表主题与样式
                        SnowMan1993
echarts信息可视化数据分析
                        
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
    
                    
    • 
                    
  • 01-Git初识
                        Meereen
Gitgit
                        
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • 【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
    
                    
    • 
                    
  • 【无标题】达瓦达瓦
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • 上图为是否色发
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • docker
                        igotyback
eureka云原生
                        
    Docker容器的文件系统是隔离的，但是可以通过挂载卷（Volumes）或绑定挂载（BindMounts）将宿主机的文件系统目录映射到容器内部。要查看Docker容器的映射路径，可以使用以下方法：查看容器配置：使用dockerinspect命令可以查看容器的详细配置信息，包括挂载的卷。例如：bashdockerinspect在输出的JSON格式中，查找"Mounts"部分，这里会列出所有的挂载信息
    
                    
    • 
                    
  • 【Git】常见命令(仅笔记)
                        好想有猫猫
GitLinux学习笔记git笔记elasticsearchlinuxc++
                        
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1）
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
    
                    
    • 
                    
  • 143234234123432
                        JhonKI
考研
                        
    博客主页：https://blog.csdn.net/2301_779549673欢迎点赞收藏⭐留言如有错误敬请指正！本文由JohnKi原创，首发于CSDN未来很长，值得我们全力奔赴更美好的生活✨文章目录前言111️‍111❤️111111111111111总结111前言111骗骗流量券，嘿嘿111111111111111111111111111️‍111❤️111111111111111总结11
    
                    
    • 
                    
  • Linux MariaDB使用OpenSSL安装SSL证书
                        Meta39
MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
                        
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
    
                    
    • 
                    
  • Python中深拷贝与浅拷贝的区别
                        yuxiaoyu.

                        
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
    
                    
    • 
                    
  • Python开发常用的三方模块如下：
                        换个网名有点难
python开发语言
                        
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
    
                    
    • 
                    
  • 【六】阿伟开始搭建Kafka学习环境
                        能源恒观
中间件学习kafkaspring
                        
    阿伟开始搭建Kafka学习环境概述上一篇文章阿伟学习了Kafka的核心概念，并且把市面上流行的消息中间件特性进行了梳理和对比，方便大家在学习过程中进行对比学习，最后梳理了一些Kafka使用中经常遇到的Kafka难题以及解决思路，经过上一篇的学习我相信大家对Kafka有了初步的认识，本篇将继续学习Kafka。一、安装和配置学习一项技术首先要搭建一套服务，而Kafka的运行主要需要部署jdk、zook
    
                    
    • 
                    
  • ExpRe[25] bash外的其它shell：zsh和fish
                        tritone
ExpRebashlinuxubuntushell
                        
    文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
    
                    
    • 
                    
  • openssl+keepalived安装部署
                        _小亦_
项目部署keepalivedopenssl
                        
    文章目录OpenSSL安装下载地址编译安装修改系统配置版本Keepalived安装下载地址安装遇到问题安装完成配置文件keepalived运行检查运行状态查看系统日志修改服务service重新加载systemd检查配置文件语法错误OpenSSL安装下载地址考虑到后面设备可能没法连接到外网，所以采用安装包的方式进行部署，下载地址：https://www.openssl.org/source/old/
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                                
  • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
    
                                
    • 
                                
  • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
    (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
    
                                
    • 
                                
  • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
    Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
    
                                
    • 
                                
  • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
    
                                
    • 
                                
  • 重绘之画图板
                                    朱辉辉33
画图板
                                    
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
    
                                
    • 
                                
  • Java的IO流
                                    西蜀石兰
java
                                    
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
    
                                
    • 
                                
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
    
                                
    • 
                                
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
    
                                
    • 
                                
  • JS 格式化时间
                                    alxw4616
JavaScript
                                    
    /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
    
                                
    • 
                                
  • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
      
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
    
                                
    • 
                                
  • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
    Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
    
                                
    • 
                                
  • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
    扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
    
                                
    • 
                                
  • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
    浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
    
                                
    • 
                                
  • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
     1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
    
                                
    • 
                                
  • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
    
                                
    • 
                                
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
    
                                
    • 
                                
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
    
                                
    • 
                                
  • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
     
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
    
                                
    • 
                                
  • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
    方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
    
                                
    • 
                                
  • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
    
                                
    • 
                                
  • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
    
                                
    • 
                                
  • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
    
                                
    • 
                                
  • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
    MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
    
                                
    • 
                                
  • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
    重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
    
                                
    • 
                                
  • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
      
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
    
                                
    • 
                                
  • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
    前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
    
                                
    • 
                                
  • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
    
                                
    • 
                                
  • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
    // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


    
                                
    • 
                                
  • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
      
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
    
                                
    • 
                                
  • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
    
                                
    •