• JDK8 的 Lambda 表达式 -- 词法范围和变量捕获

    calendar Oct 16, 2013   ---   · 2 min read · jdk8 lambda  ·
    Share on: linkedin copy
    Lambda 表达式的词法范围，一言以蔽之就是没有引入新的词法范围。这里的词法范围要研究的课题是 this 的指向有没有在变。我们知道在匿名类内部 this 指向的匿名类的实例，这种关系是在编译期就确定的。而在 Lambda 表达式中的 this 与外部的 this 没有差别，也就是说你可以把 Lambda 表达式当成一般的语句来看待，多简单啊，不像 JavaScript 中的 this 被搞的那么魔幻。


    可以这么测试：
    1public void foo(){
2    System.out.println(this);
3    Arrays.asList("Unmi").forEach((s) -> System.out.println(this));
4}

    输出的是同一个地址里的东西：

    cc.unmi.testjdk8.TestLambda@28a418fc
    cc.unmi.testjdk8.TestLambda@28a418fc

    接下来瞧瞧 Lambda 表达式对外层变量的捕获。Lambda 表达式的有个好处就是它是轻量级，可重用单元，并且可捕获外层变量。 Read More

  • JDK8 的 Lambda 表达式 -- 类型推断

    calendar Oct 15, 2013   ---   · 1 min read · jdk8 lambda  ·
    Share on: linkedin copy
    现在我们来看看 JDK8 是怎么对 Lambda 表达式进行类型推断的，Lambda 的实际类型叫做它的目标类型(target type)，因为 JDK8 沿承了已有的类型系统，所以象这样的写法：

    button.addActionListener((ActionEvent e) -> foo());

    addActionListener() 方法接收的是一个 ActionListener 类型的参数，所以这里的 Lambda 表达式 (ActionEvent e) -> foo() 代表的就是一个 ActionListener 实例，编译器是怎么知道这一点的，而且相同的 Lambda 是可以表示不同的类型的，见：

    Callable<String> c = () -> "done";     //这个 () -> "done" 是 Callable<String> 类型
    PrivilegedAction<String> a = () -> "done";  //同样的 () -> "done" 却是 PrivilegedAction<String> 类型

    答曰，根据 Lambda 表达式所处的上下文去感知。上下文决定了 Lambda 所期盼的类型，比如说变量声明类型，方法要求的输入参数类型，所以它必须是明确，不能模棱两可。所以一个 Lambda 表达式能否放在某处需要满足以下几个条件：
    1. 期盼的类型必须是一个功能性接口，这样就能唯一定位到那个抽象方法上去，确定方法签名，接下来就是 Read More

  • JDK8 的 Lambda 表达式 -- 实现原理初探

    calendar Oct 13, 2013   ---   · 3 min read · jdk8 lambda  ·
    Share on: linkedin copy
    JDK8 使用一行 Lambda 表达式可以代替先前用匿名类五六行代码所做的事情，那么它是怎么实现的呢？从所周知，匿名类会在编译的时候生成与宿主类带上 $1, $2 的类文件，如写在 TestLambda 中的匿名类产生成类文件是 TestLambda$1.class, TestLambda$2.class 等。


    我试验了一下，如果使用的是 Lambda 表达式并不会生成额外的类文件，那么字节码里是什么样子的？来看下用  javap -c 反编译出下面文件产生的 TestLambda.class，两个方法，一个是  byAnonymousClass() 使用匿名类，另一个是 byLambda 使用 Lambda 的方式：
     1package cc.unmi.testjdk8;
 2
 3import java.awt.event.ActionEvent;
 4import java.awt.event.ActionListener;
 5
 6import javax.swing.JButton;
 7
 8public class TestLambda{
 9    private JButton button = new JButton();
10    
11    public void byLambda() {
12        button.addActionListener((ActionEvent e) -&gt; System.out.println("Lambda"));
13    }
14    
15    public void byAnonymousClass(){
16        
17        button.addActionListener(new ActionListener() {
18            @Override
19            public void actionPerformed(ActionEvent e) {
20                System.out.println("Anonymous class");
21            }
22        });
23    }
24}

    Read More

  • JDK 8 的 Lambda 表达式 -- 写法

    calendar Oct 12, 2013   ---   · 1 min read · jdk8 lambda  ·
    Share on: linkedin copy
    过去，我们使用匿名类的实现像  ActionListener 这样的接口，即使最简单的情景都需要写上五六行代码，这就显得有些累赘了。因为其实我们在 new ActionListener {} 时就是在创建一个 ActionListener 子类型，重载了方法，并初始化一个实例出来。现在我们手上有了 Lambda 表达式这一武器的话，就变得简单明了了，所以说  Lambda 是一种轻量级的实现机制。


    这里是几个 Lambda 表达式的样子：
    1(int x, int y) -> x + y    //两整形参数，返回它们的和
