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

Scala 中 ensuring 方法的使用说明

2012-09-25 | 阅读(2,347)

Scala 在方法里除了可用 assert() 方法像 Java 那样进行断言，还可以使用 ensuring() 方法在返回结果的分支的花括号同一行上进行断言。它们不同的是 assert 可以随意放在哪里对任何的 boolean 类型进行断言，而 ensuring 是用来对返回结果行断言的，所以它必须尾随返回结果处。 assert 和 ensuring 方法都是定方在 Predef 中的，所以可以直接写。

在《Programming in Scala》一书中对 ensuring 使用的示例代码，会让人感到很费解的，并且对 ensuring 的解释也不多，只是说了 ensuring 中用 "_" 作为当前返回结果对象的占位符。在《Programming in Scala》中 ensuring 示例代码是：

private def widen(w: Int): Element = 
    if(w <= width)
        this
    else {
        val left = elem(' ', (w - width)/2, height)
        var right = elem(' ', (w - width -left.width, height)
        left beside this beside right
    } ensuring (w <= _.width)

private def widen(w: Int): Element =

if(w <= width)

this

else {

val left = elem(' ', (w - width)/2, height)

var right = elem(' ', (w - width -left.width, height)

left beside this beside right

} ensuring (w <= _.width)

第一个让人一下不好理解的是方法定义第一行等号后没有加花括号，一般来说方法只包一条(行)语句时花括号可以省略，多行时虽然程序能够推断出该方法在何处解释，但人来阅读时却不容易把握方法代码在哪里结束，所以最好多行时用花括号括住函数代码。再说，如果在 Scala 控制台敲上面的代码，中间加回车的时候就会报错。阅读全文 >>

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

2012-09-17 | 阅读(4,898)

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,356)

前面通过在 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,218)

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. 阅读全文 >>

AspectJ 基于自定义的方法注解来拦截方法

2012-08-16 | 阅读(10,275)

通常在使用 AspectJ 时都是基于识别方法的规则来进行方法拦截，例如切片里这样写

@Pointcut("execution(* *..StockService.getBaseInfo(..))")

它拦截到的是以 StockService 结尾的，方法名为 getBaseInfo，参数任意，返回值任意的方法。而我这里要说的一种方式是基于自定义注解来拦截方法的，此处的注解不是指 @Aspect, @Pointcut, 或 @Before 那一堆东西，而是指你可以自定义一个注解，如 @cc.unmi.testaspectj.MonitorMethod，被它所注解的方法即被拦截，像：

@cc.unmi.testaspectj.MonitorMethod
public void foo();

这可以给我们很大的自由度来快捷控制哪些方法需要被拦截，加个上面的注解 @MonitorMethod 即可，而不像从前那般要想像用什么规则去匹配某个方法，用 || 连接起来，同时还要防止影响到别的不期望被拦截的方法。

需要的代码并不多，四步，创建自定义注解类 MonitorMethod, 需被拦截的方法加上 @MonitorMethod，方面类，测试类。阅读全文 >>

Spring+AspectJ+ 简单方式来拦截方法，监测性能

2012-08-15 | 阅读(1,834)

还是在很久以前，作过一篇用 AOP 来记录每个方法的执行时间(Spring 或直接 AspectJ), 其中例示了三种方法来拦截方法，用以监测方法调用时间它们分别是：

1. Spring 2.0 用 AspectJ 实现 AOP
2. Spring 通用的方法拦截
3. 直接用 AspectJ 实现

在这里再次使用 <aop:aspect-autoproxy/> 再 @Aspect 注解的方式来写个新的例子。原理与前面基本一致，只是在类里用 @Aspect, @Pointcut, @Before, @After, @Around, @AfterReturning, @AfterThrowing 来写拦截类。

局限仍然是必须通过 Spring 的 BeanFactory 获得的实例才能被拦截到，除非是在 Eclipse 里安装 AJDT 或是使用 Maven-AspectJ Plugin 来编译工程。

好，我们来看完整的例子，下面列出所有的项目文件，这是一个 Maven 的项目，所以从 pom.xml 开始。阅读全文 >>

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

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

在网页的 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>

阅读全文 >>

JUnit 4 如何正确测试异常

2012-06-08 | 阅读(24,244)

本篇讲述如何在 JUnit 4 下正确测试异常，我会从 try..catch 的方式谈起，然后说到 @Test(expected=Exception.class), 最后论及 @Rules public ExpectedException 的实现方式，最终基本可确定用 @Rules 是最方便的。

我们在用 JUnit 测试方法异常的时候，最容易想到的办法就是用 try...catch 去捕获异常，需要断言以下几个条件：

1. 确实抛出的异常
2. 抛出异常的 Class 类型
3. 抛出异常的具体类型，一般检查异常的 message 属性中包含的字符串的断定

所以常用的代码你可能会这么写：

@Test
public void passwordLengthLessThan6LettersThrowsException(){
    try{
        Password.validate("123");
        fail("No exception thrown.");
    }catch(Exception ex){
        assertTrue(ex instanceof InvalidPasswordException);
        assertTrue(ex.getMessage().contains("contains at least 6"));
    }
}

@Test

public void passwordLengthLessThan6LettersThrowsException(){

try{

Password.validate("123");

fail("No exception thrown.");

}catch(Exception ex){

assertTrue(ex instanceof InvalidPasswordException);

assertTrue(ex.getMessage().contains("contains at least 6"));

}

这里被测试的方法是 Password.validate() 方法是否抛出了相应的异常，注意这里别漏 try 中的

fail("No Exception thrown.") 阅读全文 >>

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

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

自 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 更优雅些。

SPRING-MVC 访问静态文件, 如 jpg/js/css

2012-03-15 | 阅读(3,581)

如何你的DispatcherServlet拦截 .do这样的URL，就不存在访问不到静态资源的问题。如果你的DispatcherServlet拦截“/”，拦截了所有的请求，同时对.js,*.jpg的访问也就被拦截了。

目的：可以正常访问静态文件，不要找不到静态文件报404。

方案一：激活Tomcat的defaultServlet来处理静态文件

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.jpg</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.css</url-pattern>
</servlet-mapping>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>*.jpg</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>*.js</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>*.css</url-pattern>

</servlet-mapping>

要配置多个，每种文件配置一个阅读全文 >>

ddd on postgres in (?,?) 和 =any(?) 用法/性能对比好文章
Perry Conn on Java 9 前/后使用 JAXB (包括支持 javax.* 或 jakarta.*)Your writing has a way of making even the most complex topics accessib...
Yanbin on Windows 安装使用 GCC(mingw-w64)是的，像 Rust 和 dotnet core 一样，都可以支持 Cross compile. Rust 和 g++ 在 Linux 下编译...
MerrickZ on Windows 安装使用 GCC(mingw-w64)我记得G++/GCC都是支持交叉编译的，你可以在linux/macos下面编译出windows平台的二进制PE文件……
Jack on 从 Rust 官方文档理解 Ownership哈哈，年纪大了才会下垂