• 服务接口

• 接口实现

• 发布服务

In order to generate functional remote references, Java RMI servers must be able to supply a fully qualified hostname or IP address that is resolvable from all Java RMI clients (an example of a fully qualified hostname is foo.bar.com). If a Java RMI program provides a remote callback operation, then that program serves a Java RMI object and consequently, must be able to determine a resolvable hostname to use as its server hostname in the remote references it passes to Java RMI clients. VMs that make calls to applets that serve remote objects may throwUnknownHostExceptions because the applet has failed to provide a usable server hostname.

If your Java RMI application throws an UnknownHostException, you can look at the resulting stack trace to see if the hostname that the client is using to contact its remote server is incorrect or not fully qualified.【 If necessary, you can set the java.rmi.server.hostname property on the server to the correct IP address or hostname of the server machine and Java RMI will use this property's value to generate remote references to the server.】

否则会报
Can’t connect to X11 window server using ‘:0.0′ as the value of the DISPLAY variable
异常

启动参数  -Djava.awt.headless=true

在websphere上的配置情况：

在

应用程序服务器 > server1 > 进程定义 > Java 虚拟机 下配置：

• SAXReader saxReader = new SAXReader();
• Document document = saxReader.read(FileUtil.getFileInputStream(fileName));
  

• String xpath ="/composites/composite[@type='onDelete']";//查询属性type='ondDelete'的composite
• List<Element> composites = document.selectNodes(xpath);
  

/step/step/...

step/step/...

轴名称::节点测试[谓语]

举例来说：

public synchronized void method(){

    method body

}

等价于

public void method(){

    this.intrinsicLock.lock();

    try{

        method body;

    }finally(){

        this.intrinsicLock.unlock();

    }

}

从上面的代码示例可以看出，synchronized的使用方式是比较简单的。这也导致了大量的初学者在碰到java编程的时候落入陷阱里，认为既然synhronized可以搞定一切，那么不管三七二十一，只要有并发可能性的地方，就加上synchronized的关键字，这显然是不对的。在java对象中，这个java对象只有这一个内部锁，其中一个synchronized方法获取到了这个锁，另外一个synchronized方法的调用将被阻塞。

即

class sync{

    public synchronized void methodA(){};

    public synchronized void methodB(){};

    ... ...

}

methodA 和methodB在初始就是互斥的，如果methodA和methodB进入互相等待，就很容易出现死锁的情况。那如果碰到这种情况，应该怎么做了？常用的方式是在方法内部新建一个无意义的对象，然后对这个无意义的对象加锅。

另外需要注意的是将静态类声明为synchronized方法也是合法的。举例来说，如果Sync有一个static synchronized方法，那么这个方法被调用时,bank.class这个类对象本身在jvm中将被锁住

看这个参数很容易让人以为是线程池里保持corePoolSize个线程，如果不够用，就加线程入池直至maximumPoolSize大小，如果还不够就往workQueue里加，如果workQueue也不够就用RejectedExecutionHandler来做拒绝处理。

但实际情况不是这样，具体流程如下：

1)线程池的大小>活动的线程 就放入queue，由于有空闲的线程，就不创建线程直接用空闲的线程处理
2)线程池的大小<活动的线程&& 线程池的大小>=最大限制数，没有空闲的线程，但不能创建线程，事件入queue等待有空闲的线程，如果超时，使RejectedExecutionHandler处理
3)线程池的大小<活动的线程&& 线程池的大小<最大限制数,没有空闲线程，可以创建线程，直接创建新线程处理新事件

内部结构如下所示：

从中可以发现ThreadPoolExecutor就是依靠BlockingQueue的阻塞机制来维持线程池，当池子里的线程无事可干的时候就通过workQueue.take()阻塞住。

其实可以通过Executes来学学几种特殊的ThreadPoolExecutor是如何构建的。

newFixedThreadPool就是一个固定大小的ThreadPool

newCachedThreadPool比较适合没有固定大小并且比较快速就能完成的小任务，没必要维持一个Pool，这比直接new Thread来处理的好处是能在60秒内重用已创建的线程。

其他类型的ThreadPool看看构建参数再结合上面所说的特性就大致知道它的特性
转载自：http://blog.csdn.net/cutesource/article/details/6061229

      1.我们先讨论按key值进行排序
我们先看一下这个Sorter类：

public class Sorter {

    public static Map sort(Map map) {
        Map<Object, Object> mapVK = new TreeMap<Object, Object>(
            new Comparator<Object>() {
                public int compare(Object obj1, Object obj2) {
                    String v1 = (String)obj1;
                    String v2 = (String)obj2;
                    int s = v2.compareTo(v1);
                    return s;
                }
            }
        );

        Set col = map.keySet();
        Iterator iter = col.iterator();
        while (iter.hasNext()) {
            String key = (String) iter.next();
            Integer value = (Integer) map.get(key);
            mapVK.put(key, value);
        }
        return mapVK;
    }
   
}

最后给出一个例子：
public class SortHashMap {

    public SortHashMap() {

    }

    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<String, Integer>();
        maps.put("boy", 8);
        maps.put("cat", 7);
        maps.put("dog", 1);
        maps.put("apple", 5);
        //排序前的输出
        Set set = maps.entrySet();
        Iterator i = set.iterator();
        while(i.hasNext()){
            Map.Entry<String, Integer> entry1=(Map.Entry<String, Integer>)i.next();
            System.out.println(entry1.getKey() + "-------->" + entry1.getValue());
        }

        System.out.println("----------------");
         //排序后的输出
        Map<String, Integer> sortMaps = Sorter.sort(maps);
        Set sortSet = sortMaps.entrySet();
        Iterator ii = sortSet.iterator();
        while(ii.hasNext()){
            Map.Entry<String, Integer> entry1=(Map.Entry<String, Integer>)ii.next();
            System.out.println(entry1.getKey() + "-------->" + entry1.getValue());
        }
       
    }
}

排序前的输出结果是：
cat-------->7
apple-------->5
dog-------->1
boy-------->8

排序后的输出结果是：
dog-------->1
cat-------->7
boy-------->8
apple-------->5
经过排序后的Map有序了，是按照字母的逆序排列的。

2、我们再讨论如何按value值进行排序。
还是上面的那个例子，我们想要按照各类对象的数量打印出类别的名称。
我们再来修改一下这个SortHashMap类：

public class SortHashMap {

    public SortHashMap() {

    }

    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<String, Integer>();
        maps.put("boy", 8);
        maps.put("cat", 7);
        maps.put("dog", 1);
        maps.put("apple", 5);
        //排序前的输出
        Set set = maps.entrySet();
        Iterator i = set.iterator();
        while(i.hasNext()){
            Map.Entry<String, Integer> entry1=(Map.Entry<String, Integer>)i.next();
            System.out.println(entry1.getKey() + "-------->" + entry1.getValue());
        }

        System.out.println("----------------");
        //排序后的输出
     List<Map.Entry<String, Integer>> info = new ArrayList<Map.Entry<String, Integer>>(maps.entrySet());
        Collections.sort(info, new Comparator<Map.Entry<String, Integer>>() {
            public int compare(Map.Entry<String, Integer> obj1, Map.Entry<String, Integer> obj2) {
                return obj2.getValue() - obj1.getValue();
            }
        });

        for (int j = 0; j<info.size();j++) {
            System.out.println(info.get(j).getKey() + "------->" + info.get(j).getValue());
        }
    }
}

排序前的输出结果是：
cat-------->7
apple-------->5
dog-------->1
boy-------->8

排序后的输出结果是：
boy------->8
cat------->7
apple------->5
dog------->1

程序运行的结果，达到了我们的要求，实现了Map的排序。该方法主要是利用了ArrayList的排序实现了Map的排序输出，并没有影响到Map的存放结构。

    独立访客数 UV(unique visitor)：独立访客，将每台独立上网电脑(以cookie为依据)视为一位访客，一天之内(00:00-24:00)，访问您网站的访客数量。一天之内相同cookie的访问只被计算1次。

    平均访问页数 这是一个平均数，即在一定时间内全部页面浏览量与所有独立访客数相除的结果，即一个用户浏览的网页数量。这一指标表明了访问者对网站内容或者产品信息感兴趣的程度，也就是常说的网站“粘性”。

    访问次数 也称为登陆数，一个登陆是指客户开始访问网站到离开网站的过程。其中：相邻两次点击页面时间间隔在30分钟以内为一次登陆，大于30分钟为两次登陆。

    平均网站访问时间 同一个访问过程中最后一个页面的访问时间减去第一个页面的访问时间，得到此访问在网站上的停留时间。

    页面停留时间 显示访问者在某个特定页面或某组页面上花费的时间。∑(时间戳(N+1)-时间戳(N))/(页面访问量-退出数)

    新访客数 独立访客中，历史首次访问您网站的访客数。

    重复访客者数 重复访问者。是指在一定时期内(两年)不止一次访问一个网站的独立用户。

    新访客率 某段时间内某个页面或多个页面新访客数占所有唯一身份访问者的比例。

    回访率 重复访客占所有唯一身份访问者的比例。

    独立IP数 指访问某个站点或点击某个页面的不同IP地址的人数。 在同一天内，只记录第一次进入网站的具有独立IP的访问者，在同一天内再次访问该网站则不计数。独立IP访问者提供了一定时间内不同观众数量的统计指标，而没有反应出网站的全面活动。

    访问频度 是指您网站上访问者每日访问的频度，用于揭示您网站内容对访问者的吸引程度。

    跳出率 某个时间段内，只浏览了一页即离开网站的访问次数占总访问次数的比例。对于某页面的跳出率算法：从这个页面进入网站没有再点击其他页即离开的次数/所有进入这个页面的次数对于整个网站跳出率的算法：只浏览一个页面即离开的访问次数/进入网站的总次数

    退出率 某个时间段内，离开网页的次数占该网页总浏览次数的比例。从本页退出网站的次数/本页的综合浏览量。

    页面打开时间 页面顶部JS代码与页面底部JS代码执行时间的差值。

     唯一身份浏览量 唯一浏览量(如最常见内容报告中所示)会汇总由同一用户在同一会话期间生成的综合浏览量。唯一浏览量表示该页被浏览(一次或多次)期间的会话次数。

    页面价值 页面价值是指用户在到达目标页面或完成电子商务交易(或两者都有)前访问页面的平均价值。其计算公式如下：页面价值 =(总目标价值+电子商务收入)/指定页面的唯一身份浏览量

    投放词ROI 订单佣金/点击单价*点击量

    登陆页面 即访问入口：每次访问过程中，用户进入的第一个页面，此页面可以显示网站对外或搜索引擎的一些链接入口。

    访问路径 每个访问者从进入您的网站开始访问，一直到最后离开您的网站，整个过程中先后浏览的页面称为访问路径。

    离开页面 是指某个访客本次访问您网站时所访问的最后一个页面。

    目标完成数 到达目标页面的会话数目。

    目标转化率 目标完成的会话占总会话的比例。

    路径进入数 进入用户预定义的浏览路径的会话数。

    路径完成数 完成预定义的浏览路径的会话数。即设置的浏览路径每个步骤(页面)都覆盖到的会话的数目。

    路径转化率 完成浏览路径的会话占进入浏览路径的会话的比例。如100个人(准确的说应该是100个会话，这里假设每个人只访问了一次会话)开始了注册流程，但是最终只有20个人注册成功了(到达注册成功页面)，则转化率为20%。

    搜索深度 同一用户一次会话的搜索次数。

    搜索次数 用户使用搜索功能的次数

    搜索退出率 搜索后退出数站总搜索者的比例。

    网站 主要单个域名或多个域名的站点集合。

    频道/栏目 将网站中的各种内容根据功能归类，划分出若干逻辑上的频道或栏目。

    过滤页面 网站中的某些页面并不是独立的页面，而是附属于某个页面，如滚动条页面就是附属于首页的页面，用户可以将这些附属页面设置为过滤页面。过滤后的浏览数方能真正反映网站的访问情况。

    特定页面 对于需要特殊分析的页面，通过设置，从众多页面中独立出来，进行特定分析的页面。

    定义页面 页面功能没有定义的页面，即没有归类到任何频道的页面。

    热门 最受欢迎的页面或频道，即浏览数排名前若干位(可由用户自行定义)的页面或频道。

    冷门 最不受欢迎的页面或频道，即浏览数排名后若干位(可由用户自行定义)的页面或频道。

    热点 将一个网页中包含的各个链接根据功能归类划分出若干板块，比如机票板块、酒店板块、广告板块等，每个板块成为一个热点。进而分析出该页面上的各个热点板块被点击的情况。

    沉默时间 注册用户最后一次访问网站到分析日的天数。

    沉默用户 在沉默时间内未访问网站的注册用户。

    重度访问用户 按每次访问的停留时间划分，把停留时间超过20分钟的用户归为重度访问用户；按每次访问产生的浏览数划分，把一次访问浏览超过10个页面的用户归为重度访问用户。对于重度访问用户，包括以下四个指标，每个指标值越大，表明用户品质越高。

     轻度访问用户 按每次访问的停留时间划分，把停留时间不超过1分钟的用户归为轻度访问用户。对于轻度访问用户，包括以下三个指标，每个指标值越小，表明用户品质越高。

    拒绝率 一次访问只访问一个页面的访问次数占总访问数的比例，比例越小，表明用户品质越高。

    访客 所有访问网站的用户。

    会员 所有注册过的访客。

    客户 所有消费过的会员。

    时段 按照一天24个小时自然时间段进行划分。

    地区 访问客户的来源地区，是根据IP地区对照表，查询访问客户的IP地址落在哪个IP区段内，而得到其对应的地区。地区包括国内地区和国外地区，国内地区以省为单位，国外地区以国家为单位。

    IP地址 IP地址由4个数组成，每个数可取值0～255， 各数之间用一个点号”.”分开，例如： 202.103.8.46。

    运营商 客户端接入互联网的服务提供商，比如中国电信、中国网通、教育网等。

    接入方式 客户端接入互联网的方式，比如拨号、专线、ISDN、ADSL等。

    广告 通过在别的网站上放置网站链接或弹出窗口等方式介绍本网站的一种商业活动。

    邮件 通过发送电子邮件，邮件中包含链接地址，吸引用户通过点击邮件中包含的链接地址访问本网站，实际上也是广告的一种。

    搜索引擎 在互联网上为您提供信息”检索”服务的网站。

    关键字 用户通过搜索引擎“检索”的内容。

    投放词 在百度竞价系统后台设置的关键词。

    曝光数 广告的展示次数。

    广告点击数 用户点击弹出广告的次数，即Click数。

    趋势 趋势分为两种，第一种是以时段为单位的一天24小时发展趋势。第二种是以日为单位的周、月、以及指定区间发展趋势。

    汇总 对多网站的分析进行汇总。

    同期比较 对任意两个日、周、月、以及指定区间的浏览数(或访问数、或用户数、停留时间)进行比较。比较对象可以是页面、频道、栏目、广告、地区等。

    聚合 对日期的聚合，比如周聚合就是将7天的数据合在一起为一个分析项，聚合目的就是以聚合项为单位分析网站发展的趋势。

    环比 在趋势分析中，当前日期数据与上一日期数据的比成为环比。

    Excel导出 将分析结果以Excel表格形式输出。

    网站拓扑结构 网站的拓扑结构是由网站汇总、网站分析和频道分析三类节点构成。其中，网站汇总下可以有部门汇总，网站分析下可以有子网站，频道分析下可以有子频道。用户根据网站拓扑结构，来查询所需要的分析结果。

    日志文件 日志文件是指被分析网站的工作日志。

    状态代码 也称作错误代码，是为服务器所接收每个请求(网页点击)分配的 3 位数代码。

