• 虚幻引擎（Unreal）已支持Flash Player 11
• Adobe推出3D框架Proscenium
• Adobe将大力支持Alchemy
• CryEngine(孤岛危机引擎)可能将支持Flash Player 11
• Mandreel Framework,C++ 2 AS3框架

感谢wonder分享所悟

其实，每个人都拥有一家神奇的公司。
这公司实力雄厚，资质非凡，不是人才济济，而是天才济济。
这公司的结构，以时间和空间来划分。该类公司中高明者，甚至可将触角伸及时空之外。
从时间来分，该公司拥有过去，现在和未来三大部门。
这三个部们，虽然名头很响，法力无边，却都听从一个ceo的指挥。
这个ceo就是你自己。

经营这家公司与经营世间所有的公司一样，都需要懂点哲学中的管理学。
wonder目前所知最好的管理，是老子的无为而治。
世人误以为老子很消极。殊不知世人往往只看到“无为”，这个似乎很容易；没有看到“而治”，这个往往难上难。
治而无为，也许是世间最高深的管理学了。

一个劳心劳力的ceo，恐怕还只是较低层次的ceo。
理想的ceo，帮助他人找到自己的心声，把合适的人放到合适的位置上。公司里人人都做自己喜欢和擅长的事，工作本身就是快乐生活的一部分。
–而这些，就是ceo自己喜欢，和应该做的事。

做好自己的ceo，
把过去留给过去，
把未来交给未来，
把现在倾注在现在。

做好的ceo，
不要把过去、现在和未来全都背负在心里。

最开始，我使用Courier New做编程用的字体。时间长了感觉这种扁扁的一成不变的字体太生硬，且不支持ClearType，于是就改用了Consolas。

Consolas确实不错，但在中文显示方面，又不行了。在程序源码中，不可避免要使用中文注释。Consolas当然不支持中文，因此中文默认是使用宋体显示的。当使用10点大小的时候，中文就模糊不清了。如果采用斜体显示注释的话，宋体就更加显得支离破碎。

雅黑字体确实在中文显示上不错，但雅黑不是等宽字体，不能用于源码显示。

所以，就有网友使用字体工具将雅黑和Consolas集成在一起，让程序员可以在源码中看到优秀的中文显示效果。如下：

不过，这个字体中的Consolas有了一些变化，不像纯Consolas那么圆滑了。

字体下载：
Note: There is a file embedded within this post, please visit this post to download the file.

去字体合并作者博客下载

转自：http://bigt.javaeye.com/blog/764430

英文原文：http://www.billdwhite.com/wordpress/?p=296

“elements”是一个关键性的问题。elements是何物？它同child是否是一回事？刚开始的时候我曾武断的认为elements不过是children的另一种说法。通过反复梳理组件中所有的elements和children，我发觉在新的容器类（也包括一些经过改良的传统容器）某些似乎是理所当然应该具备的方法消失了。如果没有getElements()，我该如何获取elements的数目呢？我能否把getChildren() 的返回结果作为IVisualElement来对待。这令我十分纠结。

困扰的我于是开始认真阅读学习API文档，Flex的源码以及相关的博客文章。我也曾尝试解读一些博主发布的关于Flex4新特性的幻灯片。然而事实证明脱离讲解而孤立的看幻灯片作用相当有限。

最后，我拼凑了一些言简意赅的示例。这些示例将带领我了解有关elements的全新知识，告诉我那些在新的Spark容器背后发生的故事。

言归正传，首先从问题开始。问题一，“应该如何获得Spark 容器的全部elements？”我曾想当然的认为是通过一个类似Flex3中的getChildren() 的方法。然而实际上我们需要通过两个Property来达到这个目的：numElements & numChildren 。可以通过对numElements计数的循环语句配合getElementAt() 来实现遍历容器elements或特定访问。这种方式还比较直观。问题二，“element和child的区别何在？”，让我们来看看两者的差异。

语义上，element简单的说就是实现了IVisualElement接口的任意型别。child是指扩展了DisplayObject类的任意型别。判断某个组件是element还是child亦或两者都是的关键在于以下几点。UIComponent(所有Flex组件的基类：译者注)是由DisplayObject扩展而来，故所有UIComponent都是DisplayObject，也就是说UIComponent都是children。UIComponent同时也实现了IVisualElement接口，因而所有的UIComponent也可以被作为elements看待。但这并不是说所有的DisplayObjects（文中所言的DisplayObject一般指扩展于DisplayObject的子类，译者注）都是elements。容器中的DisplayObject对象是该无疑是容器的child。而只有当此DisplayObject对象同时也实现了IVisualElement接口时它才是容器的element。那么对容器而言，DisplayObject什么情况下是child，什么情况下又是element？通过示例来认识这个问题。

在首个示例中，我们使用了传统的Halo容器（这里我们使用的Panel）。Panel扩展与DisplayObject类，所以它可以使用addChild() 方法。进一步而言，Panel也是Container类的子类（mx.core.Container实现了IVisualElementContainer接口），它具有addElement() 方法。Container类的IVisualElementContainer接口实现只是基于显示列表API的门面，所以理论上它和同样实现了IVisualElementContainer接口的新式Spark容器具有相同的方法集合。

于是看起来我们可以任意添加children或element到容器中了。事实却不是这样。并非任意型别的element都能被添加（此处element泛指实现了IVisualElement接口的类）容器中。视觉元素（VisualElements）和图形元素（GraphicElements）有一些区别视觉元素（VisualElements）实现了IVisualElement接口，而图形元素（GraphicElements）实现的是IVisualElement接口的子接口IGraphicElement。IGraphicElement接口扩展的新特性为容器获取信息提供了额外渠道。某些elements（图形元素是其中之一）无法直接添加至Halo的Panel编译器会告知“这样的对象需事先包装进一个Group容器中”（实际上错误提示应该是在运行时出现，不关编译器什么事：译者注）。原因马上揭晓。

接下来的示例中，Panel中有若干个UIComponent，其中包括另一个Halo Panel，一个Spark Panel，几个Halo Button和几个Spark Button，以及一个包含有子组件的SkinnableContainer（注意: 包含于SkinnableContainer的组件是只属于SkinnableContainer的children，不是上级容器Panel的children）。所有组件都继承于DisplayObject，所以它们都是“children”。点击“show children”后可以清楚的了解这一点。进一步而言，所有的组件也都是“element”，因为UIComponent实现了IVisualElement接口。

看下一个示例。这次我们探讨的容器上Spark Group。与前Halo Panel类似，Group继承于DisplayObjectContainer，它具有addChild() 方法，它同时也实现了IVisualElement接口，所以我们可以用addElement() 方法来IVisualElement对象（elements）。而且Group也接受图形元素（GraphicElements）,比如spark.primitives.Rect。要知道Rect是无法直接添加到Halo Panel中的。Group是怎么做到这一点的？原因就在于Group知道如何使用一种优化的方式来呈现图形元素（GraphicElements）。什么意思？往下读。

