java缓存修改 方法 缓存没

> 博客详情
现在就分别把IE,firefox,chrome中解决办法贴出来供大家参考:
1.firefox(火狐浏览器)解决问题
第一步,在浏览器中敲入:about:config ,然后回车
第二步,在显示出的内容中找到下面的列表内容,双击下面图中圈出的内容
在出现的对话框中将3改为1
然后关闭这个页面,你就可以让你的项目在更新时浏览器及时地更新你项目中的js文件。
打开IE浏览器,同时按住ALT+X,在出现的页面上点击Internet选项,进入Internet选项配置界面中,点击在下面的图中圈出的按钮
进入设置界面,然后选中下面图中圈出的选项
然后依次点击确定,然后,IE浏览器就可以及时更新项目中更改的js文件。
3.chrome(谷歌浏览器)
此方法是根据下方评论整理,个人未验证。
只要F12打开开发者工具,点击右下角的齿轮“设置”按钮进入下一界面,选中General选项卡中的Disable cache (while DevTools is open) 就行了。下次只要你是在开发者工具打开的情况下,均会不保存缓存,因此会加载最新版本的js。
4.刚刚想起来的一个办法
这个办法也没有根本的解决为什么修改的js文件不能在浏览器中及时更新,但是使用本方法可以实现更新,这个方法就是手动删除部署的文件,然后从新部署项目。下面是分别针对myeclipse和eclipse找到部署的项目的位置。
4.1针对eclipse使用者:
使用eclipse的朋友们注意,由于eclipse默认的在tomcat中部署项目的位置并不在tomcat中的webapp目录下,而是在eclipse安装路径下,例如我使用的是eclipse luna ,我在tomcat中部署的项目的默认的位置为:&.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps ,你如果想找这个路径,那么,你就需要去你的workspace下去找.metadata文件夹,然后再按照上面的路径查找到你的部署的项目,手动删除后,在eclipse中从新部署项目,就可以消除浏览器不能更新的问题。
4.1针对Myeclipse使用者:
myeclipse中部署的项目的路径就在tomcat的安装路径中webapp文件夹下,在这个webapp文件夹中查找到你的项目,手动删除,然后在myeclipse中重新部署项目即可。
5.其他方法
根据评论本文章的朋友们的建议,我也亲自尝试了一下他们的方法,觉得这个方法还是蛮不错的,比我的上面的方法要好的多,只需要在引用的js中加入下面的一句话即可
&script&src="1.js?ver=1"&&/script&
一开始我还以为后面的ver=1需要经常修改值才不会造成仍旧读不出来,现在发现及时修改的js文件,也不需要修改这个数字就可以更新。
当然,这只是权益之计,如果想解决根本问题,还需要仔细思考为什么部署的项目不能及时更新。
这个我考虑过,可以直接在浏览器里面设置禁用缓存,但是一些表单什么的数据就没有了。
&script src=&1.js?ver=1&&&/script&每次改完都更新一下ver的值。为什么不考虑这种办法呢
&script src=&1.js?ver=1&&&/script&每次改完都更新一下ver的值。为什么不考虑这种办法呢 那你这岂不是很费时费力,每次都需要去改这个值么。文章里所写的只不过是权宜之计而已。按照我们的想法,并不需要加什么ver或者做任何配置,只要我修改了js文件,浏览器就要识别出来,但是它为什么识别不了?这才是需要解决的根本目的。
这个方法也不错。
支付宝支付
微信扫码支付
打赏金额: ¥
已支付成功
打赏金额: ¥Java怎么清除缓存_百度知道
Java怎么清除缓存
某系统 一些内容是放在缓存中的 很大一部分都是异步的 EXTJS UI 点击退出的时候如果不清空 缓存点击后退还能进行信息的修改 请问怎么办 才能清除缓存 谢谢
通过 Java 控制面板删除临时文件在 Java 控制面板的常规选项卡下,单击“临时 Internet 文件”部分下的设置。此时将显示临时文件设置对话框。&在“临时文件设置”对话框上单击删除文件。此时将显示删除文件和应用程序对话框。在删除文件和应用程序对话框上单击确定。这将从高速缓存中删除所有下载的应用程序和小应用程序。在临时文件设置对话框上单击确定。如果要从高速缓存中删除特定的应用程序和小应用程序,请分别单击“查看应用程序”和“查看小应用程序”选项。
采纳率:76%
//wenku,关于缓存是输入输出流呢还是你就想清除系统缓存呢.baidu?这个里面有一些清理缓存的方法可以看看你好
楼上说得是对的,这跟缓存没关系,是你程序考虑不够完善。
这不是你清除缓存的问题,是你设计有问题
java自带垃圾处理器,
软件设置中有清除缓存的选项。
其他3条回答
为您推荐:
其他类似问题
缓存 java的相关知识
换一换
回答问题,赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。博客分类:
public static void main(String[] args) {
Integer a=200;
Integer b=200;
System.err.println(a==b);
一般人会肯定的说结果是false。因为Integer 的缓存范围是-128至127.
但其实127这个数字是可以认为改变的(当然改变的值也不能小于127):
-Djava.lang.Integer.IntegerCache.high=250
当改成250的时候,结果是true了。
对应的jdk的源码:
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
huangyunbin
浏览: 1531623 次
来自: 广州
同志,你这不行啊!
解决了我的问题,多谢博主分享!
用 @RequestParam 的 required()属性也 ...
很赞,很赞
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'拒绝访问 | www.ggdoc.com | 百度云加速
请打开cookies.
此网站 (www.ggdoc.com) 的管理员禁止了您的访问。原因是您的访问包含了非浏览器特征(3d6f60e49a9643bf-ua98).
重新安装浏览器,或使用别的浏览器Java 日志缓存机制的实现
概述日志技术为产品的质量和服务提供了重要的支撑。JDK 在 1.4 版本以后加入了日志机制,为 Java 开发人员提供了便利。但这种日志机制是基于静态日志级别的,也就是在程序运行前就需设定下来要打印的日志级别,这样就会带来一些不便。在 JDK 提供的日志功能中,日志级别被细化为 9 级,用以区分不同日志的用途,用来记录一个错误,或者记录正常运行的信息,又或是记录详细的调试信息。由于日志级别是静态的,如果日志级别设定过高,低级别的日志难以打印出来,从而导致在错误发生时候,难以去追踪错误的发生原因,目前常常采用的方式是在错误发生的时候,不得不先调整日志级别到相对低的程度,然后再去触发错误,使得问题根源得到显现。但是这种发生问题需要改动产品配置,然后重新触发问题进行调试的方式使得产品用户体验变差,而且有些问题会因为偶发性,环境很复杂等原因很难重新触发。相反,如果起初就把日志级别调整到比较低,那么日志中间会有大量无用信息,而且当产品比较复杂的时候,会导致产生的日志文件很大,刷新很快,无法及时的记录有效的信息,甚至成为性能瓶颈,从而降低了日志功能对产品的帮助。本文借助 Java Logging 中的 MemoryHandler 类将所有级别日志缓存起来,在适当时刻输出,来解决这个问题。主要围绕 MemoryHandler 的定义和 logging.properties 文件的处理而展开。实例依附的场景如下,设想用户需要在产品发生严重错误时,查看先前发生的包含 Exception 的错误信息,以此作为诊断问题缘由的依据。使用 Java 缓冲机制作出的一个解决方案是,将所有产品运行过程中产生的包含 Exception 的日志条目保存在一个可设定大小的循环缓冲队列中,当严重错误(SEVERE)发生时,将缓冲队列中的日志输出到指定平台,供用户查阅。Java 日志机制的介绍Java 日志机制在很多文章中都有介绍,为了便于后面文章部分的理解,在这里再简单介绍一下本文用到的一些关键字。Level:JDK 中定义了 Off、Severe、Warning、Info、Config、Fine、Finer、Finest、All 九个日志级别,定义 Off 为日志最高等级,All 为最低等级。每条日志必须对应一个级别。级别的定义主要用来对日志的严重程度进行分类,同时可以用于控制日志是否输出。LogRecord:每一条日志会被记录为一条 LogRecord, 其中存储了类名、方法名、线程 ID、打印的消息等等一些信息。Logger:日志结构的基本单元。Logger 是以树形结构存储在内存中的,根节点为 root。com.test(如果存在)一定是 com.test.demo(如果存在)的父节点,即前缀匹配的已存在的 logger 一定是这个 logger 的父节点。这种父子关系的定义,可以为用户提供更为自由的控制粒度。因为子节点中如果没有定义处理规则,如级别 handler、formatter 等,那么默认就会使用父节点中的这些处理规则。Handler:用来处理 LogRecord,默认 Handler 是可以连接成一个链状,依次对 LogRecord 进行处理。Filter:日志过滤器。在 JDK 中,没有实现。Formatter:它主要用于定义一个 LogRecord 的输出格式。图 1. Java 日志处理流程图 1 展示了一个 LogRecord 的处理流程。一条日志进入处理流程首先是 Logger,其中定义了可通过的 Level,如果 LogRecord 的 Level 高于 Logger 的等级,则进入 Filter(如果有)过滤。如果没有定义 Level,则使用父 Logger 的 Level。Handler 中过程类似,其中 Handler 也定义了可通过 Level,然后进行 Filter 过滤,通过如果后面还有其他 Handler,则直接交由后面的 Handler 进行处理,否则会直接绑定到 formatter 上面输出到指定位置。在实现日志缓存之前,先对 Filter 和 Formatter 两个辅助类进行介绍。FilterFilter 是一个接口,主要是对 LogRecord 进行过滤,控制是否对 LogRecord 进行进一步处理,其可以绑定在 Logger 下或 Handler 下。只要在 boolean isLoggable(LogRecord)方法中加上过滤逻辑就可以实现对 logrecord 进行控制,如果只想对发生了 Exception 的那些 log 记录进行记录,那么可以通过清单 1 来实现,当然首先需要将该 Filter 通过调用 setFilter(Filter)方法或者配置文件方式绑定到对应的 Logger 或 Handler。清单 1. 一个 Filter 实例的实现 @Override
public boolean isLoggable(LogRecord record){
if(record.getThrown()!=null){
}FormatterFormatter 主要是对 Handler 在输出 log 记录的格式进行控制,比如输出日期的格式,输出为 HTML 还是 XML 格式,文本参数替换等。Formatter 可以绑定到 Handler 上,Handler 会自动调用 Formatter 的 String format(LogRecord r) 方法对日志记录进行格式化,该方法具有默认的实现,如果想实现自定义格式可以继承 Formater 类并重写该方法,默认情况下例如清单 2 在经过 Formatter 格式化后,会将 {0} 和 {1} 替换成对应的参数。清单 2. 记录一条 log logger.log(Level.WARNING,"this log is for test1: {0} and test2:{1}",
new Object[]{newTest1(),
new Test2()});MemoryHandlerMemoryHandler 是 Java Logging 中两大类 Handler 之一,另一类是 StreamHandler,二者直接继承于 Handler,代表了两种不同的设计思路。Java Logging Handler 是一个抽象类,需要根据使用场景创建具体 Handler,实现各自的 publish、flush 以及 close 等方法。MemoryHandler 使用了典型的“注册 - 通知”的观察者模式。MemoryHandler 先注册到对自己感兴趣的 Logger 中(logger.addHandler(handler)),在这些 Logger 调用发布日志的 API:log()、logp()、logrb() 等,遍历这些 Logger 下绑定的所有 Handlers 时,通知触发自身 publish(LogRecord)方法的调用,将日志写入 buffer,当转储到下一个日志发布平台的条件成立,转储日志并清空 buffer。这里的 buffer 是 MemoryHandler 自身维护一个可自定义大小的循环缓冲队列,来保存所有运行时触发的 Exception 日志条目。同时在构造函数中要求指定一个 Target Handler,用于承接输出;在满足特定 flush buffer 的条件下,如日志条目等级高于 MemoryHandler 设定的 push level 等级(实例中定义为 SEVERE)等,将日志移交至下一步输出平台。从而形成如下日志转储输出链:图 2. Log 转储链在实例中,通过对 MemoryHandler 配置项 .push 的 Level 进行判断,决定是否将日志推向下一个 Handler,通常在 publish() 方法内实现。代码清单如下:清单 3
// 只纪录有异常并且高于 pushLevel 的 logRecord
final Level level = record.getLevel();
final Throwable thrown = record.getThrown();
If(level &= pushLevel){
}MemoryHandler.push 方法的触发条件Push 方法会导致 MemoryHandler 转储日志到下一 handler,清空 buffer。触发条件可以是但不局限于以下几种,实例中使用的是默认的第一种:
日志条目的 Level 大于或等于当前 MemoryHandler 中默认定义或用户配置的 pushLevel;
外部程序调用 MemoryHandler 的 push 方法;
MemoryHandler 子类可以重载 log 方法或自定义触发方法,在方法中逐一扫描日志条目,满足自定义规则则触发转储日志和清空 buffer 的操作。MemoryHanadler 的可配置属性表 1.MemoryHandler 可配置属性
MemoryHandler.level
MemoryHandler 接受的输入到 buffer 的日志等级
Level.INFO
MemoryHandler.filter
在输入到 buffer 之前,可在 filter 中自定义除日志等级外的其他过滤条件
(Undefined)
MemoryHandler.formatter
指定输入至 buffer 的日志格式
(Undefined)
MemoryHandler.encoding
指定输入至 buffer 的日志编码,在 MemoryHandler 中应用甚少
(Undefined)
MemoryHandler.size
以日志条目为单位定义循环 buffer 的大小
MemoryHandler.push
定义将 buffer 中的日志条目发送至下一个 Handler 的最低 Level(包含)
Level.SEVERE
MemoryHandler.target
在构造函数中指定下一步承接日志的 Handler
(Undefined)
使用方式:以上是记录产品 Exception 错误日志,以及如何转储的 MemoryHandler 处理的内部细节;接下来给出 MemoryHandler 的一些使用方式。1. 直接使用 java.util.logging 中的 MemoryHandler清单 4 // 在 buffer 中维护 5 条日志信息
// 仅记录 Level 大于等于 Warning 的日志条目并
// 刷新 buffer 中的日志条目到 fileHandler 中处理
int bufferSize = 5;
f = new FileHandler("testMemoryHandler.log");
m = new MemoryHandler(f, bufferSize, Level.WARNING);
myLogger = Logger.getLogger("com.ibm.test");
myLogger.addHandler(m);
myLogger.log(Level.WARNING, “this is a WARNING log”);2. 自定义1)反射思考自定义 MyHandler 继承自 MemoryHandler 的场景,由于无法直接使用作为父类私有属性的 size、buffer 及 buffer 中的 cursor,如果在 MyHandler 中有获取和改变这些属性的需求,一个途径是使用反射。清单 5 展示了使用反射读取用户配置并设置私有属性。清单 5 int m_
String sizeString = manager.getProperty(loggerName + ".size");
if (null != sizeString) {
m_size = Integer.parseInt(sizeString);
if (m_size &= 0) {
m_size = BUFFER_SIZE; // default 1000
// 通过 java 反射机制获取私有属性
f = getClass().getSuperclass().getDeclaredField("size");
f.setAccessible(true);
f.setInt(this, m_size);
f = getClass().getSuperclass().getDeclaredField("buffer");
f.setAccessible(true);
f.set(this, new LogRecord[m_size]);
} catch (Exception e) {
}2)重写直接使用反射方便快捷,适用于对父类私有属性无频繁访问的场景。思考这样一种场景,默认环形队列无法满足我们存储需求,此时不妨令自定义的 MyMemoryHandler 直接继承 Handler,直接对存储结构进行操作,可以通过清单 6 实现。清单 6 public class MyMemoryHandler extends Handler{
// 默认存储 LogRecord 的缓冲区容量
private static final int DEFAULT_SIZE = 1000;
// 设置缓冲区大小
private int size = DEFAULT_SIZE;
// 设置缓冲区
private LogRecord[]
// 参考 java.util.logging.MemoryHandler 实现其它部分
}使用 MemoryHandler 时需关注的几个问题了解了使用 MemoryHandler 实现的 Java 日志缓冲机制的内部细节和外部应用之后,来着眼于两处具体实现过程中遇到的问题:Logger/Handler/LogRecord Level 的传递影响,以及如何在开发 MemoryHandler 过程中处理错误日志。1. Level 的传递影响Java.util.logging 中有三种类型的 Level,分别是 Logger 的 Level,Handler 的 Level 和 LogRecord 的 Level. 前两者可以通过配置文件设置。之后将日志的 Level 分别与 Logger 和 Handler 的 Level 进行比较,过滤无须记录的日志。在使用 Java Log 时需关注 Level 之间相互影响的问题,尤其在遍历 Logger 绑定了多个 Handlers 时。如图 3 所示:图 3. Java Log 中 Level 的传递影响Java.util.logging.Logger 提供的 setUseParentHandlers 方法,也可能会影响到最终输出终端的日志显示。这个方法允许用户将自身的日志条目打印一份到 Parent Logger 的输出终端中。缺省会打印到 Parent Logger 终端。此时,如果 Parent Logger Level 相关的设置与自身 Logger 不同,则打印到 Parent Logger 和自身中的日志条目也会有所不同。如图 4 所示:图 4. 子类日志需打印到父类输出终端2. 开发 log 接口过程中处理错误日志在开发 log 相关接口中调用自身接口打印 log,可能会陷入无限循环。Java.util.logging 中考虑到这类问题,提供了一个 ErrorManager 接口,供 Handler 在记录日志期间报告任何错误,而非直接抛出异常或调用自身的 log 相关接口记录错误或异常。Handler 需实现 setErrorManager() 方法,该方法为此应用程序构造 java.util.logging.ErrorManager 对象,并在错误发生时,通过 reportError 方法调用 ErrorManager 的 error 方法,缺省将错误输出到标准错误流,或依据 Handler 中自定义的实现处理错误流。关闭错误流时,使用 Logger.removeHandler 移除此 Handler 实例。两种经典使用场景,一种是自定义 MyErrorManager,实现父类相关接口,在记录日志的程序中调用 MyHandler.setErrorManager(new MyEroorManager()); 另一种是在 Handler 中自定义 ErrorManager 相关方法,示例如清单 7:清单 7 public class MyHandler extends Handler{
// 在构造方法中实现 setErrorManager 方法
public MyHandler(){
setErrorManager (new ErrorManager() {
public void
error (String msg, Exception ex, int code) {
System.err.println("Error reported by MyHandler "
+ msg + ex.getMessage());
public void publish(LogRecord record){
if (!isLoggable(record))
// 一些可能会抛出异常的操作
} catch(Exception e) {
reportError ("Error occurs in publish ", e, ErrorManager.WRITE_FAILURE);
}logging.propertieslogging.properties 文件是 Java 日志的配置文件,每一行以“key=value"的形式描述,可以配置日志的全局信息和特定日志配置信息,清单 8 是我们为测试代码配置的 logging.properties。清单 8. logging.properties 文件示例 #Level 等级 OFF & SEVERE & WARNING & INFO & CONFIG & FINE & FINER & FINEST & ALL
# 为 FileHandler 指定日志级别
java.util.logging.FileHandler.level=WARNING
# 为 FileHandler 指定 formatter
java.util.logging.FileHandler.formatter=java.util.logging.SimpleFormatter
# 为自定义的 TestMemoryHandler 指定日志级别
com.ibm.test.MemoryHandler.level=INFO
# 设置 TestMemoryHandler 最多记录日志条数
com.ibm.test.TestMemoryHandler.size=1000
# 设置 TestMemoryHandler 的自定义域 useParentLevel
com.ibm.test.TestMemoryHandler.useParentLevel=WARNING
# 设置特定 log 的 handler 为 TestMemoryHandler
com.ibm.test.handlers=com.ibm.test.TestMemoryHandler
# 指定全局的 Handler 为 FileHandler
handlers=java.util.logging.FileHandler从
中可以看出 logging.properties 文件主要是用来给 logger 指定等级(level),配置 handler 和 formatter 信息。如何监听 logging.properties如果一个系统对安全性要求比较高,例如系统需要对更改 logging.properties 文件进行日志记录,记录何时何人更改了哪些记录,那么应该怎么做呢?这里可以利用 JDK 提供的 PropertyChangeListener 来监听 logging.properties 文件属性的改变。例如创建一个 LogPropertyListener 类,其实现了 java.benas.PropertyChangeListener 接口,PropertyChangeListener 接口中只包含一个 propertyChange(PropertyChangeEvent)方法,该方法的实现如清 9 所示。清单 9. propertyChange 方法的实现 @Override
public void propertyChange(PropertyChangeEvent event) {
if (event.getSource() instanceof LogManager){
LogManager manager=(LogManager)event.getSource();
update(manager);
execute();
}propertyChange(PropertyChangeEvent)方法中首先调用 update(LogManager)方法来找出 logging.properties 文件中更改的,增加的以及删除的项,这部分代码如清单 10 所示;然后调用 execute() 方法来执行具体逻辑,参见 ;最后调用 reset() 方法对相关属性保存以及清空,如
所示。清单 10. 监听改变的条目 public void update(LogManager manager){
Properties logProps =
// 使用 Java 反射机制获取私有属性
Field f = manager.getClass().getDeclaredField("props");
f.setAccessible(true );
logProps=(Properties)f.get(manager);
}catch (Exception e){
logger.log(Level.SEVERE,"Get private field error.", e);
Set&String& logPropsName=logProps.stringPropertyNames();
for (String logPropName:logPropsName){
String newVal=logProps.getProperty(logPropName).trim();
// 记录当前的属性
newProps.put(logPropName, newVal);
// 如果给属性上次已经记录过
if (oldProps.containsKey(logPropName)){
String oldVal = oldProps.get(logPropName);
if (newVal== null ?oldVal== null :newVal.equals(oldVal)){
// 属性值没有改变,不做任何操作
changedProps.put(logPropName, newVal);
oldProps.remove(logPropName);
}else {// 如果上次没有记录过该属性,则其应为新加的属性,记录之
changedProps.put(logPropName, newVal);
}代码中 oldProps、newProps 以及 changedProps 都是 HashMap&String,String& 类型,oldProps 存储修改前 logging.properties 文件内容,newProps 存储修改后 logging.properties 内容,changedProps 主要用来存储增加的或者是修改的部分。方法首先通过 Java 的反射机制获得 LogManager 中的私有属性 props(存储了 logging.properties 文件中的属性信息),然后通过与 oldProps 比较可以得到增加的以及修改的属性信息,最后 oldProps 中剩下的就是删除的信息了。清单 11. 具体处理逻辑方法 private void execute(){
// 处理删除的属性
for (String prop:oldProps.keySet()){
// 这里可以加入其它处理步骤
logger.info("'"+prop+"="+oldProps.get(prop)+"'has been removed");
// 处理改变或者新加的属性
for (String prop:changedProps.keySet()){
// 这里可以加入其它处理步骤
logger.info("'"+prop+"="+oldProps.get(prop)+"'has been changed or added");
}该方法是主要的处理逻辑,对修改或者删除的属性进行相应的处理,比如记录属性更改日志等。这里也可以获取当前系统的登录者,和当前时间,这样便可以详细记录何人何时更改过哪个日志条目。清单 12. 重置所有数据结构private void reset(){
oldProps = newP
newProps= new HashMap& String,String&();
changedProps.clear();
}reset() 方法主要是用来重置各个属性,以便下一次使用。当然如果只写一个 PropertyChangeListener 还不能发挥应有的功能,还需要将这个 PropertyChangeListener 实例注册到 LogManager 中,可以通过清单 13 实现。清单 13. 注册 PropertyChangeListener // 为'logging.properties'文件注册监听器
LogPropertyListener listener= new LogPropertyListener();
LogManager.getLogManager().addPropertyChangeListener(listener);如何实现自定义标签在 中有一些自定义的条目,比如 com.ibm.test.TestMemoryHandler。useParentLever=WARNING",表示如果日志等级超过 useParentLever 所定义的等级 WARNING 时,该条日志在 TestMemoryHandler 处理后需要传递到对应 Log 的父 Log 的 Handler 进行处理(例如将发生了 WARNING 及以上等级的日志上下文缓存信息打印到文件中),否则不传递到父 Log 的 Handler 进行处理,这种情况下如果不做任何处理,Java 原有的 Log 机制是不支持这种定义的。那么如何使得 Java Log 支持这种自定义标签呢?这里可以使用 PropertyListener 对自定义标签进行处理来使得 Java Log 支持这种自定义标签,例如对“useParentLever”进行处理可以通过清单 14 实现。清单 14
private void execute(){
// 处理删除的属性
for (String prop:oldProps.keySet()){
if (prop.endsWith(".useParentLevel")){
String logName=prop.substring(0, prop.lastIndexOf("."));
Logger log=Logger.getLogger(logName);
for (Handler handler:log.getHandlers()){
if (handler
instanceof TestMemoryHandler){
((TestMemoryHandler)handler)
.setUseParentLevel(oldProps.get(prop));
// 处理改变或者新加的属性
for (String prop:changedProps.keySet()){
if (prop.endsWith(".useParentLevel")){
// 在这里添加逻辑处理步骤
}在清单 14 处理之后,就可以在自定义的 TestMemoryHandler 中进行判断了,对 log 的等级与其域 useParentLevel 进行比较,决定是否传递到父 Log 的 Handler 进行处理。在自定义 TestMemoryHandler 中保存对应的 Log 信息可以很容易的实现将信息传递到父 Log 的 Handler,而保存对应 Log 信息又可以通过 PropertyListener 来实现,例如清单 15 更改了 中相应代码实现这一功能。清单 15 if (handler
instanceof TestMemoryHandler){
((TestMemoryHandler)handler).setUseParentLevel(oldProps.get(prop));
((TestMemoryHandler)handler).addLogger(log);
}具体如何处理自定义标签的值那就看程序的需要了,通过这种方法就可以很容易在 logging.properties 添加自定义的标签了。自定义读取配置文件如果 logging.properties 文件更改了,需要通过调用 readConfiguration(InputStream)方法使更改生效,但是从 JDK 的源码中可以看到 readConfiguration(InputStream)方法会重置整个 Log 系统,也就是说会把所有的 log 的等级恢复为默认值,将所有 log 的 handler 置为 null 等,这样所有存储的信息就会丢失。比如,TestMemoryHandler 缓存了 1000 条 logRecord,现在用户更改了 logging.properties 文件,并且调用了 readConfiguration(InputStream) 方法来使之生效,那么由于 JDK 本身的 Log 机制,更改后对应 log 的 TestMemoryHandler 就是新创建的,那么原来存储的 1000 条 logRecord 的 TestMemoryHandler 实例就会丢失。那么这个问题应该如何解决呢?这里给出三种思路:1). 由于每个 Handler 都有一个 close() 方法(任何继承于 Handler 的类都需要实现该方法),Java Log 机制在将 handler 置为 null 之前会调用对应 handler 的 close() 方法,那么就可以在 handler(例如 TestMemoryHandler)的 close() 方法中保存下相应的信息。2). 研究 readConfiguration(InputStream)方法,写一个替代的方法,然后每次调用替代的方法。3). 继承 LogManager 类,覆盖 readConfiguration(InputStream)方法。这里第一种方法是保存原有的信息,然后进行恢复,但是这种方法不是很实用和高效;第二和第三种方法其实是一样的,都是写一个替代的方法,例如可以在替代的方法中对 Handler 为 TestMemoryHandler 的不置为 null,然后在读取 logging.properties 文件时发现为 TestMemoryHandler 属性时,找到对应 TestMemoryHandler 的实例,并更改相应的属性值(这个在清单 14 中有所体现),其他不属于 TestMemoryHandler 属性值的可以按照 JDK 原有的处理逻辑进行处理,比如设置 log 的 level 等。另一方面,由于 JDK1.6 及之前版本不支持文件修改监听功能,每次修改了 logging.properties 文件后需要显式调用 readConfiguration(InputStream)才能使得修改生效,但是自 JDK1.7 开始已经支持对文件修改监听功能了,主要是在 java.nio.file.* 包中提供了相关的 API,这里不再详述。那么在 JDK1.7 之前,可以使用 apache 的 commons-io 库中的 FileMonitor 类,在此也不再详述。总结通过对 MemoryHandler 和 logging.properties 进行定义,可以通过 Java 日志实现自定义日志缓存,从而提高 Java 日志的可用性,为产品质量提供更强有力的支持。
相关主题:Java 日志框架介绍的官方文档。
:Java 日志方面的 API 文档。
:主要介绍 Java 日志框架和在软件调试中的作用。
:JavaAPI 官方文档。
:介绍 Java 7 的新特性,比如文件监听功能。
:这里有数百篇关于 Java 编程各个方面的文章。
添加或订阅评论,请先或。
有新评论时提醒我
static.content.url=http://www.ibm.com/developerworks/js/artrating/SITE_ID=10Zone=Java technologyArticleID=939530ArticleTitle=Java 日志缓存机制的实现publish-date=

我要回帖

更多关于 java 本地缓存 的文章

 

随机推荐