Java | 隔叶黄莺 Yanbin Blog - 软件编程实践

切分 Tomcat 的 catalina.out 文件，解决日志文件过大的问题

2012-09-17 | 阅读(5,054)

Tomcat 下日志文件 catalina.out 过大，几百兆或几个G，进而造成再也无法写入更多的日志内容，至使 Tomcat 无法处理请求。需然你可以在 $TOMCAT_HOME/logs 目录下看到有 catalina.2012-09-16.log 这样分日期的归档，但是主文件 catalina.out 却一直在膨胀。

你可以每次手工或定时(crontab/计划任务)清理 catalina.out 文件，或是规划好日志输出(终究也会有满的时候)。再就是有两种较好的解决方案去真正的切分 catalina.out 文件，让 catalina.out 只存有最新的日志。

一. 改用 Log4J 来输出 Tomcat 日志，借助 Log4J 的各种日志切分的功能。详情可参考： http://baalwolf.iteye.com/blog/1464093， http://tomcat.apache.org/tomcat-6.0-doc/logging.html。

二. Linux 下使用 cronolog 工具来切分 catalina.out

这里重点介绍这种方法，具体步骤如下：阅读全文 >>

再说 Java 中使用正则表达式进行后向引用($1,$2...)

2012-08-17 | 阅读(3,463)

前面通过在 Java 中使用正则表达式进行后向引用($1,$2...) 讲了在 Java 中使用 JavaScript 和 JRegex 来实现正则表达式的后向分组引用 $1, $2 替换。

自 JDK 1.4 出现正则表达式以来我还真不知道 Java 的正则表达式是可以在替换时用 $1, $2 达成后向分组替换的，所以前一篇表述有些出入的。也就是要实现 JavaScript 中的

<script>
    var src = "abc def";
    var des = src.replace(/(\w+)\s+(\w+)/, "$2 $1");
    document.write(des);
    //输出为： def abc
</script>

var src = "abc def";

var des = src.replace(/(\w+)\s+(\w+)/, "$2 $1");

document.write(des);

//输出为： def abc

</script>

的功能，完全可以不求助于第三方的正则表达式组件库或是通过 ScriptEngine + JavaScript 来实现，在 Java 字符串的:

public String replaceFirst(String regex, String replacement)
public String replaceAll(String regex, String replacement)

两方法的第三个参数中是可以用 $1, $2 ... 来引用第一个参数的括号分组的，简单 Java 示例代码如下：

"abc def".replaceFirst("(\\w+)\\s+(\\w+)", "$2 $1"); //结果为 def abc
"abc def aaa bbb".replaceAll("(\\w+)\\s+(\\w+)", "$2 $1"); //结果是 def abc bbb aaa

1 2	"abc def".replaceFirst("(\\w+)\\s+(\\w+)", "$2 $1"); //结果为 def abc "abc def aaa bbb".replaceAll("(\\w+)\\s+(\\w+)", "$2 $1"); //结果是 def abc bbb aaa

Java 的正则表达式原本还是很强大的，只怕不能被人发现。

2015-07-14：补充一点，在正则表达式外是用 $1, $2 ... 来进行后向引用，如果是在正则表达式中就需要用 \1, \2 ... 的形式来进后向引用。下面例子，替换重复出现的两位数及之间的内容

"xx12abcd12345".replaceAll("(\\d{2}).+?\\1", ""); //结果为 xx345

1	"xx12abcd12345".replaceAll("(\\d{2}).+?\\1", ""); //结果为 xx345

Java 下高效的反射工具包 ReflectASM 使用例解

2012-08-17 | 阅读(12,294)

ReflectASM 使用字节码生成的方式实现了更为高效的反射机制。执行时会生成一个存取类来 set/get 字段，访问方法或创建实例。一看到 ASM 就能领悟到 ReflectASM 会用字节码生成的方式，而不是依赖于 Java 本身的反射机制来实现的，所以它更快，并且避免了访问原始类型因自动装箱而产生的问题。

下面三个图是 ReflectASM 与 Java 自身反射机制的性能对比，表现很不错的。

测试代码包含在项目文件中. 上面图形是在 Oracle 的 Java 7u3, server VM 下测试出的结果。