相对于典型的视觉元素（VisualElements），图形元素（GraphicElements）与容器的关系更为紧密。其关键在于IGraphicElement接口。上面曾经提到，这个扩展于IVisualElement的接口（此即图形元素（GraphicElements）可以通过Group的addElement() 方法来添加至其上的原因所在）。然而由于图形元素（GraphicElements）不是DisplayObject，所以他们在被“投映”到某个作为他父对象的DisplayObject前是无法被显示出来的。基于这个原因，当添加一个“Rectangle”到Group时，需要有DisplayObject来绘制这个Rectangle。更有效率一点的做法是Group尽可能的复用同一个DisplayObject来绘制多个图形元素（GraphicElements）。容器可以使用任何实现了ISharedDisplayObject接口的DisplayObject来绘制图形元素（GraphicElements）。第一个示例中的Halo Panel无法使用这种方式来绘制图形元素（GraphicElements），编译器会报错：“必须将其包装至一个合适的容器中”。而Group支持这种优化方式，所以能添加图形元素（GraphicElements）。

另外需要注意的一点是，有些图形元素（GraphicElements）的绘制由Group提供DisplayObject来完成，也有的是自行创建专属的DisplayObject来完成绘制。IGraphicElement接口甚至允许把对象自己创建的DisplayObject交由容器管理（换而言之就是以child形态添加的DisplayObject会以IGraphicElement的面貌来绘制自己）。

这意味着什么？这意味着在接下来的示例中，children的数目和elements的数目是不一样的。这个示例使用了与第一个示例相同的组件集合外，还增加了4个矩形图形元素（GraphicElements）。所有子对象皆为IVisualElement，但不是都可以称为children。几个矩形是图形元素（GraphicElements），它们并不继承于DisplayObject。Group不在乎这点，它知道添加DisplayObject来绘制这些图形元素（GraphicElements）。由于几个矩形的尺寸和角度有所不同，所以Group会创建2个新的DisplayObject来绘制这4个矩形。很酷吧！

现在来看示例三。我们用一个SkinnableContainer替换先前的Group。SkinnableContainer有和先前相同的子组件集，它还能利用Skin来增强视觉效果。Skin是SkinnableContainer唯一的child。SkinnableContainer的默认Skin类由一个矩形和一个被称为ContentGroup的Group组成。该Group的作用在于规划出容器内组件的添加位置。

这个示例证明了这样的事实，即使SkinnableContainer拥有10个elements，但它只有唯一的child：它自己的Skin。而且这个Skin也只有唯一的child：名为ContentGroup的Group组件。你也许会感到奇怪：为什么Skin的children不是2个：其一是ContentGroup，另一个是用于绘制作为边框的Rectangle的DisplayObject？这是因为Skin类继承自Group类，而Group只在它确实需要绘制其包容的图形元素（GraphicElements）时才会添加DisplayObject，目前的情况下不需要。Skin类具备直接在其上绘制Rect图形元素（GraphicElements）的能力，这归功于Skin类的上级类Group实现了ISharedDisplayObject接口。这意味着它在需要时能作为共享的DisplayObject来绘制图形元素（GraphicElements）。Skin负责管理用于呈现图形元素（GraphicElements）的DisplayObject，在当前示例中，Skin自己就是用于绘制的DisplayObject！如果你的自定义Skin中有其它的Rectangle，并将该Skin赋予SkinnableContainer，这种情况下Skin会判断是否需要更多的DisplayObject来绘制额外的Rectangle。这时你可能会发现在Skin的children列表中有更多的child。

值得注意的是，示例中SkinnableContainer，它的Skin以及Skin的ContentGroup这三者的element列表的数目是相同的。通过SkinnableContainer的源码可以知道，numElement的值实际上来源于与之对应的CurrentContentGroup的numElement。所以基本上对SkinnableContainer的elements的检索是被重定向到它的ContentGroup上的。SkinnableContainer的Skin也有类似行为。它继承于Group，Group的numElement的值取自其内部的mxmlContent属性。该属性是一个保存了Group可视内容children的数组。这两个属性与Panel的RawChildren属性十分相似，它用于返回Panel上的所有children而不是getChildren()方法返回的仅仅你添加到Panel上的那些。

通过以上阅读，也许起不到拨云见日的效果。但可以让你明白厘清以下七个类/接口的继承结构和相互关系是十分有必要的：
1. DisplayObject
2. UIComponent
3. Container
4. IVisualElement
5. IGraphicElement
6. IVisualElementContainer
7. ISharedDisplayObject

一旦你掌握它们之间的关系，你就能明白elements 和children的不同。可以肯定的是我在某些问题的认识和阐述上存在很多谬误之处。如果你发现了这样的问题望不吝赐教，在评论处写下您的正确观点吧。

访问下面的链接可以获得关于本文探讨及其相关的主题的更多内容。

Gumbo DOM Tree API（关于本话题的详实细节）
关于了解组件的owner和parent之间差异的极好的示例

转自：青竹的日志

合理使用对象

创建不同对象一般所消耗的内存是不一样的。如:Number 消耗 8 个字节,int消耗 4个字节, uint消耗 4个字节.下面我举一些例子:

1.int 类可使用表示为 32 位带符号整数的数据类型。 int 类表示的值的范围是：-2,147,483,648 (-2^31) 到 2,147,483,647 (2^31-1)，所以如果你的取值范围在-2,147,483,648 (-2^31) 到 2,147,483,647 (2^31-1)请你用int而不是用Number(刚从2.0转过来的人可能喜欢用Number).uint 范围是0 到 4,294,967,295 (2^32-1) 之间,Actionscript3中类型很少，所以这些只要你平时稍加注意一下就行.
2.合理使用Shape与Sprite,MovieClip,你可能用MovieClip可以完成Sprite与Shape的功能，但是他们所需的内存是不一样的Shape需要 236 字节,Sprite 需要 412字节, MovieClip 需要440字节,如果你只想显示图形没有交互那你使用Shape,如果是有交互的图形你可以用Sprite,如果是动画你才用MovieClip.

以上只是2个常见的实例，其实在as3中还有很多值得注意的这类情况。我还看到有些大哥为了派发一个事件而去继承Sprite类,Sprite需要消耗400字节, EventDispatcher只需要40字节.

对象重用

简单的说就是重复使用对象，而不是释放再重新申请,你可能这么认为：释放一个对象回收100字节的空间，我重新在new一个又占用100字节，返正都得占用100字。在flashplayer中不是说你想释放就能释放的,垃圾回收是由flashplayer来执行的，程序是不能控制，更不知道他是什么时候来执行的.所以对于我们来说回来是完全不可控的.所以说你觉得可回收了对象，很可能没回收继续占用空间直到flashplayer觉得内存不够时才可能执行垃圾回收从而被释放.而执行垃圾回收是非常耗费资源的操作尤其在大型的项目中.

虽然我们不能控制垃圾回收，但是我们可以降低垃圾回收器执行的次数，这就是我们尽量做到不去new,而使用现有的对象。这些做还有个好处就是，节省了创建对象的性能开销.

这里是不断的创建对象

var size:Rectangle;
var bitmap:BitmapData=new BitmapData(100,100);
for (var:int = 0; i < 100; i++)
{
 
    size = new Rectangle(i,0,1,10);
     myBitmapData.fillRect(size,COLOR);
}
 
重用对象
 