OAuth（开放授权）是一个开放标准，允许用户让第三方应用访问该用户在某一网站上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。

OAuth允许用户提供一个令牌，而不是用户名和密码来访问他们存放在特定服务提供者的数据。每一个令牌授权一个特定的网站（例如，视频编辑网站)在特定的时段（例如，接下来的2小时内）内访问特定的资源（例如仅仅是某一相册中的视频）。这样，OAuth允许用户授权第三方网站访问他们存储在另外的服务提供者上的信息，而不需要分享他们的访问许可或他们数据的所有内容。

OAuth是OpenID的一个补充，但是完全不同的服务。

认证和授权过程

在认证和授权的过程中涉及的三方包括：

使用OAuth进行认证和授权的过程如下所示:

1. 用户访问客户端的网站，想操作用户存放在服务提供方的资源。
2. 客户端向服务提供方请求一个临时令牌。
3. 服务提供方验证客户端的身份后，授予一个临时令牌。
4. 客户端获得临时令牌后，将用户引导至服务提供方的授权页面请求用户授权。在这个过程中将临时令牌和客户端的回调连接发送给服务提供方。
5. 用户在服务提供方的网页上输入用户名和密码，然后授权该客户端访问所请求的资源。
6. 授权成功后，服务提供方引导用户返回客户端的网页。
7. 客户端根据临时令牌从服务提供方那里获取访问令牌。
8. 服务提供方根据临时令牌和用户的授权情况授予客户端访问令牌。
9. 客户端使用获取的访问令牌访问存放在服务提供方上的受保护的资源。

新浪oauth认证说明：
http://open.weibo.com/wiki/Oauth
豆瓣oauth认证：
http://www.douban.com/service/apidoc/auth

      Runtime.getRuntime().addShutdownHook(shutdownHook);

   这个方法的含义说明：

       这个方法的意思就是在jvm中增加一个关闭的钩子，当jvm关闭的时候，会执行系统中已经设置的所有通过方法addShutdownHook添加的钩子，当系统执行完这些钩子后，jvm才会关闭。所以这些钩子可以在jvm关闭的时候进行内存清理、对象销毁等操作。

一、编写个测试类

  package com.test.hook;

public class TestShutdownHook {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // 定义线程1
  Thread thread1 = new Thread() {
   public void run() {
    System.out.println("thread1...");
   }
  };

  // 定义线程2
  Thread thread2 = new Thread() {
   public void run() {
    System.out.println("thread2...");
   }
  };

  // 定义关闭线程
  Thread shutdownThread = new Thread() {
   public void run() {
    System.out.println("shutdownThread...");
   }
  };

  // jvm关闭的时候先执行该线程钩子
  Runtime.getRuntime().addShutdownHook(shutdownThread);

  thread1.start();
  thread2.start();
 }
}

打印结果：

thread2...
thread1...
shutdownThread...

或者：

thread2...
thread1...
shutdownThread...

结论：

无论是先打印thread1还是thread2，shutdownThread 线程都是最后执行的（因为这个线程是在jvm执行关闭前才会执行）。

的详细内容就需要SSL
　　SSL协议的握手过程
SSL 协议既用到了公钥加密技术又用到了对称加密技术，对称加密技术虽然比公钥加密技术的速度快，可是公钥加密技术提供了更好的身份认证技术。SSL 的握手协议非常有效的让客户和服

务器之间完成相互之间的身份认证，其主要过程如下： 　　
①客户端的浏览器向服务器传送客户端 SSL 协议的版本号，加密算法的种类，产生的随机数，以及其他服务器和客户端之间通讯所需要的各种信息。 　　
②服务器向客户端传送 SSL 协议的版本号，加密算法的种类，随机数以及其他相关信息，同时服务器还将向客户端传送自己的证书。 　　
③客户利用服务器传过来的信息验证服务器的合法性，服务器的合法性包括：证书是否过期，发行服务器证书的 CA 是否可靠，发行者证书的公钥能否正确解开服务器证书的“发行者的数字

签名”，服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过，通讯将断开；如果合法性验证通过，将继续进行第四步。 　　
④用户端随机产生一个用于后面通讯的“对称密码”，然后用服务器的公钥（服务器的公钥从步骤②中的服务器的证书中获得）对其加密，然后将加密后的“预主密码”传给服务器。 　　
⑤如果服务器要求客户的身份认证（在握手过程中为可选），用户可以建立一个随机数然后对其进行数据签名，将这个含有签名的随机数和客户自己的证书以及加密过的“预主密码”一起传

给服务器。 　　
⑥如果服务器要求客户的身份认证，服务器必须检验客户证书和签名随机数的合法性，具体的合法性验证过程包括：客户的证书使用日期是否有效，为客户提供证书的CA 是否可靠，发行CA

的公钥能否正确解开客户证书的发行 CA 的数字签名，检查客户的证书是否在证书废止列表（CRL）中。检验如果没有通过，通讯立刻中断；如果验证通过，服务器将用自己的私钥解开加密的

“预主密码”，然后执行一系列步骤来产生主通讯密码（客户端也将通过同样的方法产生相同的主通讯密码）。 　　
⑦服务器和客户端用相同的主密码即“通话密码”，一个对称密钥用于 SSL 协议的安全数据通讯的加解密通讯。同时在 SSL 通讯过程中还要完成数据通讯的完整性，防止数据通讯中的任何

变化。 　　
⑧客户端向服务器端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知服务器客户端的握手过程结束。 　　
⑨服务器向客户端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知客户端服务器端的握手过程结束。 　　
⑩SSL 的握手部分结束，SSL 安全通道的数据通讯开始，客户和服务器开始使用相同的对称密钥进行数据通讯，同时进行通讯完整性的检验。

下面是在tomcat下实现https，使用jdk自带的keytool工具生成自签名证书。

1 生成keystore文件，keystore文件用来存储密钥和证书
   keystore的详细参数可使用 可使用keystore命令查看。
  
keytool -genkeypair -keyalg rsa -keysize 2048 -sigalg sha1withrsa -validity 3600 -alias www.joe.com -keystore e:\ssl\joe.keystore
输入keystore密码：
再次输入新密码:
您的名字与姓氏是什么？
  [Unknown]：  www.joe.com
您的组织单位名称是什么？
  [Unknown]：  joe
您的组织名称是什么？
  [Unknown]：  joe
您所在的城市或区域名称是什么？
  [Unknown]：  bj
您所在的州或省份名称是什么？
  [Unknown]：  bj
该单位的两字母国家代码是什么
  [Unknown]：  cn
CN=www.joe.com, OU=joe, O=joe, L=bj, ST=bj, C=cn 正确吗？
  [否]：  y

输入<www.joe.com>的主密码
        （如果和 keystore 密码相同，按回车）：
2 导出自签名证书。正是平台需要导出csr文件并去权威的ca认证机构获取受信任证书，一般是收费的。
   keytool -exportcert -alias www.joe.com -keystore e:\ssl\joe.keystore -file e:\ssl\joe.cer -rfc
输入keystore密码：
保存在文件中的认证 <e:\ssl\joe.cer>
下面配置tomcat(server.xml)使其支持https.
<Connector port="443" protocol="HTTP/1.1" SSLEnabled="true"
               maxThreads="150" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS"  keystoreFile="conf/joe.keystore" keystorePass="123456"/>
   

3 修改操作系统host文件，添加127.0.0.1 www.joe.com

4 新建web应用httpstest
并添加indexjsp:
 <body>
    <%
     for(Enumeration en = request.getAttributeNames();en.hasMoreElements();){
     String name = (String)en.nextElement();
     out.println(name);
     out.println("="+request.getAttribute(name));
     out.println();
     }
    %>
  </body>

5 为了让浏览器信任我们的证书，需要在浏览器导入我们的证书为信任根证书。
6 访问：https://www.joe.com/httpstest
输出：
javax.servlet.request.ssl_session =4e05eb849ac41a45b56725488b68c28cc8c2ea94e2ec599852e1665297b2822b
javax.servlet.request.key_size =128
javax.servlet.request.cipher_suite =SSL_RSA_WITH_RC4_128_MD5 (通讯的加密信息，由浏览器和服务器协商确定)。

工作原理

安全问题

实际应用

由于Java提供了良好的默认支持，实现基本的对象序列化是件比较简单的事。待序列化的Java类只需要实现Serializable接口即可。Serializable仅是一个标记接口，并不包含任何需要实现的具体方法。实现该接口只是为了声明该Java类的对象是可以被序列化的。实际的序列化和反序列化工作是通过ObjectOuputStream和ObjectInputStream来完成的。ObjectOutputStream的writeObject方法可以把一个Java对象写入到流中，ObjectInputStream的readObject方法可以从流中读取一个Java对象。在写入和读取的时候，虽然用的参数或返回值是单个对象，但实际上操纵的是一个对象图，包括该对象所引用的其它对象，以及这些对象所引用的另外的对象。Java会自动帮你遍历对象图并逐个序列化。除了对象之外，Java中的基本类型和数组也是可以通过 ObjectOutputStream和ObjectInputStream来序列化的。

try {
    User user = new User("Alex", "Cheng");
    ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("user.bin"));
    output.writeObject(user);
    output.close();
} catch (IOException e) {
    e.printStackTrace();
}
 
try {
    ObjectInputStream input = new ObjectInputStream(new FileInputStream("user.bin"));
    User user = (User) input.readObject();
    System.out.println(user);
} catch (Exception e) {
    e.printStackTrace();
} 
 

上面的代码给出了典型的把Java对象序列化之后保存到磁盘上，以及从磁盘上读取的基本方式。 User类只是声明了实现Serializable接口。

在默认的序列化实现中，Java对象中的非静态和非瞬时域都会被包括进来，而与域的可见性声明没有关系。这可能会导致某些不应该出现的域被包含在序列化之后的字节数组中，比如密码等隐私信息。由于Java对象序列化之后的格式是固定的，其它人可以很容易的从中分析出其中的各种信息。对于这种情况，一种解决办法是把域声明为瞬时的，即使用transient关键词。另外一种做法是添加一个serialPersistentFields? 域来声明序列化时要包含的域。从这里可以看到在Java序列化机制中的这种仅在书面层次上定义的契约。声明序列化的域必须使用固定的名称和类型。在后面还可以看到其它类似这样的契约。虽然Serializable只是一个标记接口，但它其实是包含有不少隐含的要求。下面的代码给出了 serialPersistentFields的声明示例，即只有firstName这个域是要被序列化的。

private static final ObjectStreamField[] serialPersistentFields = { 
    new ObjectStreamField("firstName", String.class) 
};  

自定义对象序列化

基本的对象序列化机制让开发人员可以在包含哪些域上进行定制。如果想对序列化的过程进行更加细粒度的控制，就需要在类中添加writeObject和对应的 readObject方法。这两个方法属于前面提到的序列化机制的隐含契约的一部分。在通过ObjectOutputStream的 writeObject方法写入对象的时候，如果这个对象的类中定义了writeObject方法，就会调用该方法，并把当前 ObjectOutputStream对象作为参数传递进去。writeObject方法中一般会包含自定义的序列化逻辑，比如在写入之前修改域的值，或是写入额外的数据等。对于writeObject中添加的逻辑，在对应的readObject中都需要反转过来，与之对应。

在添加自己的逻辑之前，推荐的做法是先调用Java的默认实现。在writeObject方法中通过ObjectOutputStream的defaultWriteObject来完成，在readObject方法则通过ObjectInputStream的defaultReadObject来实现。下面的代码在对象的序列化流中写入了一个额外的字符串。

private void writeObject(ObjectOutputStream output) throws IOException {
    output.defaultWriteObject();
    output.writeUTF("Hello World");
}
private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException {
    input.defaultReadObject();
    String value = input.readUTF();
    System.out.println(value);
}  