2() -> 42                   //无参数，直接返回 42
3x -> 100;                  //可推断出参数 x 的类型
4(String s) -> { System.out.println(s); } //传入一个字符, 只执行一个操作, 无返回值

    Lambda 的格式就是三部分：参数列表，-> 分隔符，执行体。其他语方的 Lambda 格式都这样的，可能就是分隔符不一样，如 Ruby 的 |，Scala 的 => 等。

    执行体里的 return 只是标明返回到匿名方法的调用者，不是返回值的意思； 最上层是不能用 break 和 continue 关键字的，可用在循环中； 如果 Lambda 表达式有返回值，那么在每一条路径上都要有返回值或是抛出异常。路径上最后一条语句的返回值即为 Lambda 表达的返回值。 Read More

  • JDK 8 的 Lambda 表达式 -- 应用背景

    calendar Oct 11, 2013   ---   · 2 min read · jdk8 lambda  ·
    Share on: linkedin copy
    即将到来的 JDK8 最为引人入胜之处非 Lambda 表达式莫数了，这在其他动态语方，如 Ruby, Groovy, Scala 等语言中早已大行其道。一旦 JDK 搭上了 Lambda 这趟车，从此操作事件，线程，处理集合时又大为方便了。关于现阶段如何体验 JDK8 的特性可以参考 抢鲜设置 JDK8 的编程环境，印象。

    本文主要参考于官方的 State of the Lambda，并对源码或反编译出字节码，作一定的深入以助于各位理解，在 JVM 中是如何实现 Lambda 的。

    Lambda 表达式，又称闭包(Closure)，或称匿名方法(anonymous method)。这在其他语言中，如 Ruby, Groovy, Scala, JavaScript 等，甚至是在 C# 中运用得如火纯清的特性，JDK8 这才问候他，真有些晚了。没有 Lambda 时，Java 不得不求助于匿名类的回调方法来达到相似的目的，为了捕获外部变量，变量必须声明为 final。

    一见到 Lambda，第一个反应就是 Lambda 表达式(局部而已)，其实我们这里要说的 JDK8 的 Lambda 包含以下几块内容：
    1. Lambda 表达式，俗称闭包或匿名方法
    2. 方法和构造器引用
    3. 扩充的目标类型和更强的类型推断
    4. 接口中的默认静态方法
    Lambda 这一特性使得 Java 也开始向函数式编程倾斜，关键是能更有效的应对并发环境。

    说到 Lambda，我们不得不了解一下当前背景，例如下面一个典型的事件处理场景： Read More

  • JDK 7 代码中对捕获再抛出异常时的处理--即异常类型推断

    calendar Oct 4, 2013   ---   · 3 min read · jdk7  ·
    Share on: linkedin copy
    JDK 发展过程中，第一次变化最大数 JDK1.5，加入了变长参数，泛型。泛型的最大的受益者是集合。JDK7 虽说引进了同时捕获多个异常(Multi-Catch)，更聪明一点类型推断，资源的释放等，但我觉得变化还不大。接下来众人期望的 JDK8 的 Lambda 表达式才是激动人心的，恐怕这一特性的大赢家仍是集合。


    这样 JDK 才不至于离 C# 太远，纯粹语言上讲，我更景仰 C#，比如它的匿名类型，更不论人家的 Lambda 了。

    var person = new { Name = "Unmi", Website = "http://unmi.cc" };
    Console.WriteLine(person.Name);

    这要到 Scala 中才能见到这种影子。
    注: JDK 从 1.5 起就加入了象 Chrome, Firefox 那样的版本党了，所以这个版本也叫做 JDK5，不管是后来的 JDK6, JDK7 等等，其实在命令行下 java -version 显示出来的也还是 1.5.0, 1.7.0_40 这种理智的版本号的。
    回过神来，我们要说的是 JDK7 对异常的处理，不讲同时捕获多个异常和 try-with-resource 的处理，而要说的是捕获异常再次抛出时进步，这在某方面得益于 JDK7 类型推断。JDK7 类型推断对于泛型来说，它可以不用这么写 Read More

  • 抢鲜设置 JDK8 的编程环境，印象

    calendar Sep 18, 2013   ---   · 2 min read · jdk8  ·
    Share on: linkedin copy
    和 JDK7 还没有热和，却开始关注 JDK8 起来了，JDK8 已进行到了 M8 开发预览版了，其中包含了一个千呼万唤的功能，即 Lambda 闭包的支持。在当前有对闭包特性的诉求，而 Java 本身不提供时，我们不得不转而求助于 JVM 上的其他的语言, 像 Scala, Groovy, JRuby 等。


    不得不说 Scala 给我们带来了不少的快感，以致于想以更多的精力投入到 Scala 编程中去，不过还正在换取项目实践的机会。JDK8 引入 Lambda 后同样也是能更好的解决多核计算的问题，从程序员的角度来看，只要觉得 Lambda 能给我们带来无与伦比的灵活与便利性就足够了，水很深。

    JDK8 还有增加的功能就是 JEP(JDK Enhancement-Proposal) 中的了。

    来这里 http://openjdk.java.net/projects/jdk8/ 看看 JDK8 的里程碑

    2012/04/26     M1     
    2012/06/14     M2     
    2012/08/02     M3     
    2012/09/13     M4     
    2012/11/29     M5     
    2013/01/31     M6     
    2013/06/13     M7     Feature Complete
    2013/09/05     M8     Developer Preview Read More

  • XSLT 调用 Java 的类方法 -- Tomcat 环境

    calendar Jul 26, 2013   ---   · 2 min read · xslt xml  ·
    Share on: linkedin copy
    很早很久以前写过一篇 在 xslt 调用 java 方法的日志 XSLT 调用 Java 的类方法, 其中介绍是使用 org.apache.xalan.processor.TransformerFactoryImpl 实现的例子，JDK 本身就是用这个的。但是在 Tomcat 环境下，它有它自己的 XSLT 默认实现是 net.sf.saxon.TransformerFactoryImpl， 这时候 XSLT 中的内容略有不同，而且显示更简便一些。


    这么说吧, xalan 支持以下两种调用 java 方法的方式，而 saxon 只认得第二种

    1. 声明到包，调用时带上类名
     1<?xml version="1.0" encoding="UTF-8"?>
 2<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
 3    xmlns:java="cc.unmi.commons" exclude-result-prefixes="java">
 4
 5    <xsl:output method="xml"/>
 6
 7    <xsl:template match="user/name">
 8        <li><xsl:value-of select='java:XsltFunctions.replace(.)'/></li>
 9    </xsl:template>
