管理插件

什么是插件？为什么我需要关心插件？

插件（plug-in，也称为 bundle）是 Eclipse 的功能块。在 Eclipse 中，所有的一切都有其相应的插件，这包括：

• 透视图和视图
• 编辑器
• 建模工具
• 登录和其他核心功能

事实上，整个 Eclipse IDE 就是被构建为一个大的插件集合。其他基于 Eclipse 的产品，例如 IBM Rational® Software Architect，通过添加新插件增强了基本的 Eclipse。

一组相关的插件组成特性。特性和它们的插件存在于 Eclipse 程序目录中（在这个例子中，Eclipse 被安装在 /opt/eclipse 目录中）。下面是目录布局的一个示例：

/opt/eclipse/ 
   features/ 
      org.eclipse.jdt_3.1.1/
         feature.xml 
         ... 
   plugins/
      org.eclipse.jdt.ui_3.1.1.jar
      ...
      

Eclipse 可以有许多相同的插件，针对每个不同的版本有一个这样的插件。它知道如何解决插件依赖性、避免版本冲突，因此您永远不必担心同时安装两个 Subclipse 插件。

在长期使用 Eclipse 的过程中，您总是会通过下载第三方插件或是创建您自己的插件来增加新的功能。跨不同的 Eclipse 版本管理这些插件可能是个麻烦。因为插件存在于 Eclipse 程序目录中，所以如果您安装 Eclipse 的新版本，它们就会丢失。这意味着如果您有多个 Eclipse 安装，就必须保存大量插件的多个副本；甚至，在每次想要升级 Eclipse 时，您只能很麻烦地全部重新安装。

如果将插件存储于 Eclipse 程序目录以外的独立位置，当升级到 Eclipse 的新版本时，就不需要重新安装它们，而且，可以跨多个 Eclipse 版本共享插件。

实施控制：方法 1 —— 手动的文件系统扩展

有三种方法对插件实施控制。第一种方法是手动创建一个可以保存插件的目录（称之为产品扩展），将插件移到该目录，然后告诉 Eclipse 在这里寻找特性和插件。

在我们的例子中，我们会创建一个名为 /opt/eclipse-plugins 的位置用来存储插件。为了让 Eclipse 在这里存储插件，您必须首先创建如下的目录结构和文件：

/opt/eclipse-plugins/ 
   eclipse/ 
      .eclipseextension
      features/ 
      plugins/
      

注意，除了创建这些目录以外，您还必须在 eclipse 目录（在我们的例子中，是指 /opt/eclipse-plugins/eclipse）中创建一个名为 .eclipseextension 的文件。这个文件让 Eclipse 知道在这里可以找到扩展。它应该有如下内容：

id=org.eclipse.platform name=Eclipse Platform
version=3.1.1

.eclipseextension 文件中的 version 属性应该设置为使用这个产品扩展的 Eclipse 的版本。该属性可以是特定的（3.1.1）、比较一般的（3.0.0）或者非常一般的（1.0.0）。在撰写本文时，版本号似乎对产品扩展的功能并没有任何影响。

注意，如果您使用的是 Windows®，则无法通过 Explorer shell 创建 .eclipseextension 文件。通过打开 NotePad，输入文件的内容，并将其保存为 .eclipseextension（确保文件类型选中为 “所有文件”，否则 Notepad 将会在文件名后添加 .txt），可以创建这样的文件。

下一件事是将这个插件位置告诉 Eclipse，以便它知道以后在这里寻找插件。选择 Help > Software Updates > Manager Configuration 得到 Product Configuration Manager，在这里完成这项工作。

使用 Product Configuration Manager，您可以添加新的 Eclipse 扩展。为了启用上面创建的扩展（/opt/eclipse-plugins），我们需要将它作为一个扩展位置添加。每一个人都已经有一个扩展位置，那就是 Eclipse 安装中的插件文件夹。在 Eclipse Platform 上右击，选择 Add > Extension Location 就可以添加另一个扩展。

一旦您已经选中了插件所在的目录，插件就会显示在产品扩展的列表中。在这里，您可以检验插件是否已找到。

Product Configuration 屏幕好的方面是，您可以很容易地禁用整个插件位置 —— 这在进行插件开发和测试不同配置时很有用。

实施控制：方法 2 —— 通过 Configuration Manager 添加产品扩展

不必在文件系统中创建文件夹和 .eclipseextension 文件，您可以让 Eclipse 为您创建产品扩展。

您可以在 Update Manager（Help > Software Updates > Find and Install）中创建新的产品扩展。在安装新的插件时，Eclipse 最终会提示您所要安装的位置。在这里，您可以单击 Change Location 以选择一个产品扩展。

选择 Add Location。当您选定一个目录时，Eclipse 将在那里为您创建一个产品扩展。

当您以后安装插件时，确保它们是被安装到您所想要的插件扩展地点（参见图 3 中的 Install Location 区域）

实施控制：方法 3 —— 创建管理产品扩展的 links 文件夹

如果在您的文件系统中已经有了产品扩展，例如我们在 方法 1 中创建的那个，那么您可以在 Eclipse 程序目录中创建一些简单的文件，告知 Eclipse 需要检查这些目录以寻找插件。

首先，在 Eclipse 安装文件夹（例如 /opt/eclipse）中创建一个名为 links 的目录。在这个目录中，您可以创建 *.link 文件（例如 emfPlugins.link）。每一个链接文件指向一个产品扩展位置。Eclipse 会在启动时扫描这个 links 文件夹，并在每个链接文件中所指向的产品扩展中寻找插件。下面是一个使用 links 文件夹的 Eclipse 安装布局的例子：

/opt/eclipse/
     links/
          emfPlugins.link
          webtools.link
          updateManager.link
          ...
     ...
     

链接文件的内容看上去应该像下面这样：

path=/opt/plugins/emf/

Windows 在本文中，我们着重介绍 Eclipse 的 Linux® 安装。所有提供的示例清单对于 Windows 都是有效的。您仅仅需要将路径替换为相应的 windows 路径。另外请注意，在 Windows 中，路径中需要使用双反斜杠（例如 path=c:\\plugins\\emf）。

/opt/plugins/emf/ 有一个 Eclipse 产品扩展的目录结构，如 清单 1 所示。

这个方法的优势在于，所有的插件位置被作为一个文件夹中的文本文件来存储。这意味着您可以通过简单地将 links 文件夹复制到新的 Eclipse 安装中，来升级 Eclipse 并使其指向您的产品扩展文件夹。您也可以通过从每个 Eclipse 安装建立一个到 links 文件夹的符号链接，获得一个针对所有 Eclipse 安装的公用 links 文件夹（如果您的文件系统支持符号链接）。