序列化时的对象替换

在有些情况下，可能会希望在序列化的时候使用另外一个对象来代替当前对象。其中的动机可能是当前对象中包含了一些不希望被序列化的域，比如这些域都是从另外一个域派生而来的；也可能是希望隐藏实际的类层次结构；还有可能是添加自定义的对象管理逻辑，如保证某个类在JVM中只有一个实例。相对于把无关的域都设成transient来说，使用对象替换是一个更好的选择，提供了更多的灵活性。替换对象的作用类似于Java EE中会使用到的传输对象（Transfer Object）。

考虑下面的例子，一个订单系统中需要把订单的相关信息序列化之后，通过网络来传输。订单类Order引用了客户类Customer。在默认序列化的情况下，Order类对象被序列化的时候，其引用的Customer类对象也会被序列化，这可能会造成用户信息的泄露。对于这种情况，可以创建一个另外的对象来在序列化的时候替换当前的Order类的对象，并把用户信息隐藏起来。

private static class OrderReplace implements Serializable {
    private static final long serialVersionUID = 4654546423735192613L;
    private String orderId;
    public OrderReplace(Order order) {
        this.orderId = order.getId();
    }
    private Object readResolve() throws ObjectStreamException {
        //根据orderId查找Order对象并返回
    }
}    

这个替换对象类OrderReplace只保存了Order的ID。在Order类的writeReplace方法中返回了一个OrderReplace对象。这个对象会被作为替代写入到流中。同样的，需要在OrderReplace类中定义一个readResolve方法，用来在读取的时候再转换回 Order类对象。这样对调用者来说，替换对象的存在就是透明的。

private Object writeReplace() throws ObjectStreamException {
    return new OrderReplace(this);
} 

序列化与对象创建

在通过ObjectInputStream的readObject方法读取到一个对象之后，这个对象是一个新的实例，但是其构造方法是没有被调用的，其中的域的初始化代码也没有被执行。对于那些没有被序列化的域，在新创建出来的对象中的值都是默认的。也就是说，这个对象从某种角度上来说是不完备的。这有可能会造成一些隐含的错误。调用者并不知道对象是通过一般的new操作符来创建的，还是通过反序列化所得到的。解决的办法就是在类的readObject方法里面，再执行所需的对象初始化逻辑。对于一般的Java类来说，构造方法中包含了初始化的逻辑。可以把这些逻辑提取到一个方法中，在readObject方法中调用此方法。

版本更新

把一个Java对象序列化之后，所得到的字节数组一般会保存在磁盘或数据库之中。在保存完成之后，有可能原来的Java类有了更新，比如添加了额外的域。这个时候从兼容性的角度出发，要求仍然能够读取旧版本的序列化数据。在读取的过程中，当ObjectInputStream发现一个对象的定义的时候，会尝试在当前JVM中查找其Java类定义。这个查找过程不能仅根据Java类的全名来判断，因为当前JVM中可能存在名称相同，但是含义完全不同的Java 类。这个对应关系是通过一个全局惟一标识符serialVersionUID来实现的。通过在实现了Serializable接口的类中定义该域，就声明了该Java类的一个惟一的序列化版本号。JVM会比对从字节数组中得出的类的版本号，与JVM中查找到的类的版本号是否一致，来决定两个类是否是兼容的。对于开发人员来说，需要记得的就是在实现了Serializable接口的类中定义这样的一个域，并在版本更新过程中保持该值不变。当然，如果不希望维持这种向后兼容性，换一个版本号即可。该域的值一般是综合Java类的各个特性而计算出来的一个哈希值，可以通过Java提供的serialver命令来生成。在Eclipse中，如果Java类实现了Serializable接口，Eclipse会提示并帮你生成这个serialVersionUID。

在类版本更新的过程中，某些操作会破坏向后兼容性。如果希望维持这种向后兼容性，就需要格外的注意。一般来说，在新的版本中添加东西不会产生什么问题，而去掉一些域则是不行的。

序列化安全性

前面提到，Java对象序列化之后的内容格式是公开的。所以可以很容易的从中提取出各种信息。从实现的角度来说，可以从不同的层次来加强序列化的安全性。

• 对序列化之后的流进行加密。这可以通过CipherOutputStream来实现。
• 实现自己的writeObject和readObject方法，在调用defaultWriteObject之前，先对要序列化的域的值进行加密处理。
• 使用一个SignedObject或SealedObject来封装当前对象，用SignedObject或SealedObject进行序列化。
• 在从流中进行反序列化的时候，可以通过ObjectInputStream的registerValidation方法添加ObjectInputValidation接口的实现，用来验证反序列化之后得到的对象是否合法。

RMI

RMI（Remote Method Invocation）是Java中的远程过程调用（Remote Procedure Call，RPC）实现，是一种分布式Java应用的实现方式。它的目的在于对开发人员屏蔽横跨不同JVM和网络连接等细节，使得分布在不同JVM上的对象像是存在于一个统一的JVM中一样，可以很方便的互相通讯。之所以在介绍对象序列化之后来介绍RMI，主要是因为对象序列化机制使得RMI非常简单。调用一个远程服务器上的方法并不是一件困难的事情。开发人员可以基于Apache MINA或是Netty这样的框架来写自己的网络服务器，亦或是可以采用REST架构风格来编写HTTP服务。但这些解决方案中，不可回避的一个部分就是数据的编排和解排（marshal/unmarshal）。需要在Java对象和传输格式之间进行互相转换，而且这一部分逻辑是开发人员无法回避的。RMI的优势在于依靠Java序列化机制，对开发人员屏蔽了数据编排和解排的细节，要做的事情非常少。JDK 5之后，RMI通过动态代理机制去掉了早期版本中需要通过工具进行代码生成的繁琐方式，使用起来更加简单。

RMI采用的是典型的客户端-服务器端架构。首先需要定义的是服务器端的远程接口，这一步是设计好服务器端需要提供什么样的服务。对远程接口的要求很简单，只需要继承自RMI中的Remote接口即可。Remote和Serializable一样，也是标记接口。远程接口中的方法需要抛出RemoteException。定义好远程接口之后，实现该接口即可。如下面的Calculator是一个简单的远程接口。

public interface Calculator extends Remote {
    String calculate(String expr) throws RemoteException;
}  

实现了远程接口的类的实例称为远程对象。创建出远程对象之后，需要把它注册到一个注册表之中。这是为了客户端能够找到该远程对象并调用。

public class CalculatorServer implements Calculator {
    public String calculate(String expr) throws RemoteException {
        return expr;
    }
    public void start() throws RemoteException, AlreadyBoundException {
        Calculator stub = (Calculator) UnicastRemoteObject.exportObject(this, 0);
        Registry registry = LocateRegistry.getRegistry();
        registry.rebind("Calculator", stub);
    }
}

CalculatorServer是远程对象的Java类。在它的start方法中通过UnicastRemoteObject的exportObject把当前对象暴露出来，使得它可以接收来自客户端的调用请求。再通过Registry的rebind方法进行注册，使得客户端可以查找到。

客户端的实现就是首先从注册表中查找到远程接口的实现对象，再调用相应的方法即可。实际的调用虽然是在服务器端完成的，但是在客户端看来，这个接口中的方法就好像是在当前JVM中一样。这就是RMI的强大之处。