<pre lang="actionscript">
var bitmap:BitmapData=new BitmapData(100,100);
var size:Rectangle = new Rectangle(0,0,1,10);
for (var:int = 0; i < 100; i++)
{
    size.x = i;
    myBitmapData.fillRect(size,COLOR);
}

对象池技术

对象池技术的原理就是回收不使用的对象而不是遗弃等待FlashPlayer垃圾回器的执行,等到再需要时再拿来使用.这种技术使用非常广泛,看下面的简单的实现(这里只是一个抛砖引玉，具体怎么设计这个对象池，要看各位的具体项目了).

IRecyclable接口，可以被回收对象必须实现。再就是ObjectPool.

package
{
    public interface IRecyclable
    {
       function dispose():void;
     }
}
//对象池的实现
package{
public class ObjectPool{
 
        private var pool:Vector.<IRecyclable>;
        private var type:Class;//回收对象的类型
 
       public function ObjectPool(type:Class) 
       {
          this.type=type;
            pool=new Vector.<IRecyclable>();
        }
        public function addObject(o:IRecyclable):void{
            o.dispose();
            pool.push(o);
        }
         public function getObject():*{
            if(pool.length<=0) return new type();
             return pool.pop();
          }
    }
}

对象的另类存储

在存储大量对象时，我们可以以另一种方式存储或者叫序列化，即存储对象的数据而不存储具体的对象，当需要时再根椐需要数据返序列化出一个对象。这样做法的好处在于不会有大量的对象产生，在as中对即使是空对象也会占用40个字节.

很多时候你可能这样写代码:

var p:Array=[];
 
for(var i:int=0;i<1000000;i++){
     p.push(new Point(i,i))
}

这里我来实现另一种对象存储:

package{
    import flash.geom.Point;
 
     public class PointContainer{
 
      private var container:Array
        public function PointContainer()
        {
            container=[];
         }
        public function add(v:Point):void{
            container.push(v.x);
            container.push(v.y);
        }
        public function getPointAt(index:int):Point{
           return new Point(container[index],container[index+1]);
        }
    }
}
//使用
var p:PointContainer=new PointContainer
for(var i:int=0;i<1000000;i++){
   p.add(new Point(i,i))
}
for(var i:int=0;i<1000000;i++){
   p.getPointAt(i);
}

这种对象存储方式适合大量小型对象存储，比如粒子系统.如果是庞大的对象，这种方式没有任何优式.

事件优化

使用事件模型通信与使用传统的回调函数相比，速度更慢且占用的内存更多

AS3中事件的派发传递参数是采用Event,所以在高频率派发事件的地方你可以采用传统的回调函数这样可以大大提高你的效率和内存消耗.

位图优化

一般最占用内存的部分就是位图,在我开发的MMO游戏中90%以上的的内存是由位图占据的,所以在位图的使用过程序要特别注意，不使用的位图一定要释放掉。在这里我提一些小的建议，以尽量控制位图的内存占用。

1．能共享位图的尽量共享，具体做法就是用一个BitampData创建多个Bitamp对象。尽量不要去复制BitmapData对象.
2．将滤镜应用于显示对象时，Flash Player 将在内存中创建两个位图,所以这需要大量内存。所以尽量不要去使用滤镜，一般可以用ps做好滤镜后生成位图给flash来使用.
3．合理的使用位图缓存.对矢量图形做位图缓存，其实在把矢量图形变成位图，并使用该

位图进行呈现,此会显著提高呈现的性能，但需要占用大量内存。针对复杂的矢量内容使用位图缓存功能。

释放对象

释放对象其实只有一句话,就是不支有对象的引用,包括声音/视频流，socket,件事等等.我最多的一种情况是事件忘记移除导致对象无法回收，这并不是我不知道这一点，而是在写代码时的疏忽。如果你是一个人开发，你可能经常去profile你的代码，可能很容易找出哪个地方没被移除，但是如果你主程或者架构师你手下有很多少人在Coding，你怎么让他不遗忘移除事件呢，下面我来简单介绍一种方法一次性移除所有事件，避免一个一个移除带来的遗漏问题.

一般大家都用EventDispatcher来派发事件.现在我们就对addEventListener进行一个小小的改造即可.

package
{
    import flash.events.EventDispatcher;
    import flash.events.IEventDispatcher;
 
    public class MyEventDispatcher extends EventDispatcher{
        private var events:Array
        public function MyEventDispatcher(target:IEventDispatcher=null)
        {
            super(target);
            events=[];
         }
        override public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false):void{
 
            events.push({type:type,fun:listener})
            super.addEventListener(type, listener, useCapture, priority, useWeakReference);
        }
        override public function removeEventListener (type:String, listener:Function, useCapture:Boolean = false):void{
               super. removeEventListener(type,listener, useCapture);
              for(var i:int=0;i< ;i++){
                  if( events[i].type==type && events[i].fun==listenner){
                   events.splice(i,1)
               }
            }
      }
        public function dispose():void{
          var ev:Object;
            while(events.length){
               ev=events.pop(); 
                super.removeEventListener(ev.type,ev.fun);
            }
        }
    }
}

所以你在使用EventDispatcher的地方全部使用MyEventDispatcher即可，在回收之前端调用一下dispose方法，就会内部移除所有事件.

还有很多方法可以做到这一点，以上方法只是一个抛砖引玉.

滥用强制垃圾回收

在Flashplayer debug版本提供了System.gc()接口，可以让虚拟机执行垃圾回收,但是flashplayer 普通用户版是没有这个接口的,于是有人想出使用异常还出发垃圾回收如:

function gc():void{
         try{
                (new LocalConnection).connect("foo");
                 (new LocalConnection).connect("foo");
           }catch(e){
                    trace(System.totalMemory);
                }
}

当然还有其他方法在这里我就不多举了.

Adobe为什么在普通用户版的flashplayer中取消对System.gc()接口的支持,adobe肯定不希望用户直接去触发垃圾回器,肯定是有理由的,下面我将对这个理由进行的浅薄分析.

垃圾回收器通过查找系统中的相互引用，从而检测出处于非活动状态的对象。将删除通过这种方式检测到的处于非活动状态的对象。也就说他要扫描可能持有对象的的所有变量，这一点所需的代价很大，尤其是在大型项目中.如果你经常去做这样的事，这会大大浪费你的CPU资源.

我做Flash开发已快5年了,我没有什么地方非要用到强制垃圾回收的地方.所以我要在这里提醒广大Flash开发者,在没有特术需求的时候不要使用强制垃圾回收，不要会了腾出一点内存空间而去强制垃圾回收，可能很多时候你是检芝麻丢西瓜,回收器的执行不是普通程序员管的事，Flashplayer会选择最合适的时候去调用.(原本这一节不是我要写的内容，原因是我看到在天地会主页很醒目的位置有一篇《AS3强制内存回收方法之二》,而且受到大家的广泛关注,所以我不想让这篇文章误导了一些新手,以上只是个人见解我希望大家一起讨论这个问题)

以下为评论的转载

guissy 2010-12-13 20:32
关于对象池，考虑使用new Dictionary(true),具备弱引用。
思路见贴：http://bbs.9ria.com/redirect.php?goto=findpost&pid=561614&ptid=63490