10</xsl:stylesheet>

    Read More

  • 扩展 JUnit 4，使用定制的 Runner

    calendar Apr 17, 2013   ---   · 3 min read · Java JUnit  ·
    Share on: linkedin copy
    JUnit 的测试用例总是由 Runner 去执行，JUnit 提供了 @RunWith 这个测试类的 Annotation, 可来指定自定义的 Runner。如果未指定特别的  Runner，那么会采用默认的 Runner，可能不同的环境，如 Eclipse，控制台下会有不同的默认 Runner。


    如果不清楚 Runner 是什么，那么可能见过 @RunWith(SpringJUnit4ClassRunner.class) 这个东西，它有助你加载 Spring 的配置文件，及与 Spring 相关的事物。

    那么自定义的 Runner 有什么用呢？它可以截获到 @BeforeClass, @AfterClass, @Before, @After 这些事件，也就是能在测试类开始和结束执行前后，每个测试方法的执行前后处理点事情。

    比如说从外部读取内容进行初始化测试数据，而且 JUnit 本身就提供了 @RunWith(Parameterized.class)  这个参数化 Runner，用了为带参数测试方法循环填充数据进行测试。JUnit 的参数化测试比 C# 还是要笨拙一些，C# 直接用方法注解一行行设置参数，我想 JUnit 稍加定制的话也行的。 Read More

  • 使用 JDK 5 后的线程并发，Callable, Future, ExecutorServie ...

    calendar Apr 10, 2013   ---   · 2 min read · multithread Thread JDK5  ·
    Share on: linkedin copy
    被问及 Java 多线程，多会想到 Thread, Runnable，更通常是用 new Thread(){public void run(){...}}.start() 来启动一个线程。那都是 JDK 1.5 之前的年代了，现在还这么回答就 Out 了。用用  JDK 1.5 给我们带来的  java.util.concurrent 吧，更酷了。这里不涉及它的并发集合类，同步互斥机制，只说线程及线程池的应用举例。


    1. 新的启动线程的方式：
     1public static void main(String[] args) throws Exception {
 2    Callable<Integer> callable = new Callable<Integer>() {
 3        public Integer call() throws Exception {
 4            System.out.println("callable executed.");
 5            return new Random().nextInt(100);
 6        }
 7    };
 8    
 9    FutureTask<Integer> future = new FutureTask<Integer>(callable);
10    new Thread(future).start();
11    
12    System.out.println("do your things here");
13    
14    System.out.println(future.get());
15}
    Read More