public class CalculatorClient {
    public void calculate(String expr) {
        try {
            Registry registry = LocateRegistry.getRegistry("localhost");
            Calculator calculator = (Calculator) registry.lookup("Calculator");
            String result = calculator.calculate(expr);
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
} 

在运行的时候，需要首先通过rmiregistry命令来启动RMI中用到的注册表服务器。

为了通过Java的序列化机制来进行传输，远程接口中的方法的参数和返回值，要么是Java的基本类型，要么是远程对象，要么是实现了 Serializable接口的Java类。当客户端通过RMI注册表找到一个远程接口的时候，所得到的其实是远程接口的一个动态代理对象。当客户端调用其中的方法的时候，方法的参数对象会在序列化之后，传输到服务器端。服务器端接收到之后，进行反序列化得到参数对象。并使用这些参数对象，在服务器端调用实际的方法。调用的返回值Java对象经过序列化之后，再发送回客户端。客户端再经过反序列化之后得到Java对象，返回给调用者。这中间的序列化过程对于使用者来说是透明的，由动态代理对象自动完成。除了序列化之外，RMI还使用了动态类加载技术。当需要进行反序列化的时候，如果该对象的类定义在当前JVM中没有找到，RMI会尝试从远端下载所需的类文件定义。可以在RMI程序启动的时候，通过JVM参数java.rmi.server.codebase来指定动态下载Java类文件的URL。  

参考资料

• Java对象序列化规范
• RMI规范

转载自：infoq

概念

　　TCP/IP（传输控制协议/网际协议）是异构网络互连的通信协议，通过它可以实现各种异构网络或异种机之间的互联通信。

　　TCP/IP已成为当今计算机网络最成熟、应用最广的互联协议。Internet采用的就是TCP/IP协议，网络上各种各样的计算机上只要安装了TCP/IP协议，它们之间就能相互通信。运行TCP/IP协议的网络是一种采用包（分组）交换网络。TCP/IP协议是由100多个协议组成的协议集，TCP和IP是其中两个最重要的协议。TCP和IP两个协议分别属于传输层和网络层，在Internet中起着不同的作用。

层次概述

　　

TCP/IP		OSI
应用层		应用层 表示层 会话层
传输层（TCP）		传输层
网络层（IP）		网络层
网络接口层		数据链路层

（TCP/IP结构对应OSI结构）

　　TCP/IP是一个四层的分层体系结构。

　　最高层：应用层为协议的最高层，在该层应用程序与协议相配合，发送或接收数据。TCP/IP协议集在应用层上有远程登录协议（Telnet）、文件传输协议（FTP）、电子邮箱协议（SMTP）、域名系统（DNS）等，它们构成了TCP/IP的基本应用程序。

　　高层：即传输层，其主要协议有UDP（user data protocol）和传输控制协议（TCP,Transmission Control Protocol）。TCP协议是在IP协议提供的服务基础上，支持面向连接的、可靠地传输服务，是负责聚集信息或把文件拆分成更小的包。这些包通过网络传送到接收端的TCP层，接收端的TCP层把包还原为原始文件；UDP协议时直接利用IP协议进行UDP数据报的传输，因此UDP协议提供的是无连接、不保证数据完整到达目的地的传输服务。由于UDP不使用很繁琐的流控制或错误恢复机制，只充当数据报的发送者和接收者，因此，UDP比TCP简单得多。

　　低层：是网际协议(IP,Internet Protocol)，它处理每个包的地址部分，使这些包正确的到达目的地。网络上的网关计算机根据信息的地址来进行路由选择。即使来自同一文件的分包路由也有可能不同，但最后会在目的地汇合。 TCP/IP使用客户端/服务器模式进行通信。TCP/IP通信是点对点的，意思是通信是网络中的一台主机与另一台主机之间的。TCP/IP与上层应用程序之间可以说是“没有国籍的”，因为每个客户请求都被看做是与上一个请求无关的。正是它们之间的“无国籍的”释放了网络路径，才使每个人都可以连续不断的使用网络。 许多用户熟悉使用TCP/IP协议的高层应用协议。包括万维网（www，world wide web）的超文本传输协议（HTTP），文件传输协议（FTP），远程网络访问协议(Telnet)和简单邮件传输协议（SMTP）。这些协议通常和TCP/IP协议打包在一起。 使用模拟电话调制解调器连接网络的个人电脑通常是使用串行线路接口协议（SLIP）和点对点协议（P2P）。这些协议压缩IP包后通过拨号电话线发送到对方的调制解调器中。 与TCP/IP协议相关的协议还包括用户数据报协议（UDP），它代替TCP/IP协议来达到特殊的目的。其他协议是网络主机用来交换路由信息的，包括Internet控制信息协议（ICMP），内部网关协议（IGP），外部网关协议（EGP），边界网关协议（BGP）。

编辑本段产生背景

　　众所周知，如今电脑上因特网都要作TCP/IP协议设置，显然该协议成了当今地球村“人与人”之间的“牵手协议”。

　　1997年，为了褒奖对因特网发展作出突出贡献的科学家，并对TCP/IP协议作出充分肯定，美国授予为因特网发明和定义TCP/IP协议的文顿·瑟夫和卡恩“国家技术金奖”。这无疑使人们认识到TCP/IP协议的重要性。

　　在阿帕网（ARPR）产生运作之初，通过接口信号处理机实现互联的电脑并不多，大部分电脑相互之间不兼容，在一台电脑上完成的工作，很难拿到另一台电脑上去用，想让硬件和软件都不一样的电脑联网，也有很多困难。当时美国的状况是，陆军用的电脑是DEC系列产品，海军用的电脑是Honeywell中标机器，空军用的是IBM公司中标的电脑，每一个军种的电脑在各自的系里都运行良好，但却有一个大弊病：不能共享资源。

　　当时科学家们提出这样一个理念：“所有电脑生来都是平等的。”为了让这些“生来平等”的电脑能够实现“资源共享”就得在这些系统的标准之上，建立一种大家共同都必须遵守的标准，这样才能让不同的电脑按照一定的规则进行“谈判”，并且在谈判之后能“握手”。

　　在确定今天因特网各个电脑之间“谈判规则”过程中，最重要的人物当数瑟夫（Vinton G.Cerf）。正是他的努力，才使今天各种不同的电脑能按照协议上网互联。瑟夫也因此获得了与克莱因罗克（“因特网之父”）一样的美称“互联网之父”。

　　瑟夫从小喜欢标新立异，坚强而又热情。中学读书时，就被允许使用加州大学洛杉矶分校的电脑，他认为“为电脑编程序是个非常激动人心的事，…只要把程序编好，就可以让电脑做任何事情。”1965年，瑟夫从斯坦福大学毕业到IBM的一家公司当系统工程师，工作没多久，瑟夫就觉得知识不够用，于是到加州大学洛杉矶分校攻读博士，那时，正逢阿帕网的建立，“接口信号处理机”（IMP）的研试及网络测评中心的建立，瑟夫也成了著名科学家克莱因罗克手下的一位学生。瑟夫与另外三位年轻人（温菲尔德、克罗克、布雷登）参与了阿帕网的第一个节点的联接。此后不久，BBN公司对工作中各种情况发展有很强判断能力、被公认阿帕网建成作出巨大贡献的鲍伯·卡恩（Bob Kahn）也来到了加州大学洛杉矶分校。 在那段日子里，往往是卡恩提出需要什么软件，而瑟夫则通宵达旦地把符合要求的软件给编出来，然后他们一起测试这些软件，直至能正常运行。

　　当时的主要格局是这样的，罗伯茨提出网络思想设计网络布局，卡恩设计阿帕网总体结构，克莱因罗克负责网络测评系统，还有众多的科学家、研究生参与研究、试验。69年9月阿帕网诞生、运行后，才发现各个IMP连接的时候，需要考虑用各种电脑都认可的信号来打开通信管道，数据通过后还要关闭通道。否则这些IMP不会知道什么时候应该接收信号，什么时候该结束，这就是我们现在所说的通信“协议”的概念。70年12月制定出来了最初的通信协议由卡恩开发、瑟夫参与的“网络控制协议”（NCP），但要真正建立一个共同的标准很不容易，72年10月国际电脑通信大会结束后，科学家们都在为此而努力。

　　“包切换”理论为网络之间的联接方式提供了理论基础。卡恩在自己研究的基础上，认识到只有深入理解各种操作系统的细节才能建立一种对各种操作系统普适的协议，73年卡恩请瑟夫一起考虑这个协议的各个细节，他们这次合作的结果产生了目前在开放系统下的所有网民和网管人员都在使用的“传输控制协议”（TCP，Transmission-Control Protocol）和“因特网协议”（IP，Internet Protocol）即TCP/IP协议。

　　通俗而言：TCP负责发现传输的问题，一有问题就发出信号，要求重新传输，直到所有数据安全正确地传输到目的地。而IP是给因特网的每一台电脑规定一个地址。1974年12月，卡恩、瑟夫的第一份TCP协议详细说明正式发表。当时美国国防部与三个科学家小组签定了完成TCP/IP的协议，结果由瑟夫领衔的小组捷足先登，首先制定出了通过详细定义的TCP/IP协议标准。当时作了一个试验，将信息包通过点对点的卫星网络，再通过陆地电缆，再通过卫星网络，再由地面传输，贯串欧洲和美国，经过各种电脑系统，全程9.4万公里竟然没有丢失一个数据位，远距离的可靠数据传输证明了TCP/IP协议的成功。

　　1983年1月1日，运行较长时期曾被人们习惯了的NCP被停止使用，TCP/IP协议作为因特网上所有主机间的共同协议，从此以后被作为一种必须遵守的规则被肯定和应用。正是由于TCP/IP协议，才有今天“地球村”因特网的巨大发展。

编辑本段开发过程

　　在构建了阿帕网先驱之后，DARPA开始了其他数据传输技术的研究。NCP诞生后两年，1972年，罗伯特·卡恩（Robert E. Kahn）被DARPA的信息技术处理办公室雇佣，在那里他研究卫星数据包网络和地面无线数据包网络，并且意识到能够在它们之间沟通的价值。在1973年春天，已有的ARPANET网络控制程序（NCP）协议的开发者文顿·瑟夫（Vinton Cerf）加入到卡恩为ARPANET设计下一代协议而开发开放互连模型的工作中。

　　到了1973年夏天，卡恩和瑟夫很快就开发出了一个基本的改进形式，其中网络协议之间的不同通过使用一个公用互联网络协议而隐藏起来，并且可靠性由主机保证而不是像ARPANET那样由网络保证。（瑟夫称赞Hubert Zimmerman和Louis Pouzin（CYCLADES网络的设计者）在这个设计上发挥了重要影响。）

　　由于网络的作用减少到最小的程度，就有可能将任何网络连接到一起，而不用管它们不同的特点，这样就解决了卡恩最初的问题。（一个流行的说法提到瑟夫和卡恩工作的最终产品TCP/IP将在运行“两个罐子和一根弦”上，实际上它已经用在信鸽上。一个称为网关（后来改为路由器以免与网关混淆）的计算机为每个网络提供一个接口并且在它们之间来回传输数据包。

　　这个设计思想更细的形式由瑟夫在斯坦福的网络研究组的1973年–1974年期间开发出来。（处于同一时期的诞生了PARC通用包协议组的施乐PARC早期网络研究工作也有重要的技术影响；人们在两者之间摇摆不定。）

　　DARPA于是与BBN、斯坦福和伦敦大学签署了协议开发不同硬件平台上协议的运行版本。有四个版本被开发出来——TCP v1、TCP v2、在1978年春天分成TCP v3和IP v3的版本，后来就是稳定的TCP/IP v4——目前因特网仍然使用的标准协议。

　　1975年，两个网络之间的TCP/IP通信在斯坦福和伦敦大学（UCL）之间进行了测试。1977年11月，三个网络之间的TCP/IP测试在美国、英国和挪威之间进行。在1978年到1983年间，其他一些TCP/IP原型在多个研究中心之间开发出来。ARPANET完全转换到TCP/IP在1983年1月1日发生。[1]

　　1984年，美国国防部将TCP/IP作为所有计算机网络的标准。1985年，因特网架构理事会举行了一个三天有250家厂商代表参加的关于计算产业使用TCP/IP的工作会议，帮助协议的推广并且引领它日渐增长的商业应用。

　　2005年9月9日卡恩和瑟夫由于他们对于美国文化做出的卓越贡献被授予总统自由勋章。

编辑本段主要协议

　　之所以说TCP/IP是一个协议族，是因为TCP/IP协议包括TCP、IP、UDP、ICMP、RIP、TELNET、FTP、SMTP、ARP、TFTP等许多协议，这些协议一起称为TCP/IP协议。以下是协议族中一些常用协议英文名称和用途：

　　TCP(Transport Control Protocol)传输控制协议

　　IP(Internet Protocol)因特网协议

　　UDP(User Datagram Protocol)用户数据报协议

　　ICMP(Internet Control Message Protocol)互联网控制信息协议

　　SMTP(Simple Mail Transfer Protocol)简单邮件传输协议

　　SNMP(Simple Network manage Protocol)简单网络管理协议

　　FTP(File Transfer Protocol)文件传输协议

　　ARP(Address Resolution Protocol)地址解析协议

　　TCP/IP协议簇分为四层，IP位于协议簇的第二层(对应OSI的第三层)，TCP位于协议簇的第三层(对应OSI的第四层)。

　　TCP和IP是TCP/IP协议簇的中间两层，是整个协议簇的核心，起到了承上启下的作用。

1.IP

　　网际协议IP是TCP/IP的心脏，也是网络层中最重要的协议。

　　IP层接收由更低层（网络接口层例如以太网设备驱动程序）发来的数据包，并把该数据包发送到更高层---TCP或UDP层；相反，IP层也把从TCP或UDP层接收来的数据包传送到更低层。IP数据包是不可靠的，因为IP并没有做任何事情来确认数据包是按顺序发送的或者没有被破坏。IP数据包中含有发送它的主机的地址（源地址）和接收它的主机的地址（目的地址）。

　　高层的TCP和UDP服务在接收数据包时，通常假设包中的源地址是有效的。也可以这样说，IP地址形成了许多服务的认证基础，这些服务相信数据包是从一个有效的主机发送来的。IP确认包含一个选项，叫作IP source routing，可以用来指定一条源地址和目的地址之间的直接路径。对于一些TCP和UDP的服务来说，使用了该选项的IP包好像是从路径上的最后一个系统传递过来的，而不是来自于它的真实地点。这个选项是为了测试而存在的，说明了它可以被用来欺骗系统来进行平常是被禁止的连接。那么，许多依靠IP源地址做确认的服务将产生问题并且会被非法入侵。

2.TCP

　　如果IP数据包中有已经封好的TCP数据包，那么IP将把它们向‘上’传送到TCP层。TCP将包排序并进行错误检查，同时实现虚电路间的连接。TCP数据包中包括序号和确认，所以未按照顺序收到的包可以被排序，而损坏的包可以被重传。

　　TCP将它的信息送到更高层的应用程序，例如Telnet的服务程序和客户程序。应用程序轮流将信息送回TCP层，TCP层便将它们向下传送到IP层，设备驱动程序和物理介质，最后到接收方。

　　面向连接的服务（例如Telnet、FTP、rlogin、X Windows和SMTP）需要高度的可靠性，所以它们使用了TCP。DNS在某些情况下使用TCP（发送和接收域名数据库），但使用UDP传送有关单个主机的信息。

3.UDP

　　UDP与TCP位于同一层，但它不管数据包的顺序、错误或重发。因此，UDP不被应用于那些使用虚电路的面向连接的服务，UDP主要用于那些面向查询---应答的服务，例如NFS。相对于FTP或Telnet，这些服务需要交换的信息量较小。使用UDP的服务包括NTP（网络时间协议）和DNS（DNS也使用TCP）。

　　欺骗UDP包比欺骗TCP包更容易，因为UDP没有建立初始化连接（也可以称为握手）（因为在两个系统间没有虚电路），也就是说，与UDP相关的服务面临着更大的危险。

4.ICMP

　　ICMP与IP位于同一层，它被用来传送IP的的控制信息。它主要是用来提供有关通向目的地址的路径信息。ICMP的‘Redirect’信息通知主机通向其他系统的更准确的路径，而‘Unreachable’信息则指出路径有问题。另外，如果路径不可用了，ICMP可以使TCP连接‘体面地’终止。PING是最常用的基于ICMP的服务。

5. TCP和UDP的端口结构

　　TCP和UDP服务通常有一个客户/服务器的关系，例如，一个Telnet服务进程开始在系统上处于空闲状态，等待着连接。用户使用Telnet客户程序与服务进程建立一个连接。客户程序向服务进程写入信息，服务进程读出信息并发出响应，客户程序读出响应并向用户报告。因而，这个连接是双工的，可以用来进行读写。

　　两个系统间的多重Telnet连接是如何相互确认并协调一致呢？TCP或UDP连接唯一地使用每个信息中的如下四项进行确认：

　　源IP地址 发送包的IP地址。

　　目的IP地址 接收包的IP地址。

　　源端口 源系统上的连接的端口。

　　目的端口 目的系统上的连接的端口。

　　端口是一个软件结构，被客户程序或服务进程用来发送和接收信息。一个端口对应一个16比特的数。服务进程通常使用一个固定的端口，例如，SMTP使用25、Xwindows使用6000。这些端口号是‘广为人知’的，因为在建立与特定的主机或服务的连接时，需要这些地址和目的地址进行通讯。

编辑本段IP地址

　　在Internet上连接的所有计算机，从大型机到微型计算机都是以独立的身份出现，我们称它为主机。为了实现各主机间的通信，每台主机都必须有一个唯一的网络地址。就好像每一个住宅都有唯一的门牌一样，才不至于在传输资料时出现混乱。

　　Internet的网络地址是指连入Internet网络的计算机的地址编号。所以，在Internet网络中，网络地址唯一地标识一台计算机。

　　我们都已经知道，Internet是由几千万台计算机互相连接而成的。而我们要确认网络上的每一台计算机，靠的就是能唯一标识该计算机的网络地址，这个地址就叫做IP（Internet Protocol的简写）地址，即用Internet协议语言表示的地址。

　　目前，在Internet里，IP地址是一个32位的二进制地址，为了便于记忆，将它们分为4组，每组8位，由小数点分开，用四个字节来表示，而且，用点分开的每个字节的数值范围是0~255，如202.116.0.1，这种书写方法叫做点数表示法。

地址分类

　　IP地址可确认网络中的任何一个网络和计算机，而要识别其它网络或其中的计算机，则是根据这些IP地址的分类来确定的。一般将IP地址按节点计算机所在网络规模的大小分为A，B，C三类，默认的网络屏蔽是根据IP地址中的第一个字段确定的。

　　1. A类地址

　　A类地址的表示范围为：1.0.0.1~126.255.255.255，默认网络屏蔽为：255.0.0.0；A类地址分配给规模特别大的网络使用。A类网络用第一组数字表示网络本身的地址，后面三组数字作为连接于网络上的主机的地址。分配给具有大量主机（直接个人用户）而局域网络个数较少的大型网络。例如IBM公司的网络。

　　127.0.0.0到127.255.255.255是保留地址，用做循环测试用的。

　　0.0.0.0到0.255.255.255也是保留地址，用做表示所有的IP地址。

　　一个A类IP地址由1字节（每个字节是8位）的网络地址和3个字节主机地址组成，网络地址的最高位必须是“0”,即第一段数字范围为1～127。每个A类地址理论上可连接16777214<256*256*256-2>台主机（-2是因为主机中要用去一个网络号和一个广播号），Internet有126个可用的A类地址。A类地址适用于有大量主机的大型网络。

　　2. B类地址

　　B类地址的表示范围为：128.0.0.1~191.255.255.255，默认网络屏蔽为：255.255.0.0；B类地址分配给一般的中型网络。B类网络用第一、二组数字表示网络的地址，后面两组数字代表网络上的主机地址。

　　169.254.0.0到169.254.255.255是保留地址。如果你的IP地址是自动获取IP地址，而你在网络上又没有找到可用的DHCP服务器，这时你将会从169.254.0.0到169.254.255.255中临时获得一个IP地址。

　　一个B类IP地址由2个字节的网络地址和2个字节的主机地址组成，网络地址的最高位必须是“10”，即第一段数字范围为128～191。每个B类地址可连接65534(2^16-2, 因为主机号的各位不能同时为0,1)台主机，Internet有16383(2^14-1)个B类地址(因为B类网络地址128.0.0.0是不指派的，而可以指派的最小地址为128.1.0.0[COME06]）。

　　3. C类地址

　　C类地址的表示范围为：192.0.0.1~223.255.255.255，默认网络屏蔽为：255.255.255.0；C类地址分配给小型网络，如一般的局域网，它可连接的主机数量是最少的，采用把所属的用户分为若干的网段进行管理。C类网络用前三组数字表示网络的地址，最后一组数字作为网络上的主机地址。

　　一个C类地址是由3个字节的网络地址和1个字节的主机地址组成，网络地址的最高位必须是“110”，即第一段数字范围为192～223。每个C类地址可连接254台主机，Internet有2097152个C类地址段（32*256*256），有532676608个地址（32*256*256*254）。

　　RFC 1918留出了3块IP地址空间（1个A类地址段，16个B类地址段，256个C类地址段）作为私有的内部使用的地址。在这个范围内的IP地址不能被路由到Internet骨干网上；Internet路由器将丢弃该私有地址。

　　IP地址类别　RFC 1918内部地址范围

　　A类　10.0.0.0到10.255.255.255

　　B类　172.16.0.0到172.31.255.255

　　C类　192.168.0.0到192.168.255.255

　　使用私有地址将网络连至Internet，需要将私有地址转换为公有地址。这个转换过程称为网络地址转换（Network Address Translation，NAT），通常使用路由器来执行NAT转换。

　　实际上，还存在着D类地址和E类地址。但这两类地址用途比较特殊，在这里只是简单介绍一下：

　　D类地址不分网络地址和主机地址，它的第1个字节的前四位固定为1110。 D类地址范围：224.0.0.1到239.255.255.254 。 D类地址用于多点播送。D类地址称为广播地址，供特殊协议向选定的节点发送信息时用。

　　E类地址保留给将来使用。

　　连接到Internet上的每台计算机，不论其IP地址属于哪类都与网络中的其它计算机处于平等地位，因为只有IP地址才是区别计算机的唯一标识。所以，以上IP地址的分类只适用于网络分类。

　　在Internet中，一台计算机可以有一个或多个IP地址，就像一个人可以有多个通信地址一样，但两台或多台计算机却不能共享一个IP地址。如果有两台计算机的IP地址相同，则会引起异常现象，无论哪台计算机都将无法正常工作。

　　顺便提一下几类特殊的IP地址：

　　1. 广播地址 目的端为给定网络上的所有主机，一般主机段为全1

　　2. 单播地址 目的端为指定网络上的单个主机地址

　　3. 组播地址 目的端为同一组内的所有主机地址

　　4. 环回地址 127.0.0.1 在环回测试和广播测试时会使用

网关地址

　　若要使两个完全不同的网络（异构网）连接在一起，一般使用网关，在Internet中两个网络也要通过一台称为网关的计算机实现互联。这台计算机能根据用户通信目标计算机的IP地址，决定是否将用户发出的信息送出本地网络，同时，它还将外界发送给属于本地网络计算机的信息接收过来，它是一个网络与另一个网络相联的通道。为了使TCP/IP协议能够寻址，该通道被赋予一个IP地址，这个IP地址称为网关地址。

编辑本段注意事项

　　内部地址和外部地址在局域网的IP地址分配中，并没有区别，都可以使用。

　　在局域网的IP地址分配中，子网屏蔽的“1”部分只要和对应的IP地址分类规定的前几个二进制数一致即可。

编辑本段子网划分

　　若公司不上Internet,那一定不会烦恼IP地址的问题,因为可以任意使用所有的IP地址,不管是A类或是B类,这个时候不会想到要用子网,但若是上Internet那IP地址便弥足珍贵了,目前全球一阵Internet热,IP地址已经愈来愈少了,而所申请的IP地址目前也趋保守,而且只有经申请的IP地址能在Internet使用,但对某些公司只能申请到一个C类的IP地址,但又有多个点需要使用,那这时便需要使用到子网,这就需要考虑子网的划分，下面简介子网的原理及如何规划。

子网掩码（Subnet Mask）

　　设定任何网络上的任何设备不管是主机、个人电脑、路由器等皆需要设定IP地址,而跟随着IP地址的是所谓的子网掩码（NetMask,Subnet Mask),这个子网掩码主要的目的是由IP地址中也能获得网络编码,也就是说IP地址和子网掩码合作而得到网络编码,如下所示：

　　IP地址

　　192.10.10.6 11000000.00001010.00001010.00000110

　　子网掩码

　　255.255.255.0 11111111.11111111.11111111.00000000

　　AND

　　-------------------------------------------------------------------

　　Network Number

　　192.10.10.0 11000000.00001010.00001010.00000000

　　子网掩码有所谓的默认值,如下所示

　　类 IP地址 范围 子网掩码

　　A　1.0.0.0-126.255.255.255 255.0.0.0

　　B　128.0.0.0-191.255.255.255 255.255.0.0

　　C　192.0.0.0-223.255.255.255 255.255.255.0

　　在预设的子网掩码（Net Mask）都只有255的值,在谈到子网掩码（Subnet Mask）时这个值便不一定是255了。在完整一组C类地址中如203.67.10.0-203.67.10.255 子网掩码255.255.255.0,203.67.10.0称之网络编码（Network Number，将IP 地址和子网掩码作和),而203.67.10.255是广播的IP地址,所以这两者皆不能使用,实际只能使用203.67.10.1--203.67.10.254等254个IP地址,这是以255.255.255.0作子网掩码的结果,而所谓Subnet Msk尚可将整组C类地址分成数组网络编码,这要在子网掩码上作手脚,若是要将整组C类地址分成2个网络编码那子网掩码设定为255.255.255.128,若是要将整组C类分成8组网络编码则子网掩码要为255.255.255.224,这是怎么来的,由以上知道网络编码是由IP地址和子网掩码作AND而来的,而且将子网掩码以二进制表示法知道是1的会保留,而为0的去掉

　　192.10.10.193--11000000.00001010.00001010.11000001

　　255.255.255.0--11111111.11111111.11111111.00000000

　　--------------------------------------------------------------

　　192.10.10.0--11000000.00001010.00001010.00000000

　　以上是以255.255.255.0为子网掩码的结果,网络编码是192.10.10.0,若是使用255.255.255.224作子网掩码结果便有所不同

　　192.10.10.193--11000000.00001010.00001010.11000001

　　255.255.255.224--11111111.11111111.11111111.11100000

　　--------------------------------------------------------------

　　192.10.10.192--11000000.00001010.00001010.11000000

　　此时网络编码变成了192.10.10.192,这便是子网。那要如何决定所使用的子网掩码,255.255.255.224以二进制表示法为11111111.11111111.11111111.11100000,变化是在最后一组,11100000便是224,以三个位（Bit）可表示2的3次方便是8个网络编码

　　子网掩码二进制表示法可分几个网络

　　255.255.255.011111111.11111111.11111111.00000000 1

　　255.255.255.128

　　11111111.11111111.11111111.10000000 2

　　255.255.255.192

　　11111111.11111111.11111111.11000000 4

　　255.255.255.224

　　11111111.11111111.11111111.11100000 8

　　255.255.255.240

　　11111111.11111111.11111111.11110000 16

　　255.255.255.248

　　11111111.11111111.11111111.11111000 32

　　255.255.255.252

　　11111111.11111111.11111111.11111100 64

　　以下使用255.255.255.224将C类地址203.67.10.0分成8组网络编码,各个网络编码及其广播IP地址及可使用之IP地址序号网络编码广播可使用之IP地址

　　（1）203.67.10.0--203.67.10.31

　　203.67.10.1--203.67.10.30

　　（2）203.67.10.32--203.67.10.63

　　203.67.10.33--203.67.10.62

　　（3）203.67.10.64--203.67.10.95

　　203.67.10.65--203.67.10.94

　　（4）203.67.10.96--203.67.10.127

　　203.67.10.97--203.67.10.126

　　（5）203.67.10.128--203.67.10.159

　　203.67.10.129--203.67.10.158

　　（6）203.67.10.160--203.67.10.191

　　203.67.10.161--203.67.10.190

　　（7）203.67.10.192--203.67.10.223

　　203.67.10.193--203.67.10.222

　　（8）203.67.10.224--203.67.10.255

　　203.67.10.225--203.67.10.254

　　可验证所使用的IP地址是否如上表所示

　　203.67.10.115--11001011.01000011.00001010.01110011

　　255.255.255.224--11111111.11111111.11111111.11100000

　　--------------------------------------------------------------

　　203.67.10.96--11001011.01000011.00001010.01100000

　　203.67.10.55--11001011.01000011.00001010.00110111

　　255.255.255.224--11111111.11111111.11111111.11100000

　　--------------------------------------------------------------

　　203.67.10.32--11001011.01000011.00001010.00100000

　　其它的子网掩码所分成的网络编码可自行以上述方法自行推演出来。

子网的应用

　　使用子网是要解决只有一组C类地址但需要数个网络编码的问题,并不是解决IP地址不够用的问题,因为使用子网反而能使用的IP地址会变少,子网通常是使用在跨地域的网络互联之中,两者之间使用路由器连线,同时也上Internet,但只申请到一组C 类IP地址,过路由又需不同的网络,所以此时就必须使用到子网,当然二网络间也可以远程桥接（Remote Bridge，字面翻译）连接,那便没有使用子网的问题。

编辑本段概念区分

协议阐述、IP申请的术语

　　网络地址：在申请IP地址或是阐述TCP/IP协议的IP地址分类时，用到这个术语。它表示IP地址的代码序列中不可更加需要改变的部分。

　　主机地址：在申请IP地址或是阐述TCP/IP协议的IP地址分类时，用到这个术语。它表示IP地址的代码序列中能够更具需要改变的部分。

　　子网屏蔽：在阐述TCP/IP协议的IP地址分类时，用到这个术语。在申请IP地址时，由它表示所申请到的IP地址的网络地址和主机地址。

子网划分、内网搭建的术语

　　网络编码（网络号）：经过子网划分后，子网掩码序列中“1”对应的IP地址部分。一个网络编码，对应一个网域（或网段）。包括申请到的网络地址的全部和主机地址的部分。

　　主机编码（主机号）：经过子网划分后，子网掩码序列中“0”对应的IP地址部分。一个主机编码，对应一个网域（或网段）的一台计算机。包括申请到主机地址的部分。

　　子网掩码：用于子网划分，它将能够改变的主机地址分为主机编码和网络编码的一部分。同时，它将网络地址全部确定为网络编码。

编辑本段协议层级

　　从协议分层模型方面来讲，TCP/IP由四个层次组成：网络接口层、网络层、传输层、应用层。

接口层

　　这是TCP/IP软件的最低层，负责接收IP数据报并通过网络发送之，或者从网络上接收物理帧，抽出IP数据报，交给IP层。

　　常见的接口层协议有：

　　Ethernet 802.3、Token Ring 802.5、X.25、Frame reley、HDLC、PPP ATM 等。

网络层

　　负责相邻计算机之间的通信。其功能包括三方面。

　　一、处理来自传输层的分组发送请求，收到请求后，将分组装入IP数据报，填充报头，选择去往信宿机的路径，然后将数据报发往适当的网络接口。

　　二、处理输入数据报：首先检查其合法性，然后进行寻径--假如该数据报已到达信宿机，则去掉报头，将剩下部分交给适当的传输协议；假如该数据报尚未到达信宿，则转发该数据报。

　　三、处理路径、流控、拥塞等问题。

　　网络层包括：IP(Internet Protocol)协议、ICMP(Internet Control Message Protocol)

　　控制报文协议、ARP(Address Resolution Protocol)地址转换协议、RARP(Reverse ARP)反向地址转换协议。

　　IP是网络层的核心，通过路由选择将下一跳IP封装后交给接口层。IP数据报是无连接服务。

　　ICMP是网络层的补充，可以回送报文。用来检测网络是否通畅。

　　Ping命令就是发送ICMP的echo包，通过回送的echo relay进行网络测试。

　　ARP是正向地址解析协议，通过已知的IP，寻找对应主机的MAC地址。

　　RARP是反向地址解析协议，通过MAC地址确定IP地址。比如无盘工作站和DHCP服务。

传输层

　　提供应用程序间的通信。其功能包括：一、格式化信息流；二、提供可靠传输。为实现后者，传输层协议规定接收端必须发回确认，并且假如分组丢失，必须重新发送。

　　传输层协议主要是：传输控制协议TCP(Transmission Control Protocol)和用户数据报协议UDP(User Datagram rotocol)。

　　TCP是面向连接的通信协议，通过三次握手建立连接，通讯时完成时要拆除连接，由于TCP是面向连接的所以只能用于点对点的通讯。

　　TCP提供的是一种可靠的数据流服务，采用“带重传的肯定确认”技术来实现传输的可靠性。TCP还采用一种称为“滑动窗口”的方式进行流量控制，所谓窗口实际表示接收能力，用以限制发送方的发送速度。

　　UDP是面向无连接的通讯协议，UDP数据包括目的端口号和源端口号信息，由于通讯不需要连接，所以可以实现广播发送。

　　UDP通讯时不需要接收方确认，属于不可靠的传输，可能会出丢包现象，实际应用中要求在程序员编程验证。

应用层

　　向用户提供一组常用的应用程序，比如电子邮件、文件传输访问、远程登录等。远程登录TELNET使用TELNET协议提供在网络其它主机上注册的接口。TELNET会话提供了基于字符的虚拟终端。文件传输访问FTP使用FTP协议来提供网络内机器间的文件拷贝功能。

　　应用层一般是面向用户的服务。如FTP、TELNET、DNS、SMTP、POP3。

　　FTP(File Transmision Protocol)是文件传输协议，一般上传下载用FTP服务，数据端口是20H，控制端口是21H。

　　Telnet服务是用户远程登录服务，使用23H端口，使用明码传送，保密性差、简单方便。

　　DNS(Domain Name Service)是域名解析服务，提供域名到IP地址之间的转换。

　　SMTP(Simple Mail Transfer Protocol)是简单邮件传输协议，用来控制信件的发送、中转。　

　　POP3(Post Office Protocol 3)是邮局协议第3版本，用于接收邮件。

　　数据格式：

　　数据帧：帧头＋IP数据包＋帧尾 (帧头包括源和目标主机MAC地址及类型,帧尾是校验字)

　　IP数据包：IP头部＋TCP数据信息 (IP头包括源和目标主机IP地址、类型、生存期等)

　　TCP数据信息：TCP头部+实际数据 (TCP头包括源和目标主机端口号、顺序号、确认号、校验字等)

编辑本段网络模型

　　TCP/IP协议并不完全符合OSI的七层参考模型。传统的开放式系统互连参考模型，是一种通信协议的7层抽象的参考模型,其中每一层执行某一特定任务。该模型的目的是使各种硬件在相同的层次上相互通信。这7层是:物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。而TCP/IP通讯协议采用了4层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求。

　　

OSI中的层	功能	TCP/IP协议族
应用层	文件传输，电子邮件，文件服务，虚拟终端	TFTP，HTTP，SNMP，FTP，SMTP，DNS，RIP，Telnet
表示层	数据格式化，代码转换，数据加密	没有协议
会话层	解除或建立与别的接点的联系	没有协议
传输层	提供端对端的接口	TCP，UDP
网络层	为数据包选择路由	IP，ICMP，OSPF，BGP，IGMP ，ARP，RARP
数据链路层	传输有地址的帧以及错误检测功能	SLIP，CSLIP，PPP，MTU
物理层	以二进制数据形式在物理媒体上传输数据	ISO2110，IEEE802，IEEE802.2

　　数据链路层包括了硬件接口和协议ARP，RARP，这两个协议主要是用来建立送到物理层上的信息和接收从物理层上传来的信息；

　　网络层中的协议主要有IP，ICMP，IGMP等，由于它包含了IP协议模块，所以它是所有基于TCP/IP协议网络的核心。在网络层中，IP模块完成大部分功能。ICMP和IGMP以及其他支持IP的协议帮助IP完成特定的任务，如传输差错控制信息以及主机/路由器之间的控制电文等。网络层掌管着网络中主机间的信息传输。

　　传输层上的主要协议是TCP和UDP。正如网络层控制着主机之间的数据传递，传输层控制着那些将要进入网络层的数据。两个协议就是它管理这些数据的两种方式：TCP是一个基于连接的协议；UDP则是面向无连接服务的管理方式的协议。

　　TCP/IP模型的主要缺点有：

　　首先，该模型没有清楚地区分哪些是规范、哪些是实现；其次，TCP/IP模型的主机—网络层定义了网络层与数据链路层的接口，并不是常规意义上的一层，和接口层的区别是非常重要的，TCP/IP模型没有将它们区分开来。

编辑本段协议测试

　　全面的测试应包括局域网和互联网两个方面，因此应从局域网和互联网两个方面测试，以下是在实际工作中利用命令行测试TCP/IP配置步骤：

　　1、 单击“开始”/“运行”，输入CMD按回车，打开命令提示符窗口。

　　2、 首先检查IP地址、子网掩码、默认网关、DNS服务器地址是否正确，输入命令ipconfig /all,按回车。此时显示了你的网络配置，观查是否正确。

　　3、 输入ping 127.0.0.1，观查网卡是否能转发数据，如果出现“Request timed out”，表明配置差错或网络有问题。

　　4、 Ping一个互联网地址，如ping 202.102.128.68,看是否有数据包传回，以验证与互联网的连接性。

　　5、 Ping 一个局域网地址，观查与它的连通性。

　　6、 用nslookup测试DNS解析是否正确，输入如nslookup ，查看是否能解析。

　　如果你的计算机通过了全部测试，则说明网络正常，否则网络可能有不同程度的问题。在此不展开详述。不过，要注意，在使用 ping命令时，有些公司会在其主机设置丢弃ICMP数据包，造成你的ping命令无法正常返回数据包，不防换个网站试试。

编辑本段主要特点

　　（1）开放的协议标准，可以免费使用，并且独立于特定的计算机硬件与操作系统；

　　（2）独立于特定的网络硬件，可以运行在局域网、广域网，更适用于互联网中；

　　（3）统一的网络地址分配方案，使得整个TCP/IP设备在网中都具有惟一的地址；

　　（4）标准化的高层协议，可以提供多种可靠的用户服务。

编辑本段协议优势

　　在长期的发展过程中，IP逐渐取代其他网络。这里是一个简单的解释。IP传输通用数据。数据能够用于任何目的，并且能够很轻易地取代以前由专有数据网络传输的数据。下面是一个普通的过程：

　　一个专有的网络开发出来用于特定目的。如果它工作很好，用户将接受它。

　　为了便利提供IP服务，经常用于访问电子邮件或者聊天，通常以某种方式通过专有网络隧道实现。隧道方式最初可能非常没有效率，因为电子邮件和聊天只需要很低的带宽。

　　通过一点点的投资IP 基础设施逐渐在专有数据网络周边出现。

　　用IP取代专有服务的需求出现，经常是一个用户要求。

　　IP替代品过程遍布整个因特网，这使IP替代品比最初的专有网络更加有价值（由于网络效应）。

　　专有网络受到压制。许多用户开始维护使用IP替代品的复制品。

　　IP包的间接开销很小，少于1%，这样在成本上非常有竞争性。人们开发了一种能够将IP带到专有网络上的大部分用户的不昂贵的传输媒介。

　　大多数用户为了削减开销，专有网络被取消。

编辑本段协议重置

　　在Windows XP的网络组件列表里，Internet 协议 (TCP/IP)的"卸载"按钮是灰色不可选状态。这是因为传输控制协议/Internet 协议 (TCP/IP) 堆栈是 Microsoft XP/ 2003 的核心组件(TCP/IP协议是Windows XP的默认协议),不能删除。所以Windows XP不允许卸载TCP/IP协议。如果在特殊情况下需要重新安装TCP/IP协议，如何操作？

　　解决方法

　　在这种情况下，如果需要重新安装 TCP/IP 以使 TCP/^[1]IP 堆栈恢复为原始状态。可以使用 NetShell 实用程序重置 TCP/IP 堆栈，使其恢复到初次安装操作系统时的状态。具体操作如下：

　　1、单击 开始 --> 运行，输入 "CMD" 后单击 "确定";

　　2、在命令行模式输入命令

　　netsh int ip reset C:\resetlog.txt

　　(其中，Resetlog.txt记录命令结果的日志文件，一定要指定，这里指定了Resetlog.txt 日志文件及完整路径。)

　　运行结果可以查看C:\resetlog.txt (咨询中可根据用户实际操作情况提供)

　　运行此命令的结果与删除并重新安装 TCP/IP 协议的效果相同。

　　注意

　　本操作具有一定的风险性，请在操作前备份重要数据，并根据操作熟练度酌情使用。

编辑本段协议缺陷

网络地址不足

　　传统的TCP/IP协议基于IPV4 属于第二代互联网技术，核心技术属于美国。它的最大问题是网络地址资源有限，从理论上讲，编址1600万个网络、40亿台主机。但采用A、B、C三类编址方式后，可用的网络地址和主机地址的数目大打折扣，以至目前的IP地址已经枯竭。其中北美占有3/4，约30亿个，而人口最多的亚洲只有不到4亿个，中国截止2010年6月IPv4地址数量达到2.5亿，落后于4.2亿网民的需求。虽然用动态IP及Nat地址转换等技术实现了一些缓冲，但IPV4地址枯竭已经成为不争的事实。在此，专家提出IPV6的互联网技术，也正在推行，但IPV4的使用过度到IPV6需要很长的一段过度期。

传输能力不足

　　传统的TCP/IP协议基于电话宽带 以及以太网的电器特性而制定的，其分包原则与检验占用了数据包很大的一部分比例造成了传输效率低，现在网络正向着全光纤网络和超高速以太网方向发展，TCP/IP协议不能满足其发展需要。