lcj0526 2010-12-14 09:50
另外关于对象池的看法，我提点个人意见，其实我觉得只要你不是在同时进行大量new的话，我并不赞成采用对象池的方法，加了对象池，会额外增加swf文件的大小，尽管不一定很多，另外，因为不是大量的生成，所以你new一个的对象所需的时间，可能比你去取对象池的速度还快。所以一般对象池技术是用于服务器的，除非客户端像你所说要做粒子效果的话，采用这个倒是不错，呵呵。以上纯属个人看法，不当之处还请高人指点

青竹 2010-12-14 10:25
谢谢这位兄弟的评点,对象池技术不只用在服务器，在设计中高密度创建的对象地方，对象池技术可以减小创建与销毁的代价.

guissy 2010-12-13 17:36
1.位图优化。如果是mmo之类需要严格控制内存的，这是非常值得关注的技术。如果是网页特效或一些全屏的小应用，还是矢量为佳.
2.override addEventListener 与 某人说的“事件总线”，都存在性能上和编码习惯的不友好。必要时使用弱引用，这是比较好的习惯。另外, 框架式的代码必须用profile去检测.每个类都用dispose()做销毁工作也是相当好的习惯。赞同。
3.gc是自动管理内存。但不觉得gc能占用多少cpu.除非你的是循环着用.如果真有有那么费cpu，请截图.

lcj0526 2010-12-14 09:44
呵呵，你这个占CPU的我测试过，在我的项目里如果每桢都调用gc方法的话，CPU会一直在13以上，如果不调用的一般就是在0-5之间。我指的是在同种情况下，具体就是玩家不动，当前视野里没其他对象操作的情况下测试的。另外CPU占用的多少与计算机的配置也是有很大的关系的

转自：http://blog.5d.cn/user12/dzxz/200809/500545.html
版本: 7.14
日期: 6/10/2008
中文翻译：独自行走【闪航AS】 （英文名 Richard ) 博客 http://dzxz.blog.5d.cn
TweenLite参数说明 TweenMAX参数说明
TweenFilterLite 继承自 TweenLite ，进行了功能上的扩充，提供了颜色、图象处理方面的一些简便的方法，如果对 Flash 中的矩阵有一些基本的了解之后，再来用它，会比较的得心应手，它有点像是将 Flash 的颜色矩阵和卷积矩阵揉合到一起，提供了更为简单的应用方法，因此， 一并翻译出来供大家参考。

描述:

TweenFilterLite 继承自超轻量级的（大约3k）、强大的 TweenLite 核心类，新添加了滤镜缓动（模糊、发光、阴影、斜角滤镜、等等）和图像效果（调整对比度、色调、亮度、饱和度、灰度以及阀值），加起来大约6k
TweenFilterLite 类的语法结构与 TweenLite 相同。如果你还不熟悉 TweenLite ，推荐你先把它找出来看一下。（我也推荐你看一下先前翻译的 TweenLite 使用详解，即 TweenLite 类的描述文件—-译者注）
它提供了一种简便的方法，可以在同一时间对某个对象的多个属性进行缓动，包括 MovieClip 的位置、透明度、音量、颜色等。
就像 TweenLite 一样，TweenFilterLite 允许你指定延迟缓动（让缓动在指定的时间之后开始进行—-译者注），以及在缓动开始或结束时调用任何函数（同时还可以传递任意多个参数给这些函数），自动清除掉其它的对同一目标进行的缓动（从而避免冲突）、缓动数组，等等。使用这个类的一个很大的好处就是它非常努力地缩小了文件的尺寸（正如它名字中“Lite”所代表的含意）。外面还有一些其它的缓动引擎，但是根据我的经验，它们至少比这个文件要大上3倍以上，这在需要精确控制文件尺寸的情况下是不可接受的（比如制做 banner 广告）。同样，我还尚未发现过比这更快的引擎。这里采用的语法是非常简单的，并且这个类不依赖于复杂的原型扩展手段，那样做通常会在一些编译器中制造难题。TweenFilterLite 非常的简单、快捷、并且（依旧）非常的轻盈。
如果你还在寻找更多的功能，去 www.TweenMax.com 看一下 TweenFilterLite 的大哥 TweenMax 。

参数:

• $ target : Object – 缓动的目标对象，对它的属性进行缓动
• $ duration : Number – 动画的时长（单位：秒）
• $ vars : Object – 对象类型的参数，该对象包含了所有的需要缓动的属性，属性中保存的是缓动结束时的目标值（如果使用 TweenFilterLite.from() 方法，属性中保存的是缓动开始时的初始值）。 所有的滤镜都是通过对象的属性来传递的(属性的名称必须准确，比如：blurFilter, glowFilter, colorMatrixFilter, 等等)，滤镜对象可以包含任意多个与滤镜相关的属性，比如 blurX, blurY, contrast, color, distance, colorize, brightness, highlightAlpha, 等等。

专有属性:

• delay : Number – 延迟开始缓动 (以秒为单位).
• ease : Function – 缓动函数. 例如，fl.motion.easing.Elastic.easeOut 函数。默认的是 Regular.easeOut函数。
• easeParams : Array – 用来存贮缓动公式所需要的额外数据。当使用 Elastic 公式并且希望控制一些额外的参数，比如放大系数和缓动时间。大多数的缓动公式是不需要参数的，因此，你不需要给其它的缓动公式传递参数。
• autoAlpha : Number – 用它来代替 alpha 属性，可以获得一些副加的效果，比如当 alpha 值缓动到 0时，将 visible 属性改为 false。当缓动开始前，autoAlpha 大于 0时，它将会把 visible 属性变成 true 。
• volume : Number – 对 MovieClip 或 SoundChannel 对象中的 volume 属性（音量大小）进行缓动。该属性表示的是缓动结束时的音量值（如果使用的是 TweenLite.from()，这个属性将表示目标对象开始缓动时的音量)
• tint : Number – 改变 DisplayObject 的色调或颜色，设置一个16进制颜色值，做为缓动结束时，目标对象的颜色值，（如果使用的是 TweenLite.from()，这个值将表示目标对象开始缓动时的颜色)。例如，颜色值可以设定为： 0xFF0000。如果要移除颜色，只需要传递一个 null 值给 tint 属性。( TweenLite 中使用的是 removeTint 属性—-译者注)
• frame : Number – 将 MovieClip 缓动到指帧频。
• onStart : Function – 在缓动开始时想要执行某个函数，就将函数的引用（通常是函数名）放到这里。当缓动是带延迟的，这一点会非常有用。
• onStartParams : Array – 为缓动开始时要执行的函数传递参数。(可选的)
• onUpdate : Function – 缓动过程中，每次更新属性值时，会执行这里指定的函数(缓动开始后，每一帧被触发一次)。
• onUpdateParams : Array – 给 onUpdate 参数指定的函数传递参数 (可选的)
• onComplete : Function – 缓动结束时执行的函数。
• onCompleteParams : Array – 给 onComplete 参数所指定的函数传递参数 (可选的)
• renderOnStart : Boolean – 当使用带有延迟缓动的 TweenFilterLite.from() ，并且希望阻止缓动的渲染（rendering ）效果，直到缓动真正开始，将这个值设为 true.默认情况下该值为 false ，这会让渲染效果立即被执行，甚至是在延迟尚未结束之前。
• overwrite : Boolean – 如果 不 希望当前的缓动效果自动覆盖到其它的影响同一属性的缓动，请确保这个值设为 false。
• blurFilter : Object – 应用模糊滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：blurX（横向的模糊度）, blurY（纵向的模糊度）, quality（品质,默认值为2）
• glowFilter : Object – 应用发光滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：alpha（通明度），blurX , blurY , color（颜色），strength（强度）, quality ，inner（内侧发光），knockout（挖空）
• colorMatrixFilter : Object -应用颜色矩阵滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：colorize（色调），amount（总量），contrast（对比度），brightness（亮度），saturation（饱和度），hue（色相），threshold（阀值），relative（相关性），matrix（颜色矩阵）
• dropShadowFilter : Object – 应用阴影滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：alpha, angle（角度）, blurX, blurY, color, distance（距离）, strength, quality
• bevelFilter : Object – 应用斜角滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：angle, blurX, blurY, distance, highlightAlpha（高亮区的透明度）, highlightColor（高亮区的颜色），shadowAlpha（阴影区的透明度）, shadowColor（阴影区的颜色）, strength（强度）, quality