回页首

管理 Eclipse 工作区

在 Eclipse 中，工作区的概念被简单地描述成可以通过插件访问的资源的容器。工作区是终端用户和 Eclipse 平台之间交互的枢纽。终端用户能够在工作区中创建项目并处理其中的内容。工作区本身作为一个目录存在于文件系统中，并且只局限于每个 Eclipse 实例使用一个。工作区还包含一个 .metadata 目录，用来持久存储诸如插件状态这样的私有信息。

为什么我需要多个 Eclipse 工作区？

简单的答案是为了性能。工作区中的项目越多，达到开发系统所能处理项目的临界点的机会就越大。为了解决这个问题，您可以通过 -data 参数划分 Eclipse 工作区，这个参数被传递给 Eclipse 可执行文件（例如 /opt/eclipse/eclipse）：

/opt/eclipse-3.1/eclipse -data /opt/workspaces/web
/opt/eclipse-3.2M2/eclipse -data /opt/workspaces/web
/opt/eclipse-3.2M2/eclipse -data /opt/workspaces/dev -vmargs -Xmx512m

工作区提示 您可以通过向 Eclipse 可执行文件传递 -showlocation 参数来显示工作区位置。此外，您还可以通过 -vmargs -Xms 和 Xmx 参数为不同的工作区指定不同的性能特征。

您也可以通过从 Eclipse 中选择 File > Switch Workspace 切换工作区，而不必重新启动 Eclipse。

还有一种可能的情况是，您有一个 “研究” 工作区。在这个工作区中，您需要使用 Open Type（Ctrl+Shift+T）等由 Eclipse 对载入的大代码库的代码仔细搜寻一遍。如果您试图学习一些例子，或者您曾经想知道一个开放源码项目是如何处理特定问题的，那么这种方法是极其有用的。

有多个工作区的不利方面在于需要在它们之间共享开发首选项。因为首选项被持久存储在 Eclipse 中的一个工作区中，所以您必须导出工作区的首选项并将它们导入您所要求的工作区中（File > Export > Preferences）。

回页首

管理 Eclipse 安装

为什么我需要多个 Eclipse 安装？

如果您使用多个基于 Eclipse 的产品，就必然需要多个 Eclipse 安装。例如，如果您使用基本的 Eclipse V3.1 来完成日常的 Java™ 语言编程，并使用带有 WebTool 的 Eclipse 来编写 IBM WebSphere® 应用程序，那么您就有两个完全独立的 Eclipse 安装。在这些基于 Eclipse 的产品之间共享插件和工作区可以节约时间，并避免一些升级带来的麻烦。

您在开发 Eclipse 的插件时也需要多个 Eclipse 安装。当有了多个 Eclipse 安装时，您可以跨不同的 Eclipse 版本测试您的插件的功能。您也可以将一组不同的插件对应不同的 Eclipse 安装，以便跨多个环境配置测试您的插件。

注意，通过在 Eclipse 中选择 Help > Software Updates > Manage Configuration，来考察 Eclipse IDE（它启用和禁用属于这些特性的插件）中的特性，可以管理哪些插件由 Eclipse 使用。在开发自己的插件时，您也可以通过 Run Configuration Manager 来管理运行 Eclipse 测试实例时哪些插件被启用。我们通常的经验是，使用多个 Eclipse 安装是管理多个 Eclipse 版本和配置最方便且最便于重用的方法，对于测试目的尤其如此。

多个 Eclipse 安装

Eclipse 安装独立存在于它们自己的文件夹中。要使得多个安装并存，只要下载您所要的 Eclipse 产品和版本并将其解压到它们自己的目录中即可。下面是一个用来跨不同 Eclipse 版本测试插件的示例布局：

/opt/eclipse-3.0
/opt/eclipse-3.1
/opt/eclipse-3.2-m1

对于节约所有当前安装的插件安装时间和避免工作区重复，尽可能地跨 Eclipse 安装进行共享是一个好主意。正如我们前面所讲述的，您可以共享以下内容：

• 插件 —— 有一个（或多个）供所有安装共同使用的公用的插件文件夹。最好的方法是按照 实施控制：方法 3 中所讲述的那样创建一个 links 文件夹。
• 工作区 —— 参见 管理 Eclipse 工作区
• 工作区首选项 —— 与工作区绑定的首选项。从 Eclipse 中选择 File > Export > Preferences。

注意，跨 Eclipse 安装共享工作区和首选项可能会有问题，尤其是当 Eclipse 版本的主编号不同时（例如 3.1 和 3.2）。

回页首

结束语

我们的目的有两个：初步介绍 Eclipse 的基本工作要素，比如插件、项目和工作区；告诉您管理多个 Eclipse 环境的好处以及一些不利方面。我们希望您能够接受这些知识并将其应用到您的实践中以节约 Eclipse 维护的时间。

转自：http://www-128.ibm.com/developerworks/cn/opensource/os-ecl-manage/

改正方法：-Xms256m -Xmx256m -XX:MaxNewSize=256m -XX:MaxPermSize=256m

我已经试过了，ok。

所有类型的 Java 应用程序一般都需要计划重复执行的任务。企业应用程序需要计划每日的日志或者晚间批处理过程。一个 J2SE 或者 J2ME 日历应用程序需要根据用户的约定计划闹铃时间。不过，标准的调度类 Timer 和 TimerTask 没有足够的灵活性，无法支持通常需要的计划任务类型。在本文中，Java 开发人员 Tom White 向您展示了如何构建一个简单通用的计划框架，以用于执行任意复杂的计划任务。

我将把 java.util.Timer 和 java.util.TimerTask 统称为 Java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于 J2ME 中）。在 Java 2 SDK, Standard Edition, Version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的 Object.wait() 方法。不过，Java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用 Timer 来计划，因为在夏令时开始和结束时会出现时间跳跃。

本文展示了一个通用的 Timer 和 TimerTask 计划框架，从而允许更灵活的计划任务。这个框架非常简单 —— 它包括两个类和一个接口 —— 并且容易掌握。如果您习惯于使用 Java 定时器框架，那么您应该可以很快地掌握这个计划框架。

计划单次任务
计划框架建立在 Java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。

想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单 1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用 Java 语言编写：

														
package org.tiling.scheduling.examples;

import java.util.Timer;
import java.util.TimerTask;

public class EggTimer {
    private final Timer timer = new Timer();
    private final int minutes;