下面我们自己来做个测试，测试环境是 Mac OS X 10.8, 2.4G Core 2 Duo, 4G RAM, 64 位 JDK 1.6. 阅读全文 >>

Java 使用 dom4j 来获得 XML 文档的 innerXML

2012-07-17 | 阅读(1,272)

在网页的 Document 中如果想要获得某个结点的 innerHTML 就行，而在 Java 处理 XML 文档时想要获得某个节点的的 innerXML 就没那么简单的，标准的 org.w3c.Element 和 org.w3c.Node 均未提供类似 innerXML 的方法。

幸好，我们常用的 dom4j 里的 org.dom4j.Node 有一个方法是 String asXML()，不过它的意义相当于是 outerXML，也就是说它返回的内容还包括节点本身。

比如有这么在个 XML 文档：

<BookList>
    description of book 1
    <Book id="1">Unmi</Book>
</BookList>

description of book 1

</BookList>

阅读全文 >>

在 Java 中使用正则表达式进行后向引用($1,$2...)

2012-04-25 | 阅读(2,460)

自 JDK1.4 引入正则表达式的支持可称得上是次大改变，~~可 Java 的正则表达式的能力还是很弱，别说和 Perl 比了，就是和 C# 和 JavaScript 的正则表达式比较来也逊色不少~~，不过现在 JVM 上有其他语言对正则表达式有所增强，像 Groovy, jRuby 和 Scala。

[修正一下] 第一句话的说法是有误的，其实 JDK 本身的正则表达式就支持替换时用 $1, $2 那样的后向分组引用，例如：
String s = "abc def".replaceAll("(\\w+)\\s+(\\w+)", "$2 $1"); //s 就是 "def abc"，replaceFirst 也可以用 $1, $2 的替换。

~~比如在 Java 中要实现正则表达式的分组，后向引用的方式进行替换挺复杂的~~，像 JavaScript 完成两个分组的调换：

<script>
    var src = "abc def";
    var des = src.replace(/(\w+)\s+(\w+)/, "$2 $1");
    document.write(des);
    //输出为： def abc
</script>

var src = "abc def";

var des = src.replace(/(\w+)\s+(\w+)/, "$2 $1");

document.write(des);

//输出为： def abc

</script>

在 Java 中可得用上 Pattern, Matcher，还要 find()/group() 等操作，于是我就会考虑在 Java 中完成类似的功能有没有曲线的方法，有的。你可以调用 JVM 上其他语言的功能，我这里用列了两种实现方式

JDK1.6 起可借助 ScriptEngineManager 使用 JavaScript 相应的函数，除此之外还可用第三方的库 JRegex，具体实现，请参见如下代码，还带了测试用例：

package cc.unmi.utils;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

import jregex.Pattern;
import jregex.Replacer;