举例:

一个简单示例，将 clip_mc 的模糊度从当前值，经过1.5秒后，模糊到20，代码如下：

import gs.TweenFilterLite;
TweenFilterLite.to(clip_mc, 1.5, {blurFilter:{blurX:20, blurY:20}});

下面的代码演示的是连续缓动的例子，首先用 2 秒钟的时间改变 MovieClip 的颜色，然后用 1 秒种进行模糊处理（第二个缓动延迟了两秒后进行—-译者注）：

import gs.TweenFilterLite;
TweenFilterLite.to(clip_mc, 2, {colorMatrixFilter:{colorize:0xFF0000, amount:1}});
TweenFilterLite.to(clip_mc, 1, {blurFilter:{blurX:20, blurY:20}, delay:2, overwrite:false});

import gs.TweenFilterLite;
import fl.motion.easing.Back;
TweenFilterLite.to(clip_mc, 5, {colorMatrixFilter:{saturation:0}, delay:2, onComplete:onFinishTween, onCompleteParams:[5, clip_mc]});
function onFinishTween(argument1:Number, argument2:MovieClip):void {
trace("The tween has finished! argument1 = " + argument1 + ", and argument2 = " + argument2);
}

如果舞台上的影片剪辑已经具备了期望的缓动结束时的属性值，你希望从某个色调的版本（比如 红色：0xFF0000）缓动到当前的属性状态，可以使用下面的代码：

import gs.TweenFilterLite;
TweenFilterLite.from(clip_mc, 5, {type:"color", colorize:0xFF0000});

备注:

var myNewMatrix:Array = TweenFilterLite.colorize(myOldMatrix, 0xFF0000, 1);

特别鸣谢 Mario Klingemann (http://www.quasimondo.com)，感谢他在 ColorMatrix 类中所做的工作，这个类对于图像效果真的非常有用。

转自：http://blog.5d.cn/user12/dzxz/200809/500547.html

版本: 1.17
日期: 6/10/2008
中文翻译：独自行走【闪航AS】 （英文名 Richard ) 博客 http://dzxz.blog.5d.cn

TweenLite参数说明 TweenFilterLite参数说明

TweenMax 建立在 TweenLite 和TweenFilterLite 基础之上，因此，又揉合了这二者的功能，使得功能更加的齐备，但是如果说易用性，觉得还是 TweenLite 来得方便一些。我的译文是从 TweenLite 开始的，接着是  TweenFilterLite 最后是  TweenMax ，这也恰好是这个类发展的轨迹，沿着这个轨迹一路读过来，会觉得容易理解很多。

TweenMax 建立在 TweenLite 核心类以及它的大哥 TweenFilterLite 基础之上，它为 Tween 家族增加了新的受欢迎的功能（尽管只是锦上添花），从而使家族更加的壮大，比如贝赛尔缓动、暂停/继续能力，简便的连续缓、16进制颜色缓动、以及更多的内容。
TweenMax 采用了与它的兄弟相似的易于学习的语法结构。实事上，因为它扩展自它们，TweenMax 可以做任何 TweenLite 和/或者  TweenFilterLite 能做的事，还加上了更多的特色。那么为什么要建立 3 个类，而不是 1 个呢？问的好，我的目标是：效率最大化，尺寸最小化。坦白的说，TweenLite 可能是所有的程序员在 90% 的项目中都需要用到的，而它仅有 3k。相对它的功能来说，它是非常高效和紧凑的。
但是如果你需要对滤镜进行缓动，或者更丰富的图像效果，比如说饱和度(saturation)、对比度(contrast)、色相(hue)、调色等等进行控制，
那就装上 TweenFilterLite 总共 6k 。还想要的更多？ No problem (没问题)– TweenMax 已经在总共 8k 的大小里面塞满了足够多的功能。
想查看相关的功能对比图，请访问 www.TweenMax.com 以获取更多信息。

( TweenMax 类包中直接包含有独立的 TweenLite 和 TweenFilterLite 类，因此下载这一个包就可以了，在 Flash 类路径中添加的时候，也只需要添加这一个路径就可以了—-译者注)
TweenMax 创造了一种全新的功能，叫做 “bezierThrough”（暂译为 贝塞尔通路），这个功能允许你定义一些点，通过贝塞尔曲线连接这些点，（通常的控制点只是用来拉近曲线，这里的点直接在曲线的路径上）。当然，如果你愿意，你可以用更正规的贝塞尔曲线。目前，TweenMax 增加了下列功能（相对于 TweenFilterLite 而言)：

• 进行贝塞尔缓动（包括指定通路 THROUGH 点 和 运动对象的自动方位导航(在贝塞尔曲线中移动时，对象的旋转角度是自动控制的，译者注))
• 连续的缓动 或称为 序列化的缓动
• 对对象数组(数组中存放了不同的对象，译者注) 中的对象进行统一的缓动，使用 allTo() 和 allFrom()
• 缓动中的 暂停/继续 功能，使用 pause() 和 resume() 方法，或者 “paused” 属性 (比如 myTween.paused = true)
• isTweening 静态方法，用来判断一个对象是否正在进行缓动(比如 TweenMax.isTweening(my_mc))
• 跳转至缓动的任何时段，使用 “progress” 属性。输入一个 0 到 1 之间的数值。 progress 值为零，将会把缓动的进程跳转到初始阶段，值为 1 时，跳转至 100% 完成状态，值为 0.5 时，将转至缓动过程的半山腰位置。
• 例如: myTween.progress = 0.5;
• 对 16 进制的颜色进行缓动，使用 hexColors 属性
• 获取缓动效果的实例数组，该数组中包括了加在一个指定的目标对象上的所有的缓动效果的实例，该数组可以容纳 TweenMax 和 TweenLite 和 TweenFilterLite 三种类型的缓动实例。
• 例如: TweenMax.getTweensOf(my_mc); // (如果 my_mc 上使用了不止一个的缓动效果，那么这里将返回一个数组，数组中是不同的缓动效果的实例，可以用来对每个缓动进行实时的控制，译者注)
• 获取 TweenMax (和 TweenLite 和 TweenFilterLite) 的实例数组，使用用静态函数 getAllTweens()
• 中止（杀死）所有的缓动(以及可选的完成部分缓动)
• 暂停/继续 全部的缓动