    public EggTimer(int minutes) {
        this.minutes = minutes;
    }

    public void start() {
        timer.schedule(new TimerTask() {
            public void run() {
                playSound();
                timer.cancel();
            }
            private void playSound() {
                System.out.println("Your egg is ready!");
                // Start a new thread to play a sound...
            }
        }, minutes * 60 * 1000);
    }

    public static void main(String[] args) {
        EggTimer eggTimer = new EggTimer(2);
        eggTimer.start();
    }

}

												

EggTimer 实例拥有一个 Timer 实例，用于提供必要的计划。用 start() 方法启动煮蛋计时器后，它就计划了一个 TimerTask，在指定的分钟数之后执行。时间到了，Timer 就在后台调用 TimerTask 的 start() 方法，这会使它发出声音。在取消计时器后这个应用程序就会中止。

计划重复执行的任务
通过指定一个固定的执行频率或者固定的执行时间间隔，Timer 可以对重复执行的任务进行计划。不过，有许多应用程序要求更复杂的计划。例如，每天清晨在同一时间发出叫醒铃声的闹钟不能简单地使用固定的计划频率 86400000 毫秒（24 小时），因为在钟拨快或者拨慢（如果您的时区使用夏令时）的那些天里，叫醒可能过晚或者过早。解决方案是使用日历算法计算每日事件下一次计划发生的时间。而这正是计划框架所支持的。考虑清单 2 中的 AlarmClock 实现：

														
package org.tiling.scheduling.examples;

import java.text.SimpleDateFormat;

import java.util.Date;

import org.tiling.scheduling.Scheduler;
import org.tiling.scheduling.SchedulerTask;
import org.tiling.scheduling.examples.iterators.DailyIterator;

public class AlarmClock {

    private final Scheduler scheduler = new Scheduler();
    private final SimpleDateFormat dateFormat =
        new SimpleDateFormat("dd MMM yyyy HH:mm:ss.SSS");
    private final int hourOfDay, minute, second;

    public AlarmClock(int hourOfDay, int minute, int second) {
        this.hourOfDay = hourOfDay;
        this.minute = minute;
        this.second = second;
    }

    public void start() {
        scheduler.schedule(new SchedulerTask() {
            public void run() {
                soundAlarm();
            }
            private void soundAlarm() {
                System.out.println("Wake up! " +
                    "It's " + dateFormat.format(new Date()));
                // Start a new thread to sound an alarm...
            }
        }, new DailyIterator(hourOfDay, minute, second));
    }

    public static void main(String[] args) {
        AlarmClock alarmClock = new AlarmClock(7, 0, 0);
        alarmClock.start();
    }
}

												

注意这段代码与煮蛋计时器应用程序非常相似。AlarmClock 实例拥有一个 Scheduler （而不是 Timer）实例，用于提供必要的计划。启动后，这个闹钟对 SchedulerTask （而不是 TimerTask）进行调度用以发出报警声。这个闹钟不是计划一个任务在固定的延迟时间后执行，而是用 DailyIterator 类描述其计划。在这里，它只是计划任务在每天上午 7:00 执行。下面是一个正常运行情况下的输出：

														
Wake up! It's 24 Aug 2003 07:00:00.023
Wake up! It's 25 Aug 2003 07:00:00.001
Wake up! It's 26 Aug 2003 07:00:00.058
Wake up! It's 27 Aug 2003 07:00:00.015
Wake up! It's 28 Aug 2003 07:00:00.002
...

												

DailyIterator 实现了 ScheduleIterator，这是一个将 SchedulerTask 的计划执行时间指定为一系列 java.util.Date 对象的接口。然后 next() 方法按时间先后顺序迭代 Date 对象。返回值 null 会使任务取消（即它再也不会运行）—— 这样的话，试图再次计划将会抛出一个异常。清单 3 包含 ScheduleIterator 接口：

														
package org.tiling.scheduling;

import java.util.Date;

public interface ScheduleIterator {
    public Date next();
}


												

DailyIterator 的 next() 方法返回表示每天同一时间（上午 7:00）的 Date 对象，如清单 4 所示。所以，如果对新构建的 next() 类调用 next()，那么将会得到传递给构造函数的那个日期当天或者后面一天的 7:00 AM。再次调用 next() 会返回后一天的 7:00 AM，如此重复。为了实现这种行为，DailyIterator 使用了 java.util.Calendar 实例。构造函数会在日历中加上一天，对日历的这种设置使得第一次调用 next() 会返回正确的 Date。注意代码没有明确地提到夏令时修正，因为 Calendar 实现（在本例中是 GregorianCalendar）负责对此进行处理，所以不需要这样做。

														
package org.tiling.scheduling.examples.iterators;

import org.tiling.scheduling.ScheduleIterator;

import java.util.Calendar;
import java.util.Date;

/**
 * A DailyIterator class returns a sequence of dates on subsequent days
 * representing the same time each day.
 */
public class DailyIterator implements ScheduleIterator {
    private final int hourOfDay, minute, second;
    private final Calendar calendar = Calendar.getInstance();

    public DailyIterator(int hourOfDay, int minute, int second) {
        this(hourOfDay, minute, second, new Date());
    }

    public DailyIterator(int hourOfDay, int minute, int second, Date date) {
        this.hourOfDay = hourOfDay;
        this.minute = minute;
        this.second = second;
        calendar.setTime(date);
        calendar.set(Calendar.HOUR_OF_DAY, hourOfDay);
        calendar.set(Calendar.MINUTE, minute);
        calendar.set(Calendar.SECOND, second);
        calendar.set(Calendar.MILLISECOND, 0);
        if (!calendar.getTime().before(date)) {
            calendar.add(Calendar.DATE, -1);
        }
    }

    public Date next() {
        calendar.add(Calendar.DATE, 1);
        return calendar.getTime();
    }

}

												