   写理论的东西或者深入的东西就会太多了，而且让人会看得比较烦，这里讲求实用，就不多说了，直接入正体，基本的排序代码如下：
  package ChineseSort;

import java.util.Collection;

import java.util.Iterator;

import java.util.SortedMap;

import java.util.TreeMap;

public class TestSort {

public static void main(String[] args) {

    // TODO Auto-generated method stub    

    TreeMap map = new TreeMap();      

    for(int i=0; i<10; i++) {

        String  s = ""+(int)(Math.random()*1000);

        map.put(s,s);

    }

    map.put("abcd","abcd");

    map.put("Abc", "Abc");

    map.put("bbb","bbb");

    map.put("BBBB", "BBBB");

    map.put("北京","北京");

    map.put("中国","中国");

    map.put("上海", "上海");

    map.put("厦门", "厦门");

    map.put("香港", "香港");

    map.put("碑海", "碑海");

    Collection col = map.values();

    Iterator it = col.iterator();

    while(it.hasNext()) {

        System.out.println(it.next());

    }

}

}

   代码就不多作解释了，一看就明白，开始放进去10个整数随机数，然后是英文，然后是中文。运行结果如下：

132

205

287

295

399

410

411

464

670

73

Abc

BBBB

abcd

bbb

上海

中国

北京

厦门

碑海

香港

