Yanbin | 隔叶黄莺 Yanbin Blog

JavaScript 模块应用与编程

2013-12-26 | 阅读(425)

前边有一篇关于 JavaScript 对象声明，可以作为是 JavaScript 模块化的一个铺垫。这里会涉及到两个话题模块的定义和引入，对于模块化的编程语言，我们可以用 include, require 或 import 那样的谓词来引入模块。回想下我们对于非模块化的 JavaScript 是怎么引入的，比如在 html 文件里 js 文件，用 <script src="some.js"></script>。如果是更动态一点就会用 document.createElement("script"), 再指定它的 src 属性为一个 js 文件，添加加到 DOM 中去的方式来加载 js 文件。

上面两种方式都不够优雅，我们现在想要实现为 require() 函数来引入 js 库的方式，所以 JavaScript 模块的规范就出现了 CommonJS 和 AMD(Asynchronous Module Definition) 两种。

1. CommonJS

CommonJS 中有一个全局的 require() 方法，它就是执行 require() 代码后马上使用模块提供的属性或方法，它假定执行完 require() 行后，模块即已就绪。例如加载一个 'math' 模块

var math = require('math');
math.add(2, 3);

阅读全文 >>

RESTful, 说说 http 的 patch method

2013-12-13 | 阅读(18,548)

最早的时候，我们只需要 GET 和 POST 方法，POST 方法的引入也只是为了消除 URL 过长，参数隐藏，上传文件的问题，完全和语义无关。接触到 RESTful 之后，我们开始思考 GET 和 POST 的不同语义，并且十分必要的去发掘出所有的 HTTP method，HTTP/1.1 所实现的 method，见 RFC 2616, 有这些：

OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE, CONNECT

规范是这么定义的，这还要看容器实现了多少，比如 Tomcat 7 中的 servlet api 实现了

doOptions, doGet, doHead, doPost, doPut, doDelete, doTrace 就差个 doConnect 了。

而我们这里要说的 PATCH method 是在 Servlet 3.0 和当前 Tomcat 7 中都提到的，也就是尚未实现它。

这也难怪，PATCH 在 2010 年三月份才成为正式的方法，见 RFC 5789。没有 PATCH 的时候我们进行更新的操作采用的是 PUT 方法。那么 PATCH 和 PUT 有什么区别呢？

同样可以从语义上去理解，有两方面的对比：阅读全文 >>

Apache .htaccess 重定向在别名应用中的问题

2013-11-24 | 阅读(446)

在 Apache 应用的目录中有 .htaccess 文件来进行重定向，目的是实现省略扩展名 .php 来访问相应的 php 文件，例如用 url

http://localhost/unmi/forgotPassword 来访问 http://localhost/unmi/forgotPassword.php

.htaccess 文件的内容是：

RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}\.php -f
RewriteRule ^(.*)$ $1.php

结果访问 http://localhost/unmi/forgotPassword 时出现错误：

Not Found

The requested URL /data/unmi/forgotPassword.php was not found on this server.

实际上文件 /data/unmi/forgotPassword.php 是存在的。这就奇怪了，怀疑过是文件权限的问题(Mac 平台)，改成 755 也不行。也经为是 AllowOverride 的问题，可它的值我设置成了 All 啊，又不是 None，应该不是症结所在。

费了一番功夫也明白了我是配置了别名来访问应用的，在 Apache httpd.conf 中是这样定义的别名：阅读全文 >>

JavaScript 对象声明

2013-11-23 | 阅读(278)

对象，类，模块的概念可以让系统更清晰，亦能增强代码的重用性。目前 JavaScript 规范本身并不支持类或模块，正在制定中的 ECMAScript 6^th Edition 将会纳入类，模块的概念，不过不知会是何年马月的事，毕竟这不能像 JDK 升级那么干脆。

还有种办法来写模块化的 JavaScript 就是使用微软的 TypeScript 或是 Google 的 Dart，它们是面向对象的编程语言，能直接编译成兼容的 JavaScript 代码，有条件的可以去尝试。

回到现实来，就现有的 JavaScript 规范怎么去模块化。众所周知，JavaScript 中函数是第一等公民，所以我们早先是这样使用函数来声明对象的：

1. 原始写法(比直接调用函数显得高级些)：

function Module(){
    this.count = 10;
    this.foo = function(x){
        return x+1;
    }
}

var m1 = new Module();
console.log(m1.count);
console.log(m1.foo(3));