实现计划框架
在上一节，我们学习了如何使用计划框架，并将它与 Java 定时器框架进行了比较。下面，我将向您展示如何实现这个框架。除了 清单 3 中展示的 ScheduleIterator 接口，构成这个框架的还有另外两个类 —— Scheduler 和 SchedulerTask 。这些类实际上在内部使用 Timer 和 SchedulerTask，因为计划其实就是一系列的单次定时器。清单 5 和 6 显示了这两个类的源代码：

														
package org.tiling.scheduling;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Scheduler {

    class SchedulerTimerTask extends TimerTask {
        private SchedulerTask schedulerTask;
        private ScheduleIterator iterator;
        public SchedulerTimerTask(SchedulerTask schedulerTask,
                ScheduleIterator iterator) {
            this.schedulerTask = schedulerTask;
            this.iterator = iterator;
        }
        public void run() {
            schedulerTask.run();
            reschedule(schedulerTask, iterator);
        }
    }

    private final Timer timer = new Timer();

    public Scheduler() {
    }

    public void cancel() {
        timer.cancel();
    }

    public void schedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized(schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.VIRGIN) {
                  throw new IllegalStateException("Task already 
                  scheduled " + "or cancelled");
                }
                schedulerTask.state = SchedulerTask.SCHEDULED;
                schedulerTask.timerTask =
                    new SchedulerTimerTask(schedulerTask, iterator);
                timer.schedule(schedulerTask.timerTask, time);
            }
        }
    }

    private void reschedule(SchedulerTask schedulerTask,
            ScheduleIterator iterator) {

        Date time = iterator.next();
        if (time == null) {
            schedulerTask.cancel();
        } else {
            synchronized(schedulerTask.lock) {
                if (schedulerTask.state != SchedulerTask.CANCELLED) {
                    schedulerTask.timerTask =
                        new SchedulerTimerTask(schedulerTask, iterator);
                    timer.schedule(schedulerTask.timerTask, time);
                }
            }
        }
    }

}

												

清单 6 显示了 SchedulerTask 类的源代码：

														
package org.tiling.scheduling;

import java.util.TimerTask;

public abstract class SchedulerTask implements Runnable {

    final Object lock = new Object();

    int state = VIRGIN;
    static final int VIRGIN = 0;
    static final int SCHEDULED = 1;
    static final int CANCELLED = 2;

    TimerTask timerTask;

    protected SchedulerTask() {
    }

    public abstract void run();

    public boolean cancel() {
        synchronized(lock) {
            if (timerTask != null) {
                timerTask.cancel();
            }
            boolean result = (state == SCHEDULED);
            state = CANCELLED;
            return result;
        }
    }

    public long scheduledExecutionTime() {
        synchronized(lock) {
         return timerTask == null ? 0 : timerTask.scheduledExecutionTime();
        }
    }

}

												

就像煮蛋计时器，Scheduler 的每一个实例都拥有 Timer 的一个实例，用于提供底层计划。Scheduler 并没有像实现煮蛋计时器时那样使用一个单次定时器，它将一组单次定时器串接在一起，以便在由 ScheduleIterator 指定的各个时间执行 SchedulerTask 类。

考虑 Scheduler 上的 public schedule() 方法 —— 这是计划的入口点，因为它是客户调用的方法。通过调用 ScheduleIterator 接口的 next()，发现第一次执行 SchedulerTask 的时间。然后通过调用底层 Timer 类的单次 schedule() 方法，启动计划在这一时刻执行。为单次执行提供的 TimerTask 对象是嵌入的 SchedulerTimerTask 类的一个实例，它包装了任务和迭代器（iterator）。在指定的时间，调用嵌入类的 run() 方法，它使用包装的任务和迭代器引用以便重新计划任务的下一次执行。reschedule() 方法与 schedule() 方法非常相似，只不过它是 private 的，并且执行一组稍有不同的 SchedulerTask 状态检查。重新计划过程反复重复，为每次计划执行构造一个新的嵌入类实例，直到任务或者调度程序被取消（或者 JVM 关闭）。

类似于 TimerTask，SchedulerTask 在其生命周期中要经历一系列的状态。创建后，它处于 VIRGIN 状态，这表明它从没有计划过。计划以后，它就变为 SCHEDULED 状态，再用下面描述的方法之一取消任务后，它就变为 CANCELLED 状态。管理正确的状态转变 —— 如保证不对一个非 VIRGIN 状态的任务进行两次计划 —— 增加了 Scheduler 和 SchedulerTask 类的复杂性。在进行可能改变任务状态的操作时，代码必须同步任务的锁对象。

取消任务
取消计划任务有三种方式。第一种是调用 SchedulerTask 的 cancel() 方法。这很像调用 TimerTask 的 cancel()方法：任务再也不会运行了，不过已经运行的任务仍会运行完成。 cancel() 方法的返回值是一个布尔值，表示如果没有调用 cancel() 的话，计划的任务是否还会运行。更准确地说，如果任务在调用 cancel() 之前是 SCHEDULED 状态，那么它就返回 true。如果试图再次计划一个取消的（甚至是已计划的）任务，那么 Scheduler 就会抛出一个 IllegalStateException。

取消计划任务的第二种方式是让 ScheduleIterator 返回 null。这只是第一种方式的简化操作，因为 Scheduler 类调用 SchedulerTask 类的 cancel()方法。如果您想用迭代器而不是任务来控制计划停止时间时，就用得上这种取消任务的方式了。

第三种方式是通过调用其 cancel() 方法取消整个 Scheduler。这会取消调试程序的所有任务，并使它不能再计划任何任务。

扩展 cron 实用程序
可以将计划框架比作 UNIX 的 cron 实用程序，只不过计划次数的规定是强制性而不是声明性的。例如，在 AlarmClock 实现中使用的 DailyIterator 类，它的计划与 cron 作业的计划相同，都是由以 0 7 * * * 开始的 crontab 项指定的（这些字段分别指定分钟、小时、日、月和星期）。

不过，计划框架比 cron 更灵活。想像一个在早晨打开热水的 HeatingController 应用程序。我想指示它“在每个工作日上午 8:00 打开热水，在周未上午 9:00 打开热水”。使用 cron，我需要两个 crontab 项（0 8 * * 1,2,3,4,5 和 0 9 * * 6,7）。而使用 ScheduleIterator 的解决方案更简洁一些，因为我可以使用复合（composition）来定义单一迭代器。清单 7 显示了其中的一种方法：

														
    int[] weekdays = new int[] {
        Calendar.MONDAY,
        Calendar.TUESDAY,
        Calendar.WEDNESDAY,
        Calendar.THURSDAY,
        Calendar.FRIDAY
    };
    int[] weekend = new int[] {
        Calendar.SATURDAY,
        Calendar.SUNDAY
    };
    ScheduleIterator i = new CompositeIterator(
        new ScheduleIterator[] {
            new RestrictedDailyIterator(8, 0, 0, weekdays),
            new RestrictedDailyIterator(9, 0, 0, weekend)
        }
    );

												

RestrictedDailyIterator 类很像 DailyIterator，只不过它限制为只在一周的特定日子里运行，而一个 CompositeIterator 类取得一组 ScheduleIterators，并将日期正确排列到单个计划中。