    注意，这里的数字排序正常，而英文排序是区分大小写的，这个也是正常的，因为ASCII码中小写字母比大写字母靠后，中文排序则明显的不正确，碑和北明显应该在一起的，而且应该在最前面。这个主要是java中使用中文编码GB2312或者JBK时，char型转换成int型得过程出现了比较大的偏差，很多文章介绍过了，大家可以去网上找一下，这里不多说了，直接寻找解决方案。

   Java中之所以出现偏差，主要是compare方法的问题，所以这里自己实现Comparator接口，而国际化的问题，使用Collator类来解决。这里先解决中文问题,代码如下：

package ChineseSort;

import java.text.CollationKey;

import java.text.Collator;

import java.util.Comparator;

public class CollatorComparator implements Comparator {

Collator collator = Collator.getInstance();

public int compare(Object element1, Object element2) {

    CollationKey key1 = collator.getCollationKey(element1.toString());

    CollationKey key2 = collator.getCollationKey(element2.toString());

    return key1.compareTo(key2);

}

}

    同时修改我们前面完成的TestSort类，找到TreeMap map = new TreeMap();

    修改为

    CollatorComparator comparator = new CollatorComparator();

    TreeMap map = new TreeMap();

    再次运行该类，运行结果如下：

325

62

653

72

730

757

874

895

909

921

Abc

abcd

bbb

BBBB

碑海

北京

上海

厦门

香港

中国

   此时可以看到中文的排序已经完成正常。如果想不让英文区分大小写，则修改CollatorComparator类，找到

    element1.toString()

    修改为：

    element1.toString().toLowerCase()

    当然你改成转换成大写的也无所谓了，当然element2.toString()也要同时修改为element2.toString().toLowerCase()。再次运行结果如下：

207

353

656

659

770

789

857

861

931

984

Abc

abcd

bbb

BBBB

碑海

北京

上海

厦门

香港

中国

    现在可以看到，排序已经完全符合我们的要求了。如果要反向排序也很容易，遍历的时候倒过来，或者你写两个Comparator的实现类，正向的排序就像我们前面所写的，反向排序就将return key1.compareTo(key2);修改成return -key1.compareTo(key2);，加了个负号，这里你可以直接加个符号看看效果，结果我就不写了，肯定中国是Number One。我还真没找到TreeMap里直接反向的方法，谁看到了告诉我。