参数:

1. $ target : Object – 目标 MovieClip (或其它对象)，对它的属性进行缓动
2. $ duration : Number – 动画的时间长度（单位：秒）
3. $ vars : Object – 一个包含了多种属性的对象，用来存贮缓动结束时的各种属性值（如果你使用 TweenLite.from() 方法，这里的参数表示缓动的初始值）。

例如:
alpha: 目标对象在缓动结束时的 alpha (不透明度的级别)值。（当使用 TweenMax.from()时，表示开始缓动时的 alpha 值)
举个例子，如果 target_obj.alpha 是 1，当这个缓动代码被执行时，将 alpha 参数设成 0.5 ，它将实现从 1 到 0.5 的渐变缓动。
x: 想要改变 MovieClip 的 x 位置，只需要将这个参数值设成你希望的缓动结束时的值即可。（如果使用 TweenMax.from()，则表示缓动开始时的 x 值）

专有属性:

• delay : Number – 延迟缓动 (以秒为单位)
• ease : Function – 缓动函数. 例如，fl.motion.easing.Elastic.easeOut 函数。默认的是 Regular.easeOut函数
• easeParams : Array – 用来存贮缓动公式所需要的额外数据. 当使用 Elastic 公式并且希望控制一些额外的参数，
• 比如振幅和周期。大多数的缓动公式是不需要参数的，因此，你不需要给其它的缓动公式传递参数。
• autoAlpha : Number – 用它来代替 alpha 属性，可以获得一些副加的效果，比如当 alpha 值缓动到 0时，
• 自动将 visible 属性改为 false。当缓动开始前，autoAlpha 大于 0时，它将会自动把 visible 属性变成 true 。
• volume : Number – 改变 MovieClip 或者 SoundChannel 的音量，将缓动结束时的音量值写在这里即可。(如果使用 TweenMax.from()，这里的值表示缓动开始时的音量).
• tint : Number – 改变可显示对象(DisplayObject)的色调/颜色，将缓动结束时的16进制值颜色值（比如 0xFF0000）写在这里即可。(如果使用 TweenMax.from()，这里的值表示缓动开始时的颜色值).
• 如果想要移除颜色，传一个 null 做为颜色值即可。
• frame : Number – 将 MovieClip 缓动到指定的帧频
• bezier : Array – Bezier 缓动，允许你以非线性的方式进行缓动。例如，将一个 MovieClip 从原始的 (0,0) 的位置，向右移动500像素，到(500,0)，在缓动的中间向下弯曲。只需要向贝赛尔数组中传递多个对象，每一个都是一个控制点（关于控制点是如何工作的请参考 Flash 的 curveTo() 绘图方法相关说明）。在这个例子中，假设我们的控制点是 x/y 坐标
• 250,50。把 my_mc 放到 0,0 位置，然后执行下面的代码：          TweenMax.to(my_mc, 3, {_x:500, _y:0, bezier:[{_x:250, _y:50}]});
• bezierThrough : Array – 与上面的贝赛尔数组相似，但是它接收的不是控制点，而是贝赛尔曲线要经过的位置点。与控制点相比，这样的用法更加直观。
• orientToBezier : Array (或者 Boolean 类型) – 设计师/开发人员经常用到的一个效果，让 MovieClip/Sprite 自动调整自身的方向（改变 rotation ），使之符合贝赛尔路径的方向（就像是汽车在曲折的道路上需要不断调整方向一样—-译者注）。orientToBezier 使得这一切变得简单。为了更精确的调整 rotation 属性，TweenMax 需要 4 方面的信息:
  1. 位置属性 1 (通常为 “x”)
  2. 位置属性 2 (通常为 “y”)
  3. 旋转属性 (通常为 “rotation”)
  4. 旋转的度数(可选的 – 让它更容易的正确瞄准 MovieClip )
• 当 orientToBezier 属性为数组时，该（容器）数组中的每个元素是包含了一组数据的数组（形如[[x1,y1,rota1,ang1],[x2,y2,rota2,ang2]]—-译者注）。
• 为了获得最大的灵活性，你可以向容器数组中传递任意数量的数组，逐个的指定旋转属性。这在进行 3D 工作进会很方便，因为你可以旋转多个坐标轴。如果进行的是标准的 2D x/y 坐标系贝赛尔缓动，只需要传递一个布尔值 true ，然后  TweenMax 将会使用一个典型的数组设置 [["x", "y", "rotation", 0]]。
• 提示：不要忘了这里存在着容器数组（注意：数组前后有两层方括号）
• hexColors : Object – 尽管 16 进制颜色是一种技术上使用的数字，但当你试途按照数字增减的老办法来缓动时，你会发现颜色的变化并不平滑。为了更恰当的进行颜色缓动，通常需要独立的对红、绿、蓝的成分进行缓动。TweenMax 把这一切变得简单。将一个 16 进制颜色值缓动到另一个 16 进制颜色值，只需要使用这个 TweenMax 中专用的 hexColors 属性即可。 这个属性必须是一个对象，该对象具有相关的颜色属性，属性名称与目标对象中使用的 16 进制颜色属性的名称相同。比如，如果 my_obj 对象具有一个“myHexColor”属性，想让它在两秒种内缓动为红色 (0xFF0000)，需要这样做：
• TweenMax.to(my_obj, 2, {hexColors:{myHexColor:0xFF0000}}); (内层花括号括起来的部分，表示的就是一个包含有 myHexColor 属性的对象—-译者注)
• 可以传递任意数量的 hexColor 属性。
• onStart : Function – 在缓动开始时想要执行某个函数，就将函数的引用（通常是函数名）放到这里。当缓动是带延迟的，这一点会非常有用。
• onStartParams : Array – 为缓动开始时要执行的函数传递参数。(可选的)
• onUpdate : Function – 缓动过程中，每次更新属性值时，会执行这里指定的函数(缓动开始后，每一帧被触发一次)。
• onUpdateParams : Array – 给 onUpdate 参数指定的函数传递参数 (可选的)
• onComplete : Function – 缓动结束时执行的函数。
• onCompleteParams : Array – 给 onComplete 参数所指定的函数传递参数 (可选的)
• renderOnStart : Boolean – 当使用带有延迟缓动的 TweenFilterLite.from() ，并且希望阻止缓动的渲染（rendering ）效果，直到缓动真正开始，将这个值设为 true.默认情况下该值为 false ，这会让 TweenMax.from() 渲染效果立即被执行，甚至是在延迟尚未结束之前。
• overwrite : Boolean – 如果 不 希望当前的缓动效果自动覆盖到其它的影响同一属性的缓动，请确保这个值设为 false。
• blurFilter : Object – 应用模糊滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：blurX（横向的模糊度）, blurY（纵向的模糊度）, quality（品质,默认值为2）
• glowFilter : Object – 应用发光滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：alpha（通明度），blurX , blurY , color（颜色），strength（强度）, quality ，inner（内侧发光），knockout（挖空）
• colorMatrixFilter : Object – 应用颜色矩阵滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：colorize（色调），amount（总量），contrast（对比度），brightness（亮度），saturation（饱和度），hue（色相），threshold（阀值），relative（相关性），matrix（颜色矩阵）
• dropShadowFilter : Object – 应用阴影滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：alpha, angle（角度）, blurX, blurY, color, distance（距离）, strength, quality
• bevelFilter : Object – 应用斜角滤镜，需要传递一个具有下列（一个或多个）属性的对象做为参数：angle, blurX, blurY, distance, highlightAlpha（高亮区的透明度）, highlightColor（高亮区的颜色），shadowAlpha（阴影区的透明度）, shadowColor（阴影区的颜色）, strength（强度）, quality