有许多计划是 cron 无法生成的，但是 ScheduleIterator 实现却可以。例如，“每个月的最后一天”描述的计划可以用标准 Java 日历算法来实现（用 Calendar 类），而用 cron 则无法表达它。应用程序甚至无需使用 Calendar 类。在本文的源代码中，我加入了一个安全灯控制器的例子，它按“在日落之前 15 分钟开灯”这一计划运行。这个实现使用了 Calendrical Calculations Software Package ，用于计算当地（给定经度和纬度）的日落时间。

实时保证
在编写使用计划的应用程序时，一定要了解框架在时间方面有什么保证。我的任务是提前还是延迟执行？如果有提前或者延迟，偏差最大值是多少？不幸的是，对这些问题没有简单的答案。不过在实际中，它的行为对于很多应用程序已经足够了。下面的讨论假设系统时钟是正确的（有关网络时间协议(Network Time Protocol)的信息）。

因为 Scheduler 将计划委托给 Timer 类，Scheduler 可以做出的实时保证与 Timer 的一样。Timer 用 Object.wait(long) 方法计划任务。当前线程要等待直到唤醒它，唤醒可能出于以下原因之一：

1. 另一个线程调用对象的 notify() 或者 notifyAll() 方法。
2. 线程被另一个线程中断。
3. 在没有通知的情况下，线程被唤醒（称为 spurious wakeup，Joshua Bloch 的 Effective Java Programming Language Guide 一书中 Item 50 对其进行了描述 ）。
4. 规定的时间已到。

对于 Timer 类来说，第一种可能性是不会发生的，因为对其调用 wait() 的对象是私有的。即便如此，Timer 实现仍然针对前三种提前唤醒的原因进行了保护，这样保证了线程在规定时间后才唤醒。目前，Object.wait(long) 的文档注释声明，它会在规定的时间“前后”苏醒，所以线程有可能提前唤醒。在本例中，Timer 会让另一个 wait() 执行（scheduledExecutionTime - System.currentTimeMillis()）毫秒，从而保证任务永远不会提前执行。

任务是否会延迟执行呢？会的。延迟执行有两个主要原因：线程计划和垃圾收集。

Java 语言规范故意没有对线程计划做严格的规定。这是因为 Java 平台是通用的，并针对于大范围的硬件及其相关的操作系统。虽然大多数 JVM 实现都有公平的线程调度程序，但是这一点没有任何保证 —— 当然，各个实现都有不同的为线程分配处理器时间的策略。因此，当 Timer 线程在分配的时间后唤醒时，它实际执行其任务的时间取决于 JVM 的线程计划策略，以及有多少其他线程竞争处理器时间。因此，要减缓任务的延迟执行，应该将应用程序中可运行的线程数降至最少。为了做到这一点，可以考虑在一个单独的 JVM 中运行调度程序。

对于创建大量对象的大型应用程序，JVM 花在垃圾收集（GC）上的时间会非常多。默认情况下，进行 GC 时，整个应用程序都必须等待它完成，这可能要有几秒钟甚至更长的时间（Java 应用程序启动器的命令行选项 -verbose:gc 将导致向控制台报告每一次 GC 事件）。要将这些由 GC 引起的暂停（这可能会影响快速任务的执行）降至最少，应该将应用程序创建的对象的数目降至最低。同样，在单独的 JVM 中运行计划代码是有帮助的。同时，可以试用几个微调选项以尽可能地减少 GC 暂停。例如，增量 GC 会尽量将主收集的代价分散到几个小的收集上。当然这会降低 GC 的效率，但是这可能是时间计划的一个可接受的代价。

我被计划到什么时候？
如果任务本身能监视并记录所有延迟执行的实例，那么对于确定任务是否能按时运行会很有帮助。SchedulerTask 类似于 TimerTask，有一个 scheduledExecutionTime() 方法，它返回计划任务最近一次执行的时间。在任务的 run() 方法开始时，对表达式 System.currentTimeMillis() - scheduledExecutionTime() 进行判断，可以让您确定任务延迟了多久执行（以毫秒为单位）。可以记录这个值，以便生成一个关于延迟执行的分布统计。可以用这个值决定任务应当采取什么动作 —— 例如，如果任务太迟了，那么它可能什么也不做。在遵循上述原则的情况下，如果应用程序需要更严格的时间保证，可参考 Java 的实时规范。

结束语
在本文中，我介绍了 Java 定时器框架的一个简单增强，它使得灵活的计划策略成为可能。新的框架实质上是更通用的 cron —— 事实上，将 cron 实现为一个 ScheduleIterator 接口，用以替换单纯的 Java cron，这是非常有用的。虽然没有提供严格的实时保证，但是许多需要计划定期任务的通用 Java 应用程序都可以使用这一框架。

下载本文中使用的 源代码。

http://www.dingl.com/view.shtml?xh=362

什么是DOM?

DOM 可以让你以分层次对象模型来访问储存在XML文档中的信息。DOM生成一棵节点树(以XML文档的结构和信息为基础)你可以通过这棵树来访问你的信息。在XML文档中的文本信息转变成一组树的节点。
不管你的XML文档中的信息的类型 (不管是表格数据,或是一列items,或者只是文档), DOM在你创建一个XML文档的文档对象时创建一棵节点 树。 DOM强迫你使用树状模型(就像 Swing TreeModel)去访问你的XML文档中的信息。这种模式确实不错因为XML原本就是分层次的。 这也是DOM为什么可以把你的信息放到一棵树中的原因(即使信息是表格式的或者简单的列表????这里不知道该怎么翻原文是： even if the information is actually tabular or a simple list??????)。

因为在DOM中,每一个元素节点实际上都有一系列的其他节点作为它的孩子。这些孩子节点可以包含文本值或者是其他元素节点。乍看起来，通过遍历访问一个元 素的所有孩子节点来访问这个节点的值是没有必要的(举例来说:节点 "<name> Nazmul </name>",  Nazmul是值)。如果每个元素只有值的话，这确实是没有必要的。但是，元素可能含有文本数据或者其他元素;这是你要在DOM中做额外的工作来获取元 素节点值的原因。 通常当你的文档中只有纯数据时,把所有的数据压成一个“块“放到字串中并让DOM把那个字串当成某个特定元素节点的值返回是适当的。这 种方式并不适合如果在你的XML文档中的数据是个文档（比如像WORD文档或者FRAMEMAKER文档） 在文档中，元素的顺序是非常重要的。对于纯数 据(像一个数据库表)元素的顺序是不要紧的。 之所以DOM保持从XML文档中读出的元素的顺序，因为它把所有的事物都当成文档来处理。 文档对像模型的 叫法由此而来。

