更多精彩请到 http://www.139ya.com
最近在网上查阅了不少Javascript闭包(closure)相关的资料，写的大多是非常的学术和专业。对于初学者来说别说理解闭包了，就连文字叙述都很难看懂。撰写此文的目的就是用最通俗的文字揭开Javascript闭包的真实面目。
一、什么是闭包？
“官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。
相信很少有人能直接看懂这句话，因为他描述的太学术。我想用如何在Javascript中创建一个闭包来告诉你什么是闭包，因为跳过闭包的创建过程直接理解闭包的定义是非常困难的。看下面这段代码：
function a(){
var i=0;
function b(){
alert(++i);
}
return b;
}
var c = a();
c();
这段代码有两个特点：
1、函数b嵌套在函数a内部；
2、函数a返回函数b。
这样在执行完var c=a()后，变量c实际上是指向了函数b，再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包，为什么？因为函数a外的变量c引用了函数a内的函数b，就是说：
当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。
我猜想你一定还是不理解闭包，因为你不知道闭包有什么作用，下面让我们继续探索。
二、闭包有什么作用？
简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量。这是对闭包作用的非常直白的描述，不专业也不严谨，但大概意思就是这样，理解闭包需要循序渐进的过程。
在上面的例子中，由于闭包的存在使得函数a返回后，a中的i始终存在，这样每次执行c()，i都是自加1后alert出i的值。
那 么我们来想象另一种情况，如果a返回的不是函数b，情况就完全不同了。因为a执行完后，b没有被返回给a的外界，只是被a所引用，而此时a也只会被b 引 用，因此函数a和b互相引用但又不被外界打扰(被外界引用)，函数a和b就会被GC回收。(关于Javascript的垃圾回收机制将在后面详细介绍)
三、闭包内的微观世界
如 果要更加深入的了解闭包以及函数a和嵌套函数b的关系，我们需要引入另外几个概念：函数的执行环境 (excution context)、活动对象(call object)、作用域(scope)、作用域链(scope chain)。以函数a从定义到执行的过程为例阐述这几个概念。
1、当定义函数a的时候，js解释器会将函数a的作用域链(scope chain)设置为定义a时a所在的“环境”，如果a是一个全局函数，则scope chain中只有window对象。
2、当函数a执行的时候，a会进入相应的执行环境(excution context)。
3、在创建执行环境的过程中，首先会为a添加一个scope属性，即a的作用域，其值就为第1步中的scope chain。即a.scope=a的作用域链。
4、然后执行环境会创建一个活动对象(call object)。活动对象也是一个拥有属性的对象，但它不具有原型而且不能通过JavaScript代码直接访问。创建完活动对象后，把活动对象添加到a的作用域链的最顶端。此时a的作用域链包含了两个对象：a的活动对象和window对象。
5、下一步是在活动对象上添加一个arguments属性，它保存着调用函数a时所传递的参数。
6、最后把所有函数a的形参和内部的函数b的引用也添加到a的活动对象上。在这一步中，完成了函数b的的定义，因此如同第3步，函数b的作用域链被设置为b所被定义的环境，即a的作用域。
到此，整个函数a从定义到执行的步骤就完成了。此时a返回函数b的引用给c，又函数b的作用域链包含了对函数a的活动对象的引用，也就是说b可以访问到a中定义的所有变量和函数。函数b被c引用，函数b又依赖函数a，因此函数a在返回后不会被GC回收。
当函数b执行的时候亦会像以上步骤一样。因此，执行时b的作用域链包含了3个对象：b的活动对象、a的活动对象和window对象，如下图所示：
如图所示，当在函数b中访问一个变量的时候，搜索顺序是先搜索自身的活动对象，如果存在则返回，如果不存在将继续搜索函数a的活动对象，依 次查找，直到找到为止。如果整个作用域链上都无法找到，则返回undefined。如果函数b存在prototype原型对象，则在查找完自身的活动对象 后先查找自身的原型对象，再继续查找。这就是Javascript中的变量查找机制。
四、闭包的应用场景
1、保护函数内的变量安全。以最开始的例子为例，函数a中i只有函数b才能访问，而无法通过其他途径访问到，因此保护了i的安全性。
2、在内存中维持一个变量。依然如前例，由于闭包，函数a中i的一直存在于内存中，因此每次执行c()，都会给i自加1。
以上两点是闭包最基本的应用场景，很多经典案例都源于此。
五、Javascript的垃圾回收机制
在Javascript中，如果一个对象不再被引用，那么这个对象就会被GC回收。如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。因为函数a被b引用，b又被a外的c引用，这就是为什么函数a执行后不会被回收的原因。
Thursday, December 31, 2009
Monday, December 28, 2009
架构模式的介绍
更多精彩请到 http://www.139ya.com
几种典型的架构模式：
在开发系统软件时多用架构模式：
1、分层(Layer)：从不同的层次来观察系统，处理不同层次问题的对象被封装到不同的层中。
2、管道和过滤器(Pipes and Filters)：用数据流的观点来观察系统。整个系统由一些管道和过滤器组成，需要处理的数据同管道传送给每一个过滤器，每个过滤器就是一个处理步骤。每个过滤器可以单独修改,功能单一,并且它们之间的顺序可以进行配置。但数据通过了所有的过滤器后，就完成了所有的处理操作，得到了最终的处理结果。
一个典型的管道/过滤器体系结构的例子是以Unix shell编写的程序。Unix既提供一种符号，以连接各组成部分(Unix的进程)，又提供某种进程运行时机制以实现管道。另一个著名的例子是传统的编译器。传统的编译器一直被认为是一种管道系统，在该系统中，一个阶段（包括词法分析、语法分析、语义分析和代码生成）的输出是另一个阶段的输入。
3、黑板(Blackboard)：在这种架构中，有两种不同的构件：一种是表示当前状态中心数据结构；另一种是一种相互独立的构件，这些构件对中心数据进行操作。这种架构主要用于数据库和人工智能系统的开发。
在开发分布式软件时多用架构模式：
1、经纪人(Broker)：客户和服务器通过一个经纪人部件进行通信，经纪人负责协调客户和服务器之间的操作，并且为客户和服务器发送请求和结果信息。
2、客户/服务器（Client/Server）：系统分为客户和服务器，服务器一直处于侦听的状态，客户主动连接服务器，每个服务器可以为多个客户服务
3、点对点（Peer to Peer）：系统中的节点都处于平等的地位，每个节点都可以连接其他节点。在这种架构中，一般需要由一个中心服务器完成发现和管理节点的操作。ICQ以及Web Service技术的大多数应用，都是典型的点对点结构。
开发交互软件时多用架构模式：
1、模型-视图-控制器（Model-View-Controller）：当应用程序的用户界面非常复杂，且关于用户界面的需求很容易变化时，我们可以把交互类型的软件抽象成模型、视图和控制器这三类组件单元，这种抽象可以很好地分离用户界面和业务逻辑，适应变化的需求。大多数现代交互软件都在一定程度上符合这一架构模型的特点。
2、显示-抽象-控制（Presentation-Abstraction-COntrol）：这是MVC的另一种变形。
http://en.wikipedia.org/wiki/Presentation-abstraction-control
几种典型的架构模式：
在开发系统软件时多用架构模式：
1、分层(Layer)：从不同的层次来观察系统，处理不同层次问题的对象被封装到不同的层中。
2、管道和过滤器(Pipes and Filters)：用数据流的观点来观察系统。整个系统由一些管道和过滤器组成，需要处理的数据同管道传送给每一个过滤器，每个过滤器就是一个处理步骤。每个过滤器可以单独修改,功能单一,并且它们之间的顺序可以进行配置。但数据通过了所有的过滤器后，就完成了所有的处理操作，得到了最终的处理结果。
一个典型的管道/过滤器体系结构的例子是以Unix shell编写的程序。Unix既提供一种符号，以连接各组成部分(Unix的进程)，又提供某种进程运行时机制以实现管道。另一个著名的例子是传统的编译器。传统的编译器一直被认为是一种管道系统，在该系统中，一个阶段（包括词法分析、语法分析、语义分析和代码生成）的输出是另一个阶段的输入。
3、黑板(Blackboard)：在这种架构中，有两种不同的构件：一种是表示当前状态中心数据结构；另一种是一种相互独立的构件，这些构件对中心数据进行操作。这种架构主要用于数据库和人工智能系统的开发。
在开发分布式软件时多用架构模式：
1、经纪人(Broker)：客户和服务器通过一个经纪人部件进行通信，经纪人负责协调客户和服务器之间的操作，并且为客户和服务器发送请求和结果信息。
2、客户/服务器（Client/Server）：系统分为客户和服务器，服务器一直处于侦听的状态，客户主动连接服务器，每个服务器可以为多个客户服务
3、点对点（Peer to Peer）：系统中的节点都处于平等的地位，每个节点都可以连接其他节点。在这种架构中，一般需要由一个中心服务器完成发现和管理节点的操作。ICQ以及Web Service技术的大多数应用，都是典型的点对点结构。
开发交互软件时多用架构模式：
1、模型-视图-控制器（Model-View-Controller）：当应用程序的用户界面非常复杂，且关于用户界面的需求很容易变化时，我们可以把交互类型的软件抽象成模型、视图和控制器这三类组件单元，这种抽象可以很好地分离用户界面和业务逻辑，适应变化的需求。大多数现代交互软件都在一定程度上符合这一架构模型的特点。
2、显示-抽象-控制（Presentation-Abstraction-COntrol）：这是MVC的另一种变形。
http://en.wikipedia.org/wiki/Presentation-abstraction-control
软件的架构与设计模式之模式的种类介绍
更多精彩请到 http://www.139ya.com
由于[GOF95]是论述软件模式的著作的第一本，也是OO设计理论著作中最流行的一本，因此有些人常常使用设计模式（Design Pattern）一词来指所有直接处理软件的架构、设计、程序实现的任何种类的模式。另外一些人则强调要划分三种不同层次的模式：架构模式(Architectural Pattern)、设计模式(Design Pattern)、成例(Idiom)。成例有时称为代码模式(Coding Pattern)。
这三者之间的区别在于三种不同的模式存在于它们各自的抽象层次和具体层次上。架构模式是一个系统的高层次策略，涉及到大尺度的组件以及整体性质和力学。架构模式的好坏可以影响到总体布局和框架性结构。设计模式是中等尺度的结构策略。这些中等尺度的结构实现了一些大尺度组件的行为和它们之间的关系。模式的好坏不会影响到系统的总体布局和总体框架。设计模式定义出子系统或组件的微观结构。代码模式（或成例）是特定的范例和与特定语言有关的编程技巧。代码模式的好坏会影响到一个中等尺度组件的内部、外部的结构或行为的底层细节，但不会影响到一个部件或子系统的中等尺度的结构，更不会影响到系统的总体布局和大尺度框架。
代码模式或成例(Coding Pattern 或 Idiom)
代码模式（或成例）是较低层次的模式，并与编程语言密切相关。代码模式描述怎样利用一个特定的编程语言的特点来实现一个组件的某些特定的方面或关系。
较为著名的代码模式的例子包括双检锁（Double-Check Locking）模式等。
设计模式(Design Pattern)
一个设计模式提供一种提炼子系统或软件系统中的组件的，或者它们之间的关系的纲要设计。设计模式描述普遍存在的在相互通讯的组件中重复出现的结构，这种结构解决在一定的背景中的具有一般性的设计问题。
设计模式常常划分成不同的种类，常见的种类有：
创建型设计模式，如工厂方法（Factory Method）模式、抽象工厂（Abstract Factory）模式、原型（Prototype）模式、单例（Singleton）模式，建造（Builder）模式等
结构型设计模式，如合成（Composite）模式、装饰（Decorator）模式、代理（Proxy）模式、享元（Flyweight）模式、门面（Facade）模式、桥梁（Bridge）模式等
行为型模式，如模版方法（Template Method）模式、观察者（Observer）模式、迭代子（Iterator）模式、责任链（Chain of Responsibility）模式、备忘录（Memento）模式、命令（Command）模式、状态（State）模式、访问者（Visitor）模式等等。
以上是三种经典类型，实际上还有很多其他的类型，比如Fundamental型、Partition型，Relation型等等。设计模式在特定的编程语言中实现的时候，常常会用到代码模式。比如单例（Singleton）模式的实现常常涉及到双检锁（Double-Check Locking）模式等。
架构模式(Architectural Pattern)
一个架构模式描述软件系统里的基本的结构组织或纲要。架构模式提供一些事先定义好的子系统，指定它们的责任，并给出把它们组织在一起的法则和指南。有些作者把这种架构模式叫做系统模式[STELTING02]。
一个架构模式常常可以分解成很多个设计模式的联合使用。显然，MVC模式就是属于这一种模式。MVC模式常常包括调停者（Mediator）模式、策略（Strategy）模式、合成（Composite）模式、观察者（Observer）模式等。
此外，常见的架构模式还有：
•Layers（分层）模式，有时也称Tiers模式
•Blackboard（黑板）模式
•Broker（中介）模式
•Distributed Process（分散过程）模式
•Microkernel（微核）模式
架构模式常常划分成如下的几种：
一、 From Mud to Structure型。帮助架构师将系统合理划分，避免形成一个对象的海洋（A sea of objects）。包括Layers（分层）模式、Blackboard（黑板）模式、Pipes/Filters（管道/过滤器）模式等。
二、分散系统（Distributed Systems）型。为分散式系统提供完整的架构设计，包括像Broker（中介）模式等。
三、人机互动（Interactive Systems）型，支持包含有人机互动介面的系统的架构设计，例子包括MVC（Model-View-Controller）模式、PAC（Presentation-Abstraction-Control）模式等。
四、Adaptable Systems型，支持应用系统适应技术的变化、软件功能需求的变化。如Reflection（反射）模式、Microkernel（微核）模式等。
由于[GOF95]是论述软件模式的著作的第一本，也是OO设计理论著作中最流行的一本，因此有些人常常使用设计模式（Design Pattern）一词来指所有直接处理软件的架构、设计、程序实现的任何种类的模式。另外一些人则强调要划分三种不同层次的模式：架构模式(Architectural Pattern)、设计模式(Design Pattern)、成例(Idiom)。成例有时称为代码模式(Coding Pattern)。
这三者之间的区别在于三种不同的模式存在于它们各自的抽象层次和具体层次上。架构模式是一个系统的高层次策略，涉及到大尺度的组件以及整体性质和力学。架构模式的好坏可以影响到总体布局和框架性结构。设计模式是中等尺度的结构策略。这些中等尺度的结构实现了一些大尺度组件的行为和它们之间的关系。模式的好坏不会影响到系统的总体布局和总体框架。设计模式定义出子系统或组件的微观结构。代码模式（或成例）是特定的范例和与特定语言有关的编程技巧。代码模式的好坏会影响到一个中等尺度组件的内部、外部的结构或行为的底层细节，但不会影响到一个部件或子系统的中等尺度的结构，更不会影响到系统的总体布局和大尺度框架。
代码模式或成例(Coding Pattern 或 Idiom)
代码模式（或成例）是较低层次的模式，并与编程语言密切相关。代码模式描述怎样利用一个特定的编程语言的特点来实现一个组件的某些特定的方面或关系。
较为著名的代码模式的例子包括双检锁（Double-Check Locking）模式等。
设计模式(Design Pattern)
一个设计模式提供一种提炼子系统或软件系统中的组件的，或者它们之间的关系的纲要设计。设计模式描述普遍存在的在相互通讯的组件中重复出现的结构，这种结构解决在一定的背景中的具有一般性的设计问题。
设计模式常常划分成不同的种类，常见的种类有：
创建型设计模式，如工厂方法（Factory Method）模式、抽象工厂（Abstract Factory）模式、原型（Prototype）模式、单例（Singleton）模式，建造（Builder）模式等
结构型设计模式，如合成（Composite）模式、装饰（Decorator）模式、代理（Proxy）模式、享元（Flyweight）模式、门面（Facade）模式、桥梁（Bridge）模式等
行为型模式，如模版方法（Template Method）模式、观察者（Observer）模式、迭代子（Iterator）模式、责任链（Chain of Responsibility）模式、备忘录（Memento）模式、命令（Command）模式、状态（State）模式、访问者（Visitor）模式等等。
以上是三种经典类型，实际上还有很多其他的类型，比如Fundamental型、Partition型，Relation型等等。设计模式在特定的编程语言中实现的时候，常常会用到代码模式。比如单例（Singleton）模式的实现常常涉及到双检锁（Double-Check Locking）模式等。
架构模式(Architectural Pattern)
一个架构模式描述软件系统里的基本的结构组织或纲要。架构模式提供一些事先定义好的子系统，指定它们的责任，并给出把它们组织在一起的法则和指南。有些作者把这种架构模式叫做系统模式[STELTING02]。
一个架构模式常常可以分解成很多个设计模式的联合使用。显然，MVC模式就是属于这一种模式。MVC模式常常包括调停者（Mediator）模式、策略（Strategy）模式、合成（Composite）模式、观察者（Observer）模式等。
此外，常见的架构模式还有：
•Layers（分层）模式，有时也称Tiers模式
•Blackboard（黑板）模式
•Broker（中介）模式
•Distributed Process（分散过程）模式
•Microkernel（微核）模式
架构模式常常划分成如下的几种：
一、 From Mud to Structure型。帮助架构师将系统合理划分，避免形成一个对象的海洋（A sea of objects）。包括Layers（分层）模式、Blackboard（黑板）模式、Pipes/Filters（管道/过滤器）模式等。
二、分散系统（Distributed Systems）型。为分散式系统提供完整的架构设计，包括像Broker（中介）模式等。
三、人机互动（Interactive Systems）型，支持包含有人机互动介面的系统的架构设计，例子包括MVC（Model-View-Controller）模式、PAC（Presentation-Abstraction-Control）模式等。
四、Adaptable Systems型，支持应用系统适应技术的变化、软件功能需求的变化。如Reflection（反射）模式、Microkernel（微核）模式等。
Thursday, December 17, 2009
在Java中，什么是Overriding?什么是Overloading？
更多精彩请到 http://www.139ya.com
在Java中，什么是Overriding?什么是Overloading？
Overriding翻译过来是“重写/覆盖”。 它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。
重写的主要特点是：
1）方法名必须与被重写方法一致。
2）方法参数列表必须与被重写方法一致。
3）返回类型必须与被重写方法一致。
4）重写的方法不能降低原方法的"可见度"。
例如：被重写方法为protected void do(int i,double d),则重写方法可以为protected void do(int i,double d),或者public void do(int i,double d),但是不可以是private void do(int i,double d)。
5）不能抛出新的异常或者"更宽的"异常。
例如：被重写方法为public void do(int i,double d) throws IOException,则重写方法可以为public void do(int i,double d) throws IOException ,或者public void do(int i,double d) throws ddeeException(IOException的子类），但是不可以是public void do(int i,double d) throws Exception,因为Exception是IOException的父类，比IOException"更宽"。
6）被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
Overloading，翻译成“重载”。 它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。
其特点是：
1）各重载的方法名一致。
2）各重载方法的参数列表不一样（包括参数类型，参数个数，参数顺序3项中的一项或多项）。
3）返回类型任意。（不能通过方法的返回值来区分重载方法。）
4）访问控制符任意。（不能通过方法的访问权限来区分重载方法。）
5）可以任意抛出自身的异常，而不管被重载方法。（不能通过抛出的异常来区分重载方法。）
Overloading是指“Two or more methods can have the same name if they have different numbers or types of parameters and thus different signatures. ”显然，对重载的唯一要求就是参数列表必须改变，否则就不是重载了。
在一些情况下，Java 的自动类型转换也适用于重载方法的自变量。例如，看下面的程序：
// Automatic type conversions apply to overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
void test(double a) {
System.out.println("Inside test(double) a: " + a);
}
}
class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
int i = 88;
ob.test();
ob.test(10, 20);
ob.test(i); // this will invoke test(double)
ob.test(123.2); // this will invoke test(double)
}
}
该程序产生如下输出：
No parameters
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
a and b: 10 20
Inside test(double) a: 88
Inside test(double) a: 123.2
在本例中，OverloadDemo 的这个版本没有定义test(int) 。因此当在Overload 内带整数参数调用test()时，找不到和它匹配的方法。但是，Java 可以自动地将整数转换为double 型，这种转换就可以解决这个问题。因此，在test(int) 找不到以后，Java 将i扩大到double 型，然后调用test(double) 。当然，如果定义了test(int) ，当然先调用test(int) 而不会调用test(double) 。只有在找不到精确匹配时，Java 的自动转换才会起作用，而且总是找到参数类型最"匹配"的方法，即它的形参比实参“大”且是最“接近”的。
[1]Thinking in Java 3rd
[2] Overriding和Overloading
[url]http://blog.csdn.net/andyjava2006/archive/[/url]2006/09/13 /1218858.aspx
[3] 彻底学习Java语言中的覆盖和重载
[url]http://www.blog.edu.cn/user2/41584/archives/2006/1325849.shtml[/url]
[4] JAVA 方法重载
[url]http://blog.sina.com.cn/u/[/url]538402f 901000685
HTTP协议通信过程
更多精彩请到 http://www.139ya.com
HTTP协议通信过程
当我们在浏览器的地址栏输入“www.baidu.com”然后按回车，这之后发生了什么事，我们直接看到的是打开了对应的网页，那么内部客户端和服务端是如何通信的呢？
1、 1、URL自动解析
HTTP URL包含了用于查找某个资源的足够信息，基本格式如下：HTTP://host[“:”port] [abs_path]，其中HTTP表示桶盖HTTP协议来定位网络资源；host表示合法的主机域名或IP地址，port指定一个端口号，缺省 80；abs_path指定请求资源的URI；如果URL中没有给出abs_path，那么当它作为请求URI时，必须以“/”的形式给出，通常这个工作浏览器自动帮我们完成。
例如：输入www.163.com;浏览器会自动转换成：HTTP://www.163.com/
2、获取IP，建立TCP连接
浏览器地址栏中输入"HTTP://www.xxx.com/"并提交之后，首先它会在DNS本地缓存表中查找，如果有则直接告诉IP地址。如果没有则要求网关DNS进行查找，如此下去，找到对应的IP后，则返回会给浏览器。
当获取IP之后，就开始与所请求的Tcp建立三次握手连接，连接建立后，就向服务器发出HTTP请求。
3、客户端浏览器向服务器发出HTTP请求
一旦建立了TCP连接，Web浏览器就会向Web服务器发送请求命令，接着以头信息的形式向Web服务器发送一些别的信息，之后浏览器发送了一空白行来通知服务器，它已经结束了该头信息的发送。
4、Web服务器应答，并向浏览器发送数据
客户机向服务器发出请求后，服务器会客户机回送应答，
HTTP/1.1 200 OK
应答的第一部分是协议的版本号和应答状态码，正如客户端会随同请求发送关于自身的信息一样，服务器也会随同应答向用户发送关于它自己的数据及被请求的文档。
Web服务器向浏览器发送头信息后，它会发送一个空白行来表示头信息的发送到此为结束，接着，它就以Content-Type应答头信息所描述的格式发送用户所请求的实际数据
5、Web服务器关闭TCP连接
一般情况下，一旦Web服务器向浏览器发送了请求数据，它就要关闭TCP连接，然后如果浏览器或者服务器在其头信息加入了这行代码
Connection:keep-alive
TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了网络带宽。
Monday, December 7, 2009
SyncML 简介
更多精彩请到 http://www.139ya.com
SyncML是一种唯一行业通用的移动数据同步化协议，由SyncML initiative发行，是一种开放性协议。SyncML协议的目的是解决移动设备和网络之间的数据同步和设备管理问题。在SyncML之前,数据同步和设备管理是基于各种私有协议实现的，每种协议只能支持有限的设备和数据类型。各种协议间不能互通，这就限制了用户的数据访问、传输和移动性。
SyncML的主要目的有两方面：
* 可以通过任何移动设备将网络数据同步化。
* 移动设备中的数据也可以用任何网络数据同步化。
* SyncML协议特性:
* 可以在不同的网络上工作–包括有线网络和无线网络.
* 支持多种传输协议,包括HTTP,WSP,OBEX,SMTP,Pure TCP/IP.
* 支持通用的个人数据格式,如vCard,vCalendar和E-MAIL等.
* 考虑到移动设备的资源限制，对移动设备的存储空间进行了优化.
* 建立在internet协议和web技术上,是可执行而且有很好的协作性的.
* 协议最小功能就是赋予所有设备最常用的同步能力
SyncML是一种唯一行业通用的移动数据同步化协议，由SyncML initiative发行，是一种开放性协议。SyncML协议的目的是解决移动设备和网络之间的数据同步和设备管理问题。在SyncML之前,数据同步和设备管理是基于各种私有协议实现的，每种协议只能支持有限的设备和数据类型。各种协议间不能互通，这就限制了用户的数据访问、传输和移动性。
SyncML的主要目的有两方面：
* 可以通过任何移动设备将网络数据同步化。
* 移动设备中的数据也可以用任何网络数据同步化。
* SyncML协议特性:
* 可以在不同的网络上工作–包括有线网络和无线网络.
* 支持多种传输协议,包括HTTP,WSP,OBEX,SMTP,Pure TCP/IP.
* 支持通用的个人数据格式,如vCard,vCalendar和E-MAIL等.
* 考虑到移动设备的资源限制，对移动设备的存储空间进行了优化.
* 建立在internet协议和web技术上,是可执行而且有很好的协作性的.
* 协议最小功能就是赋予所有设备最常用的同步能力
Syncml的7种同步模式
SyncML Protocol Architecture
Friday, December 4, 2009
SELINUX从理解到动手配置
更多精彩请到 http://www.139ya.com
http://www.xxlinux.com/linux/article/network/security/20090531/16821.html
SELinux 可以为你的系统提供较棒的安全防护。 使用者能被分配预先定义好的角色，以便他们不能存取文件或者访问他们不拥有的程序。
Selinux的启用与关闭
编辑/etc/selinux/conf文件
SELINUX=enforcing（强制：违反了策略，你就无法继续操作下去）
Permissive（有效，但不强制：违反了策略的话它让你继续操作，但是把你的违反的内容记录下来）
Disabled（禁用）
禁用的另一种方式：在启动的时候，也可以通过传递参数selinux给内核来控制它
编辑/etc/grup.conf
title Red Hat Enterprise Linux Server (2.6.18-8.el5)
root (hd0,0)
kernel /vmlinuz-2.6.18-8.el5 ro root=LABEL=/ rhgb quiet selinux=0
initrd /initrd-2.6.18-8.el5.img
SELINUXTYPE=targeted
此参数可选项：targeted和strice。分别是targeted只控制关键网络服务，strice控制所有的服务
查询selinux的状态
[root@linuxas ~]# /usr/sbin/getenforce
Enforcing
[root@linuxas ~]# sestatus -bv
SELinux status: enabled
SELinuxfs mount: /selinux
Current mode: enforcing
Mode from config file: enforcing
Policy version: 21
Policy from config file: targeted
查看selinux加载的内核模块
[root@linuxas selinux]# semodule -l
amavis 1.1.0
ccs 1.0.0
clamav 1.1.0
dcc 1.1.0
evolution 1.1.0
iscsid 1.0.0
mozilla 1.1.0
mplayer 1.1.0
nagios 1.1.0
oddjob 1.0.1
pcscd 1.0.0
pyzor 1.1.0
razor 1.1.0
ricci 1.0.0
smartmon 1.1.0
查看selinux错误日志
[root@linuxas selinux]# sealert -a /var/log/audit/audit.log
SElinux的图形化管理工具
[root@linuxas selinux]# system-config-selinux
Selinux的基本操作
查看文件：ls –Z（--context）
[root@linuxas ~]# ls -Z
drwx------ root root root:object_r:user_home_t Desktop
-rw------- root root system_u:object_r:user_home_t anaconda-ks.cfg
-rw-r--r-- root root root:object_r:user_home_t install.log
-rw-r--r-- root root root:object_r:user_home_t install.log.syslog
[root@linuxas ~]# ls --context
drwx------ root root root:object_r:user_home_t Desktop
-rw------- root root system_u:object_r:user_home_t anaconda-ks.cfg
-rw-r--r-- root root root:object_r:user_home_t install.log
-rw-r--r-- root root root:object_r:user_home_t install.log.syslog
查看文件系统的扩展属性：getfattr
[root@linuxas ~]# getfattr -m. -d /etc/passwd
getfattr: Removing leading '/' from absolute path names
# file: etc/passwd
security.selinux="system_u:object_r:etc_t:s0�00"
查看的文件的 security.selinux 属性中储存了此文件的安全上下文, 所以上面例子中的上下文就是 system_ubject_r:etc_t 。
所有运行了SE Linux的ext2/3文件系统上都有 security.selinux 这个属性。
更改文件的扩展属性标签：chcon （不能在 /proc 文件系统上使用，就是说 /proc 文件系统不支持这种标记的改变。）
[root@linuxas test]# ls --context aa.txt
-rw-r--r-- root root root:object_r:user_home_t aa.txt
[root@linuxas test]# chcon -t etc_t aa.txt
[root@linuxas test]# ls --context aa.txt
-rw-r--r-- root root root:object_r:etc_t aa.txt
恢复原来的文件标签: restorecon
[root@linuxas test]# restorecon aa.txt
[root@linuxas test]# ls -Z aa.txt
-rw-r--r-- root root user_u:object_r:user_home_t aa.txt
显示当前用户的Selinux context
[root@linuxas ~]# id -Z
root:system_r:unconfined_t:SystemLow-SystemHigh
runcon 使用特定的context来执行指令
[root@linuxas ~]# runcon -t user_home_t cat /etc/passwd
root:system_r:user_home_t:SystemLow-SystemHigh is not a valid context
查看某种服务是否受到SELinux的保护
[root@linuxas ~]# getsebool -a (RHEL4：inactive受保护，active不受保护；RHEL5：off受保护，on不受保护)
SELINUX从理解到动手配置
http://www.xxlinux.com/linux/article/network/security/20090531/16821.html
SELinux 可以为你的系统提供较棒的安全防护。 使用者能被分配预先定义好的角色，以便他们不能存取文件或者访问他们不拥有的程序。
Selinux的启用与关闭
编辑/etc/selinux/conf文件
SELINUX=enforcing（强制：违反了策略，你就无法继续操作下去）
Permissive（有效，但不强制：违反了策略的话它让你继续操作，但是把你的违反的内容记录下来）
Disabled（禁用）
禁用的另一种方式：在启动的时候，也可以通过传递参数selinux给内核来控制它
编辑/etc/grup.conf
title Red Hat Enterprise Linux Server (2.6.18-8.el5)
root (hd0,0)
kernel /vmlinuz-2.6.18-8.el5 ro root=LABEL=/ rhgb quiet selinux=0
initrd /initrd-2.6.18-8.el5.img
SELINUXTYPE=targeted
此参数可选项：targeted和strice。分别是targeted只控制关键网络服务，strice控制所有的服务
查询selinux的状态
[root@linuxas ~]# /usr/sbin/getenforce
Enforcing
[root@linuxas ~]# sestatus -bv
SELinux status: enabled
SELinuxfs mount: /selinux
Current mode: enforcing
Mode from config file: enforcing
Policy version: 21
Policy from config file: targeted
查看selinux加载的内核模块
[root@linuxas selinux]# semodule -l
amavis 1.1.0
ccs 1.0.0
clamav 1.1.0
dcc 1.1.0
evolution 1.1.0
iscsid 1.0.0
mozilla 1.1.0
mplayer 1.1.0
nagios 1.1.0
oddjob 1.0.1
pcscd 1.0.0
pyzor 1.1.0
razor 1.1.0
ricci 1.0.0
smartmon 1.1.0
查看selinux错误日志
[root@linuxas selinux]# sealert -a /var/log/audit/audit.log
SElinux的图形化管理工具
[root@linuxas selinux]# system-config-selinux
Selinux的基本操作
查看文件：ls –Z（--context）
[root@linuxas ~]# ls -Z
drwx------ root root root:object_r:user_home_t Desktop
-rw------- root root system_u:object_r:user_home_t anaconda-ks.cfg
-rw-r--r-- root root root:object_r:user_home_t install.log
-rw-r--r-- root root root:object_r:user_home_t install.log.syslog
[root@linuxas ~]# ls --context
drwx------ root root root:object_r:user_home_t Desktop
-rw------- root root system_u:object_r:user_home_t anaconda-ks.cfg
-rw-r--r-- root root root:object_r:user_home_t install.log
-rw-r--r-- root root root:object_r:user_home_t install.log.syslog
查看文件系统的扩展属性：getfattr
[root@linuxas ~]# getfattr -m. -d /etc/passwd
getfattr: Removing leading '/' from absolute path names
# file: etc/passwd
security.selinux="system_u:object_r:etc_t:s0�00"
查看的文件的 security.selinux 属性中储存了此文件的安全上下文, 所以上面例子中的上下文就是 system_ubject_r:etc_t 。
所有运行了SE Linux的ext2/3文件系统上都有 security.selinux 这个属性。
更改文件的扩展属性标签：chcon （不能在 /proc 文件系统上使用，就是说 /proc 文件系统不支持这种标记的改变。）
[root@linuxas test]# ls --context aa.txt
-rw-r--r-- root root root:object_r:user_home_t aa.txt
[root@linuxas test]# chcon -t etc_t aa.txt
[root@linuxas test]# ls --context aa.txt
-rw-r--r-- root root root:object_r:etc_t aa.txt
恢复原来的文件标签: restorecon
[root@linuxas test]# restorecon aa.txt
[root@linuxas test]# ls -Z aa.txt
-rw-r--r-- root root user_u:object_r:user_home_t aa.txt
显示当前用户的Selinux context
[root@linuxas ~]# id -Z
root:system_r:unconfined_t:SystemLow-SystemHigh
runcon 使用特定的context来执行指令
[root@linuxas ~]# runcon -t user_home_t cat /etc/passwd
root:system_r:user_home_t:SystemLow-SystemHigh is not a valid context
查看某种服务是否受到SELinux的保护
[root@linuxas ~]# getsebool -a (RHEL4：inactive受保护，active不受保护；RHEL5：off受保护，on不受保护)
Thursday, December 3, 2009
Eclipse插件开发小结
更多精彩请到 http://www.139ya.com
http://wjj-tt.spaces.live.com/blog/cns!91CCF857592F26C!106.entry
http://wjj-tt.spaces.live.com/blog/cns!91CCF857592F26C!106.entry
这两天看了一下Eclipse的插件开发，参考的书就是那本著名的Contributing to Eclipse。
把两点体会记录如下：
1、Extension和Extension-point
Extension 和Extension-point是相互关联的，由Extension-point定义插件具备的扩展点并且定义了如何使用这些扩展点（由Schema中 定义），而Extension则是根据扩展点中定义的Schema来描述扩展的内容。Extension定义的是对已有插件进行的扩展，其中point是 扩展源的id。对于不同的扩展源，Extension的元素定义各不相同。Extension-piont定义的是本插件向外提供的扩展功能，利用 Schema来定义Extension。
【学习心得】JFace和SWT有什么区别呢？
更多精彩请到 http://www.139ya.com
JFace：插件的用户界面框架
我们已经见到工作台定义扩展点来为使插件向平台添加用户界面功能。许多这些扩展点，特别是向导扩展，是通过使用 org.eclipse.jface.* 包中的类来实现的。有什么区别？
JFace 是一个用户界面工具箱，它提供很难实现的、用于开发用户界面功能部件的 helper 类。JFace 在原始的窗口小部件系统的级别之上运行。它提供用于处理常见的用户界面编程任务的类：
查看器负责处理填充、排序、过滤和更新窗口小部件等最辛苦的工作。
操作和添加项介绍用于定义用户操作的语义，并指定在何处提供它们。
图像和字体注册表提供用于处理用户界面资源的常见模式。
对话框和向导定义用于构建与用户进行复杂交互的框架。
JFace 使您可以专注于实现特定插件的功能，而不必花费精力来处理底层窗口小部件系统或者解决几乎在任何用户界面应用程序中都很常见的问题。
JFace 和工作台
何处是 JFace 结束而工作台开始的位置？有时候界线并不是这样明显。通常，JFace API（来自于包 org.eclipse.jface.*）独立于工作台扩展点和 API。可以想象，根本不必使用任何工作台代码就可以编写 JFace 程序。
工作台使用 JFace，但是又试图尽可能减少依赖项。例如，工作台部件模型（IWorkbenchPart）被设计为独立于 JFace。我们很早就知道可以直接使用 SWT 窗口小部件来实现视图和编辑器，而不必使用任何 JFace 类。工作台尽可能保持“JFace 中立”，允许程序员使用他们觉得有用的 JFace 的部件。实际上，在工作台的大多数实现中都使用了 JFace，并且在 API 定义中引用了 JFace 类型。（例如，IMenuManager、IToolBarManager 和 IStatusLineManager 的 JFace 接口显示为工作台 IActionBar 方法中的类型。）
JFace 和 SWT
SWT 和 JFace 之间的界线是很明显的。SWT 根本不依赖于任何 JFace 或平台代码。许多 SWT 示例说明可以如何构建独立的应用程序。
JFace 用来在 SWT 库顶部提供常见的应用程序用户界面功能。JFace 并不试图“隐藏”SWT 或者替换它的功能。它提供一些类和接口，以处理与使用 SWT 来对动态用户界面编程相关联的许多常见任务。
通过了解查看器及它们与 SWT 窗口小部件之间的关系，就可以更清楚地了解 JFace 和 SWT 之间的关系。
Java是一种强大的编程语言。但强大就意味复杂，尤其是和Java相关的名词就象天上的星星一样，数都数不过来。在本文中就涉及到两个比较常用的名词 SWT和JFace。在标题中将SWT和JFace放到一起，并不是说SWT和JFace是一个意思，而是说它们的关系非常紧密。
基于Java的图形库最主要的有三种，它们分别是Swing、AWT和SWT。其中前两个是Sun随JDK一起发布的，而SWT则是由IBM领导的开源项目（现在已经脱离IBM了）Eclipse的一个子项目。SWT的执行效率非常高。这是由于SWT的底层是由C编写的。由于SWT通过C直接调用系统层的 GUI API。因此，使用SWT编写GUI程序，在外观上就和使用C++、Delphi（在Windows下）编写的程序完全一样。它的这一点和AWT类似。 AWT在底层也是使用C直接调用系统层的GUI API。但它们是有区别的，最大的区别可能就是一个是Sun提供的，一个是Eclipse自带的。这就意味着如果使用AWT，只要机器上安装了JDK或 JRE，发布软件时无需带其它的库。而如何使用SWT，在发布时必须要自带上SWT的*.dll（Windows版）或*.so(Linux/Unix 版)文件以及相关的*.jar包。还有就是它们所提供的图形接口有一些差异。SWT可能更丰富一些，我们可以看看Eclipse的界面就知道了。但随着 Sun对AWT库的不断更新，AWT的图形表现能力也在不断地提高。
虽然SWT很强大，但它比较底层。也就是说它的一些功能在使用上还比较低级，不太符合面向对象的特征。因此，在SWT的基础上又开发了JFace。JFace在SWT上进行了一定的扩展。因此，也可说JFace是基于 SWT的，就象在VC中使用MFC来包装Win32 API一样。
JFace：插件的用户界面框架
我们已经见到工作台定义扩展点来为使插件向平台添加用户界面功能。许多这些扩展点，特别是向导扩展，是通过使用 org.eclipse.jface.* 包中的类来实现的。有什么区别？
JFace 是一个用户界面工具箱，它提供很难实现的、用于开发用户界面功能部件的 helper 类。JFace 在原始的窗口小部件系统的级别之上运行。它提供用于处理常见的用户界面编程任务的类：
查看器负责处理填充、排序、过滤和更新窗口小部件等最辛苦的工作。
操作和添加项介绍用于定义用户操作的语义，并指定在何处提供它们。
图像和字体注册表提供用于处理用户界面资源的常见模式。
对话框和向导定义用于构建与用户进行复杂交互的框架。
JFace 使您可以专注于实现特定插件的功能，而不必花费精力来处理底层窗口小部件系统或者解决几乎在任何用户界面应用程序中都很常见的问题。
JFace 和工作台
何处是 JFace 结束而工作台开始的位置？有时候界线并不是这样明显。通常，JFace API（来自于包 org.eclipse.jface.*）独立于工作台扩展点和 API。可以想象，根本不必使用任何工作台代码就可以编写 JFace 程序。
工作台使用 JFace，但是又试图尽可能减少依赖项。例如，工作台部件模型（IWorkbenchPart）被设计为独立于 JFace。我们很早就知道可以直接使用 SWT 窗口小部件来实现视图和编辑器，而不必使用任何 JFace 类。工作台尽可能保持“JFace 中立”，允许程序员使用他们觉得有用的 JFace 的部件。实际上，在工作台的大多数实现中都使用了 JFace，并且在 API 定义中引用了 JFace 类型。（例如，IMenuManager、IToolBarManager 和 IStatusLineManager 的 JFace 接口显示为工作台 IActionBar 方法中的类型。）
JFace 和 SWT
SWT 和 JFace 之间的界线是很明显的。SWT 根本不依赖于任何 JFace 或平台代码。许多 SWT 示例说明可以如何构建独立的应用程序。
JFace 用来在 SWT 库顶部提供常见的应用程序用户界面功能。JFace 并不试图“隐藏”SWT 或者替换它的功能。它提供一些类和接口，以处理与使用 SWT 来对动态用户界面编程相关联的许多常见任务。
通过了解查看器及它们与 SWT 窗口小部件之间的关系，就可以更清楚地了解 JFace 和 SWT 之间的关系。
Java是一种强大的编程语言。但强大就意味复杂，尤其是和Java相关的名词就象天上的星星一样，数都数不过来。在本文中就涉及到两个比较常用的名词 SWT和JFace。在标题中将SWT和JFace放到一起，并不是说SWT和JFace是一个意思，而是说它们的关系非常紧密。
基于Java的图形库最主要的有三种，它们分别是Swing、AWT和SWT。其中前两个是Sun随JDK一起发布的，而SWT则是由IBM领导的开源项目（现在已经脱离IBM了）Eclipse的一个子项目。SWT的执行效率非常高。这是由于SWT的底层是由C编写的。由于SWT通过C直接调用系统层的 GUI API。因此，使用SWT编写GUI程序，在外观上就和使用C++、Delphi（在Windows下）编写的程序完全一样。它的这一点和AWT类似。 AWT在底层也是使用C直接调用系统层的GUI API。但它们是有区别的，最大的区别可能就是一个是Sun提供的，一个是Eclipse自带的。这就意味着如果使用AWT，只要机器上安装了JDK或 JRE，发布软件时无需带其它的库。而如何使用SWT，在发布时必须要自带上SWT的*.dll（Windows版）或*.so(Linux/Unix 版)文件以及相关的*.jar包。还有就是它们所提供的图形接口有一些差异。SWT可能更丰富一些，我们可以看看Eclipse的界面就知道了。但随着 Sun对AWT库的不断更新，AWT的图形表现能力也在不断地提高。
虽然SWT很强大，但它比较底层。也就是说它的一些功能在使用上还比较低级，不太符合面向对象的特征。因此，在SWT的基础上又开发了JFace。JFace在SWT上进行了一定的扩展。因此，也可说JFace是基于 SWT的，就象在VC中使用MFC来包装Win32 API一样。
Wednesday, December 2, 2009
What is Spring?
更多精彩请到 http://www.139ya.com
http://onjava.com/onjava/2005/10/05/what-is-spring.html
Spring is a lightweight container, with wrappers that make it easy to use many different services and frameworks. Lightweight containers accept any JavaBean, instead of specific types of components.
"Spring is more than just a 'lightweight container,'" says Justin Gehtland. "It allows Java developers who are building J2EE apps to get to the heart of their real domain problems and stop spending so much time on the minutiae of providing services to their domain." Gehtland and Bruce Tate are coauthors of Spring: A Developer's Notebook, a no-nonsense book that will get you up to speed quickly on the new Spring open source framework. Spring: A Developer's Notebook includes examples and practical applications that demonstrate exactly how to use Spring, in ten chapters of code-intensive labs.
Today we'll feature the first of two chapters from the book, in our two-part series dubbed "What Is Spring." The series will help you understand how you can use Spring to produce simple, clean, and effective applications.
In this week's excerpt of Chapter 1, "Getting Started," authors Tate and Gehtland take a simple application and show you how to automate it and enable it for Spring. (In part 2 next week, the authors will cover how Spring can help in development of simple, clean, web-based UI's--excerpted from Chapter 2, "Building a User Interface.")
http://onjava.com/onjava/2005/10/05/what-is-spring.html
Spring is a lightweight container, with wrappers that make it easy to use many different services and frameworks. Lightweight containers accept any JavaBean, instead of specific types of components.
"Spring is more than just a 'lightweight container,'" says Justin Gehtland. "It allows Java developers who are building J2EE apps to get to the heart of their real domain problems and stop spending so much time on the minutiae of providing services to their domain." Gehtland and Bruce Tate are coauthors of Spring: A Developer's Notebook, a no-nonsense book that will get you up to speed quickly on the new Spring open source framework. Spring: A Developer's Notebook includes examples and practical applications that demonstrate exactly how to use Spring, in ten chapters of code-intensive labs.
Today we'll feature the first of two chapters from the book, in our two-part series dubbed "What Is Spring." The series will help you understand how you can use Spring to produce simple, clean, and effective applications.
In this week's excerpt of Chapter 1, "Getting Started," authors Tate and Gehtland take a simple application and show you how to automate it and enable it for Spring. (In part 2 next week, the authors will cover how Spring can help in development of simple, clean, web-based UI's--excerpted from Chapter 2, "Building a User Interface.")
Introduction to Eclipse Plugin Development
更多精彩请到 http://www.139ya.com
From : http://www.eclipsepluginsite.com/index.html
Eclipse Plugin Development TUTORIAL
Eclipse Plugin Development Tutorial website to teach you how to develop eclipse plugins using simple examples to a complex eclipse rcp over time. This chapter will give you a detailed insight into Eclipse Architecture and we will develop a simple but fully functional eclipse plug-in so as to give you a quick start with eclipse plug-in development.
Overview
Eclipse isn’t a huge single java program, but rather a small program which provides the functionality of typical loader called plug-in loader. Eclipse (plug-in loader) is surrounded by hundreds and thousands of plug-ins. Plug-in is nothing but another java program which extends the functionality of Eclipse in some way. Each eclipse plug-in can either consume services provided by other plug-in or can extend its functionality to be consumed by other plug-ins. These plug-in are dynamically loaded by eclipse at run time on demand basis.
An Open Platform
Eclipse is an open platform. It is designed to be easily and infinitely extensible by third parties. At the core is the eclipse SDK, we can build various products/tools around this SDK. These products or tools can further be extended by other products/tools and so on. For example, we can extend simple text editor to create xml editor. Eclipse architecture is truly amazing when it comes to extensibility. This extensibility is achieved by creating these products/tools in form of plug-ins.
Figure 1-1
Inside the Eclipse SDK
Figure 1-2
RCP: On the bottom is RCP which provides the architecture and framework to build any rich client application.
IDE: It is a tools platform and a rich client application itself. We can build various form of tooling by using IDE for example Database tooling.
JDT: It is a complete java IDE and a platform in itself.
PDE: It provides all tools necessary to develop plug-ins and RCP applications. This is what we will concentrate on the course of this tutorial.
Plug-ins everywhere
All the layers in eclipse SDK are made up of plug-ins. If you see all the way, you will notice that everything is a plug-in in eclipse sdk.
Figure 1-3
A plug-in can be delivered as a jar file. A plug-in is self-contained bundle in a sense that it contains the code and resources that it needs to run for ex: code, image files, resource bundles etc. A plug-in is self describing - when I say it is self describing it means that it describes who it is and what it contributes to the world. It also declares what it requires from the world.
A Mechanism For Extensibility
Figure 1-7
From : http://www.eclipsepluginsite.com/index.html
Eclipse Plugin Development TUTORIAL
Eclipse Plugin Development Tutorial website to teach you how to develop eclipse plugins using simple examples to a complex eclipse rcp over time. This chapter will give you a detailed insight into Eclipse Architecture and we will develop a simple but fully functional eclipse plug-in so as to give you a quick start with eclipse plug-in development.
Overview
Eclipse isn’t a huge single java program, but rather a small program which provides the functionality of typical loader called plug-in loader. Eclipse (plug-in loader) is surrounded by hundreds and thousands of plug-ins. Plug-in is nothing but another java program which extends the functionality of Eclipse in some way. Each eclipse plug-in can either consume services provided by other plug-in or can extend its functionality to be consumed by other plug-ins. These plug-in are dynamically loaded by eclipse at run time on demand basis.
An Open Platform
Eclipse is an open platform. It is designed to be easily and infinitely extensible by third parties. At the core is the eclipse SDK, we can build various products/tools around this SDK. These products or tools can further be extended by other products/tools and so on. For example, we can extend simple text editor to create xml editor. Eclipse architecture is truly amazing when it comes to extensibility. This extensibility is achieved by creating these products/tools in form of plug-ins.
Figure 1-1
Inside the Eclipse SDK
Figure 1-2
RCP: On the bottom is RCP which provides the architecture and framework to build any rich client application.
IDE: It is a tools platform and a rich client application itself. We can build various form of tooling by using IDE for example Database tooling.
JDT: It is a complete java IDE and a platform in itself.
PDE: It provides all tools necessary to develop plug-ins and RCP applications. This is what we will concentrate on the course of this tutorial.
Plug-ins everywhere
All the layers in eclipse SDK are made up of plug-ins. If you see all the way, you will notice that everything is a plug-in in eclipse sdk.
Figure 1-3
Plug-in Architecture
A plugin is a small unit of Eclipse Platform that can be developed separately. It must be noted that all of the functionality of eclipse is located in different plugins (except for the kernel)
A plug-in can be delivered as a jar file. A plug-in is self-contained bundle in a sense that it contains the code and resources that it needs to run for ex: code, image files, resource bundles etc. A plug-in is self describing - when I say it is self describing it means that it describes who it is and what it contributes to the world. It also declares what it requires from the world.
A Mechanism For Extensibility
Figure 1-7
We all know that eclipse is extensible. In order to achieve this extensibility eclipse uses the concept of extension points and extension. Think of extension point as Electric socket and think of extension as a plug. Plug-in A exposes a extension point (electric socket) which Plug-in B extends by providing an extension (an electric plug). Plug-in A knows nothing about plug-in B. If we think about it this is very similar to concept of Inheritance – we extend functionality of base class to provide more specific implementation. Think of Plug-in A as a text editor and Plug-in B as xml editor. Text editor declares extension point thereby declaring to the world that it is open for extension and xml editor extends text editor by using its extension point to customize it in its own way. It is important to understand that each extension point essentially declares
a contract. An extension point provider only accepts those extensions which abide by the contract.
These extension points and extensions are declared in plugin.xml (discussed earlier). The runtime is able to wire extensions and extension points and form a registry using markup alone.
Plug-in Example
Now that we have covered good amount of architecture basics, its time to get our hands dirty with some actual plug-in coding. The process for creating a plug-in is best demonstrated by implementing a plug-in on which discussion and examples can be based. Here we will take a step-by-step approach to create a simple but fully operational plug-in. This example will try to give you an feel of eclipse plug-in development. However, don’t try to grab all the details at this point. It is fine if you are not able to understand much of the details in this example. Rest of the tutorial will cover all the topics in great depth.
We will build a simple Resource Manager plug-in. Features of this plug-in are as follows:
- Ability to add/remove resources (essentially files in workspace) to resource manager.
- Display list of resources which were added to resource manager.
- Ability to open up associated editor whenever resource is clicked.
Subscribe to:
Posts (Atom)
Posts