关键属性:

• progress : Number (范围0 – 1，为 0 表示缓还未开始，0.5 缓动进行了一半，1 缓动结束)
• paused : Boolean （逻辑值）

关键方法:

• TweenMax.to(target:Object, duration:Number, vars:Object):TweenMax
• TweenMax.from(target:Object, duration:Number, vars:Object):TweenMax
• TweenMax.allTo(targets:Array, duration:Number, vars:Object):Array
• TweenMax.allFrom(targets:Array, duration:Number, vars:Object):Array
• TweenMax.sequence(target:Object, tweens:Array):Array
• TweenMax.getTweensOf(target:Object):Array
• TweenMax.isTweening(target:Object):Boolean
• TweenMax.getAllTweens():Array
• TweenMax.killAllTweens(complete:Boolean):void
• TweenMax.killAllDelayedCalls(complete:Boolean):void
• TweenMax.pauseAll(tweens:Boolean, delayedCalls:Boolean):void
• TweenMax.resumeAll(tweens:Boolean, delayedCalls:Boolean):void
• pause():void
• resume():void

示例:

对 MovieClip 进行连续的缓动，先用2秒钟时间让透明度降到 50%，然后用1秒钟时间滑落到 y 坐标为300的位置，使用如下的代码：

import gs.TweenMax;
TweenMax.sequence(clip_mc, [{time:2, alpha:0.5}, {time:1, y:300}]);

使用 Back.easeOut 函数对影片剪辑 clip_mc 进行缓动，缓动持续 5 秒钟，alpha 值变到 0.5，x 坐标变到 120，延迟 2 秒钟执行，缓动结束后，调用“onFinishTweenusing”，并且为这个函数传递几个参数（数值 5 和 对 clip_mc 的引用），代码如下：

import gs.TweenMax;
import fl.motion.easing.Back;
TweenMax.to(clip_mc, 5, {alpha:0.5, x:120, ease:Back.easeOut, delay:2, onComplete:onFinishTween, onCompleteParams:[5, clip_mc]});
function onFinishTween(argument1:Number, argument2:MovieClip):void {
trace("The tween has finished! argument1 = " + argument1 + ", and argument2 = " + argument2);
}

如果舞台上的影片剪辑已经处于期望的缓动结束时位置，而你希望它从其它位置用 5 秒钟的时间回到当前位置，（比如从比当前位置高 100 像素或屏幕外更高的地方，通过改变 y 属性，下落到当前位置）可以使用下面的代码：

import gs.TweenMax;
import fl.motion.easing.Elastic;
TweenMax.from(clip_mc, 5, {y:"-100", ease:Elastic.easeOut});

备注:

给参数值加上引号，表示对指定的属性进行相应操作。比如，使用 TweenMax.to(mc, 2, {x:”-20″}); 它将 mc.x 向左移动 20 像素，与此相同效果的代码是：

TweenMax.to(mc, 2, {x:mc.x - 20});

可以对任何 MovieClip 使用 “volume” 缓动,就比如：

TweenMax.to(myClip_mc, 1.5, {volume:0});

可以将 MovieClip 缓动成某种色调或颜色，使用 “tint” 属性,比如:

TweenMax.to(myClip_mc, 1.5, {tint:0xFF0000});

想要对数组内容进行缓动，将数值放到一个叫 endArray 的数组中即可，例如:

var myArray:Array = [1,2,3,4];
TweenMax.to(myArray, 1.5, {endArray:[10,20,30,40]});

可以在任何时候终止缓动，使用 TweenMax.killTweensOf(myClip_mc); 函数。如果想强制终止缓动，可以传递一个 true 做为第二个参数，比如

TweenMax.killTweensOf(myClip_mc, true);

去除延迟回调函数，用 TweenMax.killDelayedCallsTo(myFunction_func);这项功能可以用来控制回调函数的优先级。
使用 TweenMax.from() 方法，可以使目标对象运动回它所在的位置。比如，你可以将对象在舞台上摆放整齐（缓动结束时的位置），然后利用缓动，让它们跑到那个位置上去，你可以将缓动初始位置的 x 或 y 或 alpha (或者其它你需要的属性)当做参数传递给这个方法函数。

http://tankionline.com

http://www.smallworlds.com

转自：http://caihx.javaeye.com/blog/605143

套接字基础
1. 介绍

多数程序员，不管他们是否使用 Java 语言进行编码，都不想很多知道关于不同计算机上的应用程序彼此间如何通信的低级细节。程序员们希望处理更容易理解的更高级抽象。Java 程序员希望能用他们熟悉的 Java 构造，通过直观接口与对象交互。

套接字在两个领域中都存在 ― 我们宁愿避开的低级细节和我们更愿处理的抽象层。本教程讨论的低级细节将只限于理解抽象应用程序所必须的部分。

2. 计算机组网 101

计算机以一种非常简单的方式进行相互间的操作和通信。计算机芯片是以 1 和 0 的形式存储并传输数据的开―闭转换器的集合。当计算机想共享数据时，它们所需做的全部就是以一致的速度、顺序、定时等等来回传输几百万比特和字节的数据流。每次想在两个应用程序之间进行信息通信时，您怎么会愿意担心那些细节呢？

为免除这些担心，我们需要每次都以相同方式完成该项工作的一组包协议。这将允许我们处理应用程序级的工作，而不必担心低级网络细节。这些成包协议称为协议栈（stack） 。TCP/IP 是当今最常见的协议栈。多数协议栈（包括 TCP/IP）都大致对应于国际标准化组织（International Standards Organization，ISO）的开放系统互连参考模型（Open Systems Interconnect Reference Model，OSIRM）。OSIRM 认为在一个可靠的计算机组网中有七个逻辑层（见图）。各个地方的公司都对这个模型某些层的实现做了一些贡献，从生成电子信号（光脉冲、射频等等）到提供数据给应用程序。TCP/IP 映射到 OSI 模型中的两层的情形如图所示。

我们不想涉及层的太多细节，但您应该知道套接字位于什么地方。

3. 套接字位于什么地方

套接字大致驻留在 OSI 模型的会话层 （见图）。会话层夹在其上面向应用的层和其下的实时数据通信层之间。会话层为两台计算机之间的数据流提供管理和控制服务。作为该层的一部分，套接字提供一个隐藏从导线上获取比特和字节的复杂性的抽象。换句话说，套接字允许我们让应用程序表明它想发送一些字节即可传输数据。套接字隐藏了完成该项工作的具体细节。

