c*****s
发帖数: 214 | 1 有很大的区别。
没错，log4j确实会先判断级别再决定是不是真的写日志。但从性能上，这时候已经太晚
了。很多时间被花在了准备写入的字符串和级别检查上。
如果考虑性能，对那些频繁写的，级别又不高的日志if语句无法避免。
在我做过的项目里，最终都是像熊博士说的配置一个final的静态全局变量，然后写很多i
f。
important. |
H***a
发帖数: 189 | 2 I meant if you use Log4j, you should always do the check
if (debug)
logger.debug(.........)
【在 c*****s 的大作中提到】
: 有很大的区别。
: 没错，log4j确实会先判断级别再决定是不是真的写日志。但从性能上，这时候已经太晚
: 了。很多时间被花在了准备写入的字符串和级别检查上。
: 如果考虑性能，对那些频繁写的，级别又不高的日志if语句无法避免。
: 在我做过的项目里，最终都是像熊博士说的配置一个final的静态全局变量，然后写很多i
: f。
:
: important.
|
r***l
发帖数: 67 | 3 Not really.
The penalty is to construct your message. If your message construction does
not need a lot string concatenation, you do not need to check the debug level.
You have to put two extra lines for it.
The penalty for string cancatnatio is gettting smaller and smaller anyway.
太晚
很多i
【在 H***a 的大作中提到】
: I meant if you use Log4j, you should always do the check
: if (debug)
: logger.debug(.........)
|
m******t
发帖数: 2416 | 4
晚
多i
If you are using any logging toolkit such as log4j, the best
practice is:
if (logger.isDebug()) {
logger.debug(...);
}
This is better than an additional static variable because it's controlled
from the same log4j config file, and it gives you finer granularity.
【在 c*****s 的大作中提到】
: 有很大的区别。
: 没错，log4j确实会先判断级别再决定是不是真的写日志。但从性能上，这时候已经太晚
: 了。很多时间被花在了准备写入的字符串和级别检查上。
: 如果考虑性能，对那些频繁写的，级别又不高的日志if语句无法避免。
: 在我做过的项目里，最终都是像熊博士说的配置一个final的静态全局变量，然后写很多i
: f。
:
: important.
|
c*****s
发帖数: 214 | 5
太
很
调用一个方法比检查一个static final boolean值要慢好多好多。
【在 m******t 的大作中提到】
:
: 晚
: 多i
: If you are using any logging toolkit such as log4j, the best
: practice is:
: if (logger.isDebug()) {
: logger.debug(...);
: }
: This is better than an additional static variable because it's controlled
: from the same log4j config file, and it gives you finer granularity.
|
w*r
发帖数: 2421 | 6 what is assert for, guys??????
【在 c*****s 的大作中提到】
: 有很大的区别。
: 没错，log4j确实会先判断级别再决定是不是真的写日志。但从性能上，这时候已经太晚
: 了。很多时间被花在了准备写入的字符串和级别检查上。
: 如果考虑性能，对那些频繁写的，级别又不高的日志if语句无法避免。
: 在我做过的项目里，最终都是像熊博士说的配置一个final的静态全局变量，然后写很多i
: f。
:
: important.
|
w*r
发帖数: 2421 | 7 I think this is pointless, for trace purpose, you should use persistant
storage facility, which finally involves penalty of writing to disk output,
compare the time of IO and those you guys are talking about, check the
condition of logging and construct logging msg is nothing, for DEBUG
purpose, assert is the primitive , but powerful solution, which cost
much less and works way better!
【在 c*****s 的大作中提到】
:
: 太
: 很
: 调用一个方法比检查一个static final boolean值要慢好多好多。
|
c*****s
发帖数: 214 | 8 提到的两种情况都是没有真正去写日志的情况，都没有在IO上花时间。相信我，当你的系
统处理很繁重的事情时if(isDebugEnabled())和if(DEBUG_ENABLED)有非常明显的区别。
而当进入debug模式下以后（会真正写日志的时候）assert无法像log4j那么强大和可扩展
。相比log4j或commons-logging, assert不会"works way better"。正如你说的，这时候
判断是否写日志花去的时间相比写日志是完全可以忽略的。
controlled
【在 w*r 的大作中提到】
: I think this is pointless, for trace purpose, you should use persistant
: storage facility, which finally involves penalty of writing to disk output,
: compare the time of IO and those you guys are talking about, check the
: condition of logging and construct logging msg is nothing, for DEBUG
: purpose, assert is the primitive , but powerful solution, which cost
: much less and works way better!
|
w*******g
发帖数: 9932 | 9 for most optimizing compiler.
the method call to isDebugEnabled() is inlined so that it has some
apparent performance impact.
【在 c*****s 的大作中提到】
: 提到的两种情况都是没有真正去写日志的情况，都没有在IO上花时间。相信我，当你的系
: 统处理很繁重的事情时if(isDebugEnabled())和if(DEBUG_ENABLED)有非常明显的区别。
: 而当进入debug模式下以后（会真正写日志的时候）assert无法像log4j那么强大和可扩展
: 。相比log4j或commons-logging, assert不会"works way better"。正如你说的，这时候
: 判断是否写日志花去的时间相比写日志是完全可以忽略的。
:
: controlled
|
r***l
发帖数: 67 | 10 assert is much differnt.
Assert will abort your program at runtime if something goes wrong. It is a way
to complement unit testing. It is to test how your code works, and unit
testing is to test what your code does.
Normally, assert concerns about invariant - something should always be true in
your program, e.g. thread_in_pool >= 0. If the invariant is false, program
should terminate right there.
Assert is very important, but hard to use it right.
太晚
很多i
【在 w*r 的大作中提到】
: what is assert for, guys??????
|
|
|
o***e
发帖数: 30 | 11 it's very hard to believe, unless you have log for every statement.
【在 c*****s 的大作中提到】
: 提到的两种情况都是没有真正去写日志的情况，都没有在IO上花时间。相信我，当你的系
: 统处理很繁重的事情时if(isDebugEnabled())和if(DEBUG_ENABLED)有非常明显的区别。
: 而当进入debug模式下以后（会真正写日志的时候）assert无法像log4j那么强大和可扩展
: 。相比log4j或commons-logging, assert不会"works way better"。正如你说的，这时候
: 判断是否写日志花去的时间相比写日志是完全可以忽略的。
:
: controlled
|
o***e
发帖数: 30 | 12 you could say
assert log.debug(...); //always return true
and use -da to totally eliminate the cost. lol.
I don't even write if(debug), who has the time? let CPU burn.
【在 r***l 的大作中提到】
: assert is much differnt.
: Assert will abort your program at runtime if something goes wrong. It is a way
: to complement unit testing. It is to test how your code works, and unit
: testing is to test what your code does.
: Normally, assert concerns about invariant - something should always be true in
: your program, e.g. thread_in_pool >= 0. If the invariant is false, program
: should terminate right there.
: Assert is very important, but hard to use it right.
:
: 太晚
|
c*****s
发帖数: 214 | 13 我们的项目是处理百万数量级数据的操作，所以想尽了办法提高性能。我们甚至买了JPro
be来找可以优化的地方。
最终设计被改成了丑八怪，但确实快了很多。
的系
别。
扩展
时候
output,
【在 o***e 的大作中提到】
: it's very hard to believe, unless you have log for every statement.
|
o***e
发帖数: 30 | 14 百万是什么量级?
【在 c*****s 的大作中提到】
: 我们的项目是处理百万数量级数据的操作，所以想尽了办法提高性能。我们甚至买了JPro
: be来找可以优化的地方。
: 最终设计被改成了丑八怪，但确实快了很多。
:
: 的系
: 别。
: 扩展
: 时候
: output,
|
c*****s
发帖数: 214 | 15 每天几百万订单，每订单几十个item，半夜处理。把记录从交易系统计算后导入到分析系
统。整个过程优化以前大概四个小时。
JPro
【在 o***e 的大作中提到】
: 百万是什么量级?
|
o***e
发帖数: 30 | 16 多个CPU不就变俩小时了? 和和．
【在 c*****s 的大作中提到】
: 每天几百万订单，每订单几十个item，半夜处理。把记录从交易系统计算后导入到分析系
: 统。整个过程优化以前大概四个小时。
:
: JPro
|
r***l
发帖数: 67 | 17 why use Java for this kind of system?
系
了
【在 c*****s 的大作中提到】
: 每天几百万订单，每订单几十个item，半夜处理。把记录从交易系统计算后导入到分析系
: 统。整个过程优化以前大概四个小时。
:
: JPro
|
c*****s
发帖数: 214 | 18 说对了，后来还真是让两台机器并行处理。
最终时间减到了小于50分钟。
析系
【在 o***e 的大作中提到】
: 多个CPU不就变俩小时了? 和和．
|
c*****s
发帖数: 214 | 19 不用JAVA就轮不到俺们公司做啊。
用一个同事的话来讲，软件公司的目的就是把简单的事情变得复杂，把便宜的方案变得昂
贵，庆幸的是，客户的IT部门通常也是这个逻辑。
析
买
【在 r***l 的大作中提到】
: why use Java for this kind of system?
:
: 系
: 了
|
w******n
发帖数: 692 | 20 At least, Java is much much better for future maintaince.
昂
分
【在 c*****s 的大作中提到】
: 不用JAVA就轮不到俺们公司做啊。
: 用一个同事的话来讲，软件公司的目的就是把简单的事情变得复杂，把便宜的方案变得昂
: 贵，庆幸的是，客户的IT部门通常也是这个逻辑。
:
: 析
: 买
|
|
|
w*r
发帖数: 2421 | 21 ur absolutely right~~~
hiahia..
昂
分
至
statement.
【在 c*****s 的大作中提到】
: 不用JAVA就轮不到俺们公司做啊。
: 用一个同事的话来讲，软件公司的目的就是把简单的事情变得复杂，把便宜的方案变得昂
: 贵，庆幸的是，客户的IT部门通常也是这个逻辑。
:
: 析
: 买
|
w*r
发帖数: 2421 | 22 working for Walmart?
系
了
【在 c*****s 的大作中提到】
: 每天几百万订单，每订单几十个item，半夜处理。把记录从交易系统计算后导入到分析系
: 统。整个过程优化以前大概四个小时。
:
: JPro
|
m******t
发帖数: 2416 | 23
A global static final variable is not flexible if you need to
control logging on/off by categories/packages. It's worth the
small amount of performance penalty to me.
If you are talking about having a class level static final variable,
I'm fine with that, except it will break when you use dynamically
refreshable logging configuration.
【在 c*****s 的大作中提到】
: 不用JAVA就轮不到俺们公司做啊。
: 用一个同事的话来讲，软件公司的目的就是把简单的事情变得复杂，把便宜的方案变得昂
: 贵，庆幸的是，客户的IT部门通常也是这个逻辑。
:
: 析
: 买
|
m******t
发帖数: 2416 | 24
dude, we just want to log something, not to half the jvm. 8-)
【在 w*r 的大作中提到】
: what is assert for, guys??????
|
m******t
发帖数: 2416 | 25
我们的项目是处理百万数量级数据的操作，所以想尽了办法提高性能。我们甚至买了JPro
If the ugly design does not make it a lot harder for future enhancement,
then it's not an ugly design. If it does, well, I guess it's a matter of
a choice between spending some extra money on hardware or spending some
more money on rewriting the system in the future. 8-)
【在 c*****s 的大作中提到】
: 我们的项目是处理百万数量级数据的操作，所以想尽了办法提高性能。我们甚至买了JPro
: be来找可以优化的地方。
: 最终设计被改成了丑八怪，但确实快了很多。
:
: 的系
: 别。
: 扩展
: 时候
: output,
|
r***l
发帖数: 67 | 26 I hear you. lol
昂
分
至
statement.
【在 c*****s 的大作中提到】
: 不用JAVA就轮不到俺们公司做啊。
: 用一个同事的话来讲，软件公司的目的就是把简单的事情变得复杂，把便宜的方案变得昂
: 贵，庆幸的是，客户的IT部门通常也是这个逻辑。
:
: 析
: 买
|
f*****g
发帖数: 31 | 27
log (Log.DEBUG, your_message)
Do you know how to use log4j?
important. |
f*****g
发帖数: 31 | 28
晚
not really. Read log4j code first. Or you can write your own filter.
Or you can use JDK 1.4 log.
多i
they
【在 c*****s 的大作中提到】
: 有很大的区别。
: 没错，log4j确实会先判断级别再决定是不是真的写日志。但从性能上，这时候已经太晚
: 了。很多时间被花在了准备写入的字符串和级别检查上。
: 如果考虑性能，对那些频繁写的，级别又不高的日志if语句无法避免。
: 在我做过的项目里，最终都是像熊博士说的配置一个final的静态全局变量，然后写很多i
: f。
:
: important.
|
m******t
发帖数: 2416 | 29
The if(logger.isDebugEnabled()) practice is to avoid the evaluation
penalty on the message, which must be done before the log method
is invoked per the Java Language Spec. In many scenarios, the
evaluation of the message can be very expensive, e.g., the toString
method of most of the collection classes.
【在 f*****g 的大作中提到】
:
: 晚
: not really. Read log4j code first. Or you can write your own filter.
: Or you can use JDK 1.4 log.
: 多i
: they
|
f*****g
发帖数: 31 | 30
In that case you can just have your own log filter,
pass the collection object rather than object.toString
to the log system. if(logger.isDebugEnabled()) is ugly
and may break the streamline of your code, should be avoided.
Use your own filter, or AOP.
【在 m******t 的大作中提到】
:
: The if(logger.isDebugEnabled()) practice is to avoid the evaluation
: penalty on the message, which must be done before the log method
: is invoked per the Java Language Spec. In many scenarios, the
: evaluation of the message can be very expensive, e.g., the toString
: method of most of the collection classes.
|
|
|
m******t
发帖数: 2416 | 31
Filters won't help when you want to log something like:
logger.debug("User name: " + userName + ", role: " + userRole);
AOP won't help in this case either because any interception
wouldn't happen until the parameter is fully evaluated.
Also in both the filter and AOP approaches, the penalty is
much more than an inline call to logger.isDebugEnabled().
I agree it does not make the code look more elegant, but IMO
it gives me the level of control at an acceptable price. And
I don't use it around ev
【在 f*****g 的大作中提到】
:
: In that case you can just have your own log filter,
: pass the collection object rather than object.toString
: to the log system. if(logger.isDebugEnabled()) is ugly
: and may break the streamline of your code, should be avoided.
: Use your own filter, or AOP.
|
c*****s
发帖数: 214 | 32 这个又不是什么很难理解的东西。
做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
sDebugEnabled(), 最后变成简单判断静态boolean的循环。
在我的机器上结果是218ms, 203ms和16ms。
log4j还在IBM的时候我们的项目就开始用它了，不能说改就改，几千个类在用它。另外我
也实在想不出什么用jdk logging的理由，改用commons-logging API还说得过去。
太
很
【在 f*****g 的大作中提到】
:
: In that case you can just have your own log filter,
: pass the collection object rather than object.toString
: to the log system. if(logger.isDebugEnabled()) is ugly
: and may break the streamline of your code, should be avoided.
: Use your own filter, or AOP.
|
f*****g
发帖数: 31 | 33
做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
Like I've said, what you need is just put isDebugEnabled() or similar
code to a log4j filter.
我
no matter how many classes are using log4j, if you have a good design,
just need to change several lines to switch to other logging systems.
I am not asking to do so, just want to let you know JDK logging also has
a "filter" mechanism. You can do the urgly isDebugEnabled in a plugin class.
经
写
【在 c*****s 的大作中提到】
: 这个又不是什么很难理解的东西。
: 做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
: sDebugEnabled(), 最后变成简单判断静态boolean的循环。
: 在我的机器上结果是218ms, 203ms和16ms。
: log4j还在IBM的时候我们的项目就开始用它了，不能说改就改，几千个类在用它。另外我
: 也实在想不出什么用jdk logging的理由，改用commons-logging API还说得过去。
:
: 太
: 很
|
c*****s
发帖数: 214 | 34 换一个Filter后会比 if(DEBUG_ENABLED) 快吗？
俺还没算方法被调用前构造大字符串的时间尼。
做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
外
已
后
【在 f*****g 的大作中提到】
:
: 做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
: Like I've said, what you need is just put isDebugEnabled() or similar
: code to a log4j filter.
: 我
: no matter how many classes are using log4j, if you have a good design,
: just need to change several lines to switch to other logging systems.
: I am not asking to do so, just want to let you know JDK logging also has
: a "filter" mechanism. You can do the urgly isDebugEnabled in a plugin class.
: 经
|
f*****g
发帖数: 31 | 35
We are talking about Java and the OO phylosopy.
If you want fast speed, use C instead. if(DEBUG_ENABLED)
style conditions are not good OO behaviors.
做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
另
class.
候
然
【在 c*****s 的大作中提到】
: 换一个Filter后会比 if(DEBUG_ENABLED) 快吗？
: 俺还没算方法被调用前构造大字符串的时间尼。
:
: 做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
: 外
: 已
: 后
|
m******t
发帖数: 2416 | 36
I am with you on this one - static varialbe is a bad idea.
But you haven't responded to my last post on why filter
doesn't help avoiding the parameter evaluation penalty. 8-)
【在 f*****g 的大作中提到】
:
: We are talking about Java and the OO phylosopy.
: If you want fast speed, use C instead. if(DEBUG_ENABLED)
: style conditions are not good OO behaviors.
: 做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
: 另
: class.
: 候
: 然
|
c*****s
发帖数: 214 | 37 当然, 理想情况下没有if 的logger.debug()是最干净的，simple is beauty。我完全同
意（我还有件印着它的T恤呢, 都穿变色了还在办公室里现）。设计和实际脏代码间的平
衡主观上我和你一样偏向设计。
是java的不完美产生这些实际问题（没有完美的东西）。而软件以用为本，做项目做设计
时不能忽略这些问题，谁还有写PP程序的快感不成。当频繁的log导致的性能问题比较明
显时(通常也不会发生，怕是非得到俺们那个百万订单处理时），if(DEBUG_ENABLED)就是
最优解。题外话, 类似的事情还发生在String.intern()上过。
我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
sDebugEnabled())都不是。
做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
。
。
时
【在 f*****g 的大作中提到】
:
: We are talking about Java and the OO phylosopy.
: If you want fast speed, use C instead. if(DEBUG_ENABLED)
: style conditions are not good OO behaviors.
: 做一个log4j写日志但级别低于配置的实验，重复1M次。然后把直接写日志变成判断log.i
: 另
: class.
: 候
: 然
|
m******t
发帖数: 2416 | 38
同
平
It's not about whether your code looks elegant or not, it's about your logging
isn't controlled from one centralized place, and hardcoded to some extent - it
defeats the purpose of using a logging kit to begin with.
计
明
是
我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
AS fuxxing pointed out, if performance is your top priority to the point
where you start worrying about the difference between a static variable and
an extra method call, you should not have picked Java to begin with
【在 c*****s 的大作中提到】
: 当然, 理想情况下没有if 的logger.debug()是最干净的，simple is beauty。我完全同
: 意（我还有件印着它的T恤呢, 都穿变色了还在办公室里现）。设计和实际脏代码间的平
: 衡主观上我和你一样偏向设计。
: 是java的不完美产生这些实际问题（没有完美的东西）。而软件以用为本，做项目做设计
: 时不能忽略这些问题，谁还有写PP程序的快感不成。当频繁的log导致的性能问题比较明
: 显时(通常也不会发生，怕是非得到俺们那个百万订单处理时），if(DEBUG_ENABLED)就是
: 最优解。题外话, 类似的事情还发生在String.intern()上过。
: 我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
: sDebugEnabled())都不是。
:
|
Q**g
发帖数: 183 | 39
为啥不能是 controlled from one centralized place 呢？
比如，
class logger{
public static boolean DEBUG;
static {
DEBUG = // code for reading the setting from .properties file
}
.........
}
然后到处都写
if (logger.DEBUG) logger.log(....);
这样至少没有函数调用的开销吧。如果觉得check logger.DEBUG 开销还大，那就在
每个OBJECT构造的时候copy一下logger.DEBUG到一个本地的class member好了
【在 m******t 的大作中提到】
:
: 同
: 平
: It's not about whether your code looks elegant or not, it's about your logging
: isn't controlled from one centralized place, and hardcoded to some extent - it
: defeats the purpose of using a logging kit to begin with.
: 计
: 明
: 是
: 我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
|
m******t
发帖数: 2416 | 40
logging
- it
And the centralized place being the log4j config file, not one of your
home-made logger class? 8-)
file
This is completely different. You are proposing your own logger class that
handles all the logging. One of the reasons people uses logging kits like
log4j is to have category/class-level logging control.
【在 Q**g 的大作中提到】
:
: 为啥不能是 controlled from one centralized place 呢？
: 比如，
: class logger{
: public static boolean DEBUG;
: static {
: DEBUG = // code for reading the setting from .properties file
: }
: .........
: }
|
|
|
Q**g
发帖数: 183 | 41 这不是问题。你可以在log4j外头包一个dummy logger嘛，就是说你的logger掉
log4j不就行了，呵呵
【在 m******t 的大作中提到】
:
: logging
: - it
: And the centralized place being the log4j config file, not one of your
: home-made logger class? 8-)
: file
: This is completely different. You are proposing your own logger class that
: handles all the logging. One of the reasons people uses logging kits like
: log4j is to have category/class-level logging control.
|
c*****s
发帖数: 214 | 42
全
的
logging
it
怎么会不是呢？现在我做的就是在一个 properties文件里配置log4j和开关。
设
较
显时(通常也不会发生，怕是非得到俺们那个百万订单处理时），if(DEBUG_ENABLED)就
我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
就是在抬杠了。你的意思是要么写纯OO的好看的JAVA，要么不要用JAVA?
用什么语言，基于什么技术是不可能因为觉得写日值还不够快而改变的，决定用JAVA的理
由实在是太多了，不在这里讨论的范围内。另外我的case不是两个类的家庭作业，是有几
千个类，发展了若干年的产品。
但写几句不完美的代码应该不是那么难以忍受吧，何况人家只是不够帅，谈不上丑。
【在 m******t 的大作中提到】
:
: logging
: - it
: And the centralized place being the log4j config file, not one of your
: home-made logger class? 8-)
: file
: This is completely different. You are proposing your own logger class that
: handles all the logging. One of the reasons people uses logging kits like
: log4j is to have category/class-level logging control.
|
w******n
发帖数: 692 | 43 我还是不明白if(DEBUG_ENABLED)能好到哪里, 按你的testing, 多调几个million次,
总共也就一秒到两秒的差别. 难道你们处理一个record就要调几百次log?
同
平
计
明
是
我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
【在 c*****s 的大作中提到】
: 当然, 理想情况下没有if 的logger.debug()是最干净的，simple is beauty。我完全同
: 意（我还有件印着它的T恤呢, 都穿变色了还在办公室里现）。设计和实际脏代码间的平
: 衡主观上我和你一样偏向设计。
: 是java的不完美产生这些实际问题（没有完美的东西）。而软件以用为本，做项目做设计
: 时不能忽略这些问题，谁还有写PP程序的快感不成。当频繁的log导致的性能问题比较明
: 显时(通常也不会发生，怕是非得到俺们那个百万订单处理时），if(DEBUG_ENABLED)就是
: 最优解。题外话, 类似的事情还发生在String.intern()上过。
: 我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
: sDebugEnabled())都不是。
:
|
m******t
发帖数: 2416 | 44
Which means your dummy logger would have to replicate all the log4j
logger API? What's the point? 8-)
【在 Q**g 的大作中提到】
: 这不是问题。你可以在log4j外头包一个dummy logger嘛，就是说你的logger掉
: log4j不就行了，呵呵
|
m******t
发帖数: 2416 | 45
-
Are you suggesting to have a class level static variable which is
initialized by calling isDebugEnabled()? If that's the case, then
I don't have problem. I may have mixed up your approach with somebody
else earlier suggesting to have a global static variable.
【在 c*****s 的大作中提到】
:
: 全
: 的
: logging
: it
: 怎么会不是呢？现在我做的就是在一个 properties文件里配置log4j和开关。
: 设
: 较
: 显时(通常也不会发生，怕是非得到俺们那个百万订单处理时），if(DEBUG_ENABLED)就
: 我在说的是，如果要考虑性能，if(DEBUG_ENABLED)是最好方案，建Filter和if(logger.i
|
Q**g
发帖数: 183 | 46 你高兴直接call
log4j也行啊。自定义的那个logger你愿意做成wrapper也行，愿意作成filter也行。repl
icate all log4j API也没什么大不了的，每个函数就一句话，就是call log4j的对应函
数。
还不高兴呢，就只在if判断的时候用logger，真正写log的时候直接调log4j就行，那样就
是一个filter.
作filter的话其实根cyclops proposed的方法是一样的。俺自己是倾向于做成wrapper。
这样其实更灵活。以后如果想换别掉log4j用别的包的话，改改logger类就行了，成百上
千的clie
nt程序都可以不改，只要你在logger上的interface不变
【在 m******t 的大作中提到】
:
: -
: Are you suggesting to have a class level static variable which is
: initialized by calling isDebugEnabled()? If that's the case, then
: I don't have problem. I may have mixed up your approach with somebody
: else earlier suggesting to have a global static variable.
|