    最后一些要说明的，这里我就不再写实现的代码了，就是我们要实现的是根据model中的一个列进行排序，而我们测试代码只是简单的一些值，这个容易，遍历所有model，把要排序的列值取出来作为TreeMap的key，然后model放进去作为value就行了，这个很简单，如果想写成稍微通用点的，就使用反射机制，把取值方法封装一下就行了，然后把model对象和方法名扔进去就行了。至于value值重复的问题，也好办，只要value相同只要不是多列同时作为排序的键，那么他们之间的前后顺序无所谓，判断一下当前Map中是否含有该key值，存在，则新的key做成value+longtime就行了，就是加个时间戳（感觉用时间戳比较方便，其它的能区分的办法也行啦）。至于多列的排序，其实也容易，按照列的前后顺序firstvalue+secondvalue+......组成key放到TreeMap里照样OK J 方便吧。

• 首次被JSTL 1.0引入的EL现在被合并到JSP规范中，就像应用template text一样地使用所有的标准的和定制的组件。
• 新的EL已经被扩展，具备一个函数调用机制，JSTL1.1整合了一系列经常需要使用的函数。
• 新增加的变量和servlet 规范定义的错误处理机制被更好地组织起来。通过新增加的变量，JSP error pages 现在可以提供更多的错误信息。
• 容器因为更加严格的语法检查可以更容易地找出发生的错误。
• 所有的J2EE 1.4规范（包括JSP 2.0 和 Servlet 2.4），为了声明部署的规则描述而应用了XML schema。这样的好处之一是你现在可以通过任何顺序列出web.xml文件中的描述。JSP 2.0也增加了一些新的配置选项用于部署描述，允许通过全局的配置来代替基于每页的配置。
• 由于更具伸缩性的规则和新的自定义action element，现在就像编写XML文件一样，编写JSP页面变得更加容易。
• 定制的标签库现在可以开发成一系列的标签文件（具有JSP元素的文本文件），标签处理器可以使用新的、简化的标签处理器的API。与此同时，新规范加入了一些新的特性，比如：支持在jsp页面上显示动态属性列表和可执行片断属性。

在众多的书籍中，这是头一个讲解JSP 2.0新特性的文章。在这一部分，我们将看到和EL相关的信息，其他的新特性留到后面。在这里我假定读者已经熟悉JSP 1.2，而且至少听说过JSTL。

你可能对这本第三版的《JavaServer Pages》感兴趣。这本书中，我尽可能在细节上讲述所有的内容，而且并不认为你对JSP或者JSTL了解一切。这本书预计在2003年12月 出版，但是你现在可以在http://www.amazon.com、Barnes&Noble，或者其他在线书店预订。

EL(The Expression Language)

如果过去使用过JSTL，那么你可能已经熟悉 了EL。EL在JSTL 1.0规范中被引入，用来在运行期间对Java表达式中action element属性赋值提供另一种选择。当JSTL EL已经非常迅速的流行起来情况下，还是存在一个问题： JSTL EL 表达式仅仅可以与JSTL和custom action一起使用，怎样才能使用非标准API对EL表达式求值？

JSP 2.0中,JSP容器自己可以理解EL表达式。这使你在所有过去只能应用Java表达式的地方应用EL表达式成为可能，比如：标准和定制action的属性值，模板文本。

在我们看具体的例子前，让我们更进一步的看看 什么是EL。EL是从JavaScript中获得启发的一种语言，XPath(一种用来访问XML文档的语言)，但是EL在对变量的null值和执行更多 数据类型的自动类型转换的处理上更加宽松。这些新特性对于web应用非常重要，在这些应用中输入通常通过html表单的request parameter来得到。这些参数可能仅仅在某些请求下才能体现出来，而且浏览器经常将request parameter作为文本发送，然而应用程序经常需要把他们作为数字类型、布尔类型（true 或者 false）来使用。通过EL，你根本就很少需要关心缺少某些参数的值或者类型转换。

一个EL表达式包含变量和操作符。任何存储在某个JSP作用范围(如：page、 request、session、application)的bean能被作为一个EL变量来使用。另外，EL支持以下预定义的变量：

操作符描述了你对变量所期望的操作。如果你之前曾经使用过任何编程语言的话，在EL表达式中所使用的操作符对你来说可能看起来很熟悉。因为它们和那些在大多数语言中所支持的操作符一样。

一个EL表达式可以包含：数字、文本（在单引号或者双引号之间）、布尔值、null值。

因为一个EL表达式可以出现在静态文本出现的 地方，因此你必须告诉JSP容器它应该被当作一个EL表达式来处理。你可以通过使用定界符来做到这一点。一个EL表达式总是以”${ }”来标记（一个“$”符号和一个左花括号,右花括号）。这里有一个EL表达式，它将一个命名为amount的变量加5：

${amount + 5}

如果你想要将5加到一个bean的property上，可以使用property访问操作符：

${order.amount + 5}

在当前这个指定的bean或者collection集合中，Property访问操作符（一个“.“符号）告诉EL去寻找名字为amount的property。

${order['amount'] + 5}

在[]之间的值必须是一个property的名字（就像上面的例子中那样）或者是一个保存property名字的变量（或者是一个完整的EL子表达式）。

EL表达式可以被用来赋值给任何标准的或者定制的JSP行为属性（action attribute），这些行为属性被标记为可以接受动态值（或者请求期间的属性值，就象它被正式调用一样）：

<c:out value=”${order.amount + 5}”/>

在JSP 2.0之前，你不得不使用Java表达式去给一个属性动态赋值。在过去的很多年中，这已经成为语法混乱的一个普遍根源。

最后，EL表达式可以在页面中和模板直接混合使用。当你生成HTML并且需要设置一个动态值给一个属性的时候，这非常方便：

<input name=”firstName” value=”${customer.firstName}”>

JSP 1.2中，你不得不使用JSTL的<c:out>来实现同样的事情，最后把各种不同类型的元素混合起来，这导致程序理解起来非常的困难：

<input name=”firstName”

value=”<c:out value=”${customer.firstName}”/>” >

新JSTL 1.1 Tag Library 标识符

JSTL1.1发布的是一个初级的版本，主要 目的是用来整合JSTL和JSP2.0 。最明显的变化是JSTL1.0 “孪生函数库”（一组库用来接受EL表达式，另外一组用来接受JAVA表达式），而它们已经被一组既可以用于EL表达式也可以用于JAVA表达式的函数库 所代替。

在JSTL 1.1中使用以下标识符:

如果你曾经使用过JSTL1.0，你可能会注意到新的标识符和旧的EL库标试符一模一样，除了加入了“/jsp path” element。你也可能注意到在JSTL1.1中有一个库，包含了EL的函数。我们稍后就会看到。

一个新的EL操作符

在JSP页面中一个非常普遍的需求就是：当某 个条件为真时，要在网页中包含一些文字。在JSP1.2和JSTL1.1中，用具有代表性的<c:if>来实现，但是这样做非常繁琐。 JSP2.0增加了一个新的条件操作符用于EL，以更加优雅的方式来处理这样的情况。这个条件操作符存在于很多编程语言中（比 如：Java,C,JavaScript）,因此你可能以前就见过它。它判断一个布尔的条件，当条件为真或者假时，分别取不同的结果。

一个能清楚说明它如何工作的例子：

<select name=”artist”>

<option value=”1″ ${param.artist == 1 ? ‘selected’ : ”}>

Vesica Pisces

<option value=”2″ ${param.artist == 2 ? ‘selected’ : ”}>

Cortical Control

<option value=”3″ ${param.artist == 3 ? ‘selected’ : ”}>

Vida Vierra

</select>

在这里，我使用了EL表达式和条件操作符来选 择是否包含 html 中的 “selected”属性，只有符合条件的 “option” 才被添加 “selected” 属性。如果条件（param.artist==1）为真时，前面的“selected” 才被添加到网页中；否则就添加后面的（在这里是空字符串 ‘’）到页面中。

EL函数

当EL从JSTL规范中移到JSP规范中，它使用了一个如何进行函数调用的技巧。这个EL函数语法非常简单：方法名，紧接着在圆括号中有一组参数：<%@ taglib prefix=”fn”

uri=”http://java.sun.com/jsp/jstl/functions” %>

${fn:length(myCollection)}

这是一个属于标签库中的函数,并且函数名字在页面中所包含的前缀要指定taglib库。在这个例子中，我使用了前缀fn,这是JSTL function库默认的前缀。

标签库描述符（Tag Library Descriptor,TLD）将函数名称映射到一个由JAVA实现的静态方法中：<function>

<description>

Returns the number of items in a collection or the number of characters in a string.

</description>

<name>length</name>

<function-class>

org.apache.taglibs.standard.functions.Functions

</function-class>

<function-signature>

int length(java.lang.Object)

</function-signature>

</function>

在这里最有趣的element 是<function-signature>。它包含一个函数返回类型的声明，静态的方法的名字，在圆括号中声明该方法所有参数的类型（可以 没有参数或者有多个，参数间用逗号间隔开）。返回值类型和参数类型必须是java的原始类型（Object）或者是其他合法类型。

这个静态方法 length()在Jakarta Taglibs标准库中用类似于下面的代码实现的：

1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            17
            18
            19
            20
            21
            22
            23
            24
            25
            26
            27
            28
            29
            30
            31
            32
            33
            34
            35
            36
            37
            38
            39
            40
            41
            42
            43
            44
            45
            46
            47
            48
            49
            50
            51
            52
            53
            54
            55
            56
            57
            58
            59
            60
            61
            62
            63
            64
            65
            66
            67
            68
            69
            

public static int length(Object obj)
             
            throws JspTagException {
             
            if (obj == null)
             
            return 0;
             
            if (obj instanceof String)
             
            return ((String)obj).length();
             
            if (obj instanceof Collection)
             
            return ((Collection)obj).size();
             
            if (obj instanceof Map)
             
            return ((Map)obj).size();
             
            int count = 0;
             
            if (obj instanceof Iterator) {
             
            Iterator iter = (Iterator) obj;
             
            count = 0;
             
            while (iter.hasNext()) {
             
            count++;
             
            iter.next();
             
            }
             
            return count;
             
            }
             
            if (obj instanceof Enumeration) {
             
            Enumeration enum = (Enumeration) obj;
             
            count = 0;
             
            while (enum.hasMoreElements()) {
             
            count++;
             
            enum.nextElement();
             
            }
             
            return count;
             
            }
             
            try {
             
            count = Array.getLength(obj);
             
            return count;
             
            } catch (IllegalArgumentException ex) {}
             
            throw new JspTagException("Unsupported type"));
             
            }

就像你所看到的，在那里没有什么出奇的地方。它是一个常规的静态方法，这个函数中通过对运行期中的参数类别的判断，找出参数的长度。

除了在这个方法中使用的length()方法，JSTL1.1标签库还包含了许多其它经常使用的函数：

在JSP中使用标签是很平常的事情，在制作自定义变迁时，通常都需要写tld文件来定义变迁的各种属性，对应的java类，前缀等等。标签与tld文件紧紧相连，那么，到底应该怎么放置tld文件？在web.xml中怎么定义tld文件的位置？

以下是具体的分析

Ø  Taglib的使用：

首先是在头部申明taglib, uri必须是web.xml定义的，或者是原始tld文件定义的。

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>

<%@ taglib prefix="ex" uri="/jstl-examples-taglib" %>

然后便可以在jsp页面中通过prefix使用相应的标签

<c:import varReader="reader" url="${filepath}">

  <ex:escapeHtml reader="${reader}"/>

</c:import>

Ø  Uri与tld文件的映射关系

JSP文件中使用的标签通常都有一个tld定义文件(标签库定义文件，主要定义标签对应的java类，标签的属性等等信息)与之对应的,web容器需要找到相应的tld文件，以tld文件中定义的内容判断标签的使用是否正确。

Web做【使用正确性】判断处理，当遇到类似【<c:import】这样的标签时，会通过prefix定位到uri，再根据uri定位到相应的tld文件，对tld文件进行解析。其中urißàtld文件的映射关系如下：

Key

（Uri）
 Value

（String[] taglib_tld_location）
 
Taglib-URI：