如果你计划用DOM做为JAVA对象模型用于你存储在XML文档中的信息，那么你不需要考虑SAX。可是如果你发现DOM不是一个可以用于处理XML文档 信息的好的对象模式，那么你可能想看看SAX了。在一些必须使用自定义对象模型的案例中使用SAX是非常普遍的。说一句让事情看来有些糊涂的话，你也可以 在DOM的基础之上创建自己的对象模式。面向对象真是个好东东。

什么是SAX?

SAX让你访问储存在XML文档中的信息，不是通过节点树，而是一系列的事件。你会问，这有什么益处？回答是，SAX选择不在XML文档上创建JAVA对象模型(像DOM做的那样)。 这样使得SAX更快, 同时使下面所述成为必要:

创立你自己的自定义对像模型
创建一个监听SAX事件的类同时创建你自己的对象模型
注意这些步骤对DOM而言是不必要的，因为DOM已经为你创建了一个对象模型(将你的信息用一棵节点树表示)。

在使用DOM的情况下,解析器做了绝大多数事情, 读入XML文档, 在这基础之上创建JAVA对象模型，然后给你一个对这个对象的引用(一个  Document对象)，因而你可以操作使用它。SAX被叫做Simple API for XML不是没有原因的, 她真的很简单。 SAX没有期待 解析器去做这么多工作，所有SAX 要求的是解析器应该读入XML文档,同时根据所遇到的XML文档的标签发出一系列事件。你要自己写一个XML文档处理 器类（XML document handler class）来处理这些事件,这意味着使所有标签事件有意义还有用你自己的对象模型创建对象。所以你要 完成:

控制所有XML文档信息的自定义对象模型（或者源文档在这里的写法从来没有见过，或者怀疑源文档在这里有排版错误，先这么翻了）
一个监听SAX事件(事件由SAX解析器读取你的XML文档时产生)的文档处理器，还有解释这些事件创建你自定义对象模型中的对象
如果你的对象模型简单的话那么SAX在运行时会非常快。在这种情况下，它会比DOM快,因为它忽略了为你的信息创建一个树形对象模型的过程。从另一方面来说，你必须写一个SAX 文档处理器来解释所有的SAX事件(这会是一件很繁重的工作)。

什么类型的SAX事件被SAX解析器抛出了哪? 这些事件实际上是非常简单的。SAX会对每一个开始标签抛出事件,对每一个结束标签也是如此。它对 #PCDATA和 CDATA 部分同样抛出事件。你的文档处理器 (对这些事件的监听器)要解释这些事件同时还要在他们基础之上创建你自定义的对象模 型。 你的文档处理器必须对这些事件做出解释，同时这些事件发生的顺序是非常重要的。SAX同时也对processing instructions,  DTDs, comments, 抛出事件. 但是它们在概念上是一样的, 你的解析器要解释这些事件(还有这些事件的发生顺序)以及使他们有意义。

什么时候使用DOM

如果你的XML文档包含文档数据(例如, Framemaker documents stored in XML format), 那么DOM就是你 的解决方案的最自然选择。如果你要创建一些类似于文档信息管理的系统，那么你不得不处理大量的文档数据。Datachannel RIO 产品就是这么一 个例子,它可以索引和组织各种类型文档资源中的信息(例如Word和Excel 文件)。在这种情况下，DOM是非常合适程序去访问存贮在这些文档中的信 息的。

然而,如果你主要处理的是结构化的数据(在XML中的序列化的JAVA对象the equivalent of serialized Java objects in XML)，DOM不是最好的选择。那就是SAX会比较合适的地方。

什么时候使用SAX

如果在你XML文档中的信息是机器易读的(和机器生成的)数据，那么SAX是让你可以访问这些信息的合适的API。机器易读和生成的数据类型包含像下面这些东东:

存成XML格式的Java对象属性
用一些以文本为基础的查询语句(SQL, XQL, OQL)表示的查询
由查询生成的结果集(这也许包含关系型数据库表中的数据编码成XML).
这么看来机器生成的数据是你一般要在java中生成数据结构和类的信息。一个简单的例子是包含个人信息的地址簿，在上图所示。这个地址簿xml文件不像字处理器文档，它是一个包含已经被编码成文本的纯数据的XML文档。

当你的数据是这种样式，你要创建你自己的数据结构和类（对象模型）来管理操作以及持续保存这些数据。SAX容许你快速创建一个可以生成你的对象模型实例的 处理器类。一个实例是：一个SAX文档处理器。它完成的工作有读入包含我的地址薄信息的XML文档，创建一个可以访问到这些信息的AddressBook 类。SAX指南告诉你该怎么做到这些。这个地址薄XML文档包含person元素，person元素中有name和email元素。我的 AddressBook对象模型包括下面的类：

AddressBook 类,Person对象的容器
Person 类,String 型的name和email的容器
这样我的“SAX 地址簿文档处理器”可以把person元素转变成Person对象了，然后把它们都存入AddressBook对象。这个文档处理器将name和email元素转变为String对象。

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

　　2.取整(大)
　　S:select ceiling(-1.001) value
　　O:select ceil(-1.001) value from dual

　　3.取整（小）
　　S:select floor(-1.001) value
　　O:select floor(-1.001) value from dual

　　4.取整（截取）
　　S:select cast(-1.002 as int) value
　　O:select trunc(-1.002) value from dual

　　5.四舍五入
　　S:select round(1.23456,4) value 1.23460
　　O:select round(1.23456,4) value from dual 1.2346

　　6.e为底的幂
　　S:select Exp(1) value 2.7182818284590451
　　O:select Exp(1) value from dual 2.71828182

　　7.取e为底的对数
　　S:select log(2.7182818284590451) value 1
　　O:select ln(2.7182818284590451) value from dual; 1

　　8.取10为底对数
　　S:select log10(10) value 1
　　O:select log(10,10) value from dual; 1

　　9.取平方
　　S:select SQUARE(4) value 16
　　O:select power(4,2) value from dual 16

　　10.取平方根
　　S:select SQRT(4) value 2
　　O:select SQRT(4) value from dual 2

　　11.求任意数为底的幂
　　S:select power(3,4) value 81
　　O:select power(3,4) value from dual 81

　　12.取随机数
　　S:select rand() value
　　O:select sys.dbms_random.value(0,1) value from dual;