function Module(){

this.count = 10;

this.foo = function(x){

return x+1;

}

var m1 = new Module();

console.log(m1.count);

console.log(m1.foo(3));

阅读全文 >>

CountDownLatch 协调线程

2013-10-19 | 阅读(657)

JDK8 都快要出来了，在 JDK 5 中仍有许多好宝贝值得去挖掘。提到 JDK5 我们或许只知道它给了我们泛型，其实还有那个并发包 java.util.concurrent 却不那么引人注目，其实就是 NIO。

若是并发包是在某个 JDK 版本中单独奉上，反响就不同了，想想 JDK 6 似乎未带来多少改变--至少对于编程者来说没有明显感受。java.util.concurrent 包中的东西对于我们处理线程带来了很大的便利，例如线程池，线程同步，Future, Callable 等。

这里我记录一下 CountDownLatch 的使用，在此之前在处理

线程 A 等待线程 B，C，D 全部执行完后才继续执行（比如要每个线程都访问一个 Web 服务，等所有的请求响应成功后进行结果处理）

这样场景的时候，我一般能想到的办法是，初始一个计数器，线程 B，C，D 各自初始化的时候，计数器加一，然后 A 线程等待，每个线程执行完后计数器减一，当计数器为 0 时表明所有任务执行完毕，就通知 A 可以开始运作起来。但这样的方案还是得小心的处理好同步的问题。阅读全文 >>

JDK8 的 Lambda 表达式 -- 方法引用

2013-10-17 | 阅读(698)

Lambda 允许我们定义匿名方法(即那个 Lambda 表达式，或叫闭包)，作为一个功能性接口的实例。如果你不想把一个 Lambda 表达式写得过大，那么你可以把表达式的内容分离出来写在一个方法中，然后在放置 Lambda 表达式的位置上填上对那个方法的引用。

方法引用也应看作是一个 Lambda 表达式，所以它也需要一个明确的目标类型充当功能性接口的实例。简单说就是被引用的方法要与功能接口的 SAM(Single Abstract Method) 参数、返回类型相匹配。方法引用的引入避免了 Lambda 写复杂了可读性的问题，也使得逻辑更清晰。

为了应对方法引用这一概念， JDK8 又重新借用了 C++ 的那个 “::” 域操作符，全称为作用域解析操作符。

上面的表述也许不好明白，我看官方的那份 State of the Lambda 也觉得不怎么容易理解，特别是它举了那个例子很难让人望文生意。我用个自己写的例子来说明一下吧。

目前的 Eclipse-JDK8 版还不能支持方法引用的特性，幸好就是在昨天正式版的 NetBeans IDE 7.4 对 JDK8 有了较好的支持，所以在 NetBeans 7.4 中写测试代码。阅读全文 >>

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

2013-10-16 | 阅读(369)

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

可以这么测试：

public void foo(){
    System.out.println(this);
    Arrays.asList("Unmi").forEach((s) -> System.out.println(this));
}

public void foo(){

System.out.println(this);

Arrays.asList("Unmi").forEach((s) -> System.out.println(this));

}

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

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

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

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

2013-10-15 | 阅读(652)

现在我们来看看 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 表达式能否放在某处需要满足以下几个条件：

期盼的类型必须是一个功能性接口，这样就能唯一定位到那个抽象方法上去，确定方法签名，接下来就是阅读全文 >>

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

2013-10-13 | 阅读(1,346)

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

我试验了一下，如果使用的是 Lambda 表达式并不会生成额外的类文件，那么字节码里是什么样子的？来看下用 javap -c 反编译出下面文件产生的 TestLambda.class，两个方法，一个是 byAnonymousClass() 使用匿名类，另一个是 byLambda 使用 Lambda 的方式：

package cc.unmi.testjdk8;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;

public class TestLambda{
    private JButton button = new JButton();
    
    public void byLambda() {
        button.addActionListener((ActionEvent e) -> System.out.println("Lambda"));
    }
    
    public void byAnonymousClass(){
        
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("Anonymous class");
            }
        });
    }
}

package cc.unmi.testjdk8;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

public class TestLambda{

private JButton button = new JButton();

public void byLambda() {

button.addActionListener((ActionEvent e) -> System.out.println("Lambda"));

}

public void byAnonymousClass(){

button.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

System.out.println("Anonymous class");

}

});

}

阅读全文 >>

JDK 8 的 Lambda 表达式 -- 写法

2013-10-13 | 阅读(574)

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

这里是几个 Lambda 表达式的样子：

(int x, int y) -> x + y    //两整形参数，返回它们的和
() -> 42                   //无参数，直接返回 42
x -> 100;                  //可推断出参数 x 的类型
(String s) -> { System.out.println(s); } //传入一个字符，只执行一个操作，无返回值

(int x, int y) -> x + y //两整形参数，返回它们的和

() -> 42 //无参数，直接返回 42

x -> 100; //可推断出参数 x 的类型

(String s) -> { System.out.println(s); } //传入一个字符，只执行一个操作，无返回值

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

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

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...
Zhe on 体验 Python FastAPI 的并发能力及线, 进程模型你在trio下得用 trio.sleep()，调用asyncio.sleep() 就会报错。