AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Spring+Log4j+ActiveMQ实现远程记录日志——实战+分析

2017-06-04 1792
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 这几天由于工作需要，研究了一下远程打印日志的方式，于是将研究结果记录在此，分享给大家，希望对大家有所帮助。

应用场景

随着项目的逐渐扩大，日志的增加也变得更快。Log4j是常用的日志记录工具，在有些时候，我们可能需要将Log4j的日志发送到专门用于记录日志的远程服务器，特别是对于稍微大一点的应用。这么做的优点有：

可以集中管理日志：可以把多台服务器上的日志都发送到一台日志服务器上，方便管理、查看和分析

可以减轻服务器的开销：日志不在服务器上了，因此服务器有更多可用的磁盘空间

可以提高服务器的性能：通过异步方式，记录日志时服务器只负责发送消息，不关心日志记录的时间和位置，服务器甚至不关心日志到底有没有记录成功

远程打印日志的原理：项目A需要打印日志，而A调用Log4j来打印日志，Log4j的JMSAppender又给配置的地址（ActiveMQ地址）发送一条JMS消息，此时绑定在Queue上的项目B的监听器发现有消息到来，于是立即唤醒监听器的方法开始输出日志。

本文将使用两个Java项目Product和Logging，其中Product项目就是模拟线上的项目，而Logging项目模拟运行在专用的日志服务器上的项目。说明：本文的例子是在Windows平台下。

安装ActiveMQ

  1. 下载：http://activemq.apache.org/download.html
  2. 解压后不需要任何配置，进入到bin下对应的系统架构文件夹

image

  1. 双击activemq.bat启动，如果看到类似下面的页面，就代表activemq启动好了：

image

然后打开浏览器，输入地址：http://localhost:8161进入管理页面，用户名admin，密码admin：

image

可以点击Manage ActiveMQ broker进入Queue的查看界面。

实战

我用Maven来管理项目，方便维护各种依赖的jar包。先看下项目结构：

image

项目不复杂，主要是4个文件：pom.xml，Main.java，log4j.properties和jndi.properties

pom.xml中主要是声明项目的依赖包，其余没有什么东西了：

<!-- Use to call write log methods -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

<!-- Log4j uses this lib -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.13</version>
</dependency>

<!-- Spring jms lib -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
    <version>4.0.0.RELEASE</version>
</dependency>

<!-- ActiveMQ lib -->
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-core</artifactId>
    <version>5.7.0</version>
</dependency>

Main.java：

package com.demo.product;

import javax.jms.Connection;
import javax.jms.Destination;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.Session;

import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQObjectMessage;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;

public class Main implements MessageListener {
    
    public Main() throws Exception {
        // create consumer and listen queue
        ActiveMQConnectionFactory factory = 
                new ActiveMQConnectionFactory("tcp://localhost:61616");
        Connection connection = factory.createConnection();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        connection.start();
        //////////////注意这里JMSAppender只支持TopicDestination，下面会说到////////////////
        Destination topicDestination = session.createTopic("logTopic");
        MessageConsumer consumer = session.createConsumer(topicDestination);
        consumer.setMessageListener(this);
        
        // log a message
        Logger logger = Logger.getLogger(Main.class);
        logger.info("Info Log.");
        logger.warn("Warn Log");
        logger.error("Error Log.");
        
        // clean up
        Thread.sleep(1000);
        consumer.close();
        session.close();
        connection.close();
        System.exit(1);
    }
    
    public static void main(String[] args) throws Exception {
        new Main();
    }
    