　　13.取符号
　　S:select sign(-8) value -1
　　O:select sign(-8) value from dual -1
　　----------数学函数

　　14.圆周率
　　S:SELECT PI() value 3.1415926535897931
　　O:不知道

　　15.sin,cos,tan 参数都以弧度为单位
　　例如：select sin(PI()/2) value 得到1（SQLServer）

　　16.Asin,Acos,Atan,Atan2 返回弧度

　　17.弧度角度互换(SQLServer，Oracle不知道)
　　DEGREES：弧度-〉角度
　　RADIANS：角度-〉弧度

　　---------数值间比较

　　18. 求集合最大值
　　S:select max(value) value from
　　(select 1 value
　　union
　　select -2 value
　　union
　　select 4 value
　　union
　　select 3 value)a

　　O:select greatest(1,-2,4,3) value from dual

　　19. 求集合最小值
　　S:select min(value) value from
　　(select 1 value
　　union
　　select -2 value
　　union
　　select 4 value
　　union
　　select 3 value)a

　　O:select least(1,-2,4,3) value from dual

　　20.如何处理null值(F2中的null以10代替)
　　S:select F1,IsNull(F2,10) value from Tbl
　　O:select F1,nvl(F2,10) value from Tbl

　　--------数值间比较

　　21.求字符序号
　　S:select ascii('a') value
　　O:select ascii('a') value from dual

　　22.从序号求字符
　　S:select char(97) value
　　O:select chr(97) value from dual

　　23.连接
　　S:select '11'+'22'+'33' value
　　O:select CONCAT('11','22')||33 value from dual

　　23.子串位置 --返回3
　　S:select CHARINDEX('s','sdsq',2) value
　　O:select INSTR('sdsq','s',2) value from dual

　　23.模糊子串的位置 --返回2,参数去掉中间%则返回7
　　S:select patindex('%d%q%','sdsfasdqe') value
　　O:oracle没发现，但是instr可以通过第四霾问刂瞥鱿执问?BR>　　select INSTR('sdsfasdqe','sd',1,2) value from dual 返回6

　　24.求子串
　　S:select substring('abcd',2,2) value
　　O:select substr('abcd',2,2) value from dual

　　25.子串代替 返回aijklmnef
　　S:SELECT STUFF('abcdef', 2, 3, 'ijklmn') value
　　O:SELECT Replace('abcdef', 'bcd', 'ijklmn') value from dual

　　26.子串全部替换
　　S:没发现
　　O:select Translate('fasdbfasegas','fa','我' ) value from dual

　　27.长度
　　S:len,datalength
　　O:length

　　28.大小写转换 lower,upper

　　29.单词首字母大写
　　S:没发现
　　O:select INITCAP('abcd dsaf df') value from dual

　　30.左补空格（LPAD的第一个参数为空格则同space函数）
　　S:select space(10)+'abcd' value
　　O:select LPAD('abcd',14) value from dual

　　31.右补空格（RPAD的第一个参数为空格则同space函数）
　　S:select 'abcd'+space(10) value
　　O:select RPAD('abcd',14) value from dual

　　32.删除空格
　　S:ltrim,rtrim
　　O:ltrim,rtrim,trim

　　33. 重复字符串
　　S:select REPLICATE('abcd',2) value
　　O:没发现

　　34.发音相似性比较(这两个单词返回值一样，发音相同)
　　S:SELECT SOUNDEX ('Smith'), SOUNDEX ('Smythe')
　　O:SELECT SOUNDEX ('Smith'), SOUNDEX ('Smythe') from dual
　　SQLServer中用SELECT DIFFERENCE('Smithers', 'Smythers') 比较soundex的差
　　返回0-4，4为同音，1最高

　　--------------日期函数

　　35.系统时间
　　S:select getdate() value
　　O:select sysdate value from dual

　　36.前后几日
　　直接与整数相加减

　　37.求日期
　　S:select convert(char(10),getdate(),20) value
　　O:select trunc(sysdate) value from dual
　　select to_char(sysdate,'yyyy-mm-dd') value from dual

　　38.求时间
　　S:select convert(char(8),getdate(),108) value
　　O:select to_char(sysdate,'hh24:mm:ss') value from dual

　　39.取日期时间的其他部分
　　S:DATEPART 和 DATENAME 函数 （第一个参数决定）
　　O:to_char函数 第二个参数决定

　　参数---------------------------------下表需要补充
　　year yy, yyyy
　　quarter qq, q (季度)
　　month mm, m (m O无效)
　　dayofyear dy, y (O表星期)
　　day dd, d (d O无效)
　　week wk, ww (wk O无效)
　　weekday dw (O不清楚)
　　Hour hh,hh12,hh24 (hh12,hh24 S无效)
　　minute mi, n (n O无效)
　　second ss, s (s O无效)
　　millisecond ms (O无效)
　　----------------------------------------------

　　40.当月最后一天
　　S:不知道
　　O:select LAST_DAY(sysdate) value from dual

　　41.本星期的某一天（比如星期日）
　　S:不知道
　　O:SELECT Next_day(sysdate,7) vaule FROM DUAL;

　　42.字符串转时间
　　S:可以直接转或者select cast('2004-09-08'as datetime) value
　　O:SELECT To_date('2004-01-05 22:09:38','yyyy-mm-dd hh24-mi-ss') vaule FROM DUAL;

　　43.求两日期某一部分的差（比如秒）
　　S:select datediff(ss,getdate(),getdate()+12.3) value
　　O:直接用两个日期相减（比如d1-d2=12.3）
　　SELECT (d1-d2)*24*60*60 vaule FROM DUAL;

　　44.根据差值求新的日期（比如分钟）
　　S:select dateadd(mi,8,getdate()) value
　　O:SELECT sysdate+8/60/24 vaule FROM DUAL;

　　45.求不同时区时间
　　S:不知道
　　O:SELECT New_time(sysdate,'ydt','gmt' ) vaule FROM DUAL;

　　-----时区参数,北京在东8区应该是Ydt-------
　　AST ADT 大西洋标准时间
　　BST BDT 白令海标准时间
　　CST CDT 中部标准时间
　　EST EDT 东部标准时间
　　GMT 格林尼治标准时间
　　HST HDT 阿拉斯加—夏威夷标准时间
　　MST MDT 山区标准时间
　　NST 纽芬兰标准时间
　　PST PDT 太平洋标准时间
　　YST YDT YUKON标准时间
　　---------------------------------------

