虽然无奈，但是不想一有什么就去写JS，冲突也会是个头痛的问题，所以这个Expression还是挺有用的，在CSS代码后插入expression语句，自定义控制属性，只被IE识别的方法，通常针对IE6及其一下的版本居多，IE7对CSS的支持已经有了很大改进，会用到的情况比较少，IE8已宣布在其标准模式下不再支持这一语句，呵呵，多好啊，以后为不同版本的IE还要多写几份HACK，咱们不怕没工作做了哩~~无奈到想哭。。。
1. min-width/max-width 控制容器最小宽度或图片最大宽度，对IE6及其以下版本无效
div {width:100%;min-width:600width:expression(this.Width & 600 ? &600px& :&100%& );}
img {max-width:750width:expression(onload=function() {this.style.width=(this.offsetWidth & 750)?&750px&:&auto&}
/*max-width: 750width:expression(this.offsetWidth& 750? &750px& : this.offsetWidth+&px&) ;不要使用这种写法，初次载入图片有时会很小，需刷新*/
2. position:fixed IE6下无效
div {position:top:expression(eval(document .compatMode &&& document .compatMode==&CSS1Compat&) ?& documentElement.scrollTop& +(documentElement.clientHeight-this.clientHeight) & 1 : document.body.scrollTop& +(document.body.clientHeight-this.clientHeight) & 1;}
div {position:left:&expression(&(johndoe2&=&document.documentElement.scrollLeft&?document.documentElement.scrollLeft&:&document.body.scrollLeft&)&+&&px&&);top:&expression(&(johndoe1&=&document.documentElement.scrollTop&?document.documentElement.scrollTop&:&document.body.scrollTop&)&+&&px&&);}
实际用了下，上面那种好像不太保险的，下面这个OK的~~ 但是注意，这种方式因为是不停的用expression计算位置，滚动过程中会有抖动的
另外还找到了一种，如果你有多个需要固定的DIV，并且这种方式没有抖动~~
3. 实现伪类的Hover效果
span.link {cursor:color:text-decoration:m: expression(this.onmouseover =& new Function(&this.className = &link-hover&;&));}
4. 消除页面链接虚线
a {star: expression(onfocus=this.blur)}
其他还有做隔行换色表格啦~鼠标移上更换图片啦~其他什么的，需要注意的是，expression这种东西能不用还是不要轻易使用，因为是比较消耗浏览器资源滴，不仅仅是在页面显示和缩放时，就是在页面滚动、乃至移动鼠标时都会要重新计算一次。
在新型浏览器迈着轻松的步子优雅前行的时候，身后不知道瘫倒着多少像俺这样写HACK的可怜娃啊，喂！~ 还真就说不管就不管啦？~ 那你起码回个头把你家不争气的小子处理掉先啊！~~&&555，还真是可怜的娃，谁都来欺负一把，现在是IE三兄弟、FF3、Safari、Opera、Chrome都压上身了，我爬。。。好重。。。
本文已收录于以下专栏：
相关文章推荐
所有浏览器
通用 color:#999;
_color:#000;
作如下文件itetest.html
#test{color:#999;_color:#...
一、现在有一要求改页面所有的A {target :expression(this.target=&_blank&);} 二、在CSS中使用expression，用来把CSS属性和Javascript表...
原文 :/longhubo/blog/item/f2da4b58c568add29d820466.html
-moz-user-select:...
用CSS按比例缩放图片CSS图片自动适应大小防止表格被撑开或div层被撑开的多种方法css实现按比例限制图片的显示大小。css ie中最小（最大）高度（宽度） 的处理方法用CSS如何控制网页中图片自适...
chrome下运行编写的javascript代码时，在工具javascript控制台下有时会出现“Uncaught SyntaxError: Unexpected identifier ”的报错，经过...
他的最新文章
讲师：王哲涵
讲师：韦玮
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)简介(译者注:虽然看着很先进，其实Lambda表达式的本质只是一个"",由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。本人建议不要乱用,因为这就和某些很高级的黑客写的代码一样,简洁,难懂,难以调试,维护人员想骂娘.)Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包:&java.util.function&包以及java.util.stream&包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来说,lambda表达式和 stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。 在本文中,我们将从简单到复杂的示例中见认识lambda表达式和stream的强悍。环境准备如果还没有安装Java 8,那么你应该先安装才能使用lambda和stream(译者建议在虚拟机中安装,测试使用)。 像NetBeans 和IntelliJ IDEA 一类的工具和IDE就支持Java 8特性,包括lambda表达式,可重复的注解,紧凑的概要文件和其他特性。下面是Java SE 8和NetBeans IDE 8的下载链接:: 从Oracle下载Java 8,也可以和NetBeans IDE一起下载: 从NetBeans官网下载NetBeans IDELambda表达式的语法基本语法:(parameters) -& expression或(parameters) -&{ }下面是Java lambda表达式的简单例子:
// 1. 不需要参数,返回值为 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -& 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -& x & y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -& x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -& System.out.print(s)
基本的Lambda例子现在,我们已经知道什么是lambda表达式,让我们先从一些基本的例子开始。 在本节中,我们将看到lambda表达式如何影响我们编码的方式。 假设有一个玩家List ,程序员可以使用 for 语句 ("for 循环")来遍历,在Java SE 8中可以转换为另一种形式:
String[] atp = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka",
"David Ferrer","Roger Federer",
"Andy Murray","Tomas Berdych",
"Juan Martin Del Potro"};
List&String& players =
Arrays.asList(atp);
// 以前的循环方式
for (String player : players) {
System.out.print(player + "; ");
// 使用 lambda 表达式以及函数操作(functional operation)
players.forEach((player) -& System.out.print(player + "; "));
// 在 Java 8 中使用双冒号操作符(double colon operator)
players.forEach(System.out::println);
正如您看到的,lambda表达式可以将我们的代码缩减到一行。 另一个例子是在图形用户界面程序中,匿名类可以使用lambda表达式来代替。 同样,在实现Runnable接口时也可以这样使用:
// 使用匿名内部类
btn.setOnAction(new EventHandler&ActionEvent&() {
public void handle(ActionEvent event) {
System.out.println("Hello World!");
// 或者使用 lambda expression
btn.setOnAction(event -& System.out.println("Hello World!"));
下面是使用lambdas 来实现 Runnable接口 的示例:
// 1.1使用匿名内部类
new Thread(new Runnable() {
public void run() {
System.out.println("Hello world !");
}).start();
// 1.2使用 lambda expression
new Thread(() -& System.out.println("Hello world !")).start();
// 2.1使用匿名内部类
Runnable race1 = new Runnable() {
public void run() {
System.out.println("Hello world !");
// 2.2使用 lambda expression
Runnable race2 = () -& System.out.println("Hello world !");
// 直接调用 run 方法(没开新线程哦!)
race1.run();
race2.run();
Runnable 的 lambda表达式,使用块格式,将五行代码转换成单行语句。 接下来,在下一节中我们将使用lambdas对集合进行排序。使用Lambdas排序集合在Java中,Comparator 类被用来排序集合。 在下面的例子中,我们将根据球员的 name, surname, name 长度 以及最后一个字母。 和前面的示例一样,先使用匿名内部类来排序,然后再使用lambda表达式精简我们的代码。在第一个例子中,我们将根据name来排序list。 使用旧的方式,代码如下所示:
String[] players = {"Rafael Nadal", "Novak Djokovic",
"Stanislas Wawrinka", "David Ferrer",
"Roger Federer", "Andy Murray",
"Tomas Berdych", "Juan Martin Del Potro",
"Richard Gasquet", "John Isner"};
// 1.1 使用匿名内部类根据 name 排序 players
Arrays.sort(players, new Comparator&String&() {
public int compare(String s1, String s2) {
return (s1.compareTo(s2));
使用lambdas,可以通过下面的代码实现同样的功能:
// 1.2 使用 lambda expression 排序 players
Comparator&String& sortByName = (String s1, String s2) -& (s1.compareTo(s2));
Arrays.sort(players, sortByName);
// 1.3 也可以采用如下形式:
Arrays.sort(players, (String s1, String s2) -& (s1.compareTo(s2)));
其他的排序如下所示。 和上面的示例一样,代码分别通过匿名内部类和一些lambda表达式来实现Comparator :
// 1.1 使用匿名内部类根据 surname 排序 players
Arrays.sort(players, new Comparator&String&() {
public int compare(String s1, String s2) {
return (s1.substring(s1.indexOf(" ")).compareTo(s2.substring(s2.indexOf(" "))));
// 1.2 使用 lambda expression 排序,根据 surname
Comparator&String& sortBySurname = (String s1, String s2) -&
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) );
Arrays.sort(players, sortBySurname);
// 1.3 或者这样,怀疑原作者是不是想错了,括号好多...
Arrays.sort(players, (String s1, String s2) -&
( s1.substring(s1.indexOf(" ")).compareTo( s2.substring(s2.indexOf(" ")) ) )
// 2.1 使用匿名内部类根据 name lenght 排序 players
Arrays.sort(players, new Comparator&String&() {
public int compare(String s1, String s2) {
return (s1.length() - s2.length());
// 2.2 使用 lambda expression 排序,根据 name lenght
Comparator&String& sortByNameLenght = (String s1, String s2) -& (s1.length() - s2.length());
Arrays.sort(players, sortByNameLenght);
// 2.3 or this
Arrays.sort(players, (String s1, String s2) -& (s1.length() - s2.length()));
// 3.1 使用匿名内部类排序 players, 根据最后一个字母
Arrays.sort(players, new Comparator&String&() {
public int compare(String s1, String s2) {
return (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
// 3.2 使用 lambda expression 排序,根据最后一个字母
Comparator&String& sortByLastLetter =
(String s1, String s2) -&
(s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1));
Arrays.sort(players, sortByLastLetter);
// 3.3 or this
Arrays.sort(players, (String s1, String s2) -& (s1.charAt(s1.length() - 1) - s2.charAt(s2.length() - 1)));
就是这样,简洁又直观。 在下一节中我们将探索更多lambdas的能力,并将其与 stream 结合起来使用。使用Lambdas和StreamsStream是对集合的包装,通常和lambda一起使用。 使用lambdas可以支持许多操作,如 map, filter, limit, sorted, count, min, max, sum, collect 等等。 同样,Stream使用懒运算,他们并不会真正地读取所有数据,遇到像getFirst()&这样的方法就会结束链式语法。 在接下来的例子中,我们将探索lambdas和streams 能做什么。 我们创建了一个Person类并使用这个类来添加一些数据到list中,将用于进一步流操作。 Person 只是一个简单的POJO类:
public class Person {
private String firstName, lastName, job,
private int salary,
public Person(String firstName, String lastName, String job,
String gender, int age, int salary)
this.firstName = firstN
this.lastName = lastN
this.gender =
this.age =
this.job =
this.salary =
// Getter and Setter
// . . . . .
接下来,我们将创建两个list,都用来存放Person对象:
List&Person& javaProgrammers = new ArrayList&Person&() {
add(new Person("Elsdon", "Jaycob", "Java programmer", "male", 43, 2000));
add(new Person("Tamsen", "Brittany", "Java programmer", "female", 23, 1500));
add(new Person("Floyd", "Donny", "Java programmer", "male", 33, 1800));
add(new Person("Sindy", "Jonie", "Java programmer", "female", 32, 1600));
add(new Person("Vere", "Hervey", "Java programmer", "male", 22, 1200));
add(new Person("Maude", "Jaimie", "Java programmer", "female", 27, 1900));
add(new Person("Shawn", "Randall", "Java programmer", "male", 30, 2300));
add(new Person("Jayden", "Corrina", "Java programmer", "female", 35, 1700));
add(new Person("Palmer", "Dene", "Java programmer", "male", 33, 2000));
add(new Person("Addison", "Pam", "Java programmer", "female", 34, 1300));
List&Person& phpProgrammers = new ArrayList&Person&() {
add(new Person("Jarrod", "Pace", "PHP programmer", "male", 34, 1550));
add(new Person("Clarette", "Cicely", "PHP programmer", "female", 23, 1200));
add(new Person("Victor", "Channing", "PHP programmer", "male", 32, 1600));
add(new Person("Tori", "Sheryl", "PHP programmer", "female", 21, 1000));
add(new Person("Osborne", "Shad", "PHP programmer", "male", 32, 1100));
add(new Person("Rosalind", "Layla", "PHP programmer", "female", 25, 1300));
add(new Person("Fraser", "Hewie", "PHP programmer", "male", 36, 1100));
add(new Person("Quinn", "Tamara", "PHP programmer", "female", 21, 1000));
add(new Person("Alvin", "Lance", "PHP programmer", "male", 38, 1600));
add(new Person("Evonne", "Shari", "PHP programmer", "female", 40, 1800));
现在我们使用forEach方法来迭代输出上述列表:
System.out.println("所有程序员的姓名:");
javaProgrammers.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
phpProgrammers.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
我们同样使用forEach方法,增加程序员的工资5%:
System.out.println("给程序员加薪 5% :");
Consumer&Person& giveRaise = e -& e.setSalary(e.getSalary() / 100 * 5 + e.getSalary());
javaProgrammers.forEach(giveRaise);
phpProgrammers.forEach(giveRaise);
另一个有用的方法是过滤器filter() ,让我们显示月薪超过1400美元的PHP程序员:
System.out.println("下面是月薪超过 $1,400 的PHP程序员:")
phpProgrammers.stream()
.filter((p) -& (p.getSalary() & 1400))
.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
我们也可以定义过滤器,然后重用它们来执行其他操作:
// 定义 filters
Predicate&Person& ageFilter = (p) -& (p.getAge() & 25);
Predicate&Person& salaryFilter = (p) -& (p.getSalary() & 1400);
Predicate&Person& genderFilter = (p) -& ("female".equals(p.getGender()));
System.out.println("下面是年龄大于 24岁且月薪在$1,400以上的女PHP程序员:");
phpProgrammers.stream()
.filter(ageFilter)
.filter(salaryFilter)
.filter(genderFilter)
.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
// 重用filters
System.out.println("年龄大于 24岁的女性 Java programmers:");
javaProgrammers.stream()
.filter(ageFilter)
.filter(genderFilter)
.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
使用limit方法,可以限制结果集的个数:
System.out.println("最前面的3个 Java programmers:");
javaProgrammers.stream()
.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
System.out.println("最前面的3个女性 Java programmers:");
javaProgrammers.stream()
.filter(genderFilter)
.forEach((p) -& System.out.printf("%s %s; ", p.getFirstName(), p.getLastName()));
排序呢? 我们在stream中能处理吗? 答案是肯定的。 在下面的例子中,我们将根据名字和薪水排序Java程序员,放到一个list中,然后显示列表:
System.out.println("根据 name 排序,并显示前5个 Java programmers:");
List&Person& sortedJavaProgrammers = javaProgrammers
.sorted((p, p2) -& (p.getFirstName().compareTo(p2.getFirstName())))
.collect(toList());
sortedJavaProgrammers.forEach((p) -& System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));
System.out.println("根据 salary 排序 Java programmers:");
sortedJavaProgrammers = javaProgrammers
.sorted( (p, p2) -& (p.getSalary() - p2.getSalary()) )
.collect( toList() );
sortedJavaProgrammers.forEach((p) -& System.out.printf("%s %s; %n", p.getFirstName(), p.getLastName()));
如果我们只对最低和最高的薪水感兴趣,比排序后选择第一个/最后一个 更快的是min和max方法:
System.out.println("工资最低的 Java programmer:");
Person pers = javaProgrammers
.min((p1, p2) -& (p1.getSalary() - p2.getSalary()))
System.out.printf("Name: %s %s; Salary: $%,d.", pers.getFirstName(), pers.getLastName(), pers.getSalary())
System.out.println("工资最高的 Java programmer:");
Person person = javaProgrammers
.max((p, p2) -& (p.getSalary() - p2.getSalary()))
System.out.printf("Name: %s %s; Salary: $%,d.", person.getFirstName(), person.getLastName(), person.getSalary())
上面的例子中我们已经看到 collect 方法是如何工作的。 结合 map 方法,我们可以使用 collect 方法来将我们的结果集放到一个字符串,一个 Set 或一个TreeSet中:
System.out.println("将 PHP programmers 的 first name 拼接成字符串:");
String phpDevelopers = phpProgrammers
.map(Person::getFirstName)
.collect(joining(" ; ")); // 在进一步的操作中可以作为标记(token)
System.out.println("将 Java programmers 的 first name 存放到 Set:");
Set&String& javaDevFirstName = javaProgrammers
.map(Person::getFirstName)
.collect(toSet());
System.out.println("将 Java programmers 的 first name 存放到 TreeSet:");
TreeSet&String& javaDevLastName = javaProgrammers
.map(Person::getLastName)
.collect(toCollection(TreeSet::new));
Streams 还可以是并行的(parallel)。 示例如下:
System.out.println("计算付给 Java programmers 的所有money:");
int totalSalary = javaProgrammers
.parallelStream()
.mapToInt(p -& p.getSalary())
我们可以使用summaryStatistics方法获得stream 中元素的各种汇总数据。 接下来,我们可以访问这些方法,比如getMax, getMin, getSum或getAverage:
//计算 count, min, max, sum, and average for numbers
List&Integer& numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
IntSummaryStatistics stats = numbers
.mapToInt((x) -& x)
.summaryStatistics();
System.out.println("List中最大的数字 : " + stats.getMax());
System.out.println("List中最小的数字 : " + stats.getMin());
System.out.println("所有数字的总和
: " + stats.getSum());
System.out.println("所有数字的平均值 : " + stats.getAverage());
OK,就这样,希望你喜欢它!
总结在本文中,我们学会了使用lambda表达式的不同方式,从基本的示例,到使用lambdas和streams的复杂示例。 此外,我们还学习了如何使用lambda表达式与Comparator 类来对Java集合进行排序。
阅读(...) 评论()posts - 474,&
comments - 479,&
trackbacks - 20
          在常规的信息系统中, 我们有需要动态多条件查询的情况, 例如UI上有多个选择项可供用户选择多条件查询数据.
那么在.net平台下, 我们用树如何实现, 这里我们需要一个PredicateBuilder的UML类图:
实现的代码是这样的:
/// &summary&
/// Enables the efficient, dynamic composition of query predicates.
/// &/summary&
public static class PredicateBuilder
/// &summary&
/// Creates a predicate that evaluates to true.
/// &/summary&
public static Expression&Func&T, bool&& True&T&() { return param =& true; }
/// &summary&
/// Creates a predicate that evaluates to false.
/// &/summary&
public static Expression&Func&T, bool&& False&T&() { return param =& false; }
/// &summary&
/// Creates a predicate expression from the specified lambda expression.
/// &/summary&
public static Expression&Func&T, bool&& Create&T&(Expression&Func&T, bool&& predicate) { return }
/// &summary&
/// Combines the first predicate with the second using the logical &and&.
/// &/summary&
public static Expression&Func&T, bool&& And&T&(this Expression&Func&T, bool&& first, Expression&Func&T, bool&& second)
return pose(second, Expression.AndAlso);
/// &summary&
/// Combines the first predicate with the second using the logical &or&.
/// &/summary&
public static Expression&Func&T, bool&& Or&T&(this Expression&Func&T, bool&& first, Expression&Func&T, bool&& second)
return pose(second, Expression.OrElse);
/// &summary&
/// Negates the predicate.
/// &/summary&
public static Expression&Func&T, bool&& Not&T&(this Expression&Func&T, bool&& expression)
var negated = Expression.Not(expression.Body);
return Expression.Lambda&Func&T, bool&&(negated, expression.Parameters);
/// &summary&
/// Combines the first expression with the second using the specified merge function.
/// &/summary&
static Expression&T& Compose&T&(this Expression&T& first, Expression&T& second, Func&Expression, Expression, Expression& merge)
// zip parameters (map from parameters of second to parameters of first)
var map = first.Parameters
.Select((f, i) =& new { f, s = second.Parameters[i] })
.ToDictionary(p =& p.s, p =& p.f);
// replace parameters in the second lambda expression with the parameters in the first
var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
// create a merged lambda expression with parameters from the first expression
return Expression.Lambda&T&(merge(first.Body, secondBody), first.Parameters);
/// &summary&
/// ParameterRebinder
/// &/summary&
class ParameterRebinder : ExpressionVisitor
/// &summary&
/// The ParameterExpression map
/// &/summary&
readonly Dictionary&ParameterExpression, ParameterExpression&
/// &summary&
/// Initializes a new instance of the &see cref=&ParameterRebinder&/& class.
/// &/summary&
/// &param name=&map&&The map.&/param&
ParameterRebinder(Dictionary&ParameterExpression, ParameterExpression& map)
this.map = map ?? new Dictionary&ParameterExpression, ParameterExpression&();
/// &summary&
/// Replaces the parameters.
/// &/summary&
/// &param name=&map&&The map.&/param&
/// &param name=&exp&&The exp.&/param&
/// &returns&Expression&/returns&
public static Expression ReplaceParameters(Dictionary&ParameterExpression, ParameterExpression& map, Expression exp)
return new ParameterRebinder(map).Visit(exp);
/// &summary&
/// Visits the parameter.
/// &/summary&
/// &param name=&p&&The p.&/param&
/// &returns&Expression&/returns&
protected override Expression VisitParameter(ParameterExpression p)
ParameterEx
if (map.TryGetValue(p, out replacement))
return base.VisitParameter(p);
UnitTest的片断代码, 一个产品查询的场景:
var myProduct=pr.Repository.Find(
BuildFindByAllQuery(productName, beignUpdateDate, endUpdateDate) ,
e =& e.UpdatedTime,
pageIndex,
pageSize);
Assert.IsTrue(myProduct.Count&0);
UnitTest使用到 生成查询条件 的 私有方法:
/// &summary&
/// Builds the find by all query.
/// &/summary&
private static Expression&Func&Product, bool&& BuildFindByAllQuery(string productName,DateTime? beignUpdateDate, DateTime? endUpdateDate)
var list = new List&Expression&Func&Product, bool&&&();
if (!string.IsNullOrEmpty(productName)) list.Add(c =& c.ProductName == productName);
if (beignUpdateDate != null) list.Add(c =& c.UpdatedTime &= beignUpdateDate);
if (endUpdateDate != null) list.Add(c =& c.UpdatedTime &= endUpdateDate);
//Add more condition
Expression&Func&Product, bool&& productQueryTotal = null;
foreach (var expression in list)
productQueryTotal = expression.And(expression);
return productQueryT
上面的方法中由三个条件动态组成,  一个是匹配productName, 另两个是beginUpdateDate与endUpdateDate. 在判断它们是否为时, 构建最终查询条件集合.
最后把结果传给某个Repository类, 完成相应的数据访问.
是不是很简单, 希望对您的软件开发有帮助.
您可能感兴趣的文章:
如有想了解更多软件开发资讯，请关注我的微信订阅号：
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
该文章也同时发布在我的独立博客中-。
阅读(...) 评论()