public class StringUtils {
    public static String replaceStringByJS(String src, String jsRegex, String replacement) {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("JavaScript");
        String script =
                "function rep(target, regex, replacement){\n"
              + "    var patt = new RegExp(regex,'g');\n"
              + "    return target.replace(patt, replacement);\n"
              + "}";

        try {
            engine.eval(script);
            Invocable inv = (Invocable) engine;
            String result = (String) inv.invokeFunction("rep", src, jsRegex,
                    replacement);
            return result;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public static String replaceStringByJRegex(String src, String regex, String replacement) {
        Pattern pattern = new Pattern(regex);
        Replacer replacer = pattern.replacer(replacement);
        String result = replacer.replace(src);
        return result;
    }

    public static void main(String[] args) {
        String link="<link url=\"http://unmi.cc\" >\"Home\"</link>"
                +"<link url=\"http://yanbin.blog/tag/java\" >\"Java\"</link>";
        String jsString = StringUtils.replaceStringByJS(link,
                "<link\\s+url=\\\"(.+?)\\\".[^/]*?>\\\"(.+?)\\\"</link>", "<a href=\"$1\">$2</a>");
        System.out.println(jsString);

        String jregexString = StringUtils.replaceStringByJRegex(link,
                "<link\\s+url=\\\"(.+?)\\\".[^/]*?>\\\"(.+?)\\\"</link>", "<a href=\"$1\">$2</a>");
        System.out.println(jregexString);
    }
    
    /*
     * 程序输出
     * <a href="http://unmi.cc">Home</a><a href="http://yanbin.blog/tag/java">Java</a>
     * <a href="http://unmi.cc">Home</a><a href="http://yanbin.blog/tag/java">Java</a>
     */
}

package cc.unmi.utils;

import javax.script.Invocable;

import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;

import jregex.Pattern;

import jregex.Replacer;

public class StringUtils {

public static String replaceStringByJS(String src, String jsRegex, String replacement) {

ScriptEngineManager manager = new ScriptEngineManager();

ScriptEngine engine = manager.getEngineByName("JavaScript");

String script =

"function rep(target, regex, replacement){\n"

+ " var patt = new RegExp(regex,'g');\n"

+ " return target.replace(patt, replacement);\n"

+ "}";

try {

engine.eval(script);

Invocable inv = (Invocable) engine;

String result = (String) inv.invokeFunction("rep", src, jsRegex,

replacement);

return result;

} catch (Exception e) {

throw new RuntimeException(e);

}

public static String replaceStringByJRegex(String src, String regex, String replacement) {

Pattern pattern = new Pattern(regex);

Replacer replacer = pattern.replacer(replacement);

String result = replacer.replace(src);

return result;

}

public static void main(String[] args) {

String link="<link url=\"http://unmi.cc\" >\"Home\"</link>"

+"<link url=\"http://yanbin.blog/tag/java\" >\"Java\"</link>";

String jsString = StringUtils.replaceStringByJS(link,

"<link\\s+url=\\\"(.+?)\\\".[^/]*?>\\\"(.+?)\\\"</link>", "<a href=\"$1\">$2</a>");

System.out.println(jsString);

String jregexString = StringUtils.replaceStringByJRegex(link,

"<link\\s+url=\\\"(.+?)\\\".[^/]*?>\\\"(.+?)\\\"</link>", "<a href=\"$1\">$2</a>");

System.out.println(jregexString);

}

* 程序输出

* <a href="http://unmi.cc">Home</a><a href="http://yanbin.blog/tag/java">Java</a>

}

起初我是用的第一种方法，后来找到了第二种方式，感觉用 JRegex 更优雅些。

有一种方法给 XSLT 中变量进行赋值，是保持状态的那种

2011-05-04 | 阅读(5,049)

在 XSLT 中声明变量可以用 <xsl:variable> 和 <xsl:param>，它们的区别是可以通过 <xsl:param> 从外部向 XSLT 文件传参数，除此之外，在 xslt 内部使用时这两者的用法基本是一样的。下面只以 <xsl:variable> 为例子，例子中的 xsl:variable 替换成 xsl:param 也是能 run 的。

<xsl:variable> 的基本用法是：

<xsl:variable name="username" select="'Initial'"/> <!-- 不写 select 则默认为 '' -->

<xsl:variable name="username" select="'New Value'"/> <!-- 赋值 -->

<xsl:value-of select="$username"/> <!-- 显示变量值，变量名前加上 $ 符号 -->

<xsl:variable name="username" select="'Initial'"/>

<xsl:variable name="username" select="'New Value'"/>

<xsl:value-of select="$username"/>

阅读全文 >>

应用 JAXB 把 XML 转换成相应的 JavaBean

2011-04-21 | 阅读(4,587)

跨系统的调用目前无疑是 WebService 的天下，指的是通过 HTTP 请求方式获得 XML 或 JSON 数据的方式，RESTFul 也得到了很好的应用。规范意义上的 Soap 调用不知道还不多不多，反正当年用过的 Corba 鲜有耳闻了，就像很多人对 EJB2 不会有概念一样。

Java 在调用 WebService 获得了 XML 之后，接下来一种常见的处理方式就是把它转换成相应的 JavaBean，再丢给其他组件像 Jsp 标签，FreeMarker 等去就很流畅了。关于 XML 与 JavaBean 互相转换有两个操作叫做：Marshaller 和 Unmarshaller，还没见一个权威的翻译，大概就是编组与反编组，意义如同序列化与反序列化。也就是由 JavaBean 到 XML 叫做 Marshal，由 XML 到 Java 叫做 Unmarshal。

通常从 XML 到 JavaBean 的转换机会大的多，所以我主要也是研究了下如何把 XML 映射成 JavaBean，虽然现在的工具一样也都支持这两个方向的转换。有许多组件可以做到，像 JAXB(Java Architecture for XML Binding)、阅读全文 >>

Java 何日能随意实现自定义的对象装箱

2011-01-11 | 阅读(346)

Java 步入到 Tiger 后增加了自动拆装箱特性，构造 Integer 不用 Integer i = new Integer(1); 或者 Integer i = Integer.valueOf(1); 只要写成 Integer i=1 就行了。Java 的自动拆装箱只是针对基本类型与其封装类型之间的转换，无法自定义类似的行为，比如想实现某个自定义类 Item，能够通过 Item i = 1; 就完成从整形 1 到自定义类的自动装箱功能。

Java 在目前还是没办法做到的，当然也是我自己的一个猜想。Java 的自动拆装箱与 C# 相比也是要弱些，C# 中 int 仅仅是 Int32 这样的类型的别名，所以它们也是等效的，声明 int i=0; 你就可以呼叫 i.ToString() 方法了。可以说 C# 比 Java 更对象化了。

现在来看下 C++ 是怎么实现自定义类的 Item i = 10; 这样的声明的，见代码：阅读全文 >>

Java 的方法签名与字段类型表示-[Ljava.lang.String;

2011-01-11 | 阅读(8,783)

我们什么时候会接触到 Java 的方法签名呢？在进行 JNI 调用时，还有在看方法重载时。重载的方法是有不同的方法签名的，而是不区分返回值，而实际方法签名还揉入了返回值类型的，还有就是 javap -s 查看方法签名时，如 javap -s java.util.Date。

看来方法签名与我们实际工作的关系还真的不大。倒是有次遇着了，事出于 Struts2 应用中提交表单时报出了下面的错误：

00:43:59.716 [http-8080-4] WARN com.opensymphony.xwork2.ognl.OgnlValueStack - Error setting expression 'version' with value '[Ljava.lang.String;@e18a9a'
ognl.MethodFailedException: Method "setVersion" failed for object cc.unmi.model.Post@ed0cd7
at ognl.OgnlRuntime.callAppropriateMethod(OgnlRuntime.java:1285) ~[ognl-3.0.jar:na]
at ognl.OgnlRuntime.setMethodValue(OgnlRuntime.java:1474) ~[ognl-3.0.jar:na]
at ognl.ObjectPropertyAccessor.setPossibleProperty(ObjectPropertyAccessor.java:85 阅读全文 >>

XSLT 调用 Java 的类方法

2011-01-10 | 阅读(2,185)

曾经有两篇介绍了在 XSLT 里如何调用 C# 或 Js 写的函数，其中用到了与微软相关的，像：xmlns:msxsl="urn:schemas-microsoft-com:xslt", <msxsl:script implements-prefix="unmifn" language="C#">。回到了 Java 环境同样得考虑在 XSLT 中如何调用 Java 的方法，毕竟在 XSLT 外处理内容要方便许多。

参考了一些网上的文章，大多讲的不怎么好理解与应用，未尝试之前不免让人想缩手。其实做起来可以更简单些，两步而已：

1）声明时指定包名和函数前缀
2）调用时加上前缀和类名及静态方法，传入参数

要想再深入些，可注意有时候 Java 函数应该传入的参数类型是什么？是否能调用非静态方法，public 是最基本的要求，以及通过什么组件来调用的等等。阅读全文 >>

best coffee on SciPy 最优化之最小化I wanted to take a moment to commend you on the outstanding quality of...
seetimee on 体验 Python FastAPI 的并发能力及线, 进程模型感谢
Yanbin on Mockito 3.4.0 开始可 Mock 静态方法有一个补救，新写了一篇 https://yanbin.blog/mockito-mock-static-method-in-multiple...
Yanbin on 升级到 Spring Boot 3 后 javax.inject.Named 不可用怎么，被抄袭了！算是被机器翻译引用的？
oleksi on 升级到 Spring Boot 3 后 javax.inject.Named 不可用https://www.springcloud.io/post/2023-02/springboot-3-javax-inject-name...