n     释出版 (Latest Release builds)  E.g.,3.1.2

               Releases are builds that have been declared major releases by the development team - for example "R1.0". Releases are the right builds for people who want to be on a stable, tested release, and don't need the latest greatest features and improvements. Release builds always have an "R" at the beginning of the name i.e. R1.0, R2.0 etc. Non-release builds are named according to the date of the build - for example 20011027 is the build from Oct 27, 2001.

由Eclipse开发团队所宣称的主要稳定版本。Release builds经过完整测试，并具有一致性、定义清楚的功  能。它的定位就跟上市的商业软件一样。

n     稳定版 (Stream Stable  builds) E.g., 3.2RC7

         Stable builds are integration builds that have been found to be stable enough for most people to use. They are promoted from integration build to stable build by the architecture team after they have been used for a few days and deemed reasonably stable. The latest stable build is the right build for people who want to stay up to date with what is going on in the latest development stream, and don't mind putting up with a few problems n in order to get the latest greatest features and bug fixes. The latest stable build is the one the development team likes people to be using, because of the valuable and timely feedback.

比Release build新一级的版本，经由Eclipse开发团队测试，并认定它相当稳定。新功能通常会在此过渡版本出现。它的定位就跟商业软件的beta版一样。

n       整合版 (Stream Integration  builds) E.g., I20060614-0843

      Periodically, component teams version off their work in what they believe is a stable, consistent state, and they update the build configuration to indicate that the next integration build should take this version of the component. Integration builds are built from these stable component versions that have been specified by each component team as the best version available. Integration builds may be promoted to stable builds after a few days of testing. Integration builds are built whenever new stable component versions are released into the build.

此版本的各个独立的组件已经过Eclipse开发团队认定具有稳定度，但不保证集成在一起没问题。若集成在一起 够稳定，它就有可能晋升成Stable build。

n    当日最新版（ Stream Nightly  builds) E.g., N20060617-0010

                 Nightly builds are produced every night from whatever has been released into the HEAD stream of the CVS repository. They are completely untested and will almost always have major problems. Many will not work at all. These drops are normally only useful to developers actually working on the Eclipse Project.

此版本显然是从最新的原始码产生出来的。可想而知，此版本当然不保证它跑起来没问题，搞不好还有严重的bug。

 n   维护版 (Stream Maintenance Build) E.g.,. R2_1_maintenance ， R2.1 or R2.1.2

Maintenance builds are produced periodically to incorporate fixes into an existing release. They are typically built from tagged plug-in and feature pojects in a maintenance stream of the CVS repository (i.e. R2_1_maintenance). Maintenance builds are promoted to a minor or service release (i.e. R2.1 or R2.1.2) after development teams have deemed one to be stable following one or more test-fix pass cycles.

命令：ping 192.168.0.8 －t ，参数－t是等待用户去中断测试

友情提示：这个是最基本，最常用的网络命令

2.查看DNS、IP、Mac等信息

A.Win98：winipcfg

B.Win2000以上：Ipconfig/all

3.网络信使

命令：Net send 计算机名/IP　* (广播) 传送内容，注意不能跨网段

命令：net stop messenger 停止信使服务，也可以在面板－服务修改

命令：net start messenger 开始信使服务

4.探测对方计算机名，所在的组、域及当前用户名 （追捕的工作原理）

命令：ping －a IP －t ，只显示NetBios名

命令：nbtstat -aIP 比较全的

5.netstat -a 显示出你的计算机当前所开放的所有端口

命令：netstat -s -e 

比较详细的显示你的网络资料，包括TCP、UDP、ICMP 和 IP的统计等

6.探测arp绑定（动态和静态）列表，显示所有连接了我的计算机，显示对方IP和MAC地址

命令：arp -a

7.在代理服务器端

捆绑IP和MAC地址，解决局域网内盗用IP！：

命令：ARP －s 192.168.10.59 00 －50－ff－6c－08－75

解除网卡的IP与MAC地址的绑定：

命令：arp -d 网卡IP

8.在网络邻居上隐藏你的计算机

命令：net config server /hidden:yes

命令：net config server /hidden:no 则为开启

9.net命令

A.显示当前工作组服务器列表 net view，当不带选项使用本命令时，它就会显示当前域或网络上的计算机上的列表。

比如：查看这个IP上的共享资源，就可以

C:\>net view 192.168.10.8

在 192.168.10.8 的共享资源

资源共享名 类型 用途 注释

网站服务 Disk

命令成功完成。

B.查看计算机上的用户帐号列表 net user

C.查看网络链接 net use

例如：net use z: \192.168.10.8\movie 将这个IP的movie共享目录映射为本地的Z盘

D.记录链接 net session

例如: C:\>net session

计算机 用户名 客户类型 打开空闲时间

\192.168.10.110 ROME Windows 2000 2195 0 00:03:12

\192.168.10.51 ROME Windows 2000 2195 0 00:00:39

命令成功完成。

10.路由跟踪命令

A.tracert software.pchome.net

B.pathping software.pchome.net 除了显示路由外，还提供325S的分析，计算丢失包的％

11.关于共享安全的几个命令

A.查看你机器的共享资源 net share

B.手工删除共享（可以编个bat文件，开机自运行，把共享都删了！）

命令：net share c$ /d

命令：net share d$ /d

命令：net share ipc$ /d

命令：net share admin$ /d

注意$后有空格。

C.增加一个共享：

c:\net share mymovie=e:\downloads\movie /users:1

mymovie 共享成功。

同时限制链接用户数为1人。

12.在DOS行下设置静态IP

A.设置静态IP

CMD

netsh

netsh>int

interface>ip

interface ip>set add "本地链接" static IP地址 mask gateway

B.查看IP设置

interface ip>show address

Arp

显示和修改“地址解析协议 (ARP)”缓存中的项目。ARP 缓存中包含一个或多个表，它们用于存储 IP 地址及其经过解析的以太网或令牌环物理地址。计算机上安装的每一个以太网或令牌环网络适配器都有自己单独的表。如果在没有参数的情况下使用，则 arp 命令将显示帮助信息。

觉得有用,记得点收藏哦~~

    AOP没有出现以前，该领域经典的设计模式是Decorator，像Java IO Stream的设计就是如此.不过，如果为每个DAO, 每个方法的写Decorator函数会写死人的，所以用上cglib的好处是一次过拦截所有方法。 

     另外，cglib除了Enhancer之外，还有BulkBean和Transform，都是Hibernate持久化的基础，但文档贫乏，一时还没去看怎么用。

1.AOP里讲了一百遍阿一百遍的log aspect在cglib是这样做的: