blocks|key|2633047|text|想法1很好。创建一个实用程序方法，将条目记录到数据库中。所以每次你想记录一些事件时，只要调用这个方法即可。不应该占用太多的服务器资源，也不会显著减慢响应时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2633048|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Idea 1 is good. Create a utility method to log the entries into the database. So every time you want to log some event, just call this method. Shouldn't take too much of your server resources, nor will it slow down the response time considerably.

blocks|key|508663|text|建议1:使用和不使用数据库日志记录系统分析应用程序。您可能会发现，无需重大架构更改或性能调优，DB日志记录就能满足您的性能需求。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|508664|如果您发现能够满足吞吐量需求，但偶尔会在高峰期进行备份，则可以将数据库日志记录移动到单个线程中，并使用来自java.util.concurrent的并发队列传递日志消息。这将比为每个日志事件派生单独的线程效率高得多。|offset|length|style|CODE|508665|我怀疑如果你发现一个性能问题，你会发现瓶颈是数据库。但这只是一种预感--您必须分析您自己的设置，以找到其优缺点。|508666|注意:要比较启用和不启用日志记录的性能，您可以在启动时将打开/关闭布尔值或特定日志级别配置为最终静态变量。如果这些条件被保证为假，则JIT将优化出if+(loggingEnabled)或if+(logLevel+>+3)块中包含的任何代码。这使您可以在有日志记录和没有日志记录的情况下运行相同的代码，而不会在分析当前(非日志)方法时为日志记录代码付出性能损失。|508667|entityMap^0|0|1H|K|0|0|21|J|2L|H|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|M|$]]

Recommendation 1: Profile your application with and without your database logging system. You may find that DB logging meets your performance needs without major architectural changes or performance tuning.

If you find that you're able to sustain your throughput requirements, but occasionally back up during peak periods, you could move the DB logging into a single thread and pass log messages using a concurrent queue from <code>java.util.concurrent</code>. That will be much more efficient than forking a separate thread for each log event.

My suspicion is that if you find a performance issue, you'll find the bottleneck to be the database. But that's just a hunch - you'll have to profile your own setup to find the strengths and weaknesses.

Note: To compare performance with and without logging enabled, you could configure an on/off boolean or specific log levels at startup into final static variables. The JIT will optimize out any code contained in an <code>if (loggingEnabled)</code> or <code>if (logLevel &gt; 3)</code> block, if those conditions are guaranteed to be false. That lets you run the same code with and without logging, without paying a performance penalty for the logging code when profiling the current (non-logging) approach.

blocks|key|508705|text|对您的问题的描述似乎符合生产者/消费者模式。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|508706|您有许多处理用户请求的线程，这些请求将产生将信息写入数据库的请求。您将有一个(或多个)线程使用这些请求，并将数据写入数据库。|508707|在Java中有许多方法可以实现这一点。您可以：|508708|508709|每次您想要将一条信息记录到数据库中时，都会启动一个新线程|unordered-list-item|508710|使用具有有限线程数的共享ExecutorService，它将得到重用并避免许多类型的开销|CODE|508711|使用一个共享BlockingQueue，您将把来自servlet的日志请求放入其中，并将其中的一个(或多个)线程servlet元素放在一个循环中，并根据您获取的元素将数据写入数据库<代码>H211<代码>F212|508712|508713|在任何情况下，我都会将此逻辑封装在RequestLogger类中，例如：|508714|public+class+RequestLogger+{
++private+final+Thread+thread;
++private+final+BlockingQueue<LogRequest>+logRequestQueue+=+new+LinkedBlockingQueue<>();
++public+RequestLogger()+{
++++this.thread+=+new+Thread(new+Runnable()+{
++++++@Override+public+void+run()+{
++++++++try+{
++++++++++while+(!Thread.currentThread().isInterrupted())+{
++++++++++++final+LogRequest+req+=+logRequestQueue.take();
++++++++++++//+...+log+it+to+the+database+somehow+...
++++++++++}
++++++++}+catch+(Exception+e)+{+...+do+something+...+}
++++++}
++++});
++}

++public+void+start()+{+thread.start();+}
++public+void+stop()+{+thread.interrupt();+}
++public+void+log(...)+{
++++logRequestQueue.offer(new+LogRequest(...));
++}
}|code-block|syntax|javascript|508715|只需实例化该类一次，调用.start()，就可以记录所需的所有内容。|508716|如果您愿意(例如，因为您发现日志请求累积得太快)，您可以更改while(...)循环中的逻辑，使其一次接收更多请求(如果可用)，并使您的代码向数据库发出一次写入，或在单个事务中写入，或类似以下内容。|508717|这真的取决于您的特定场景，但如果您有性能问题，瓶颈将是数据库。|508718|entityMap^0|C|7|0|0|0|0|0|C|F|0|6|D|0|0|H|D|0|0|C|8|0|U|A|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1C|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]|$1|K|3|L|5|M|7|1E|8|@]|D|@]|E|$]]|$1|N|3|O|5|M|7|1F|8|@$9|1G|A|1H|B|P]]|D|@]|E|$]]|$1|Q|3|R|5|M|7|1I|8|@$9|1J|A|1K|B|P]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1M|8|@$9|1N|A|1O|B|P]]|D|@]|E|$]]|$1|V|3|W|5|X|7|1P|8|@]|D|@]|E|$Y|Z]]|$1|10|3|11|5|6|7|1Q|8|@$9|1R|A|1S|B|P]]|D|@]|E|$]]|$1|12|3|13|5|6|7|1T|8|@$9|1U|A|1V|B|P]]|D|@]|E|$]]|$1|14|3|15|5|6|7|1W|8|@]|D|@]|E|$]]|$1|16|3|-4|5|6|7|1X|8|@]|D|@]|E|$]]]|17|$]]

The description of your problem seems to fit the Producer / Consumer pattern.

You have many threads processing user requests that will produce a request to write information into a database. You will have one single (or maybe more than one) thread consuming those requests and write the data to the database.

There are many ways to implement this in Java. You could:

<ul>
<li>start a new thread each time you want to log a piece of information into the database</li>
<li>use a shared <code>ExecutorService</code> with a limited number of threads, that will get reused and avoid many kinds of overhead</li>
<li>use a shared <code>BlockingQueue</code> in which you will put log requests from your servlets, and have one (or more) thread <code>take()</code> elements from it in a loop and write data to the database according to the element you took</li>
</ul>

In any case, I would encapsulate this logic in a <code>RequestLogger</code> class, for instance:

<pre><code>public class RequestLogger {
 private final Thread thread;
 private final BlockingQueue&lt;LogRequest&gt; logRequestQueue = new LinkedBlockingQueue&lt;&gt;();
 public RequestLogger() {
 this.thread = new Thread(new Runnable() {
 @Override public void run() {
 try {
 while (!Thread.currentThread().isInterrupted()) {
 final LogRequest req = logRequestQueue.take();
 // ... log it to the database somehow ...
 }
 } catch (Exception e) { ... do something ... }
 }
 });
 }

 public void start() { thread.start(); }
 public void stop() { thread.interrupt(); }
 public void log(...) {
 logRequestQueue.offer(new LogRequest(...));
 }
}
</code></pre>

You instantiate this class one time, call <code>.start()</code>, and you are ready to log everything you want.

If you want (for example, because you see that there are log requests accumulating too fast), you could change the logic in the <code>while(...)</code> loop to take more requests at a time (if available), and make your code issue a single write to the database, or write in a single transaction, or something like this.

It really depends on your particular scenario, but if you have a performance issue, the bottleneck is going to be the database.

blocks|key|2633157|text|出于性能原因，最好将日志处理与页面呈现分开，这可以使用JMS来完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2633158|当用户执行某些操作时，您需要做的就是创建日志对象并使用消息源发送JMS消息(JMS队列应该是合适的)。|2633159|在另一端(消息接收器)，您需要设置一个消息接收器来接收消息并记录它们(在本例中为DB+)。|2633160|这种解耦确保对用户活动的影响最小，并为使用操作提供可靠的日志记录。|2633161|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

For performance reasons it's better to separate the log processing from page rendering, this can be best done using JMS. 

When the user does some action all what you need to do is that you create the log object and send a JMS message using message source (JMS Queue should be suitable).

at the other end (message sink), you need to setup a message sink that receives messages and log them (to DB in your case).

this decoupling ensures minimum impact on user activities and reliable logging for use actions.

blocks|key|5985238|text|现代日志记录框架支持异步日志记录的思想。例如，有一个log+appender+in+LogBack，它支持异步日志记录，具有非常好的响应时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|5985239|entityMap|0|LINK|mutability|MUTABLE|url|https://logback.qos.ch/manual/appenders.html#AsyncAppender^0|Q|N|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Modern logging framework supports the idea of ASYNCHRONOUS loggin. Fro example there is an <a href="https://logback.qos.ch/manual/appenders.html#AsyncAppender" rel="nofollow noreferrer">log appender in LogBack</a> which support Async logging with a very good response time.

I have a web application and my client requests that he wants to know. 

I have come up with two ideas. 
I would like to have my ideas verified if they are correct. 

 
These are the client requirements. 
who: who the visitor is(e.g. remoteAddress-IP) 
when: what time the visitor did something on the web application 
what: what exact action did the visitor take, such as "pushed print button" 
where: which page, e.g. a URL the visitor accessed 

My idea 1. 
Simply issue an SQL query to log user activities for everyone visiting the web site.
If the visitor clicked on a link to a page, the web application would write the user activity to the database and render the requested page. 
I think this will have a bad impact on user experience. Page rendering could get slower because it has to do extra work. Will this method end up issuing too many SQL queries and ultimately be a bad idea ? 
 
My idea 2. 
Start a new thread for each user or each user activity such as clicking print button.
Page rendering go on at its own speed and logging will be seperately done in the thread. I think this might create too many threads. Is this a good idea or would it end up using too much resources ? 

I wonder if any of those are a good, real world practice. If there is a better way, please share. :)

Real world user activity logging strategy for web applications

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个web应用程序，我的客户请求他想知道。我想出了两个主意。我想验证一下我的想法是否正确。这些是客户的要求。谁:访问者是谁(例如，remoteAddress-IP)时间:访问者在web应用程序上做了一些事情事件:访问者采取了什么具体操作，比如“按下打印按钮”where:哪个页面，例如访问者访问的URL我的想法1.只...

问web应用程序的真实用户活动日志记录策略
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问web应用程序的真实用户活动日志记录策略EN