当您打电话时，您的声音传到传感器，传感器把它转换成可以传输的电数据。电话机是人与电信网络的接口。您无须知道声音如何传输的细节，只要知道想打电话给谁就行了。同样地，套接字扮演隐藏在未知通道上传输 1 和 0 的复杂性的高级接口的角色。

4. 把套接字暴露给应用程序

使用套接字的代码工作于表示层 。表示层提供应用层 能够使用的信息的公共表示。假设您打算把应用程序连接到只能识别 EBCDIC 的旧的银行系统。应用程序的域对象以 ASCII 格式存储信息。在这种情况下，您得负责在表示层上编写把数据从 EBCDIC 转换成 ASCII 的代码，然后（比方说）给应用层提供域对象。应用层然后就可以用域对象来做它想做的任何事情。

您编写的套接字处理代码只存在于表示层中。您的应用层无须知道套接字如何工作的任何事情。

5. 什么是套接字？

既然我们已经知道套接字扮演的角色，那么剩下的问题是：什么是套接字？Bruce Eckel 在他的《Java 编程思想》 一书中这样描述套接字：

套接字是一种软件抽象，用于表达两台机器之间的连接“终端”。对于一个给定的连接，每台机器上都有一个套接字，您也可以想象它们之间有一条虚拟的“电缆”，“电缆”的每一端都插入到套接字中。当然，机器之间的物理硬件和电缆连接都是完全未知的。抽象的全部目的是使我们无须知道不必知道的细节。

简言之，一台机器上的套接字与另一台机器上的套接字交谈就创建一条通信通道。程序员可以用该通道来在两台机器之间发送数据。当您发送数据时，TCP/IP 协议栈的每一层都会添加适当的报头信息来包装数据。这些报头帮助协议栈把您的数据送到目的地。好消息是 Java 语言通过”流”为您的代码提供数据，从而隐藏了所有这些细节，这也是为什么它们有时候被叫做流套接字（streaming socket） 的原因。

把套接字想成两端电话上的听筒 ― 我和您通过专用通道在我们的电话听筒上讲话和聆听。直到我们决定挂断电话，对话才会结束（除非我们在使用蜂窝电话）。而且我们各自的电话线路都占线，直到我们挂断电话。

如果想在没有更高级机制如 ORB（以及 CORBA、RMI、IIOP 等等）开销的情况下进行两台计算机之间的通信，那么套接字就适合您。套接字的低级细节相当棘手。幸运的是，Java 平台给了您一些虽然简单但却强大的更高级抽象，使您可以容易地创建和使用套接字。

6. 套接字的类型

一般而言，Java 语言中的套接字有以下两种形式：

• TCP 套接字（由 Socket 类实现，稍后我们将讨论这个类）
• UDP 套接字（由 DatagramSocket 类实现）

TCP 和 UDP 扮演相同角色，但做法不同。两者都接收传输协议数据包并将其内容向前传送到表示层。TCP 把消息分解成数据包（数据报，datagrams ）并在接收端以正确的顺序把它们重新装配起来。TCP 还处理对遗失数据包的重传请求。有了 TCP，位于上层的层要担心的事情就少多了。UDP 不提供装配和重传请求这些功能。它只是向前传送信息包。位于上层的层必须确保消息是完整的并且是以正确的顺序装配的。

一般而言，UDP 强加给您的应用程序的性能开销更小，但只在应用程序不会突然交换大量数据并且不必装配大量数据报以完成一条消息的时候。否则，TCP 才是最简单或许也是最高效的选择。

因为多数读者都喜欢 TCP 胜过 UDP，所以我们将把讨论限制在 Java 语言中面向 TCP 的类。

转自：http://blog.csdn.net/zsnlovewl/archive/2009/12/12/4991820.aspx

1、TCP连接

要想明白Socket连接，先要明白TCP连接。手机能够使用联网功能是因为手机底层实现了TCP/IP协议，可以使手机终端通过无线网络建立TCP连接。TCP协议可以对上层网络提供接口，使上层网络数据的传输建立在“无差别”的网络之上。

建立起一个TCP连接需要经过“三次握手”：

第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；

第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”（过程就不细写了，就是服务器和客户端交互，最终确定断开）
2、HTTP连接

HTTP协议即超文本传送协议(Hypertext Transfer Protocol )，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。

HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。

1）在HTTP 1.0中，客户端的每次请求都要求建立一次单独的连接，在处理完本次请求后，就自动释放连接。

2）在HTTP 1.1中则可以在一次连接中处理多个请求，并且多个请求可以重叠进行，不需要等待一个请求结束后再发送下一个请求。

由于HTTP在每次请求结束后都会主动释放连接，因此HTTP连接是一种“短连接”，要保持客户端程序的在线状态，需要不断地向服务器发起连接请求。通常的做法是即时不需要获得任何数据，客户端也保持每隔一段固定的时间向服务器发送一次“保持连接”的请求，服务器在收到该请求后对客户端进行回复，表明知道客户端“在线”。若服务器长时间无法收到客户端的请求，则认为客户端“下线”，若客户端长时间无法收到服务器的回复，则认为网络已经断开。
3、SOCKET原理

3.1套接字（socket）概念

套接字（socket）是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议，本地主机的IP地址，本地进程的协议端口，远地主机的IP地址，远地进程的协议端口。

应用层通过传输层进行数据通信时，TCP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个 TCP协议端口传输数据。为了区别不同的应用程序进程和连接，许多计算机操作系统为应用程序与TCP／IP协议交互提供了套接字(Socket)接口。应用层可以和传输层通过Socket接口，区分来自不同应用程序进程或网络连接的通信，实现数据传输的并发服务。
3.2 建立socket连接
建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。

套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。

服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。

客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。
4、SOCKET连接与TCP连接

创建Socket连接时，可以指定使用的传输层协议，Socket可以支持不同的传输层协议（TCP或UDP），当使用TCP协议进行连接时，该Socket连接就是一个TCP连接。
5、Socket连接与HTTP连接

由于通常情况下Socket连接就是TCP连接，因此Socket连接一旦建立，通信双方即可开始相互发送数据内容，直到双方连接断开。但在实际网络应用中，客户端到服务器之间的通信往往需要穿越多个中间节点，例如路由器、网关、防火墙等，大部分防火墙默认会关闭长时间处于非活跃状态的连接而导致 Socket 连接断连，因此需要通过轮询告诉网络，该连接处于活跃状态。

而HTTP连接使用的是“请求—响应”的方式，不仅在请求时需要先建立连接，而且需要客户端向服务器发出请求后，服务器端才能回复数据。

很多情况下，需要服务器端主动向客户端推送数据，保持客户端与服务器数据的实时与同步。此时若双方建立的是Socket连接，服务器就可以直接将数据传送给客户端；若双方建立的是HTTP连接，则服务器需要等到客户端发送一次请求后才能将数据传回给客户端，因此，客户端定时向服务器端发送连接请求，不仅可以保持在线，同时也是在“询问”服务器是否有新的数据，如果有就将数据传给客户端。