JavaEye论坛精彩帖子

**NullException。**

        struts
        com.demo2do.lighturl.LightURLFilter

        struts
        /*

## action package config
lighturl.action.packages=com.demo2do.lighturl.action

## action mapping implementation class
struts.mapper.class=com.demo2do.lighturl.LightURLActionMapper

## default parent package
lighturl.action.default.parent.package=struts-config

## define your entity package (optional)
# lighturl.entity.package=com.demo2do.lighturl.entity

lighturl.action.packages=com.demo2do.lighturl.action

package com.demo2do.lighturl.action.user;

import com.demo2do.lighturl.annotation.Action;
import com.opensymphony.xwork2.ActionSupport;

/**
 * @author Downpour
 *
 */
public class Search extends ActionSupport {

	private static final long serialVersionUID = -1728616675239859226L;

	/* (non-Javadoc)
	 * @see com.opensymphony.xwork2.ActionSupport#execute()
	 */
	@Override
	@Action("/all/search-user")
	public String execute() throws Exception {
		return super.execute();
	}

}

package com.demo2do.lighturl.action.blog;

import com.demo2do.lighturl.annotation.Action;
import com.opensymphony.xwork2.ActionSupport;

/**
 * @author Downpour
 *
 */
public class Category extends ActionSupport {

	private static final long serialVersionUID = -1535992103374733252L;

        private Long id;

	private int year;

	private int month;

	private int day;

	/* (non-Javadoc)
	 * @see com.opensymphony.xwork2.ActionSupport#execute()
	 */
	@Override
	@Action("/blogs/${year}/${month}/${day}")
	public String execute() throws Exception {
		return super.execute();
	}

        @Action("/blog/${id}/edit")
	public String edit() throws Exception {
		return super.execute();
	}
        // setters and getters

}

package com.demo2do.lighturl.action.user;

import com.demo2do.lighturl.entity.User;
import com.opensymphony.xwork2.ActionSupport;

/**
 * @author Downpour
 *
 */
public class Index extends ActionSupport {

	private static final long serialVersionUID = -5017825114664788765L;

	private User user;

	/* (non-Javadoc)
	 * @see com.opensymphony.xwork2.ActionSupport#execute()
	 */
	@Override
	public String execute() throws Exception {
		return "j:user";
	}

        // setters and getters
}

package com.demo2do.lighturl.action.user;

import com.demo2do.lighturl.entity.User;
import com.opensymphony.xwork2.ActionSupport;

/**
 * @author Downpour
 *
 */
public class Index extends ActionSupport {

	private static final long serialVersionUID = -5017825114664788765L;

	private User user;

	/* (non-Javadoc)
	 * @see com.opensymphony.xwork2.ActionSupport#execute()
	 */
	@Override
	public String execute() throws Exception {
		return "r:/user/add-user";
	}

        // setters and getters
}

lighturl.result.code.config=yourpackage.ResultCodeConfigImpl1,yourpackage.ResultCodeConfigImpl2

src="./冰酷一夏.files/gif-0268.gif"