    public void onMessage(Message message) {
        try {
            // receive log event in your consumer
            LoggingEvent event = (LoggingEvent)((ActiveMQObjectMessage)message).getObject();
            System.out.println("Received log [" + event.getLevel() + "]: "+ event.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}

说明：然后是log4j.properties：

log4j.rootLogger=INFO, stdout, jms
 
## Be sure that ActiveMQ messages are not logged to 'jms' appender
log4j.logger.org.apache.activemq=INFO, stdout
 
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %-5p %c - %m%n
 
## Configure 'jms' appender. You'll also need jndi.properties file in order to make it work
log4j.appender.jms=org.apache.log4j.net.JMSAppender
log4j.appender.jms.InitialContextFactoryName=org.apache.activemq.jndi.ActiveMQInitialContextFactory
log4j.appender.jms.ProviderURL=tcp://localhost:61616
log4j.appender.jms.TopicBindingName=logTopic
log4j.appender.jms.TopicConnectionFactoryBindingName=ConnectionFactory

其实按理说只需要这么三个文件就可以了，但是这时候执行会报错：

javax.naming.NameNotFoundException: logTopic
    at org.apache.activemq.jndi.ReadOnlyContext.lookup(ReadOnlyContext.java:235)
    at javax.naming.InitialContext.lookup(Unknown Source)
    at org.apache.log4j.net.JMSAppender.lookup(JMSAppender.java:245)
    at org.apache.log4j.net.JMSAppender.activateOptions(JMSAppender.java:222)
    at org.apache.log4j.config.PropertySetter.activate(PropertySetter.java:307)
        ...
    at org.apache.activemq.ActiveMQPrefetchPolicy.<clinit>(ActiveMQPrefetchPolicy.java:39)
    at org.apache.activemq.ActiveMQConnectionFactory.<init>(ActiveMQConnectionFactory.java:84)
    at org.apache.activemq.ActiveMQConnectionFactory.<init>(ActiveMQConnectionFactory.java:137)
    at com.demo.product.Main.<init>(Main.java:20)
    at com.demo.product.Main.main(Main.java:43)

为什么会报错呢？来看看JMSAppender的javadoc文档，它是这么描述的：

image

大意是说，JMSAppender需要一个jndi配置来初始化一个JNDI上下文（Context）。因为有了这个上下文才能管理JMS Topic和topic的连接。于是为项目配置一个叫jndi.properties的文件，其内容为：

topic.logTopic=logTopic

然后再运行就不会报错了。我们先来看看ActiveMQ（注意切换到Topic标签页下）：

image

可以看到，主题为logTopic的消息，有3条进Queue，这3条也出Queue了。而出Queue的消息，已经被我们的监听器收到并打印出来了：

image

Spring整合

需要注意的是，本例只是一个很简单的例子，目的是阐明远程打印日志的原理。实际项目中，一般日志服务器上运行着的，不是项目，而是专用的日志记录器。下面，我们就把这个项目拆分成两个项目，并用Spring来管理这些用到的Bean

修改Product项目

修改后的Product的项目结构并没有改变，改变的只是Main类：

package com.demo.product;

import org.apache.log4j.Logger;

public class Main{
    private static final Logger logger = Logger.getLogger(Main.class);
    public static void main(String[] args) throws Exception {
        // just log a message
        logger.info("Info Log.");
        logger.warn("Warn Log");
        logger.error("Error Log.");
        System.exit(0);
    }
}

这个Main类和普通的logger调用一样，仅仅负责打印日志。有没有觉得太简单了呢？

Logging项目

来看看项目结构图：

image

为了让监听器一直活着，我把Logging写成了一个Web项目，跑在Tomcat上。index.jsp就是个Hello World字符串而已，用来验证Logging活着。注意，在Logging项目中，已没有Product项目中的log4j.properties和jndi.properties两个文件。

来看看另外几个文件：

pom.xml（每个包的目的都写在注释里了）：

<!-- Use to cast object to LogEvent when received a log -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

<!-- Use to receive jms message -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jms</artifactId>
    <version>4.0.0.RELEASE</version>
</dependency>

<!-- Use to load spring.xml -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.0.0.RELEASE</version>
</dependency>

<!-- ActiveMQ lib -->
<dependency>
    <groupId>org.apache.activemq</groupId>
    <artifactId>activemq-core</artifactId>
    <version>5.7.0</version>
</dependency>

web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>
    
    <!-- Use to load spring.xml -->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="connectionFactory"/>
    </bean>
    <bean id="connectionFactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    </bean>
    <bean id="targetConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://localhost:61616"/>
    </bean>
<!-- As JMSAppender only support the topic way to send messages, 
     thus queueDestination here is useless.
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg name="name" value="queue" />
    </bean>
 -->
    <bean id="topicDestination" class="org.apache.activemq.command.ActiveMQTopic">
        <constructor-arg name="name" value="logTopic" />
    </bean>
    <bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory" />
         <!-- <property name="destination" ref="queueDestination" />  -->
         <property name="destination" ref="topicDestination" />
         <property name="messageListener" ref="logMessageListener" />
    </bean>
    <bean id="logMessageListener" class="com.demo.logging.LogMessageListener"/>
</beans>

logMessageListener指向我们自己实现的日志消息处理逻辑类，topicDestination则关注topic为“logTopic”的消息，而jmsContainer把这两个对象绑在一起，这样就能接收并处理消息了。

最后就是伟大的监听器了LogMessageListener了：

package com.demo.logging;

import javax.jms.Message;
import javax.jms.MessageListener;
import org.apache.activemq.command.ActiveMQObjectMessage;
import org.apache.log4j.spi.LoggingEvent;

public class LogMessageListener implements MessageListener {
    public void onMessage(Message message) {
        try {
            // receive log event in your consumer
            LoggingEvent event = (LoggingEvent)((ActiveMQObjectMessage)message).getObject();
            System.out.println("Logging project: [" + event.getLevel() + "]: "+ event.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

哈哈，说伟大，其实太简单了。但是可以看到，监听器里面就是之前Product项目中Main类里面移除的实现了MessageListener接口中的代码。

测试

在执行测试前，删掉ActiveMQ中所有的Queue，确保测试效果。

先运行Logging项目，开始Queue的监听。再运行Product的Main类的main函数，可以先看到Main类打印到控制台的日志：

image

接下来去看看Queue中的情况：

image

可以看到有个叫logTopic的主题的消息，进了3条，出了3条。不用想，出Queue的3条日志已经被Logging项目的Listener接收并打印出来了，现在去看看Tomcat的控制台：

image

还要注意Queue中的logTopic的Consumer数量为1而不是0，这与开始的截图不同。我们都知道这个Consumer是Logging项目中的LogMessageListener对象，它一直活着，是因为Tomcat一直活着；之前的Consumer数量为0，是因为在main函数执行完后，Queue的监听器（也是写日志的对象）就退出了。

通过把Product和Logging项目分别放在不同的机器上执行，在第三台机器上部署ActiveMQ（当然你可以把ActiveMQ搭建在任意可以访问的地方），再配置一下Product项目的log4j.properties文件和Logging项目的spring.xml文件就能用于生产环境啦。

JMSAppender类的分析

JMSAppender类将LoggingEvent实例序列化成ObjectMessage，并将其发送到JMS Server的一个指定Topic中，因此，使用此种将日志发送到远程的方式只支持Topic方式发送，不支持Queue方式发送。我们再log4j.properties中配置了这一句：

log4j.appender.jms=org.apache.log4j.net.JMSAppender

这一句指定了使用的Appender，打开这个Appender，在里面可以看到很多setter，比如：

image

这些setter不是巧合，而正是对应了我们在log4j.properties中设置的其他几个选项：

log4j.appender.jms.InitialContextFactoryName=org.apache.activemq.jndi.ActiveMQInitialContextFactory
log4j.appender.jms.ProviderURL=tcp://localhost:61616
log4j.appender.jms.TopicBindingName=logTopic
log4j.appender.jms.TopicConnectionFactoryBindingName=ConnectionFactory

来看看JMSAppender的activeOptions方法，这个方法是用于使我们在log4j.properties中的配置生效的：

/**
 * Options are activated and become effective only after calling this method.
 */
public void activateOptions() {
    TopicConnectionFactory topicConnectionFactory;
    try {
        Context jndi;
        LogLog.debug("Getting initial context.");
        if (initialContextFactoryName != null) {
            Properties env = new Properties();
            env.put(Context.INITIAL_CONTEXT_FACTORY, initialContextFactoryName);
            if (providerURL != null) {
                env.put(Context.PROVIDER_URL, providerURL);
            } else {
                LogLog.warn("You have set InitialContextFactoryName option but not the "
                        + "ProviderURL. This is likely to cause problems.");
            }
            if (urlPkgPrefixes != null) {
                env.put(Context.URL_PKG_PREFIXES, urlPkgPrefixes);
            }

            if (securityPrincipalName != null) {
                env.put(Context.SECURITY_PRINCIPAL, securityPrincipalName);
                if (securityCredentials != null) {
                    env.put(Context.SECURITY_CREDENTIALS, securityCredentials);
                } else {
                    LogLog.warn("You have set SecurityPrincipalName option but not the "
                            + "SecurityCredentials. This is likely to cause problems.");
                }
            }
            jndi = new InitialContext(env);
        } else {
            jndi = new InitialContext();
        }

        LogLog.debug("Looking up [" + tcfBindingName + "]");
        topicConnectionFactory = (TopicConnectionFactory) lookup(jndi, tcfBindingName);
        LogLog.debug("About to create TopicConnection.");
        
        ///////////////////////////////注意这里只会创建TopicConnection////////////////////////////
        if (userName != null) {
            topicConnection = topicConnectionFactory.createTopicConnection(userName, password);
        } else {
            topicConnection = topicConnectionFactory.createTopicConnection();
        }

        LogLog.debug("Creating TopicSession, non-transactional, " + "in AUTO_ACKNOWLEDGE mode.");
        topicSession = topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);

        LogLog.debug("Looking up topic name [" + topicBindingName + "].");
        Topic topic = (Topic) lookup(jndi, topicBindingName);

        LogLog.debug("Creating TopicPublisher.");
        topicPublisher = topicSession.createPublisher(topic);

        LogLog.debug("Starting TopicConnection.");
        topicConnection.start();

        jndi.close();
    } catch (JMSException e) {
        errorHandler.error("Error while activating options for appender named [" + name + "].", e,
                ErrorCode.GENERIC_FAILURE);
    } catch (NamingException e) {
        errorHandler.error("Error while activating options for appender named [" + name + "].", e,
                ErrorCode.GENERIC_FAILURE);
    } catch (RuntimeException e) {
        errorHandler.error("Error while activating options for appender named [" + name + "].", e,
                ErrorCode.GENERIC_FAILURE);
    }
}

上面初始化了一个TopicConnection，一个TopicSession，一个TopicPublisher。咱们再来看看这个Appender的append方法：

/**
 * This method called by {@link AppenderSkeleton#doAppend} method to do most
 * of the real appending work.
 */
public void append(LoggingEvent event) {
    if (!checkEntryConditions()) {
        return;
    }
    try {
        ObjectMessage msg = topicSession.createObjectMessage();
        if (locationInfo) {
            event.getLocationInformation();
        }
        msg.setObject(event);
        topicPublisher.publish(msg);///////////////注意这一句//////////////
    } catch (JMSException e) {
        errorHandler.error("Could not publish message in JMSAppender [" + name + "].", 
            e, ErrorCode.GENERIC_FAILURE);
    } catch (RuntimeException e) {
        errorHandler.error("Could not publish message in JMSAppender [" + name + "].", 
            e, ErrorCode.GENERIC_FAILURE);
    }
}

这里使用TopicPublisher.publish()方法，把序列化的消息发布出去。可见这也证明了JMSAppender只支持以Topic方式发送消息。

样例下载：百度网盘

链接: http://pan.baidu.com/s/1pJF1ybx 密码: x5r6

参考：

http://activemq.apache.org/how-do-i-use-log4j-jms-appender-with-activemq.html

文章转载自 开源中国社区[https://www.oschina.net]

文章标签：
日志服务
Java
监控
Apache
Spring
消息中间件
关键词：
日志服务实战
日志服务日志
spring日志服务
Spring日志
日志服务分析
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
行者武松
目录
相关文章
土木林森
|
13天前
|
Java API UED
【实战秘籍】Spring Boot开发者的福音：掌握网络防抖动，告别无效请求，提升用户体验！
【8月更文挑战第29天】网络防抖动技术能有效处理频繁触发的事件或请求，避免资源浪费，提升系统响应速度与用户体验。本文介绍如何在Spring Boot中实现防抖动，并提供代码示例。通过使用ScheduledExecutorService，可轻松实现延迟执行功能，确保仅在用户停止输入后才触发操作，大幅减少服务器负载。此外，还可利用`@Async`注解简化异步处理逻辑。防抖动是优化应用性能的关键策略，有助于打造高效稳定的软件系统。
土木林森
27 2
土木林森
|
11天前
|
人工智能 Java Spring
Spring框架下，如何让你的日志管理像‘AI’一样智能，提升开发效率的秘密武器！
【8月更文挑战第31天】日志管理在软件开发中至关重要，不仅能帮助开发者追踪问题和调试程序，还是系统监控和运维的重要工具。在Spring框架下，通过合理配置Logback等日志框架，可大幅提升日志管理效率。本文将介绍如何引入日志框架、配置日志级别、在代码中使用Logger，以及利用ELK等工具进行日志聚合和分析，帮助你构建高效、可靠的日志管理系统，为开发和运维提供支持。
土木林森
23 0
土木林森
|
13天前
|
JSON Java API
解码Spring Boot与JSON的完美融合：提升你的Web开发效率，实战技巧大公开！
【8月更文挑战第29天】Spring Boot作为Java开发的轻量级框架，通过`jackson`库提供了强大的JSON处理功能，简化了Web服务和数据交互的实现。本文通过代码示例介绍如何在Spring Boot中进行JSON序列化和反序列化操作，并展示了处理复杂JSON数据及创建RESTful API的方法，帮助开发者提高效率和应用性能。
土木林森
44 0
土木林森
|
13天前
|
SQL Java 数据库连接
Spring Boot联手MyBatis，打造开发利器：从入门到精通，实战教程带你飞越编程高峰！
【8月更文挑战第29天】Spring Boot与MyBatis分别是Java快速开发和持久层框架的优秀代表。本文通过整合Spring Boot与MyBatis，展示了如何在项目中添加相关依赖、配置数据源及MyBatis，并通过实战示例介绍了实体类、Mapper接口及Controller的创建过程。通过本文，你将学会如何利用这两款工具提高开发效率，实现数据的增删查改等复杂操作，为实际项目开发提供有力支持。
土木林森
53 0
土木林森
|
13天前
|
缓存 NoSQL Java
惊！Spring Boot遇上Redis，竟开启了一场缓存实战的革命！
【8月更文挑战第29天】在互联网时代，数据的高速读写至关重要。Spring Boot凭借简洁高效的特点广受开发者喜爱，而Redis作为高性能内存数据库，在缓存和消息队列领域表现出色。本文通过电商平台商品推荐系统的实战案例，详细介绍如何在Spring Boot项目中整合Redis，提升系统响应速度和用户体验。
土木林森
40 0
土木林森
|
13天前
|
Java 开发者 Spring
Spring Boot实战宝典：揭秘定时任务的幕后英雄，让业务处理如流水般顺畅，轻松驾驭时间管理艺术！
【8月更文挑战第29天】在现代应用开发中，定时任务如数据备份、报告生成等至关重要。Spring Boot作为流行的Java框架，凭借其强大的集成能力和简洁的配置方式，为开发者提供了高效的定时任务解决方案。本文详细介绍了如何在Spring Boot项目中启用定时任务支持、编写定时任务方法，并通过实战案例展示了其在业务场景中的应用，同时提供了注意事项以确保任务的正确执行。
土木林森
27 0
嘟嘟嘟嘟嘟嘟
|
16天前
|
监控 Java Serverless
美团 Flink 大作业部署问题之想在Serverless平台上实时查看Spring Boot应用的日志要怎么操作
美团 Flink 大作业部署问题之想在Serverless平台上实时查看Spring Boot应用的日志要怎么操作
嘟嘟嘟嘟嘟嘟
26 0
路边两盏灯
|
17天前
|
存储 Java Spring
【Azure Spring Cloud】Azure Spring Cloud服务，如何获取应用程序日志文件呢？
【Azure Spring Cloud】Azure Spring Cloud服务，如何获取应用程序日志文件呢？
路边两盏灯
9 0
游客vujifjtitkdbq
|
Java 应用服务中间件 数据库连接
Spring全家桶之Spring篇深度分析(一)
Spring 框架不局限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何 Java 应用都可以从 Spring 中受益。Spring 框架还是一个超级粘合平台，除了自己提供功能外，还提供粘合其他技术和框架的能力。
游客vujifjtitkdbq
215 0
Spring全家桶之Spring篇深度分析(一)
萝卜丝丸子
|
21天前
|
缓存 Java Maven
Java本地高性能缓存实践问题之SpringBoot中引入Caffeine作为缓存库的问题如何解决
Java本地高性能缓存实践问题之SpringBoot中引入Caffeine作为缓存库的问题如何解决
萝卜丝丸子
32 1

热门文章

最新文章

  • 1
    Oracle自动清理日志脚本
  • 2
    Kubernetes全方位日志采集与管理的最佳实践 资料下载
  • 3
    海量游戏日志收集与分析
  • 4
    [日志服务][数据加工]e_output使用总结
  • 5
    linux下清理日志的脚本
  • 6
    05【在线日志分析】之Kafka 0.10.1.0 Cluster的搭建和Topic简单操作实验
  • 7
    SLS新版告警入门-监控OSS访问日志
  • 8
    log4net的配置与使用
  • 9
    Linux部署webalizer日志分析工具
  • 10
    仿酷狗音乐播放器开发日志四——标题栏和状态栏的完善
  • 1
    18：面向切面编程-Java Spring
    60
  • 2
    17：缓存机制-Java Spring
    80
  • 3
    16：事务-Java Spring
    47
  • 4
    15：MyBatis对象关系与映射结构-Java Spring
    80
  • 5
    Spring Boot中获取配置参数的几种方法
    223
  • 6
    从前端Vue到后端Spring Boot：接收JSON数据的正确姿势
    191
  • 7
    Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
    53
  • 8
    Spring缓存是如何实现的？如何扩展使其支持过期删除功能？
    41
  • 9
    Springboot整合与使用log4j2日志框架【详解版】
    324
  • 10
    Springboot实战篇--Springboot框架通过@Scheduled实现定时任务
    47

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第一阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 使用CloudLens管理SLS日志采集
  • 使用CloudLens采集PolarDB日志并进行审计分析
  • 使用CloudLens采集RDS日志并进行审计分析
  • 使用日志服务SLS进行OSS可观测分析
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
    • 下一篇
    DDNS