(如/jstl-examples-taglib、http://java.sun.com/jstl/core等)
 taglib_tld_location[0]
 
taglib_tld_location[1]
 

本文主要介绍的便是uri到tld的映射

Ø  Tld文件路径定义方式

如下方式1和方式2只能在2.3版本使用，Servlet2.4开始便不能在web.xml中定义taglib了。

<!DOCTYPE web-app

    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

    "http://java.sun.com/dtd/web-app_2_3.dtd">

l  方式1：

如下所示，在web.xml中定义

    <taglib>

        <taglib-uri>/jstl-examples-taglib</taglib-uri>

        <taglib-location>/WEB-INF/lib/jstl-examples.tld</taglib-location>

</taglib>

如果这样定义的话，映射关系便如下：

/jstl-examples-taglibßà{“/WEB-INF/lib/jstl-examples.tld”,””} // taglib_tld_location[0]就足以表示tld路径，因此taglib_tld_location[1]为空。

l  方式2：

如下所示，在web.xml中定义

    <taglib>

        <taglib-uri>/jstl-examples-taglib</taglib-uri>

        <taglib-location>/WEB-INF/lib/ jstl-examples.jar</taglib-location>

</taglib>

如果这样定义的话，映射关系便如下：

/jstl-examples-taglibßà{“/WEB-INF/lib/ jstl-examples.jar”,” META-INF/taglib.tld”}

 // taglib_tld_location[0]表示jar路径，taglib_tld_location[1]固定为META-INF/taglib.tld(也就是说，tld在jar文件中的保存路径必须是META-INF/taglib.tld，名称必须是taglib.tld)。这就是说一个jar里只能有一个tld。如果代码中不固定为taglib.tld的话，也很难处理，因为如果tld的名称可以随便定义的话，出现多个tld在jar文件中时将会导致混乱。

l  方式3：

不需要在web.xml中定义，只需要把tld保存在web应用能够使用的jar文件中的META-INF路径下便可。这种情况的机制是这样的：web容器会遍历当前web应用能够访问的jar文件，从jar文件中查找META-INF/xxx.tld文件，当找到一个tld文件之后，便会解析tld文件，取出<taglib>节点的<uri>值，把uri作为key值生成映射关系。

如下所示的jstl的core标签库的tld文件，便会有如下的映射关系

http://java.sun.com/jstl/coreßà{“tld文件所在的jar文件的路径”,” META-INF/xxx.tld”}//taglib_tld_location[0]表示jar路径，taglib_tld_location[1]为所搜到的tld在jar文件中的相对路径

……

<taglib>

  <tlib-version>1.0</tlib-version>

  <jsp-version>1.2</jsp-version>

  <short-name>c</short-name>

  <uri>http://java.sun.com/jstl/core</uri>

  <display-name>JSTL core</display-name>

  <description>JSTL 1.0 core library</description>

……

  <tag>

    <name>catch</name>

    <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>

    <body-content>JSP</body-content>

    <description>

        Catches any Throwable that occurs in its body and optionally

        exposes it.

    </description>

    <attribute>

        <name>var</name>

        <required>false</required>

        <rtexprvalue>false</rtexprvalue>

    </attribute>

  </tag>

……

Ø  Tld文件的解析逻辑

以jstl为例：

Web容器遇到类似【<c:import】标签时，就会通过在头部中定义的<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>找到uri，再根据此uri便可以定位到taglib_tld_location。当taglib_tld_location[0]不是jar文件时，便直接使用java的FileInputStream读取tld文件；当taglib_tld_location[0]是jar文件时，则会

通过如下代码读取tld文件。

URL jarFileUrl = new URL("jar:" + location[0] + "!/");

ZipEntry jarEntry = jarFile.getEntry(location[1]);

Ø  总结：

Tld的定义可以不在web.xml中定义，这时需要保证tld在web应用能够访问的jar中，并且保存在jar的META-INF目录下。此时JSP直接使用tld中定义的<uri>便可；

如果在web.xml中定义tld的路径的话，可以直接指定tld文件路径，此时要保证tld不在jar包中(比如在WEB-INF目录下)；也可以指定为jar文件路径，此时要保证tld在jar中且路径为META-INF/taglib.tld。

以前用WSAD wizard做的，都可以在JSP页面中解析到EL表达式，当然前提是JSP2.0的情况下。
今天遇到了一个莫名其妙的问题。刚下载Eclipse3.3+MyEclipse6.0体验的过程中，遇上了解析不到EL表达式的问题。经过好几个小时的琢磨终于发现了，给大家share一下：
问题就出在建Web Project的时候web.xml声明上。
web.xml声明部分一般分为如下版本的xsd,
web-app_2_2.xsd
web-app_2_3.xsd
web-app_2_4.xsd
web-app_2_5.xsd

更详细的列出各版本web.xml声明部分吧，如下：
web-app_2_2.xsd

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN" "http://java.sun.com/dtd/web-app_2_2.dtd">

web-app_2_3.xsd

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">

web-app_2_4.xsd

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee  http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

web-app_2_5.xsd

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


确定web.xml里的xsd版本之后一定要在JSP的声明(<%@page %>)部分加一行，如下：
<%@ page isELIgnored="false" %>
这样设为false才能解析EL表达式。
经过各版本的test之后....
注意!! 其中servlets 2.4(我没记错的话JSP 2.0出来之后的第一个版本)，这个版本的isELIgnored默认设置为false。所以使用web.xml里用web-app_2_4.xsd声明的时候在JSP页面不用特意声明。

下面是官方Documention中isELIgnored Attribute的详解：
The isELIgnored Attribute
• Format
– <%@ page isELIgnored="false" %>
– <%@ page isELIgnored="true" %>
Purpose
– To control whether the JSP 2.0 Expression Language
(EL) is ignored (true) or evaluated normally (false).
• Notes
– If your web.xml specifies servlets 2.3 (corresponding to
JSP 1.2) or earlier, the default is true
• But it is still legal to change the default—you are permitted
to use this attribute in a JSP-2.0-compliant server
regardless of the web.xml version.
– If your web.xml specifies servlets 2.4 (corresponding to
JSP 2.0) or earlier, the default is false

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/qingkangxu/archive/2010/12/05/6057034.aspx

要搭建整个流程需要四个阶段：

一、建立测试用数据库
        我们这里用Mysql进行测试，其他数据库完全一样。
    1、创建用户表
            CREATE TABLE users (
                  id int(11) NOT NULL auto_increment,
                    username varchar(20) NOT NULL,
                    password varchar(20) NOT NULL,
                    PRIMARY KEY  (id)
               )

    2、创建权限表（此事例中用不到）
           CREATE TABLE roles(
                    id int(11) NOT NULL auto_increment,
                    rolename varchar(20) NOT NULL,
                    PRIMARY KEY  (id)
               )
               
    3、创建用户－权限对应表
       CREATE TABLE user_roles (
          id int(11) NOT NULL auto_increment,
          username varchar(20) NOT NULL,
          rolename varchar(20) NOT NULL,
          PRIMARY KEY  (id)
        )
        
    4、插入数据
       insert into users(username,password) values('zhangdongyu', 'loveyuanyuan')
       insert into roles(rolename) values('manager')
       insert into user_roles(username,rolename) values('zhangdongyu', 'manager')
       
二、修改${tomcat}\conf\server.xml
  找到
   <!--
      <Realm className="org.apache.catalina.realm.MemoryRealm" />
      -->
     
    在上面这句话下面添加一下内容：
    <Realm
      className="org.apache.catalina.realm.JDBCRealm"
      debug="99"
      driverName="org.gjt.mm.mysql.Driver"
      connectionURL="jdbc:mysql://localhost/weblogin" <!--数据库连接地址-->
      connectionName="root"              <!--数据库用户名-->
           connectionPassword="123"            <!--数据库密码-->
          userTable="users"                <!--用户表-->
           userNameCol="username"              <!--用户名列-->
           userCredCol="password"             <!--密码列-->  
           userRoleTable="user_roles"            <!--用户权限对应表-->
           roleNameCol="rolename"              <!--权限列-->
    />   

三、创建工程
  在Eclipse创建一个web工程sercurityTest，在WebRoot下面创建一个文件夹admin(也可在里面建立几个文件)

  在web.xml文件中添加以下片段：
    <security-constraint>
      <web-resource-collection>
       <web-resource-name>Web Demo</web-resource-name>
       <url-pattern>/admin/*</url-pattern>
      </web-resource-collection>
      <auth-constraint>
       <role-name>manager</role-name>
      </auth-constraint>
     </security-constraint>
    <login-config>
      <auth-method>BASIC</auth-method>
      <realm-name>Web Demo</realm-name>
    </login-config>

四、重启Tomcat，使设置生效

总结测试：
  通过上面的四部分配置，当你再次访问程序中受保护的地址，如:http://localhost/sercurityTest/admin时
  会弹出验证对话框，让你输入用户名和密码，只有输入库中的用户名密码并且该用户有manager权限时才能进
  入受保护目录。

Heap = {Old + NEW = { Eden , from, to } }
具体可查看javavisualvm

JVM内存模型中分两大块，一块是 NEW Generation, 另一块是Old Generation. 在New Generation中，有一个叫Eden的空间，主要是用来存放新生的对象，还有两个Survivor Spaces（from,to）, 它们用来存放每次垃圾回收后存活下来的对象。在Old Generation中，主要存放应用程序中生命周期长的内存对象，还有个Permanent Generation，主要用来放JVM自己的反射对象，比如类对象和方法对象等。
 

垃圾回收描述：

在New Generation块中，垃圾回收一般用Copying的算法，速度快。每次GC的时候，存活下来的对象首先由Eden拷贝到某个Survivor Space, 当Survivor Space空间满了后, 剩下的live对象就被直接拷贝到Old Generation中去。因此，每次GC后，Eden内存块会被清空。在Old Generation块中，垃圾回收一般用mark-compact的算法，速度慢些，但减少内存要求.
垃圾回收分多级，0级为全部(Full)的垃圾回收，会回收OLD段中的垃圾；1级或以上为部分垃圾回收，只会回收NEW中的垃圾，内存溢出通常发生于OLD段或Perm段垃圾回收后，仍然无内存空间容纳新的Java对象的情况。

当一个URL被访问时，内存申请过程如下：
A. JVM会试图为相关Java对象在Eden中初始化一块内存区域
B. 当Eden空间足够时，内存申请结束。否则到下一步
C. JVM试图释放在Eden中所有不活跃的对象（这属于1或更高级的垃圾回收）, 释放后若Eden空间仍然不足以放入新对象，则试图将部分Eden中活跃对象放入Survivor区
D. Survivor区被用来作为Eden及OLD的中间交换区域，当OLD区空间足够时，Survivor区的对象会被移到Old区，否则会被保留在Survivor区
E. 当OLD区空间不够时，JVM会在OLD区进行完全的垃圾收集（0级）
F. 完全垃圾收集后，若Survivor及OLD区仍然无法存放从Eden复制过来的部分对象，导致JVM无法在Eden区为新对象创建内存区域，则出现”out of memory错误”

JVM调优建议:

ms/mx：定义YOUNG+OLD段的总尺寸，ms为JVM启动时YOUNG+OLD的内存大小；mx为最大可占用的YOUNG+OLD内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
NewSize/MaxNewSize：定义YOUNG段的尺寸，NewSize为JVM启动时YOUNG的内存大小；MaxNewSize为最大可占用的YOUNG内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
PermSize/MaxPermSize：定义Perm段的尺寸，PermSize为JVM启动时Perm的内存大小；MaxPermSize为最大可占用的Perm内存大小。在用户生产环境上一般将这两个值设为相同，以减少运行期间系统在内存申请上所花的开销。
SurvivorRatio：设置Survivor空间和Eden空间的比例

内存溢出的可能性

1. OLD段溢出
这种内存溢出是最常见的情况之一，产生的原因可能是：
1) 设置的内存参数过小(ms/mx, NewSize/MaxNewSize)
2) 程序问题
单个程序持续进行消耗内存的处理，如循环几千次的字符串处理，对字符串处理应建议使用StringBuffer。此时不会报内存溢出错，却会使系统持续垃圾收集，无法处理其它请求，相关问题程序可通过Thread Dump获取（见系统问题诊断一章）单个程序所申请内存过大，有的程序会申请几十乃至几百兆内存，此时JVM也会因无法申请到资源而出现内存溢出，对此首先要找到相关功能，然后交予程序员修改，要找到相关程序，必须在Apache日志中寻找。
当Java对象使用完毕后，其所引用的对象却没有销毁，使得JVM认为他还是活跃的对象而不进行回收，这样累计占用了大量内存而无法释放。由于目前市面上还没有对系统影响小的内存分析工具，故此时只能和程序员一起定位。

2. Perm段溢出
通常由于Perm段装载了大量的Servlet类而导致溢出，目前的解决办法：
1) 将PermSize扩大，一般256M能够满足要求
2) 若别无选择，则只能将servlet的路径加到CLASSPATH中，但一般不建议这么处理

3. C Heap溢出
系统对C Heap没有限制，故C Heap发生问题时，Java进程所占内存会持续增长，直到占用所有可用系统内存

其他：

JVM有2个GC线程。第一个线程负责回收Heap的Young区。第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区。Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。

为什么一些程序频繁发生GC？有如下原因：
l         程序内调用了System.gc()或Runtime.gc()。
l         一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。
l         Java的Heap太小，一般默认的Heap值都很小。
l         频繁实例化对象，Release对象。此时尽量保存并重用对象，例如使用StringBuffer()和String()。
如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态。许多Server端的Java程序每次GC后最好能有65%的剩余空间。
经验之谈：
1．Server端JVM最好将-Xms和-Xmx设为相同值。为了优化GC，最好让-Xmn值约等于-Xmx的1/3[2]。
2．一个GUI程序最好是每10到20秒间运行一次GC，每次在半秒之内完成[2]。
注意：
1．增加Heap的大小虽然会降低GC的频率，但也增加了每次GC的时间。并且GC运行时，所有的用户线程将暂停，也就是GC期间，Java应用程序不做任何工作。
2．Heap大小并不决定进程的内存使用量。进程的内存使用量要大于-Xmx定义的值，因为Java为其他任务分配内存，例如每个线程的Stack等。
2．Stack的设定
每个线程都有他自己的Stack。

-Xss 每个线程的Stack大小

Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。
3．硬件环境
硬件环境也影响GC的效率，例如机器的种类，内存，swap空间，和CPU的数量。
如果你的程序需要频繁创建很多transient对象，会导致JVM频繁GC。这种情况你可以增加机器的内存，来减少Swap空间的使用[2]。
4．4种GC
第一种为单线程GC，也是默认的GC。，该GC适用于单CPU机器。
第二种为Throughput GC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。
第三种为Concurrent Low Pause GC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。
第四种为Incremental Low Pause GC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。

    所谓PhraseQuery，就是通过短语来检索，比如我想查“big car”这个短语，那么如果待匹配的document的指定项里包含了"big car"这个短语，这个document就算匹配成功。可如果待匹配的句子里包含的是“big black car”，那么就无法匹配成功了，如果也想让这个匹配，就需要设定slop，先给出slop的概念：slop是指两个项的位置之间允许的最大间隔距离，下面我举例来解释：

   我的待匹配的句子是：the quick brown fox jumped over the lazy dog.

   例1： 如果我想用“quick fox”来匹配出上面的句子，我发现原句里是quick [brown] fox，就是说和我的“quick fox”中间相差了一个单词的距离，所以，我这里把slop设为1，表示quick和fox这两项之间最大可以允许有一个单词的间隔，这样所有“quick [***] fox”就都可以被匹配出来了。

   例2：如果我想用“fox quick”来匹配出上面的句子，这也是可以的，不过比例1要麻烦，我们需要看把“fox quick”怎么移动能形成“quick [***] fox”，如下表所示，把fox向右移动3次即可：

    例3：如果我想用“lazy jumped quick”该如何匹配上面的句子呢？这个比例2还要麻烦，我们要考虑3个单词，不管多少个单词，slop表示的是间隔的最大距离，详细起见，我们分别来看每种组合：(我的待匹配的句子是：the quick brown fox jumped over the lazy dog.)

• lazy jumped:原句是jumped [over] [the] lazy，就是说它们两个之间间隔了2个词,如下所示：需要把lazy向右移动4位

•   lazy jumped quick：我们主要看lazy和quick，但是由于jumped是在中间，所以移动的时候还是要把jumped考虑在内，原句里lazy和quick的关系是：quick [brown] [fox] [jumped] [over] [the] lazy ，quick lazy中间间隔了5个词，所以如下图所示，把lazy向右移动8次

•  最后是jumped qucik，这里不详细画表格了，大家可以自己试试，应该是把jumped向右移动4次。

   综合以上3种情况，所以我们需要把slop设为8才令“lazy jumped quick”可以匹配到原句。