str = path.gsub(/&#(\d+);/) { |s| [$1.to_i(16)].pack("U") } 
puts str

path = "./冰酷一夏.files/gif-0268.gif"
str = path.gsub(/&#(\d+);/) { |s| [$1.to_i(16)].pack("U") }
puts str
require "iconv"
puts Iconv.conv("gbk", "utf-8", str)

./馉鸱埞饳エ稷灆.files/gif-0268.gif
./馉鸱埞饳エ稷灆.files/gif-0268.gif

//str是通过正则表达式取出的数字，这样做是可以的
(char)Integer.valueof(str).intValue()

    i = Ja::Integer.new(number)
    c = Ja::Character.new(i.intValue())
    Ja::String.valueOf(c)   

str = path.gsub(/&#(\d+);/) { |s| [$1.to_i(10)].pack("U") }
puts str
require "iconv"
puts Iconv.conv("gbk", "utf-8", str)

class User < ActiveRecord::Base
  acts_as_cached
end

#find没有使用cache机制
User.find(params[:id])
#必需使用get_cache方法，才能让cache生效
User.get_cache(params[:id])

class Topic < ActiveRecord::Base
  belongs_to :user
end

#不会使用cache机制
topic.user

def find_one_with_cache(id, options)
  Rails.cache.fetch(cache_key(id)) {find_one_without_cache(id, options)}
end

alias_method_chain :find_one, :cache

config.cache_store = :mem_cache_store

class User < ActiveRecord::Base
  acts_as_cached
end

class Forum < ActiveRecord::Base
  acts_as_cached
  def self.all_for_option
    get_cache("all_for_options") {find(:all, :order => 'category, position')}
  end  
end

Funcionalidade: Adição
  Para evitar erros bobos
  Como um péssimo matemático
  Eu quero saber como somar dois números

  Cenário: Adicionar dois números
    Dado que eu digitei 50 na calculadora
    E que eu digitei 70 na calculadora
    Quando eu aperto o botão de soma
    Então o resultado na calculadora deve ser 120

#features/steps/accounts.rb
Given /I have \$(\d+) in my (.*) account/ do |dollars, account_type|
  ...
end

cucumber -r features/steps/accounts.rb features/transfer_money

cucumber features
//Scala
val acronym = "Microsoft Certified Systems Engineer".reduce
println(acronym)            // MCSE
class MyStr(str:String) {
    def reduce = str.foldLeft(""){ (s,c) =>
                     if(c.isUpperCase) s+c else s
                 }
}

implicit def str2MyStr(str:String) = new MyStr(str)
class String
  def reduce
    arr = unpack('c*').select { |c| (65..90).include? c }
    arr.pack 'c*'
  end
end

puts 'HyperText Transfer Protocol'.reduce       # HTTP
//Scala,that's all
implicit def lessThanOverload(i: Int) = new {
    def <(str: String) = str.length < i
}
class Fixnum
  def <(str)
    str.size < self
  end
end
class Fixnum
  def <(str)
    self >= str.size
  end
end
class Fixnum
  alias_method :__old_less_than__, '<'.to_sym
  def <(target)
    if target.kind_of? String
      __old_less_than__ target.size
    else
      __old_less_than__ target
    end
  end
end
Function.prototype.method = function (name, func) {
	this.prototype[name] = func;
	return this;
};

Function.method('inherits', function (parent) {
	var d = {}, // 递归调用时的计数器
		// 下面这行已经完成了最简单的原型继承：将子类的prototype设为父类的实例
		p = (this.prototype = new parent());

	// 下面给子类增加uber方法（类似Java中的super方法），以调用上层继承链中的方法
	this.method('uber', function uber(name) {
		if (!(name in d)) {
			d[name] = 0;
		}
		var f, r, t = d[name], v = parent.prototype;
		if (t) {
			while (t) {
				// 往上追溯一级
				v = v.constructor.prototype;
				t -= 1;
			}
			f = v[name];
		} else {
			f = p[name];
			if (f == this[name]) {
				f = v[name];
			}
		}
		// 因为f函数中，可能存在uber调用上层的f
		// 不设置d[name]的话，将导致获取的f始终为最近父类的f（陷入死循环）
		d[name] += 1;

		// slice.apply的作用是将第2个及其之后的参数转换为数组
		// 第一个参数就是f的名字，无需传递
		// 这样，通过uber调用上层方法时可以传递参数：
		// sb.uber(methodName, arg1, arg2, ...);
		r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));

		// 还原计数器
		d[name] -= 1;

		return r;
	});
	// 返回this, 方便chain操作
	return this;
});

function println(msg) {
	document.write(msg + '
');
}

// 例1
function A() { }
A.prototype.getName = function () { return 'A'; }; // @1

function B() { }
B.inherits(A);
B.prototype.getName = function () { return this.uber('getName') + ',B'; }; // @2

function C() { }
C.inherits(B);
C.prototype.getName = function () { return this.uber('getName') + ',C'; }; // @3

var c = new C();
println(c.getName()); // => A,B,C
println(c.uber('getName')); // => A,B

while (t) {
	// 往上追溯一级
	v = v.constructor.prototype;
	t -= 1;
}
f = v[name];

p = (this.prototype = new parent());

// 例2
function D1() {}
D1.prototype.getName = function() { return 'D1' }; // @4

function D2() {}
D2.inherits(D1);
D2.prototype.getName = function () { return this.uber('getName') + ',D2'; }; // @5

function D3() {}
D3.inherits(D2);

function D4() {}
D4.inherits(D3);

function D5() {}
D5.inherits(D4);
D5.prototype.getName = function () { return this.uber('getName') + ',D5'; }; // @6

function D6() {}
D6.inherits(D5);

var d6 = new D6();
println(d6.getName()); // => ?
println(d6.uber('getName')); // => ?

println(d6.getName()); // => D1,D5,D5
println(d6.uber('getName')); // => D1,D5

// 对于d6来说, parent == D5
var f, v = parent.prototype;
f = p[name];
// 对于d6来说，p[name] == this[name]
if (f == this[name]) {
    // 因此f = D5.prototype[name]
    f = v[name];
}

// 计数器加1
d[name] += 1;

// 等价为 D5.prototype.getName.apply(d6);
f.apply(this);

var f, t = 1, v = D5.prototype;
while (t) {
	// 这里有个陷阱，v.constructor == D1
	// 因为 this.prototype = new parent(), 形成了下面的指针链：
	// D5.prototype = d4
	// D4.prototype = d3
	// D3.prototype = d2
	// D2.prototype = d1
	// 因此v.constructor == d1.constructor
	// 而d1.constructor == D1.prototype.constructor
	// D1.prototype.constructor指向D1本身，因此最后v.constructor = D1
	v = v.constructor.prototype;
	t -= 1;
}
// 这时f = D1.prototype.getName
f = v[name];

d[name] += 1;
// 等价为 D1.prototype.getName.apply(d6)
f.apply(this);

return 'D1';

// 例3
function F1() { }
F1.prototype.getName = function() { return 'F1'; };

function F2() { }
F2.inherits(F1);
F2.prototype.getName = function() { return this.uber('getName') + ',F2'; };

function F3() { }
F3.inherits(F2);
F3.prototype.getName = function() { return this.uber('getName') + ',F3'; };

function F4() { }
F4.inherits(F3);
F4.prototype.getName = function() { return this.uber('getName') + ',F4'; };

var f3 = new F3();
println(f3.getName()); // => F1,F2,F3

var f4 = new F4();
println(f4.getName()); // => F1,F3,F4

p = (this.prototype = new parent());

// patched by lifesinger@gmail.com 2008/10/4
Function.method('inherits', function (parent) {
    var d = { }, 
        p = (this.prototype = new parent());
        // 还原constructor
        p.constructor = this;
        // 添加superclass属性
        p.superclass = parent;

    this.method('uber', function uber(name) {
        if (!(name in d)) {
            d[name] = 0;
        }
        var f, r, t = d[name], v = parent.prototype;
        if (t) {
            while (t) {
                // 利用superclass来上溯，避免contructor陷阱
                v = v.superclass.prototype;
                // 跳过“断层”的继承点
                if(v.hasOwnProperty(name)) {
                    t -= 1;
                }
            }
            f = v[name];
        } else {
            f = p[name];
            if (f == this[name]) {
                f = v[name];
            }
        }
        d[name] += 1;        
        if(f == this[name]) { // this[name]在父类中的情景
            r = this.uber.apply(this, Array.prototype.slice.apply(arguments));
        } else {
            r = f.apply(this, Array.prototype.slice.apply(arguments, [1]));
        }
        d[name] -= 1;
        return r;
    });
    return this;
});

JavaEye论坛精彩帖子

MySQL数据库操作实战

写给我的团队成员（二）—— 编程，乐趣何在？

1. 什么是软件开发？

2. 原本的乐趣：挑战和控制欲

3. 为什么软件开发越来越无趣？

3.1. 首先，软件开发并不是数学

3.2. 第二，软件工程技术的发展，限制了施展的空间

3.3. 第三，VB、PHP和Java

4. 寻找新乐趣之旅

4.1.创新：用户UI体验的乐趣

4.2. 探险：扒开“框架”的乐趣

4.3. 拓展：扩展眼界的乐趣

4.4.协作：大制作的乐趣

Pomer：基于Flex和Java EE的信息管理系统基础框架

TL日记

LightURL——打造零配置的Struts2开发方式

Ruby on Rails 在国内的使用情况

理解渐进增强（Progressive Enhancement）

这里有个（微妙的）差别

优雅降级的视角

渐进增强的视角

它是怎样运作的

花生仁

巧克力外衣

糖果硬壳

都放在一起

译注：

ruby处理中文URL的办法

一行代码搞定ActiveRecord的二级缓存

Cucumber - 将在RSpec1.1.5中取代Story Runner

大胆预测下JS框架的走势

理由：

写给我的团队成员（一）——什么是BUG？

隐式转换：比动态类型更强大？

JavaScript中的继承学习笔记(1)：Crockford uber方法中的陷阱