下面我们来仔细看一下这7大新功能：
      1 对集合类的语言支持
      Java将包含对创建集合类的第一类语言支持。这意味着集合类的创建可以像Ruby和Perl那样了。
      原本需要这样：
         List<String> list = new ArrayList<String>();
         list.add("item");
         String item = list.get(0);
  
         Set<String> set = new HashSet<String>();
         set.add("item");
         Map<String, Integer> map = new HashMap<String, Integer>();
         map.put("key", 1);
         int value = map.get("key");

      现在你可以这样：
         List<String> list = ["item"];
         String item = list[0];
        
         Set<String> set = {"item"};
        
         Map<String, Integer> map = {"key" : 1};
         int value = map["key"];

      这些集合是不可变的。

  
      2 自动资源管理
      Java中某些资源是需要手动关闭的，如InputStream，Writes，Sockets，Sql classes等。这个新的语言特性允许try语句本身申请更多的资源，
   这些资源作用于try代码块，并自动关闭。
      这个：
         BufferedReader br = new BufferedReader(new FileReader(path));
         try {
         return br.readLine();
               } finally {
                   br.close();
         }

      变成了这个：
          try (BufferedReader br = new BufferedReader(new FileReader(path)) {
             return br.readLine();
          }
   
      你可以定义关闭多个资源：
         try (
             InputStream in = new FileInputStream(src);
             OutputStream out = new FileOutputStream(dest))
         {
         // code
         }
      为了支持这个行为，所有可关闭的类将被修改为可以实现一个Closable（可关闭的）接口。
  

      3 增强的对通用实例创建（diamond）的类型推断
      类型推断是一个特殊的烦恼，下面的代码：
         Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

      通过类型推断后变成：
         Map<String, List<String>> anagrams = new HashMap<>();
      这个<>被叫做diamond（钻石）运算符，这个运算符从引用的声明中推断类型。

  
      4 数字字面量下划线支持
      很长的数字可读性不好，在Java 7中可以使用下划线分隔长int以及long了，如：
         int one_million = 1_000_000;
   运算时先去除下划线，如：1_1 * 10 = 110，120 – 1_0 = 110
  

      5 switch中使用string
      以前你在switch中只能使用number或enum。现在你可以使用string了：
         String s = ...
         switch(s) {
         case "quux":
              processQuux(s);
     // fall-through
         case "foo":
   case "bar":
              processFooOrBar(s);
     break;
         case "baz":
        processBaz(s);
              // fall-through
   default:
              processDefault(s);
            break;
  }

  
      6 二进制字面量
      由于继承C语言，Java代码在传统上迫使程序员只能使用十进制，八进制或十六进制来表示数(numbers)。
      由于很少的域是以bit导向的，这种限制可能导致错误。你现在可以使用0b前缀创建二进制字面量：
         int binary = 0b1001_1001;
   现在，你可以使用二进制字面量这种表示方式，并且使用非常简短的代码，可将二进制字符转换为数据类型，如在byte或short。
   byte aByte = (byte)0b001;   
   short aShort = (short)0b010;   

  
      7 简化的可变参数调用
      当程序员试图使用一个不可具体化的可变参数并调用一个*varargs* （可变）方法时，编辑器会生成一个“非安全操作”的警告。
   JDK 7将警告从call转移到了方法声明(methord declaration)的过程中。这样API设计者就可以使用vararg，因为警告的数量大大减少了。

例如：声明Vector vect＝new Vector()时，系统调用：

public Vector() {

// 缺省构造函数

this(10);

// 容量是

10;}　

缺省分配10个对象大小容量。

2 优化循环体

循环是比较重复运行的地方，如果循环次数很大，循环体内不好的代码对效率的影响就会被放大而变的突出。

3 少用new初始化一个实例

尽量少用new来初始化一个类的实例，当一个对象是用new进行初始化时，其构造函数链的所有构造函数都被调用到，所以new操作符是很消耗系统资源的，new一个对象耗时往往是局部变量赋值耗时的上千倍。同时，当生成对象后，系统还要花时间进行垃圾回收和处理。当new创建对象不可避免时，注意避免多次的使用new初始化一个对象。尽量在使用时再创建该对象，另外，应该尽量重复使用一个对象，而不是声明新的同类对象。一个重用对象的方法是改变对象的值，如可以通过setValue之类的方法改变对象的变量达到重用的目的。

4 选择合适的方法调用：

在Java中，一切都是对象，如果有方法（Method）调用，处理器先要检查该方法是属于哪个对象，该对象是否有效，对象属于什么类型，然后选择合适的方法并调用。可以减少方法的调用，不影响可读性等情况下，可以把几个小的方法合成一个大的方法。另外，在方法前加上final，private关键字有利于编译器的优化。

5异常处理技巧

异常是Java的一种错误处理机制，对程序来说是非常有用的，但是异常对性能不利。抛出异常首先要创建一个新的对象，并进行相关的处理，造成系统的开销，所以异常应该用在错误处理的情况，不应该用来控制程序流程，流程尽量用while，if等处理。在不是很影响代码健壮性的前提下，可以把几个try/catch块合成一个。

6 尽量使用局部变量

尽量使用局部变量，调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack） 中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。　　

7同步处理技巧

同步主要出现在多线程的情况，为多线程同时运行时提供对象数据安全的机制，多线程是比较复杂话题，应用多线程也是为了获得性能的提升，应该尽可能减少同步。

另外，如果需要同步的地方，可以减少同步的代码段，如只同步某个方法或函数，而不是整个代码。

8 尽可能的使用Java自身提供的API

Java的API一般都做了性能的考虑，如果完成相同的功能，优先使用API而不是自己写的代码，如数组复制。

9 尽量减少I/O操作

输入/输出（I/O）包括很多方面，我们知道，进行I/O操作是很消耗系统资源的。程序中应该尽量少用I/O操作。使用时可以注意： . 合理控制输出函数System.out.println()对于大多时候是有用的，特别是系统调试的时候，但也会产生大量的信息出现在控制台和日志上，同时输出时，有序列化和同步的过程，造成了开销。

特别是在发行版中，要合理的控制输出，可以在项目开发时，设计好一个Debug的工具类，在该类中可以实现输出开关，输出的级别，根据不同的情况进行不同的输出的控制。

10 尽量使用缓存

读写内存要比读写硬盘上的文件要快很多，应尽可能使用缓冲，以便直接从内存中读取数据。尽可能使用带有Buffer的类代替没有Buffer的类，如可以用BufferedReader 代替Reader，用BufferedWriter代替Writer来进行处理I/O操作。

同样可以用BufferedInputStream代替InputStream都可以获得性能的提高

11 尽量不使用同步：

Servlet是多线程的，以处理不同的请求，基于前面同步的分析，如果有太多的同步就失去了多线程的优势了。

12 不用保存太多的信息在HttpSession中

很多时候，存储一些对象在HttpSession中是有必要的，可以加快系统的开发，如网上商店系统会把购物车信息保存在该用户的Session中，但当存储大量的信息或是大的对象在会话中时，是有害的，特别是当系统中用户的访问量很大，对内存的需求就会很高。具体开发时，在这两者之间应作好权衡。

13清除SESSION：

通常情况，当达到设定的超时时间时，同时有些Session没有了活动，服务器会释放这些没有活动的Session，.. 不过这种情况下，特别是多用户并访时，系统内存要维护多个的无效Session。当用户退出时，应该手动释放，回收资源，实现如下：..
HttpSession theSession = request.getSession();
// 获取当前Session
if(theSession != null){
　theSession.invalidate(); // 使该Session失效
}

14 缓存Home接口

EJB库使用Enterprise Bean 的客户端通过它的Home接口创建它的实例。客户端能通过JNDI访问它。服务器通过Lookup方法来获取。
JNDI是个远程对象，通过RMI方式调用，对它的访问往往是比较费时的。所以，在设计时可以设计一个类专门用来缓存Home接口，在系统初始化时就获得需要的Home接口并缓存，以后的引用只要引用缓存即可。

15 使用快速度的Jdbc驱动

JDBC API包括两种实现接口形式，一种是纯Java实现的驱动，一种利用ODBC驱动和数据库客户端实现，具体有四种驱动模式：

第一类：JDBC-ODBC桥，再加上ODBC驱动程序。
JDBC驱动程序是JDBC-ODBC桥再加上一个ODBC驱动程序。建议第一类驱动程序只用于原型开发，而不要用于正式的运行环境。桥接驱动程序由Sun提供，它的目标是支持传统的数据库系统。Sun为该软件提供关键问题的补丁，但不为该软件的最终用户提供支持。一般地，桥接驱动程序用于已经在ODBC技术上投资的情形，例如已经投资了Windows应用服务器。
尽管Sun提供了JDBC-ODBC桥接驱动程序，但由于ODBC会在客户端装载二进制代码和数据库客户端代码，这种技术不适用于高事务性的环境。另外，第一类JDBC驱动程序不支持完整的Java命令集，而是局限于ODBC驱动程序的功能，这种驱动方式也叫胖客户，主要用于低并发请求，大数据量传输的应用。

第二类：本机API，部分是Java的驱动程序。
JDBC驱动程序是本机API的部分Java代码的驱动程序，用于把JDBC调用转换成主流数据库API的本机调用。这类驱动程序也存在与第一类驱动程序一样的性能问题，即客户端载入二进制代码的问题，而且它们被绑定了特定的平台。
第二类驱动程序要求编写面向特定平台的代码，主流的数据库厂商，例如Oracle和IBM，都为它们的企业数据库平台提供了第二类驱动程序，使用这些驱动程序的开发者必须及时跟进不同数据库厂商针对不同操作系统发行的各个驱动程序版本。
另外，由于第二类驱动程序没有使用纯Java的API，把Java应用连接到数据源时，往往必须执行一些额外的配置工作。很多时候，第二类驱动程序不能在体系结构上与大型主机的数据源兼容；即使做到了兼容，效果也是比较差。

第三类：面向数据库中间件的纯Java驱动程序。
JDBC驱动程序是面向数据库中间件的纯Java驱动程序，JDBC调用被转换成一种中间件厂商的协议，中间件再把这些调用转换到数据库API。第三类JDBC驱动程序的优点是它以服务器为基础，也就是不再需要客户端的本机代码，这使第三类驱动程序要比第一、二两类快。另外，开发者还可以利用单一的驱动程序连接到多种数据库。

第四类：直接面向数据库的纯Java驱动程序。
JDBC驱动程序是直接面向数据库的纯Java驱动程序，即所谓的“瘦”（thin）驱动程序，它把JDBC调用转换成某种直接可被DBMS使用的网络协议，这样，客户机和应用服务器可以直接调用DBMS服务器。对于第四类驱动程序，不同DBMS的驱动程序不同。因此，在一个异构计算环境中，驱动程序的数量可能会比较多。但是，由于第四类驱动程序具有较高的性能，能够直接访问DBMS，所以这一问题就不那么突出了， 这种驱动方式，主要用于高并发，低数据量请求的应用中。

16 使用Jdbc链接池

为了提高访问数据库的性能，我们还可以使用JDBC 2.0的一些规范和特性，JDBC是占用资源的，在使用数据库连接时可以使用连接池Connection Pooling，避免频繁打开、关闭Connection。而我们知道，获取Connection是比较消耗系统资源的。
Connection缓冲池：当一个应用程序关闭一个数据库连接时，这个连接并不真正释放而是被循环利用，建立连接是消耗较大的操作，循环利用连接可以显著的提高性能，因为可以减少新连接的建立。

一个通过DataSource获取缓冲池获得连接，并连接到一个CustomerDB数据源的代码演示如下：
Context ctx = new InitialContext();
DataSource dataSource = (DataSource) ctx.lookup("jdbc/CustomerDB");
Connection conn = dataSource.getConnection("password","username");

17 缓存DataSorce

一个DataSource对象代表一个实际的数据源。这个数据源可以是从关系数据库到表格形式的文件，完全依赖于它是怎样实现的，一个数据源对象注册到JNDI名字服务后，应用程序就可以从JNDI服务器上取得该对象，并使用之和数据源建立连接。
　　通过上面的例子，我们知道DataSource是从连接池获得连接的一种方式，通过JNDI方式获得，是占用资源的。
　　为了避免再次的JNDI调用，可以系统中缓存要使用的DataSource。

18 即时关闭使用过的资源

互联网应用系统一般是并发的系统，在每次申请和使用完资源后，应该释放供别人使用，使用完成后应该保证彻底的释放。

19 架构选型

CoreMediaCMS将整个应用分成四成架构，每一层都可以独立于其他层而正常运行，每一层都可以分布式布署，极大的提高了应用系统的稳定性、可扩展性、支持高并发的要求，每一次之前通过中间件Corba进行稳定的传输数据。

20 开发框架的选型

充分利用开源框架，可以大大提高开发效率。很多初级开发者，都采用DB+JavaBean+JSP这种初级的开发模式，而现在主要使用Struts、Spring等MVC开发框架。

常用开发框架构选型有：

Struts、Spring、Webwork等。

天极传媒选择的开发框架是：Struts+Spring+iBatis，在这个开发框架里，充分利用了Struts、Spring各自己的优点，可以选择Stuts　MVC，也可以选择Spring MVC。

21 分级存储

１）数据库数据分级存储：

将经常访问的数据和访问频度低的数据，分别存放到不同的分区，甚至存放到不同的数据库服务器，以便合进分配硬盘I/O及系统I/O。

２）网站内容发布之后，分级存储：

任何一个大型的网站，一般都有海量的内容，为了提高访问效率，应搭建分级存储体系，根据应用的重要性和访问并发要求，将这些内容分级存储，同时将静态内容中的静态页面文件、图片文件、下载文件分不同的Web服务器访问，降低I/O争用，提高访问效率，同时让数据存储、管理、备份更加清晰。

22 页面静态化

一个大型网站，既有静态内容，也有动态内容。静态内容，直接通过Apache或者Squid访问，效率高，稳定可靠，更多的是受服务器等硬件设备的I/O吞吐量、网络环境及页面代码本身质量限制，不受应用系统及数据库性能限制，这些内容往往访问速度和效率不会有较大的问题。

而动态内容，除了受硬件设备I/O、操作系统I/O及内容、网络环境及页面代码的影响，还要受应用服务器和数据库性能影响，因此，这部份内容，要尽可能作静态化或者伪静态，并采用缓存技术，将其缓存，以减少对应用服务器和数据库服务器的操作次数，提高用户访问效率和稳定性。

23 缓存策略

对于构建的业务系统，如果有些数据要经常要从数据库中读取，同时，这些数据又不经常变化，这些数据就可以在系统中缓存起来，使用时直接读取缓存，而不用频繁的访问数据库读取数据。
缓存工作可以在系统初始化时一次性读取数据，特别是一些只读的数据，当数据更新时更新数据库内容，同时更新缓存的数据值。

例如：在CMS2005系统中，我们将很少发生变化的网站节点树数据，缓存在客户端，当用户登录时，一次性读入到客户端缓存起来，以后编辑在使用时，不用再从数据库中读取，大大提高了应用系统的访问速度。

当然，也可以将数据库中重复访问的数据缓存在应用服务器内存中，减少对数据库的访问次数，Java常用的缓存技术产品有：MemoryCache、OSCache等。

类加载器基本概念

顾名思义，类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。一般来说，Java 虚拟机使用 Java 类的方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class 类的一个实例。每个这样的实例用来表示一个 Java 类。通过此实例的 newInstance()方法就可以创建出该类的一个对象。实际的情况可能更加复杂，比如 Java 字节代码可能是通过工具动态生成的，也可能是通过网络下载的。

基本上所有的类加载器都是 java.lang.ClassLoader 类的一个实例。下面详细介绍这个 Java 类。

java.lang.ClassLoader 类介绍

java.lang.ClassLoader 类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class 类的一个实例。除此之外，ClassLoader 还负责加载 Java 应用所需的资源，如图像文件和配置文件等。不过本文只讨论其加载类的功能。为了完成加载类的这个职责，ClassLoader 提供了一系列的方法，比较重要的方法如 表 1 所示。关于这些方法的细节会在下面进行介绍。

对于 表 1 中给出的方法，表示类名称的 name 参数的值是类的二进制名称。需要注意的是内部类的表示，如 com.example.Sample$1 和 com.example.Sample$Inner 等表示方式。这些方法会在下面介绍类加载器的工作机制时，做进一步的说明。下面介绍类加载器的树状组织结构。

类加载器的树状组织结构

Java 中的类加载器大致可以分成两类，一类是系统提供的，另外一类则是由 Java 应用开发人员编写的。系统提供的类加载器主要有下面三个：

• 引导类加载器（bootstrap class loader）：它用来加载 Java 的核心库，是用原生代码来实现的，并不继承自 java.lang.ClassLoader。
• 扩展类加载器（extensions class loader）：它用来加载 Java 的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。
• 系统类加载器（system class loader）：它根据 Java 应用的类路径（CLASSPATH）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader() 来获取它。

除了系统提供的类加载器以外，开发人员可以通过继承 java.lang.ClassLoader 类的方式实现自己的类加载器，以满足一些特殊的需求。

除了引导类加载器之外，所有的类加载器都有一个父类加载器。通过 表 1 中给出的 getParent() 方法可以得到。对于系统提供的类加载器来说，系统类加载器的父类加载器是扩展类加载器，而扩展类加载器的父类加载器是引导类加载器；对于开发人员编写的类加载器来说，其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样，也是要由类加载器来加载的。一般来说，开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来，形成树状结构。树的根节点就是引导类加载器。图 1 中给出了一个典型的类加载器树状组织结构示意图，其中的箭头指向的是父类加载器。

代码清单 1 演示了类加载器的树状组织结构。

public class ClassLoaderTree { 

            

            public static void main(String[] args) { 

            ClassLoader loader = ClassLoaderTree.class.getClassLoader(); 

            while (loader != null) { 

            System.out.println(loader.toString()); 

            loader = loader.getParent(); 

            } 

            } 

            }

每个 Java 类都维护着一个指向定义它的类加载器的引用，通过 getClassLoader() 方法就可以获取到此引用。代码清单 1 中通过递归调用 getParent() 方法来输出全部的父类加载器。代码清单 1 的运行结果如 代码清单 2 所示。

sun.misc.Launcher$AppClassLoader@9304b1 

            sun.misc.Launcher$ExtClassLoader@190d11

如 代码清单 2 所示，第一个输出的是 ClassLoaderTree 类的类加载器，即系统类加载器。它是 sun.misc.Launcher$AppClassLoader 类的实例；第二个输出的是扩展类加载器，是 sun.misc.Launcher$ExtClassLoader 类的实例。需要注意的是这里并没有输出引导类加载器，这是由于有些 JDK 的实现对于父类加载器是引导类加载器的情况，getParent() 方法返回 null。

在了解了类加载器的树状组织结构之后，下面介绍类加载器的代理模式。

类加载器的代理模式

类加载器在尝试自己去查找某个类的字节代码并定义它时，会先代理给其父类加载器，由父类加载器先去尝试加载这个类，依次类推。在介绍代理模式背后的动机之前，首先需要说明一下 Java 虚拟机是如何判定两个 Java 类是相同的。Java 虚拟机不仅要看类的全名是否相同，还要看加载此类的类加载器是否一样。只有两者都相同的情况，才认为两个类是相同的。即便是同样的字节代码，被不同的类加载器加载之后所得到的类，也是不同的。比如一个 Java 类 com.example.Sample，编译之后生成了字节代码文件 Sample.class。两个不同的类加载器 ClassLoaderA 和 ClassLoaderB 分别读取了这个 Sample.class 文件，并定义出两个 java.lang.Class 类的实例来表示这个类。这两个实例是不相同的。对于 Java 虚拟机来说，它们是不同的类。试图对这两个类的对象进行相互赋值，会抛出运行时异常 ClassCastException。下面通过示例来具体说明。代码清单 3 中给出了 Java 类 com.example.Sample。

package com.example; 

            

            public class Sample { 

            private Sample instance; 

            

            public void setSample(Object instance) { 

            this.instance = (Sample) instance; 

            } 

            }

如 代码清单 3 所示，com.example.Sample 类的方法 setSample 接受一个 java.lang.Object 类型的参数，并且会把该参数强制转换成 com.example.Sample 类型。测试 Java 类是否相同的代码如 代码清单 4 所示。

public void testClassIdentity() { 

            String classDataRootPath = "C:\\workspace\\Classloader\\classData"; 

            FileSystemClassLoader fscl1 = new FileSystemClassLoader(classDataRootPath); 

            FileSystemClassLoader fscl2 = new FileSystemClassLoader(classDataRootPath); 

            String className = "com.example.Sample";  

            try { 

            Class<?> class1 = fscl1.loadClass(className); 

            Object obj1 = class1.newInstance(); 

            Class<?> class2 = fscl2.loadClass(className); 

            Object obj2 = class2.newInstance(); 

            Method setSampleMethod = class1.getMethod("setSample", java.lang.Object.class); 

            setSampleMethod.invoke(obj1, obj2); 

            } catch (Exception e) { 

            e.printStackTrace(); 

            } 

            }

代码清单 4 中使用了类 FileSystemClassLoader 的两个不同实例来分别加载类 com.example.Sample，得到了两个不同的 java.lang.Class 的实例，接着通过 newInstance() 方法分别生成了两个类的对象 obj1 和 obj2，最后通过 Java 的反射 API 在对象 obj1 上调用方法 setSample，试图把对象 obj2 赋值给 obj1 内部的 instance 对象。代码清单 4 的运行结果如 代码清单 5 所示。

java.lang.reflect.InvocationTargetException 

            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 

            at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) 

            at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) 

            at java.lang.reflect.Method.invoke(Method.java:597) 

            at classloader.ClassIdentity.testClassIdentity(ClassIdentity.java:26) 

            at classloader.ClassIdentity.main(ClassIdentity.java:9) 

            Caused by: java.lang.ClassCastException: com.example.Sample 

            cannot be cast to com.example.Sample 

            at com.example.Sample.setSample(Sample.java:7) 

            ... 6 more 

            

从 代码清单 5 给出的运行结果可以看到，运行时抛出了 java.lang.ClassCastException 异常。虽然两个对象 obj1 和 obj2 的类的名字相同，但是这两个类是由不同的类加载器实例来加载的，因此不被 Java 虚拟机认为是相同的。

了解了这一点之后，就可以理解代理模式的设计动机了。代理模式是为了保证 Java 核心库的类型安全。所有 Java 应用都至少需要引用 java.lang.Object 类，也就是说在运行的时候，java.lang.Object 这个类需要被加载到 Java 虚拟机中。如果这个加载过程由 Java 应用自己的类加载器来完成的话，很可能就存在多个版本的 java.lang.Object 类，而且这些类之间是不兼容的。通过代理模式，对于 Java 核心库的类的加载工作由引导类加载器来统一完成，保证了 Java 应用所使用的都是同一个版本的 Java 核心库的类，是互相兼容的。

不同的类加载器为相同名称的类创建了额外的名称空间。相同名称的类可以并存在 Java 虚拟机中，只需要用不同的类加载器来加载它们即可。不同类加载器加载的类之间是不兼容的，这就相当于在 Java 虚拟机内部创建了一个个相互隔离的 Java 类空间。这种技术在许多框架中都被用到，后面会详细介绍。

下面具体介绍类加载器加载类的详细过程。

加载类的过程

在前面介绍类加载器的代理模式的时候，提到过类加载器会首先代理给其它类加载器来尝试加载某个类。这就意味着真正完成类的加载工作的类加载器和启动这个加载过程的类加载器，有可能不是同一个。真正完成类的加载工作是通过调用 defineClass 来实现的；而启动类的加载过程是通过调用 loadClass 来实现的。前者称为一个类的定义加载器（defining loader），后者称为初始加载器（initiating loader）。在 Java 虚拟机判断两个类是否相同的时候，使用的是类的定义加载器。也就是说，哪个类加载器启动类的加载过程并不重要，重要的是最终定义这个类的加载器。两种类加载器的关联之处在于：一个类的定义加载器是它引用的其它类的初始加载器。如类 com.example.Outer 引用了类 com.example.Inner，则由类 com.example.Outer 的定义加载器负责启动类 com.example.Inner 的加载过程。

方法 loadClass() 抛出的是 java.lang.ClassNotFoundException 异常；方法 defineClass() 抛出的是 java.lang.NoClassDefFoundError 异常。

类加载器在成功加载某个类之后，会把得到的 java.lang.Class 类的实例缓存起来。下次再请求加载该类的时候，类加载器会直接使用缓存的类的实例，而不会尝试再次加载。也就是说，对于一个类加载器实例来说，相同全名的类只加载一次，即 loadClass 方法不会被重复调用。

下面讨论另外一种类加载器：线程上下文类加载器。

线程上下文类加载器

线程上下文类加载器（context class loader）是从 JDK 1.2 开始引入的。类 java.lang.Thread 中的方法 getContextClassLoader() 和 setContextClassLoader(ClassLoader cl) 用来获取和设置线程的上下文类加载器。如果没有通过 setContextClassLoader(ClassLoader cl) 方法进行设置的话，线程将继承其父线程的上下文类加载器。Java 应用运行的初始线程的上下文类加载器是系统类加载器。在线程中运行的代码可以通过此类加载器来加载类和资源。

前面提到的类加载器的代理模式并不能解决 Java 应用开发中会遇到的类加载器的全部问题。Java 提供了很多服务提供者接口（Service Provider Interface，SPI），允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。这些 SPI 的接口由 Java 核心库来提供，如 JAXP 的 SPI 接口定义包含在 javax.xml.parsers 包中。这些 SPI 的实现代码很可能是作为 Java 应用所依赖的 jar 包被包含进来，可以通过类路径（CLASSPATH）来找到，如实现了 JAXP SPI 的 Apache Xerces 所包含的 jar 包。SPI 接口中的代码经常需要加载具体的实现类。如 JAXP 中的 javax.xml.parsers.DocumentBuilderFactory 类中的 newInstance() 方法用来生成一个新的 DocumentBuilderFactory 的实例。这里的实例的真正的类是继承自 javax.xml.parsers.DocumentBuilderFactory，由 SPI 的实现所提供的。如在 Apache Xerces 中，实现的类是 org.apache.xerces.jaxp.DocumentBuilderFactoryImpl。而问题在于，SPI 的接口是 Java 核心库的一部分，是由引导类加载器来加载的；SPI 实现的 Java 类一般是由系统类加载器来加载的。引导类加载器是无法找到 SPI 的实现类的，因为它只加载 Java 的核心库。它也不能代理给系统类加载器，因为它是系统类加载器的祖先类加载器。也就是说，类加载器的代理模式无法解决这个问题。

线程上下文类加载器正好解决了这个问题。如果不做任何的设置，Java 应用的线程的上下文类加载器默认就是系统上下文类加载器。在 SPI 接口的代码中使用线程上下文类加载器，就可以成功的加载到 SPI 实现的类。线程上下文类加载器在很多 SPI 的实现中都会用到。

下面介绍另外一种加载类的方法：Class.forName。

Class.forName

Class.forName 是一个静态方法，同样可以用来加载类。该方法有两种形式：Class.forName(String name, boolean initialize, ClassLoader loader) 和 Class.forName(String className)。第一种形式的参数 name 表示的是类的全名；initialize 表示是否初始化类；loader 表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize 的值为 true，loader 的值为当前类的类加载器。Class.forName 的一个很常见的用法是在加载数据库驱动的时候。如 Class.forName("org.apache.derby.jdbc.EmbeddedDriver").newInstance() 用来加载 Apache Derby 数据库的驱动。

在介绍完类加载器相关的基本概念之后，下面介绍如何开发自己的类加载器。

回页首

开发自己的类加载器

虽然在绝大多数情况下，系统默认提供的类加载器实现已经可以满足需求。但是在某些情况下，您还是需要为应用开发出自己的类加载器。比如您的应用通过网络来传输 Java 类的字节代码，为了保证安全性，这些字节代码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码，接着进行解密和验证，最后定义出要在 Java 虚拟机中运行的类来。下面将通过两个具体的实例来说明类加载器的开发。

文件系统类加载器

第一个类加载器用来加载存储在文件系统上的 Java 字节代码。完整的实现如 代码清单 6 所示。

public class FileSystemClassLoader extends ClassLoader { 

            

            private String rootDir; 

            

            public FileSystemClassLoader(String rootDir) { 

            this.rootDir = rootDir; 

            } 

            

            protected Class<?> findClass(String name) throws ClassNotFoundException { 

            byte[] classData = getClassData(name); 

            if (classData == null) { 

            throw new ClassNotFoundException(); 

            } 

            else { 

            return defineClass(name, classData, 0, classData.length); 

            } 

            } 

            

            private byte[] getClassData(String className) { 

            String path = classNameToPath(className); 

            try { 

            InputStream ins = new FileInputStream(path); 

            ByteArrayOutputStream baos = new ByteArrayOutputStream(); 

            int bufferSize = 4096; 

            byte[] buffer = new byte[bufferSize]; 

            int bytesNumRead = 0; 

            while ((bytesNumRead = ins.read(buffer)) != -1) { 

            baos.write(buffer, 0, bytesNumRead); 

            } 

            return baos.toByteArray(); 

            } catch (IOException e) { 

            e.printStackTrace(); 

            } 

            return null; 

            } 

            

            private String classNameToPath(String className) { 

            return rootDir + File.separatorChar 

            + className.replace('.', File.separatorChar) + ".class"; 

            } 

            }

如 代码清单 6 所示，类 FileSystemClassLoader 继承自类 java.lang.ClassLoader。在 表 1 中列出的 java.lang.ClassLoader 类的常用方法中，一般来说，自己开发的类加载器只需要覆写 findClass(String name) 方法即可。java.lang.ClassLoader 类的方法 loadClass() 封装了前面提到的代理模式的实现。该方法会首先调用 findLoadedClass() 方法来检查该类是否已经被加载过；如果没有加载过的话，会调用父类加载器的 loadClass() 方法来尝试加载该类；如果父类加载器无法加载该类的话，就调用 findClass() 方法来查找该类。因此，为了保证类加载器都正确实现代理模式，在开发自己的类加载器时，最好不要覆写 loadClass() 方法，而是覆写 findClass() 方法。

类 FileSystemClassLoader 的 findClass() 方法首先根据类的全名在硬盘上查找类的字节代码文件（.class 文件），然后读取该文件内容，最后通过 defineClass() 方法来把这些字节代码转换成 java.lang.Class 类的实例。

网络类加载器

下面将通过一个网络类加载器来说明如何通过类加载器来实现组件的动态更新。即基本的场景是：Java 字节代码（.class）文件存放在服务器上，客户端通过网络的方式获取字节代码并执行。当有版本更新的时候，只需要替换掉服务器上保存的文件即可。通过类加载器可以比较简单的实现这种需求。

类 NetworkClassLoader 负责通过网络下载 Java 类字节代码并定义出 Java 类。它的实现与 FileSystemClassLoader 类似。在通过 NetworkClassLoader 加载了某个版本的类之后，一般有两种做法来使用它。第一种做法是使用 Java 反射 API。另外一种做法是使用接口。需要注意的是，并不能直接在客户端代码中引用从服务器上下载的类，因为客户端代码的类加载器找不到这些类。使用 Java 反射 API 可以直接调用 Java 类的方法。而使用接口的做法则是把接口的类放在客户端中，从服务器上加载实现此接口的不同版本的类。在客户端通过相同的接口来使用这些实现类。网络类加载器的具体代码见 下载。

在介绍完如何开发自己的类加载器之后，下面说明类加载器和 Web 容器的关系。


类加载器与 Web 容器

对于运行在 Java EE™ 容器中的 Web 应用来说，类加载器的实现方式与一般的 Java 应用有所不同。不同的 Web 容器的实现方式也会有所不同。以 Apache Tomcat 来说，每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式，所不同的是它是首先尝试去加载某个类，如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。这是 Java Servlet 规范中的推荐做法，其目的是使得 Web 应用自己的类的优先级高于 Web 容器提供的类。这种代理模式的一个例外是：Java 核心库的类是不在查找范围之内的。这也是为了保证 Java 核心库的类型安全。

绝大多数情况下，Web 应用的开发人员不需要考虑与类加载器相关的细节。下面给出几条简单的原则：

• 每个 Web 应用自己的 Java 类文件和使用的库的 jar 包，分别放在 WEB-INF/classes 和 WEB-INF/lib 目录下面。
• 多个应用共享的 Java 类文件和 jar 包，分别放在 Web 容器指定的由所有 Web 应用共享的目录下面。
• 当出现找不到类的错误时，检查当前类的类加载器和当前线程的上下文类加载器是否正确。

在介绍完类加载器与 Web 容器的关系之后，下面介绍它与 OSGi 的关系。

类加载器与 OSGi

OSGi™ 是 Java 上的动态模块系统。它为开发人员提供了面向服务和基于组件的运行环境，并提供标准的方式用来管理软件的生命周期。OSGi 已经被实现和部署在很多产品上，在开源社区也得到了广泛的支持。Eclipse 就是基于 OSGi 技术来构建的。

OSGi 中的每个模块（bundle）都包含 Java 包和类。模块可以声明它所依赖的需要导入（import）的其它模块的 Java 包和类（通过 Import-Package），也可以声明导出（export）自己的包和类，供其它模块使用（通过 Export-Package）。也就是说需要能够隐藏和共享一个模块中的某些 Java 包和类。这是通过 OSGi 特有的类加载器机制来实现的。OSGi 中的每个模块都有对应的一个类加载器。它负责加载模块自己包含的 Java 包和类。当它需要加载 Java 核心库的类时（以 java 开头的包和类），它会代理给父类加载器（通常是启动类加载器）来完成。当它需要加载所导入的 Java 类时，它会代理给导出此 Java 类的模块来完成加载。模块也可以显式的声明某些 Java 包和类，必须由父类加载器来加载。只需要设置系统属性 org.osgi.framework.bootdelegation 的值即可。

假设有两个模块 bundleA 和 bundleB，它们都有自己对应的类加载器 classLoaderA 和 classLoaderB。在 bundleA 中包含类 com.bundleA.Sample，并且该类被声明为导出的，也就是说可以被其它模块所使用的。bundleB 声明了导入 bundleA 提供的类 com.bundleA.Sample，并包含一个类 com.bundleB.NewSample 继承自 com.bundleA.Sample。在 bundleB 启动的时候，其类加载器 classLoaderB 需要加载类 com.bundleB.NewSample，进而需要加载类 com.bundleA.Sample。由于 bundleB 声明了类 com.bundleA.Sample 是导入的，classLoaderB 把加载类 com.bundleA.Sample 的工作代理给导出该类的 bundleA 的类加载器 classLoaderA。classLoaderA 在其模块内部查找类 com.bundleA.Sample 并定义它，所得到的类 com.bundleA.Sample 实例就可以被所有声明导入了此类的模块使用。对于以 java 开头的类，都是由父类加载器来加载的。如果声明了系统属性 org.osgi.framework.bootdelegation=com.example.core.*，那么对于包 com.example.core 中的类，都是由父类加载器来完成的。

OSGi 模块的这种类加载器结构，使得一个类的不同版本可以共存在 Java 虚拟机中，带来了很大的灵活性。不过它的这种不同，也会给开发人员带来一些麻烦，尤其当模块需要使用第三方提供的库的时候。下面提供几条比较好的建议：

• 如果一个类库只有一个模块使用，把该类库的 jar 包放在模块中，在 Bundle-ClassPath 中指明即可。
• 如果一个类库被多个模块共用，可以为这个类库单独的创建一个模块，把其它模块需要用到的 Java 包声明为导出的。其它模块声明导入这些类。
• 如果类库提供了 SPI 接口，并且利用线程上下文类加载器来加载 SPI 实现的 Java 类，有可能会找不到 Java 类。如果出现了 NoClassDefFoundError 异常，首先检查当前线程的上下文类加载器是否正确。通过 Thread.currentThread().getContextClassLoader() 就可以得到该类加载器。该类加载器应该是该模块对应的类加载器。如果不是的话，可以首先通过 class.getClassLoader() 来得到模块对应的类加载器，再通过 Thread.currentThread().setContextClassLoader() 来设置当前线程的上下文类加载器。

总结

类加载器是 Java 语言的一个创新。它使得动态安装和更新软件组件成为可能。本文详细介绍了类加载器的相关话题，包括基本概念、代理模式、线程上下文类加载器、与 Web 容器和 OSGi 的关系等。开发人员在遇到 ClassNotFoundException 和 NoClassDefFoundError 等异常的时候，应该检查抛出异常的类的类加载器和当前线程的上下文类加载器，从中可以发现问题的所在。在开发自己的类加载器的时候，需要注意与已有的类加载器组织结构的协调。

JDBC,JNDI,EJBs,RMI,JSP,Javaservlets,XML,JMS,JavaIDL,JTS, JTA,JavaMail和JAF，同时还将描述在何时、何处需要使用这些技术。当然，我还要介绍这些不同的技术之间是如何交互的。此外，为了让您更好地 感受J2EE的真实应用，将在WebLogic应用服务器,来自BEA Systems公司的一种广为应用的产品环境下来介绍这些技术。不论对于Web Logic应用服务器和J2EE的新手，还是那些想了解J2EE能带来什么好处的项目管理者和系统分析员，相信本文一定很有参考价值。

一、宏观印象:分布式结构和J2EE

过去，二层化应用--通常被称为client/server应用--是大家谈论的最多的。在很多情况下，服务器提供的惟一服务就是数据库服务。在这 种解决方案中，客户端程序负责数据访问、实现业务逻辑、用合适的样式显示结果、弹出预设的用户界面、接受用户输入等。client/server结构通常 在第一次部署的时候比较容易，但难于升级或改进，而且经常基于某种专有的协议，通常是某种数据库协议。它使得重用业务逻辑和界面逻辑非常困难。更重要的 是，在Web时代，二层化应用通常不能体现出很好的伸缩性，因而很难适应Internet的要求。

Sun设计J2EE的部分起因就是想解决二层化结构的缺陷。于是，J2EE定义了一套标准来简化N层企业级应用的开发。它定义了一套标准化的组件，并为这些组件提供了完整的服务。J2EE还自动为应用程序处理了很多实现细节，如安全、多线程等。

用J2EE开发N层应用包括将二层化结构中的不同层面切分成许多层。一个N层化应用A能够为以下的每种服务提供一个分开的层：

显示：在一个典型的Web应用中，客户端机器上运行的浏览器负责实现用户界面。 字串1

动态生成显示:尽管浏览器可以完成某些动态内容显示，但为了兼容不同的浏览器，这些动态生成工作应该放在Web服务器端进行，使用JSP、Servlets，或者XML（可扩展标记语言）和（可扩展样式表语言）。 字串6

业务逻辑：业务逻辑适合用SessionEJBs（后面将介绍）来实现。

数据访问：数据访问适合用EntityEJBs（后面将介绍）和JDBC来实现。

后台系统集成:同后台系统的集成可能需要用到许多不同的技术，至于何种最佳需要根据后台系统的特征而定。

您可能开始诧异：为什么有这么多的层？事实上，多层方式可以使企业级应用具有很强的伸缩性，它允许每层专注于特定的角色。例如，让Web服务器负责提供页面，应用服务器处理应用逻辑，而数据库服务器提供数据库服务。

由于J2EE建立在Java2平台标准版（J2SE）的基础上，所以具备了J2SE的所有优点和功能。包括“编写一次，到处可用”的可移植性、通过 JDBC访问数据库、同原有企业资源进行交互的CORBA技术，以及一个经过验证的安全模型。在这些基础上，J2EE又增加了对EJB（企业级Java组 件）、Javaservlets、Java服务器页面（JSPs）和XML技术的支持。

二、分布式结构与WebLogic应用服务器

J2EE提供了一个框架--一套标准API--用于开发分布式结构的应用，这个框架的实际实现留给了第三方厂商。部分厂商只是专注于整个J2EE架 构中的的特定组件，例如Apache的Tomcat提供了对JSP和servlets的支持，BEA系统公司则通过其WebLogic应用服务器产品为整 个J2EE规范提供了一个较为完整的实现。

WebLogic服务器已使建立和部署伸缩性较好的分布式应用的过程大为简化。WebLogic和J2EE代你处理了大量常规的编程任务，包括提供事务服务、安全领域、可靠的消息、名字和目录服务、数据库访问和连接池、线程池、负载平衡和容错处理等。

通过以一种标准、易用的方式提供这些公共服务，象WebLogic服务器这样的产品造就了具有更好伸缩性和可维护性的应用系统，使其为大量的用户提供了增长的可用性。

J2EE技术

在接下来的部分里，我们将描述构成J2EE的各种技术，并且了解WebLogic服务器是如何在一个分布式应用中对它们进行支持的。最常用的J2EE技术应该是JDBC、JNDI、EJB、JSP和servlets，对这些我们将作更仔细的考察。

三、Java Database Connectivity(JDBC)

JDBCAPI以一种统一的方式来对各种各样的数据库进行存取。和ODBC一样，JDBC为开发人员隐藏了不同数据库的不同特性。另外，由于JDBC建立在Java的基础上,因此还提供了数据库存取的平台独立性。 字串5

JDBC定义了4种不同的驱动程序，现分述如下：

类型1:JDBC-ODBCBridge

在JDBC出现的初期，JDBC-ODBC桥显然是非常有实用意义的，通过JDBC-ODBC桥，开发人员可以使用JDBC来存取ODBC数据源。 不足的是，他需要在客户端安装ODBC驱动程序，换句话说，必须安装MicrosoftWindows的某个版本。使用这一类型你需要牺牲JDBC的平台 独立性。另外，ODBC驱动程序还需要具有客户端的控制权限。

类型2:JDBC-nativedriverbridge

JDBC本地驱动程序桥提供了一种JDBC接口，它建立在本地数据库驱动程序的顶层，而不需要使用ODBC。JDBC驱动程序将对数据库的API从标准的JDBC调用转换为本地调用。使用此类型需要牺牲JDBC的平台独立性，还要求在客户端安装一些本地代码。 字串3

类型3:JDBC-networkbridge

JDBC网络桥驱动程序不再需要客户端数据库驱动程序。它使用网络上的中间服务器来存取数据库。这种应用使得以下技术的实现有了可能，这些技术包括 负载均衡、连接缓冲池和数据缓存等。由于第3种类型往往只需要相对更少的下载时间，具有平台独立性，而且不需要在客户端安装并取得控制权，所以很适合于 Internet上的应用。

类型4:PureJavadriver

第4种类型通过使用一个纯Java数据库驱动程序来执行数据库的直接访问。此类型实际上在客户端实现了2层结构。要在N-层结构中应用，一个更好的做法是编写一个EJB，让它包含存取代码并提供一个对客户端具有数据库独立性的服务。

WebLogic服务器为一些通常的数据库提供了JDBC驱动程序，包括Oracle,Sybase,MicrosoftSQLServer以及 Informix。它也带有一种JDBC驱动程序用于Cloudscape，这是一种纯Java的DBMS，WebLogic服务器中带有该数据库的评估 版本。

以下让我们看一个JDBC实例：在这个例子中我们假定你已经在Cloudscape中建立了一个PhoneBook数据库，并且包含一个表，名为 CONTACT_TABLE，它带有2个字段：NAME和PHONE。开始的时候先装载CloudscapeJDBCdriver，并请求 drivermanager得到一个对PhoneBookCloudscape数据库的连接。通过这一连接，我们可以构造一个Statement对象并用 它来执行一个简单的SQL查询。最后，用循环来遍历结果集的所有数据，并用标准输出将NAME和PHONE字段的内容进行输出。

import java.sql.*; 字串5 public class JDBCExample{public static void main( String args[] ){try{Class.forName("COM.cloudscape.core.JDBCDriver");Connection conn = DriverManager.getConnection("jdbc:cloudscape:PhoneBook");Statement stmt = conn.createStatement();String sql = "SELECT name, phone FROM CONTACT_TABLE ORDER BYname";ResultSet resultSet = stmt.executeQuery( sql ); 字串8 String name;String phone;while ( resultSet.next() ){name = resultSet.getString(1).trim();phone = resultSet.getString(2).trim();System.out.println( name + ", " + phone ); }catch ( Exception e ){// Handle exception heree.printStackTrace();}}}

OK。接着来看一看JDBC是如何在企业应用中的进行使用。

JDBC在企业级应用中的应用。以上实例其实是很基本的，可能有些微不足道。它假定了一个2层结构。在一个多层的企业级应用中，更大的可能是在客户 端和一个EJB进行通信，该EJB将建立数据库连接。为了实现和改进可伸缩性和系统性能， WebLogic服务器提供了对连接缓冲池connection pool的支持。

Connection pool减少了建立和释放数据库连接的消耗。在系统启动以后即可建立这样的缓冲池，此后如故再有对数据库的请求，WebLogic服务器可以很简单地从缓 冲池中取出数据。数据缓冲池可以在WebLogic服务器的 weblogic.properties 文件中进行定义。

在企业级应用的另一个常见的数据库特性是事务处理。事务是一组申明statement，它们必须做为同一个statement来处理以保证数据完整 性。缺省情况下JDBC使用 auto-commit 事务模式。这可以通过使用Connection类的setAutoCommit() 方法来实现。现在已经对JDBC有了一些认识，下面该转向JNDI了。

四、Java Naming and Directory Interface (JNDI) 字串3

JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统，后者在应用服务器中的对象。在JNDI 中，在目录结构中的每一个结点称为context。每一个JNDI名字都是相对于context的。这里没有绝对名字的概念存在。对一个应用来说，它可以 通过使用 InitialContext 类来得到其第一个context: 字串6

Context ctx = new InitialContext();

应用可以通过这个初始化的context经有这个目录树 来定位它所需要的资源或对象。例如，假设你在Weblogic服务器中展开了一个EJB并将home接口绑定到名字 myApp.myEJB ，那么该EJB的某个客户在取得一个初始化context以后，可以通过以下语句定位home接口：

MyEJBHome home = ctx.lookup( "myApp.myEJB" );

在这个例子中，一旦你有了对被请求对象的参考，EJB的home接口就可以在它上面调用方法。我们将在下面的"Enterprise Java Beans"章节中做更多的介绍。

以上关于JNDI的讨论只是冰山之一角而已。如果要更进一步地在context中查找对象，JNDI也提供了一些方法来进行以下操作：将一个对象插 入或绑定到context。这在你展开一个EJB的时候是很有效的。从context中移去对象。列出context中的所有对象。创建或删除子一级的 context。接下来，要开始关注EJB了。
五、Enterprise Java Beans (EJB)

J2EE技术之所以赢得某体广泛重视的原因之一就是EJB。它们提供了一个框架来开发和实施分布式商务逻辑，由此很显著地简化了具有可伸缩性和高度 复杂的企业级应用的开发。EJB规范定义了EJB组件在何时如何与它们的容器进行交互作用。容器负责提供公用的服务，例如目录服务、事务管理、安全性、资 源缓冲池以及容错性。 字串8

EJB规范定义了三种基本的bean类型:

Stateless session beans: 提供某种单一的服务，不维持任何状态，在服务器故障发生时无法继续存在，生命期相对较短。例如，一个stateless sessionbean可能被用于执行温度转换计算。

Stateful session bean: T提供了与客户端的会话交互，可以存储状态从而代表一个客户。典型例子是购物车。Stateful session bean在服务器故障时无法继续生存，生命气相对较短。每一个实例只用于一个单个的线程。

Entity beans: 提供了一致性数据的表示-- 通常存放在数据库中 -- 在服务器故障发生后能继续存在。多用户情况下可以使用EJB来表示相同的数据。entity EJB的一个典型例子是客户的帐号信息。 字串2

尽管有以上的区别，所有的EJB还是有许多的共同之处。它们都处理homeinterface。它定义了一个客户端是如何创建与消亡EJB的。可以 在bean中对定义了客户端方法的远程接口进行调用；bean类则执行了主要的商务逻辑。描述EJB的开发已经超出了本文的范围。但是，如果一个EJB已 经被开发了或者从第三方进行了购买，它就必须在应用服务器中进行发布。WebLogic Server 5.1带有一个EJB Deployer Tool来协助处理EJB的发布。当你使用EJB Deployer Tool的时候，你要定义客户端所用的JNDI名字来定位EJB。Deployer Tool将生成wrapper类来处理和容器的通信以及在一个jar文件中把被请求的Java类绑定在一起。

一旦EJB被发布，客户端就可以使用它的JNDI名字来定位EJB。首先，它必须得到一个到home接口的reference。然后，客户端可以使 用该接口，调用一个create() 方法来得到服务器上运行的某个bean实例的句柄；最后，客户端可以使用该句柄在bean中调用方法。了解 EJB后，让我们再来看JSP。 字串4

六、JavaServer Pages (JSPs) 字串4

可能已经有许多人已经熟悉Microsoft的Active Server Pages(ASP)技术了。JSP和ASP相对应的，但更具有平台对立性。他们被设计用以帮助Web内容开发人员创建动态网页，并且只需要相对较少的代 码。 即使Web设计师不懂得如何编程也可以使用JSP，因为JSP应用是很方便的。 JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端所请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给 客户端的浏览器。 字串5

下面来看一个JSP的简单实例。它只显示了服务器的当前日期和时间。虽然，对语法的具体解释已经超出了本文的范围，但我们还是可以很直观地看到，Java代码被放在 符号的中间，而Java的表达式则放在符号之间。

＜H1＞Date JSP sample＜/H1＞＜H2＞＜% response.setHeader("Refresh", 5); %＞The current date is ＜%= new Date() %＞.＜/H2＞ 字串1

下面是: Java servlets

七、Java Servlets

Servlet 提供的功能大多与JSP类似，不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的Java代码，而servlets全部由Java写成并且 生成HTML。Servlet是一种小型的Java程序，它扩展了Web服务器的功能。作为一种服务器端的应用，当被请求时开始执行，这和CGI Perl脚本很相似。Servlets和CGI脚本的一个很大的区别是：每一个CGI在开始的时候都要求开始一个新的进程 -- 而servlets是在servlet引擎中以分离的线程来运行的。因此servlets在可伸缩性上提供了很好的改进。

在开发servlets的时候，您常常需要扩展javax.servlet.http.HttpServlet类，并且override一些它的方法，其中包括：

service(): 作为dispatcher来实现命令-定义方法

doGet(): 处理客户端的HTTP GET请求。

doPost(): 进行HTTP POST操作 字串7

其它的方法还包括处理不同类型的HTTP请求 -- 可以参考HttpServlet API文档。以上描述的是标准J2EE Servlet API的各种方法。WebLogic服务器提供了一个该API完整的实现途径。一旦你开发了一个servlet，你就可以在 weblogic.properties 中加以注册并由此可以在WebLogic服务器中对它进行配置。 字串8

通过Java servlets,我们已经到达了J2EE主要技术的末尾了。但J2EE所提供的并不止于这些。下面的段落中我们将简要地看一下现存的一些技术，包括RMI,Java IDL和CORBA, JTA, 以及XML，等等。 字串1

八、Remote Method Invocation (RMI)

正如其名字所表示的那样，RMI协议是在远程对象上调用一些方法。它使用了连续序列方式在客户端和服务器端传递数据。RMI是一种被EJB使用的更下层的协议。 字串5

九、Java IDL/CORBA 字串5

在Java IDL的支持下，开发人员可以将Java和CORBA集成在一起。 他们可以创建Java对象并使之可在CORBA ORB中展开, 或者他们还可以创建Java类并作为和其它ORB一起展开的CORBA对象的客户。后一种方法提供了另外一种途径，通过它Java可以被用于将你的新的应 用和legacy系统相集成。 字串4

十、Java Transaction Architecture (JTA)/Java Transaction Service (JTS)

JTA定义了一种标准的API，应用系统由此可以存取各种事务监控。JTS是CORBA OTS事务监控的基本的实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持Java Transaction API (JTA)规范，并且在较底层实现OMG OTS specification的Java映像。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。

十一、JavaMail and JavaBeans Activation Framework

JavaMail是用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类。仅支持SMTP服务器，也支持IMAP服务器。JavaMail 利用JavaBeans Activation Framework (JAF)来处理MIME-编码的邮件附件。MIME的字节流可以被转换成Java对象，或者转换自Java对象。由此大多数应用都可以不需要直接使用 JAF。

十二、Java Messaging Service (JMS)

JMS是用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域，有支持发布/订阅(publish/subscribe) 类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另一种方式来对您的应用 与legacy backend系统相集成。

十三、Extensible Markup Language (XML) 字串7

XML是一种可以用来定义其它标记语言的语言。它被用来在不同的商务过程中共享数据。XML的发展和Java是相互独立的，但是，它和Java具有 的相同目标正是平台独立性。通过将Java和XML的组合，您可以得到一个完美的具有平台独立性的解决方案。目前正有许多不同的公司在为Java和XML 的组合而努力。如果要了解更多的这方面的信息，可以访问Sun的Java-XML页面，或者IBM developerWorks的XML Zone。

1.字符

x    字符 x。例如a表示字符a
\\    反斜线字符。在书写时要写为\\\\。（注意：因为java在第一次解析时,把\\\\解析成正则表达式\\，在第二次解析时再解析为\，所以凡是不是1.1列举到的转义字符，包括1.1的\\,而又带有\的都要写两次）
\0n    带有八进制值 0的字符 n (0 <= n <= 7)
\0nn    带有八进制值 0的字符 nn (0 <= n <= 7)
\0mnn    带有八进制值 0的字符 mnn（0 <= m <= 3、0 <= n <= 7）
\xhh    带有十六进制值 0x的字符 hh
\uhhhh    带有十六进制值 0x的字符 hhhh
\t    制表符 ('\u0009')
\n    新行（换行）符 ('\u000A')
\r    回车符 ('\u000D')
\f    换页符 ('\u000C')
\a    报警 (bell) 符 ('\u0007')
\e    转义符 ('\u001B')
\cx    对应于 x 的控制符
2.字符类
[abc]    a、b或 c（简单类）。例如[egd]表示包含有字符e、g或d。
[^abc]    任何字符，除了 a、b或 c（否定）。例如[^egd]表示不包含字符e、g或d。
[a-zA-Z]    a到 z或 A到 Z，两头的字母包括在内（范围）
[a-d[m-p]]    a到 d或 m到 p：[a-dm-p]（并集）
[a-z&&[def]]    d、e或 f（交集）
[a-z&&[^bc]]    a到 z，除了 b和 c：[ad-z]（减去）
[a-z&&[^m-p]]    a到 z，而非 m到 p：[a-lq-z]（减去）
3.预定义字符类(注意反斜杠要写两次，例如\d写为\\d)任何字符

（与行结束符可能匹配也可能不匹配）
\d    数字：[0-9]
\D    非数字： [^0-9]
\s    空白字符：[ \t\n\x0B\f\r]
\S    非空白字符：[^\s]
\w    单词字符：[a-zA-Z_0-9]
\W    非单词字符：[^\w]
4.POSIX 字符类（仅 US-ASCII)(注意反斜杠要写两次，例如\p{Lower}写为\\p{Lower})
\p{Lower}    小写字母字符：[a-z]。
\p{Upper}    大写字母字符：[A-Z]
\p{ASCII}    所有 ASCII：[\x00-\x7F]
\p{Alpha}    字母字符：[\p{Lower}\p{Upper}]
\p{Digit}    十进制数字：[0-9]
\p{Alnum}    字母数字字符：[\p{Alpha}\p{Digit}]
\p{Punct}    标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph}    可见字符：[\p{Alnum}\p{Punct}]
\p{Print}    可打印字符：[\p{Graph}\x20]
\p{Blank}    空格或制表符：[ \t]
\p{Cntrl}    控制字符：[\x00-\x1F\x7F]
\p{XDigit}    十六进制数字：[0-9a-fA-F]
\p{Space}    空白字符：[ \t\n\x0B\f\r]
5.java.lang.Character 类（简单的 java 字符类型）
\p{javaLowerCase}    等效于 java.lang.Character.isLowerCase()
\p{javaUpperCase}    等效于 java.lang.Character.isUpperCase()
\p{javaWhitespace}    等效于 java.lang.Character.isWhitespace()
\p{javaMirrored}    等效于 java.lang.Character.isMirrored()
6.Unicode 块和类别的类
\p{InGreek}    Greek 块（简单块）中的字符
\p{Lu}    大写字母（简单类别）
\p{Sc}    货币符号
\P{InGreek}    所有字符，Greek 块中的除外（否定）
[\p{L}&&[^\p{Lu}]]     所有字母，大写字母除外（减去）
7.边界匹配器
^    行的开头，请在正则表达式的开始处使用^。例如：^(abc)表示以abc开头的字符串。注意编译的时候要设置参数MULTILINE，如 Pattern p = Pattern.compile(regex,Pattern.MULTILINE);
$    行的结尾，请在正则表达式的结束处使用。例如：(^bca).*(abc$)表示以bca开头以abc结尾的行。
\b    单词边界。例如\b(abc)表示单词的开始或结束包含有abc,（abcjj、jjabc 都可以匹配）
\B    非单词边界。例如\B(abc)表示单词的中间包含有abc,(jjabcjj匹配而jjabc、abcjj不匹配)
\A    输入的开头
\G    上一个匹配的结尾(个人感觉这个参数没什么用)。例如\\Gdog表示在上一个匹配结尾处查找dog如果没有的话则从开头查找,注意如果开头不是dog则不能匹配。
\Z    输入的结尾，仅用于最后的结束符（如果有的话）
行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。
以下代码被识别为行结束符：
‐新行（换行）符 ('\n')、
‐后面紧跟新行符的回车符 ("\r\n")、
‐单独的回车符 ('\r')、
‐下一行字符 ('\u0085')、
‐行分隔符 ('\u2028') 或
‐段落分隔符 ('\u2029)。
\z    输入的结尾
当编译模式时，可以设置一个或多个标志，例如
Pattern pattern = Pattern.compile(patternString,Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CASE);
下面六个标志都是支持的：
‐CASE_INSENSITIVE：匹配字符时与大小写无关，该标志默认只考虑US ASCII字符。
‐UNICODE_CASE：当与CASE_INSENSITIVE结合时，使用Unicode字母匹配
‐MULTILINE：^和$匹配一行的开始和结尾，而不是整个输入
‐UNIX_LINES： 当在多行模式下匹配^和$时，只将'\n'看作行终止符
‐DOTALL: 当使用此标志时，.符号匹配包括行终止符在内的所有字符
‐CANON_EQ: 考虑Unicode字符的规范等价
8.Greedy 数量词
X?    X，一次或一次也没有
X*    X，零次或多次
X+    X，一次或多次
X{n}    X，恰好 n 次
X{n,}    X，至少 n 次
X{n,m}    X，至少 n 次，但是不超过 m 次
9.Reluctant 数量词
X??    X，一次或一次也没有
X*?    X，零次或多次
X+?    X，一次或多次
X{n}?    X，恰好 n 次
X{n,}?    X，至少 n 次
X{n,m}?    X，至少 n 次，但是不超过 m 次
10.Possessive 数量词
X?+    X，一次或一次也没有
X*+    X，零次或多次
X++    X，一次或多次
X{n}+    X，恰好 n 次
X{n,}+    X，至少 n 次
X{n,m}+    X，至少 n 次，但是不超过 m 次
Greedy，Reluctant，Possessive的区别在于:(注意仅限于进行.等模糊处理时)
greedy量 词被看作“贪婪的”，因为它第一次就读入整个被模糊匹配的字符串。如果第一个匹配尝试（整个输入字符串）失败，匹配器就会在被匹配字符串中的最后一位后退一个字符并且再次尝试，重复这个过程，直到找到匹配或者没有更多剩下的字符可以后退为止。根据表达式中使用的量词，它最后试图匹配的内容是1 个或者0个字符。
但是，reluctant量词采取相反的方式：它们从被匹配字符串的开头开始，然后逐步地一次读取一个字符搜索匹配。它们最后试图匹配的内容是整个输入字符串。
最后，possessive量词总是读完整个输入字符串，尝试一次（而且只有一次）匹配。和greedy量词不同，possessive从不后退。
11.Logical 运算符
XY    X 后跟 Y
X|Y    X 或 Y
(X)    X，作为捕获组。例如(abc)表示把abc作为一个整体进行捕获
12.Back 引用
\n    任何匹配的 nth捕获组
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C)))中，存在四个这样的组：
1        ((A)(B(C)))
2        \A
3        (B(C))
4        (C)
在表达式中可以通过\n来对相应的组进行引用，例如(ab)34\1就表示ab34ab，(ab)34(cd)\1\2就表示ab34cdabcd。
13.引用
\    Nothing，但是引用以下字符
\Q    Nothing，但是引用所有字符，直到 \E。QE之间的字符串会原封不动的使用(1.1中转义字符的除外)。例如, ab\\Q{|}\\\\E
可以匹配ab{|}\\
\E    Nothing，但是结束从 \Q开始的引用
14.特殊构造（非捕获）
(?:X)    X，作为非捕获组
(?idmsux-idmsux)     Nothing，但是将匹配标志由 on 转为 off。比如：表达式 (?i)abc(?-i)def 这时，(?i) 打开不区分大小写开关，abc 匹配
idmsux说明如下：
‐i CASE_INSENSITIVE :US-ASCII 字符集不区分大小写。(?i)
‐d UNIX_LINES : 打开UNIX换行符
‐m MULTILINE :多行模式(?m)
UNIX下换行为\n
WINDOWS下换行为\r\n(?s)
‐u UNICODE_CASE : Unicode 不区分大小写。(?u)
‐x COMMENTS :可以在pattern里面使用注解，忽略pattern里面的whitespace，以及"#"一直到结尾（#后面为注解）。(?x)例如(?x)abc#asfsdadsa可以匹配字符串abc
(?idmsux-idmsux:X)     X，作为带有给定标志 on - off 的非捕获组。与上面的类似，上面的表达式，可以改写成为：(?i:abc)def，或者 (?i)abc(?-i:def)
(?=X)    X，通过零宽度的正 lookahead。零宽度正先行断言，仅当子表达式 X 在 此位置的右侧匹配时才继续匹配。例如，\w+(?=\d) 表示字母后面跟数字，但不捕获数字（不回溯）
(?!X)    X，通过零宽度的负 lookahead。零宽度负先行断言。仅当子表达式 X 不在 此位置的右侧匹配时才继续匹配。例如，\w+(?!\d) 表示字母后面不跟数字，且不捕获数字。
(?<=X)    X，通过零宽度的正 lookbehind。零宽度正后发断言。仅当子表达式 X 在 此位置的左侧匹配时才继续匹配。例如，(?<=19)99 表示99前面是数字19，但不捕获前面的19。（不回溯）
(? (?>X)    X，作为独立的非捕获组（不回溯）
(?=X)与(?>X)的区别在于(?>X)是不回溯的。例如被匹配的字符串为abcm
当表达式为a(?:b|bc)m是可以匹配的，而当表达式是a(?>b|bc)时是不能匹配的，因为当后者匹配到b时，由于已经匹配，就跳出了非捕获组，而不再次对组内的字符进行匹配。可以加快速度。

Java下的一个简单易用的反编译工具jad, 可以很方便的将.class反编译为.Java. 点击下载  

一、基本用法
Usage:jad [option(s)]
直接输入类文件名，且支持通配符，如下所示。
c:\Java\>jad example1.class
c:\Java\>jad *.class
结果是将example1.class反编译为example1.jad。将example1.jad改为example1.Java即得源文件。

二、Option -o
不提示，覆盖源文件

三、Option -s
c:\Java\>jad -sJava example1.class
反编译结果以.Java为扩展名。

四、Option -p
将反编译结果输出到屏幕
c:\Java\>jad -p example1.class
将反编译结果重定向到文件
c:\Java\>jad -p example1.class>example1.Java

五、Option -d
指定反编译的输出文件目录
c:\Java\>jad -o -dtest -sJava *.class

该文章转载自网络大本营：http://www.haoad.net/Info/3883.Html

　　反编译别人的程序是不对的，但是有时候由于某种原因，不得不反编译别人的代码，那就需要一个工具了。小颖JAVA源代码反编译专家V1.4终极版是个很好的工具，但是只能对JDK1.4.2和之前的版本编译的程序反编译，而JDK5.0后的就无能为力了，但是可以下载JAD.EXE来逐个反编译 CLASS文件，不过如果碰到有几十个或几百个文件夹，并且目录很深的时候，就麻烦了，这个给出一个直接使用命令行反编译整个目录的方法：使用jad批量反编译

jad -o -r -sjava -d src bin/**/*.class

src: 是反编後的目錄

bin:指 package 開頭

将bin里面所有的.class反编译到src下面JAD下载： 文件名: jadnt157.ziphttp://download.pchome.net/php/dl.php?sid=9111

jad:反编译工具
可以将class文件反编译成java文件
假设将jad.exe安装在f:\java\jad目录下
把要反编译的文件*.class复制到此目录下，接着接以下步骤，
在命令行窗口环境中进入jad目录，
然后运行：jad -s java *.class   (附，*.class指要反编译的文件名)
如果*.class文件和jad程序不在同一个目录，就要用到path环境变量，
将jad 所在目录加到path路径中即可：set path=%path%;f:\java\jad
若要了解jad更为详细的使用帮助信息，直接运行jad.exe查看

以下假设jad.exe在c:\java目录下

一、基本用法
Usage:jad [option(s)]
直接输入类文件名，且支持通配符，如下所示。
c:\java\>jad example1.class
c:\java\>jad *.class
结果是将example1.class反编译为example1.jad。将example1.jad改为example1.java即得源文件。

二、Option -o
不提示，覆盖源文件

三、Option -s
c:\java\>jad -sjava example1.class
反编译结果以.java为扩展名。

四、Option -p
将反编译结果输出到屏幕
c:\java\>jad -p example1.class
将反编译结果重定向到文件
c:\java\>jad -p example1.class>example1.java

五、Option -d
指定反编译的输出文件目录
c:\java\>jad -o -dtest -sjava *.class

六、Option -r
按*.class的包结构输出文件目录
c:\java\>jad -o -r -dtest -sjava d:/1/**/*.class
将d:\1\文件夹下的.class文件按照原程序的包结构反编译到test目录下。

命令行选择的列表

      -a        - 用JVM字节格式来注解输出
      -af       - 同 -a,但是注解的时候用全名称
      -clear    - 清除所有的前缀
      -b        - 输出多于的括号 (e.g., if(a) { b(); }, default: no)
      -d

  byte[] bos = new byte[1024];
  int length = 0;
  try {

   response.setContentType("application/x-msdownload");
   response.setHeader("Content-disposition", "attachment;filename="
     + new String(fileName.getBytes("gb2312"),"iso8859-1"));
  
   fis = new FileInputStream(file);
   os = response.getOutputStream();
   while((length=fis.read(bos))!=-1){
    os.write(bos, 0, length);
//    os.flush();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   try {
    if(os!=null)
     os.close();
    if(fis!=null)
     fis.close();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }

注意:

1.response.setContentType("application/x-msdownload");

2.response.setHeader("Content-disposition", "attachment;filename="
     + new String(fileName.getBytes("gb2312"),"iso8859-1"));

 PS:解决下载中文乱码 fileName.getBytes("gb2312"),"iso8859-1")

3.待解决问题：选择图片下载时候点取消抛异常

----------------------------------------------------------------------------------------------
用commons.fileupload实现文件的上传和下载2008年04月11日 星期五 15:27commons.fileupload实现文件的上传，需要用到的组件如下：

1）Commons-fileupload-1.1.zip,下载地址为http://archive.apache.org/dist/jakarta/commons/fileupload/

2)commons-io-1.1.zip,下载地址为:http://archive.apache.org/dist/jakarta/commons/io/

代码如下：
<%!
//服务器端保存上传文件的路径
    String saveDirectory = "g:\\upload\\";
    // 临时路径 一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
    String tmpDirectory = "g:\\upload\\tmp\\";
    // 最多只允许在内存中存储的数据大小,单位:字节
    int maxPostSize = 1024 * 1024;
%>
<%
    // 文件内容
    String FileDescription = null;
    // 文件名（包括路径）
    String FileName = null;
    // 文件大小
    long FileSize = 0;
    // 文件类型
    String ContentType = null;

%>

<%
   DiskFileUpload fu = new DiskFileUpload();//创建一个新的文件上传句柄
    // 设置允许用户上传文件大小,单位:字节
   fu.setSizeMax(200*1024*1024);
    // 设置最多只允许在内存中存储的数据,单位:字节
   fu.setSizeThreshold(maxPostSize);
    // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录
   fu.setRepositoryPath("g:\\upload\\tmp\\");
    //开始读取上传信息 得到所有文件
   try{
      List fileItems = fu.parseRequest(request);//解析上传的请求
     }catch(FileUploadException e){
         //这里异常产生的原因可能是用户上传文件超过限制、不明类型的文件等
         //自己处理的代码
     }
%>
<%
// 依次处理每个上传的文件
   Iterator iter = fileItems.iterator();
   while (iter.hasNext()) {
     FileItem item = (FileItem) iter.next();
       //忽略其他不是文件域的所有表单信息
     if (!item.isFormField()) {
       String name = item.getName();
       long size = item.getSize();
       String contentType = item.getContentType();
     if((name==null||name.equals("")) && size==0)
       continue;
%>
<%
   //保存上传的文件到指定的目录
String[] names=StringUtils.split(name,"\\"); //对原来带路径的文件名进行分割
   name = names[names.length-1];
   item.write(new File(saveDirectory+ name));
}
}
%>
下面是其简单的使用场景：
A、上传项目只要足够小，就应该保留在内存里。
B、较大的项目应该被写在硬盘的临时文件上。
C、非常大的上传请求应该避免。
D、限制项目在内存中所占的空间，限制最大的上传请求，并且设定临时文件的位置。

可以根据具体使用用servlet来重写，具体参数配置可以统一放置到一配置文件

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

文件的下载用servlet实现
      public void doGet(HttpServletRequest request,
                       HttpServletResponse response)
     {
        String aFilePath = null;    //要下载的文件路径
         String aFileName = null;    //要下载的文件名
         FileInputStream in = null; //输入流
         ServletOutputStream out = null; //输出流

         try
    {
        
             aFilePath = getFilePath(request);
             aFileName = getFileName(request);

             response.setContentType(getContentType(aFileName) + "; charset=UTF-8");
             response.setHeader("Content-disposition", "attachment; filename=" + aFileName);

             in = new FileInputStream(aFilePath + aFileName); //读入文件
            out = response.getOutputStream();
            out.flush();
           int aRead = 0;
           while((aRead = in.read()) != -1 & in != null)
       {
             out.write(aRead);
         }
           out.flush();
      }
       catch(Throwable e)
     {
     log.error("FileDownload doGet() IO error!",e);
      }
         finally
         {
             try
             {
                 in.close();
                 out.close();
             }
             catch(Throwable e)
             {
             log.error("FileDownload doGet() IO close error!",e);
             }
         }
     }

pg:pager【这个标签用来设置分页的总体参数】重要参数说明：
 url:分页的链接根地址，pager标签会在这个链接的基础上附加分页参数
 items:总记录数，pager标签正是根据这个值来计算分页参数的
 maxPageItems:每页显示的行数，默认为10
 maxIndexPages:在循环输出页码的时候，最大输出多少个页码，默认是10
 
pg:first【第一页的标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 首页第一行的索引值
 lastItem - 首页最后一行的索引值
 
pg:pre【上一页标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 前页第一行的索引值
 lastItem - 前页最后一行的索引值

pg:next【下一页标签】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 下页第一行的索引值
 lastItem - 下页最后一行的索引值
 
pg:last重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - 尾页第一行的索引值
 lastItem - 尾页最后一行的索引值
 
pg:pages【这个标签用来循环输出页码信息】重要参数说明：
 export变量的意义：
 pageUrl - 分页链接URL地址（最重要的export参数）
 pageNumber - 页码
 firstItem - pageNumber这个页码指定的那一页的第一行的索引值
 lastItem - pageNumber这个页码指定的那一页的最后一行的索引值

 public void init(ServletConfig config) throws ServletException {
  savePath = config.getInitParameter("savePath");//得到初始化信息
  sc = config.getServletContext();//得到ServletContext接口的实例
 }

 private static final long serialVersionUID = 7093971456528100363L;

 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  doPost(request, response);
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  DiskFileItemFactory factory = new DiskFileItemFactory();
  ServletFileUpload upload = new ServletFileUpload(factory);
  try {
   List items = upload.parseRequest(request);
   for (int i = 0; i < items.size(); i++) {
    FileItem item = (FileItem) items.get(i);
    if (item.isFormField()) {
     System.out.println("表单的参数名称：" + item.getFieldName()
       + ",对应的参数值：" + item.getString("UTF-8"));
    } else {
     if (item.getName() != null && !item.getName().equals("")) {
      System.out.println("上传文件的大小:" + item.getSize());
      System.out.println("上传文件的类型:" + item.getContentType());
      System.out.println("上传文件的名称:" + item.getName());

      File temFile = new File(item.getName());
      File file = new File(sc.getRealPath("/") + savePath,
        temFile.getName());
      item.write(file);

      request.setAttribute("upload.message", "上传文件成功！");
     } else {
      request.setAttribute("upload.message", "没有上传文件成功！");
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("upload.message", "没有上传文件成功！");
  }
  request.getRequestDispatcher("/uploadresult.jsp").forward(request, response);
 }
}
-----------------------------------------------------------------------------------
4 配置web.xml
<servlet>
    <servlet-name>UploadServlet</servlet-name>
    <servlet-class>com.webs.UploadServlet</servlet-class>
    <init-param>
    <param-name>savePath</param-name>
    <param-value>uploads</param-value>
    </init-param>
  </servlet>

  <servlet-mapping>
    <servlet-name>UploadServlet</servlet-name>
    <url-pattern>/servlet/upload</url-pattern>
  </servlet-mapping>

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
Apache的commons-fileupload.jar可方便的实现文件的上传功能，本文通过实例来介绍如何使用commons-fileupload.jar。
@author:ZJ 07-2-22
Blog: http://zhangjunhd.blog.51cto.com/
    将Apache的commons-fileupload.jar放在应用程序的WEB-INF\lib下，即可使用。下面举例介绍如何使用它的文件上传功能。
所使用的fileUpload版本为1.2，环境为Eclipse3.3+MyEclipse6.0。FileUpload 是基于 Commons IO的，所以在进入项目前先确定Commons IO的jar包（本文使用commons-io-1.3.2.jar）在WEB-INF\lib下。
此文作示例工程可在文章最后的附件中下载。
示例1
最简单的例子，通过ServletFileUpload静态类来解析Request，工厂类FileItemFactory会对mulipart类的表单中的所有字段进行处理，不只是file字段。getName（）得到文件名，getString（）得到表单数据内容，isFormField（）可判断是否为普通的表单项。
demo1.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
       //必须是multipart的表单数据。
    <form name="myform" action="demo1.jsp" method="post"
       enctype="multipart/form-data">
       Your name: <br>
       <input type="text" name="name" size="15"><br>
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo1.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
    boolean isMultipart = ServletFileUpload.isMultipartContent(request);//检查输入请求是否为multipart表单数据。
    if (isMultipart == true) {
       FileItemFactory factory = new DiskFileItemFactory();//为该请求创建一个DiskFileItemFactory对象，通过它来解析请求。执行解析后，所有的表单项目都保存在一个List中。
       ServletFileUpload upload = new ServletFileUpload(factory);
       List<FileItem> items = upload.parseRequest(request);
       Iterator<FileItem> itr = items.iterator();
       while (itr.hasNext()) {
           FileItem item = (FileItem) itr.next();
           //检查当前项目是普通表单项目还是上传文件。
           if (item.isFormField()) {//如果是普通表单项目，显示表单内容。
       String fieldName = item.getFieldName();
       if (fieldName.equals("name")) //对应demo1.html中type="text" name="name"
           out.print("the field name is" + item.getString());//显示表单内容。
       out.print("<br>");
           } else {//如果是上传文件，显示文件名。
       out.print("the upload file name is" + item.getName());
       out.print("<br>");
           }
       }
    } else {
       out.print("the enctype must be multipart/form-data");
    }
%>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
</body>
</html>

结果：
the field name isjeff
the upload file name isD:\C语言考试样题\作业题.rar

示例2
上传两个文件到指定的目录。
demo2.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
    <form name="myform" action="demo2.jsp" method="post"
       enctype="multipart/form-data">
       File1:<br>
       <input type="file" name="myfile"><br>
       File2:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo2.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%String uploadPath="D:\\temp";
  boolean isMultipart = ServletFileUpload.isMultipartContent(request);
  if(isMultipart==true){
      try{
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        List<FileItem> items = upload.parseRequest(request);//得到所有的文件
       Iterator<FileItem> itr = items.iterator();
        while(itr.hasNext()){//依次处理每个文件
         FileItem item=(FileItem)itr.next();
         String fileName=item.getName();//获得文件名，包括路径
         if(fileName!=null){
             File fullFile=new File(item.getName());
             File savedFile=new File(uploadPath,fullFile.getName());
             item.write(savedFile);
         }
        }
        out.print("upload succeed");
      }
      catch(Exception e){
         e.printStackTrace();
      }
  }
  else{
      out.println("the enctype must be multipart/form-data");
  }
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GB18030">
<title>File upload</title>
</head>
<body>
</body>
</html>

结果：
upload succeed

此时，在"D:\temp"下可以看到你上传的两个文件。
示例3
上传一个文件到指定的目录，并限定文件大小。
demo3.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
    <form name="myform" action="demo3.jsp" method="post"
       enctype="multipart/form-data">
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

demo3.jsp
<%@ page language="java" contentType="text/html; charset=GB18030"
    pageEncoding="GB18030"%>
<%@ page import="org.apache.commons.fileupload.*"%>
<%@ page import="org.apache.commons.fileupload.servlet.*"%>
<%@ page import="org.apache.commons.fileupload.disk.*"%>
<%@ page import="java.util.*"%>
<%@ page import="java.io.*"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
    File uploadPath = new File("D:\\temp");//上传文件目录
    if (!uploadPath.exists()) {
       uploadPath.mkdirs();
    }
    // 临时文件目录
    File tempPathFile = new File("d:\\temp\\buffer\\");
    if (!tempPathFile.exists()) {
       tempPathFile.mkdirs();
    }
    try {
       // Create a factory for disk-based file items
       DiskFileItemFactory factory = new DiskFileItemFactory();

       // Set factory constraints
       factory.setSizeThreshold(4096); // 设置缓冲区大小，这里是4kb
       factory.setRepository(tempPathFile);//设置缓冲区目录

       // Create a new file upload handler
       ServletFileUpload upload = new ServletFileUpload(factory);

       // Set overall request size constraint
       upload.setSizeMax(4194304); // 设置最大文件尺寸，这里是4MB

       List<FileItem> items = upload.parseRequest(request);//得到所有的文件
       Iterator<FileItem> i = items.iterator();
       while (i.hasNext()) {
           FileItem fi = (FileItem) i.next();
           String fileName = fi.getName();
           if (fileName != null) {
       File fullFile = new File(fi.getName());
       File savedFile = new File(uploadPath, fullFile
              .getName());
       fi.write(savedFile);
           }
       }
       out.print("upload succeed");
    } catch (Exception e) {
       e.printStackTrace();
    }
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=GB18030">
<title>File upload</title>
</head>
<body>
</body>
</html>

示例4
利用Servlet来实现文件上传。
Upload.java
package com.zj.sample;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;

@SuppressWarnings("serial")
public class Upload extends HttpServlet {
    private String uploadPath = "D:\\temp"; // 上传文件的目录
    private String tempPath = "d:\\temp\\buffer\\"; // 临时文件目录
    File tempPathFile;

    @SuppressWarnings("unchecked")
    public void doPost(HttpServletRequest request, HttpServletResponse response)
           throws IOException, ServletException {
       try {
           // Create a factory for disk-based file items
           DiskFileItemFactory factory = new DiskFileItemFactory();

           // Set factory constraints
           factory.setSizeThreshold(4096); // 设置缓冲区大小，这里是4kb
           factory.setRepository(tempPathFile);// 设置缓冲区目录

           // Create a new file upload handler
           ServletFileUpload upload = new ServletFileUpload(factory);

           // Set overall request size constraint
           upload.setSizeMax(4194304); // 设置最大文件尺寸，这里是4MB

           List<FileItem> items = upload.parseRequest(request);// 得到所有的文件
           Iterator<FileItem> i = items.iterator();
           while (i.hasNext()) {
              FileItem fi = (FileItem) i.next();
              String fileName = fi.getName();
              if (fileName != null) {
                  File fullFile = new File(fi.getName());
                  File savedFile = new File(uploadPath, fullFile.getName());
                  fi.write(savedFile);
              }
           }
           System.out.print("upload succeed");
       } catch (Exception e) {
           // 可以跳转出错页面
           e.printStackTrace();
       }
    }

    public void init() throws ServletException {
       File uploadFile = new File(uploadPath);
       if (!uploadFile.exists()) {
           uploadFile.mkdirs();
       }
       File tempPathFile = new File(tempPath);
        if (!tempPathFile.exists()) {
           tempPathFile.mkdirs();
       }
    }
}

demo4.html
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=GB18030">
    <title>File upload</title>
</head>
<body>
// action="fileupload"对应web.xml中<servlet-mapping>中<url-pattern>的设置.
    <form name="myform" action="fileupload" method="post"
       enctype="multipart/form-data">
       File:<br>
       <input type="file" name="myfile"><br>
       <br>
       <input type="submit" name="submit" value="Commit">
    </form>
</body>
</html>

web.xml
<servlet>
    <servlet-name>Upload</servlet-name>
    <servlet-class>com.zj.sample.Upload</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>Upload</servlet-name>
    <url-pattern>/fileupload</url-pattern>
</servlet-mapping>

 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  doPost(request,response);
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  file=this.doAtta(request);
  MultiPartEmail email=new MultiPartEmail();//生成SimpleEmail对象
  email.setHostName("smtp.163.com");//生成邮件
  email.setAuthentication("ywj_316", "1234567890");//建立用户
  email.setCharset("UTF-8");//邮件内容编码
  try {
   email.setFrom(parameters.get("from"));//发件人
   email.addTo(parameters.get("to"));//收件人
   email.setMsg(parameters.get("context"));//内容 
   email.setSubject(parameters.get("title"));//主题
   if(file!=null){
    EmailAttachment attachment=new EmailAttachment();//附什对象
    attachment.setPath(file.getParent());//附件路径
    attachment.setDescription(EmailAttachment.ATTACHMENT);//附件类型
    attachment.setName(file.getName());//附件名称
    email.attach(attachment);
   }
   System.out.println("ssssssssssssssssssssssssssssssssssss");
   email.send();//发送邮件
   request.setAttribute("sendmail.message", "邮件发送成功！");
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("sendmail.message", "邮件发送不成功！");
  }
  request.getRequestDispatcher("/sendResult.jsp").forward(request, response);
 }
 
 public File doAtta(HttpServletRequest request)throws ServletException,IOException{
  DiskFileItemFactory factory = new DiskFileItemFactory();
  ServletFileUpload upload = new ServletFileUpload(factory);
  try {
   List items = upload.parseRequest(request);
   for (int i = 0; i < items.size(); i++) {
    FileItem item = (FileItem) items.get(i);
    if (item.isFormField()) {
     parameters.put(item.getFieldName(), item.getString("UTF-8"));
     System.out.println(item.getFieldName());
     System.out.println(item.getString("UTF-8"));
    } else {
     if (item.getName() != null && !item.getName().equals("")) {
      File temFile = new File(item.getName());
      file = new File(sc.getRealPath("/") + savePath,
        temFile.getName());
      item.write(file);

      request.setAttribute("upload.message", "上传文件成功！");
     } else {
      request.setAttribute("upload.message", "没有上传文件成功！");
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("upload.message", "没有上传文件成功！");
  }
  return file;
 }
 
 public void init(ServletConfig config) throws ServletException {
  savePath = config.getInitParameter("savePath");//得到初始化信息
  sc = config.getServletContext();//得到ServletContext接口的实例
 }
}
3 配置web.xml文件
 <servlet>
    <servlet-name>SendCommMail</servlet-name>
    <servlet-class>com.webs.SendCommMail</servlet-class>
      <init-param>
    <param-name>savePath</param-name>
    <param-value>uploads</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>SendCommMail</servlet-name>
    <url-pattern>/servlet/sendMail</url-pattern>
  </servlet-mapping>
4 页面
 <body>
    发送邮件的程序<br>
    <form action="servlet/sendMail" name="form1"  enctype="multipart/form-data" method="post">
     收件人：<input type="text" name="to"/><br>
    发件人：<input type="text" name="from"/><br>
    主题：<input type="text" name="title"/><br>
    附件：<input type="file" name="file"/><br>
    内容：<input type="text" name="context"/><br>
    <input type="submit"/>
    </form>
  </body>

import java.io.*;

public class SerializationDemo{
        public static void main(String args[]){

//Object serialization
try{
 MyClass object1=new MyClass("Hello",-7,2.7e10);
 System.out.println("object1:"+object1);
 FileOutputStream fos=new FileOutputStream("serial");
 ObjectOutputStream oos=new ObjectOutputStream(fos);
 oos.writeObject(object1);
 oos.flush();
 oos.close();
 }
catch(Exception e){
 System.out.println("Exception during serialization:"+e);
 System.exit(0);
 }

//Object deserialization
try{
 MyClass object2;
 FileInputStream fis=new FileInputStream("serial");
 ObjectInputStream ois=new ObjectInputStream(fis);
 object2=(MyClass)ois.readObject();
 ois.close();
 System.out.println("object2:"+object2);
 }
catch(Exception e){
 System.out.println("Exception during deserialization:"+e);
 System.exit(0);
 }
}
}

class MyClass implements Serializable{
 String s;
 int i;
 double d;
 public MyClass(String s,int i,double d){
  this.s=s;
  this.i=i;
  this.d=d;
 }
 public String toString(){
  return "s="+s+";i="+i+";d="+d;
 }
}

程序运行结果：object1和object2的实例变量是一样的，输出如下：
object1:s=Hello;i=-7;d=2.7E10
object2:s=Hello;i=-7;d=2.7E10

我补充一下：

Object serialization的定义：
Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 

serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序（用Unix下的c开发过网络编程的人应该知道这个概念，我就容易在这上面犯错）等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。

Object serialization主要用来支持2种主要的特性：
1。Java的RMI(remote method invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时，就需要用到serializaiton机制来发送参数和接收返回直。

2。Java的JavaBeans.   Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。

二。sakulagi和rollingpig说的持久化我也说一下。
我觉得你们说的应该是英文里的persistence.但是Java语言里现在只支持lightweight persistence,就是轻量级持久化，这是通过serialization机制来实现的。

persistence是指一个对象的生命周期不由程序是否执行来决定，即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘（本机或其他机器上的非RAM存储器），并在程序重新调用时再读取对象到通常的RAM存储器。

为什么说Java的serialization机制实现的是lightweight persistence?因为你必须显式的序列化和反序列化程序里的对象；而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。  如果以后的Java版本出现一个新的关键字来实现这种机制，比如就是persistence,如果我用

persistence  (String s="chinaunix")

然后系统自动做猫小程序里的那些处理，那么Java就实现了persistence.

【创建新线程的方法有两种】

1 定义线程类实现Runnable接口
public class MyThred implements Runnable{
     @overwrite
     public void run(){}
}

起用线程：
MyThred myThred=new MyThred();
Thread t=new Thread(myThred);
t.start();

2 定义线程类继承Thread类并重写其run方法
public class MyThred extends Thread{
     @overwrite
     public void run(){}
}

起用线程：
MyThred myThred=new MyThred();
myThred.start();

说明：一般使用接口来实现
-------------------------------------------------
【线程状态转换】

【线程控制基本方法】：
isAlive() 判断线程是否还“活”着
getPriority() 获得线程的优先级
setPriority() 设置线程的优先级
Thread.sleep() 将当前线程睡眠指定的毫秒数
join()  调用某线程的该方法，将当前线程与该线程“合并”，即等待
        该线程线束，再恢复当前线程的运行。
yield() 让出CPU，当前线程进入就绪队列等待调度
wait() 当胶线程进入对象的wait pool。
notify()/notifyAll() 唤醒对象的wait pool中的一个/所有等待线程。
Thread.currentThread() 得到当前线程
----------------------------------------------------------------
【sleep/join/yield 方法】

sleep示例:
public class TestInterrupt {
  public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
    //主线程睡眠
    try {Thread.sleep(10000);}
    catch (InterruptedException e) {}
    //停下当前线程，这个方法一般不建议使用
    thread.interrupt();
    //使用这个结束线程
    shutDown();
  }
}

class MyThread extends Thread {
 boolean flag = true;
  public void run(){
    while(flag){
      System.out.println("==="+new Date()+"===");
      try {
 //当前子线程睡眠
        sleep(1000);
 //sleep时被打断会抛InterruptedException
      } catch (InterruptedException e) {
        return;
      }
    }
  }
  //结束线程的方法
  public void shutDown(){
      flag = false;
  }
}

jion示例:
public class TestJoin {
  public static void main(String[] args) {
    MyThread2 t1 = new MyThread2("abcde");
    t1.start();
    try {
        //当前线程合并到主线程，相当于方法调用
     t1.join();
    } catch (InterruptedException e) {}
     
    for(int i=1;i<=10;i++){
      System.out.println("i am main thread");
    }
  }
}
class MyThread2 extends Thread {
  //给当前线程起个别名
  MyThread2(String s){
   super(s);
  }
 
  public void run(){
    for(int i =1;i<=10;i++){
      System.out.println("i am "+getName());
      try {
       sleep(1000);
      } catch (InterruptedException e) {
       return;
      }
    }
  }
}

yield示例:
public class TestYield {
  public static void main(String[] args) {
    //可以用同一个线程类创建不同的线程对象，分别执行
    MyThread3 t1 = new MyThread3("t1");
    MyThread3 t2 = new MyThread3("t2");
    t1.start(); t2.start();
  }
}
class MyThread3 extends Thread {
  MyThread3(String s){super(s);}
  public void run(){
    for(int i =1;i<=100;i++){
      System.out.println(getName()+": "+i);
      if(i%10==0){
 //让出时间给其它线程执行
        yield();
      }
    }
  }
}

--------------------------------------------------------------
【线程的优先级别】getPriority()/setProority(int newPriority)

线程的优先级用数字表示，范围从1到10，默认为5.
Thread.MIN_PRIORITY=1
Thread.MAX_PRIORITY=10
Thread.NORM_PRIORITY=5

示例：
public class TestPriority {
 public static void main(String[] args) {
  Thread t1 = new Thread(new T1());
  Thread t2 = new Thread(new T2());
  //将t1的优先级提高3级
  t1.setPriority(Thread.NORM_PRIORITY + 3);
  t1.start();
  t2.start();
 }
}

class T1 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("T1: " + i);
  }
 }
}

class T2 implements Runnable {
 public void run() {
  for(int i=0; i<1000; i++) {
   System.out.println("------T2: " + i);
  }
 }
}

--------------------------------------------------------------------
【线程的同步】未看完

*.*是指当前目录下所有文件打包到目标目录下

是否是该类或该类的子类类型的对象
instanceof
car instanceof Car

增加的for循环
int[] arr={1,2,4,5,6};
for(int i:arr){}//只用于显示，不可以访问i

System.currentTimeMillis();
以毫秒为单位返回当前时间

java.util.Calendar

1.直接操作对象属性
User u=new User();
Class c=u.getClass();//同Class.forName("p2.User");
Field f=c.getField(fieldName);
Object fv=f.get(u);//得到对象u实例对应f属性的值
f.set(u,value);设置u对象f属性的值为value
2.调用对象成员方法
Class[] argTypes={String.class,int.class};
//上行等同Class[] argTypes=new Class[]{String.class,int.class};
Object[] args=new Object[]{"王五",99};

Class c-u.getClass();
Method m=c.getMethod(methodName,argTypes);
Object result=m.invoke(u,args);
System.out.println(result);
3.调用类成员方法
Class c=Class.forName("className");
Method m=c.getMethod(methodName,argTypes);
Object result=m.invoke(null,args);//没有对象，所以指定为null
---------------------------------------------------------------
获取class对象
*针对引用数据类型
1.调用静态方法Class.forName()
Class.forName("p1.User");
2.调用Object类中定义的getClass()方法
User u=new User();
Class c=u.getClass();
3.使用.class表达式
Class c1=String.class;
Class c2=p1.User.class;
*针对基本数据类型及void
1.使用.class表达式
Class c1=int.class;
Class c2=double.class;
Class c3=void.class;
2.调用相应封装类的.Type属性
Class c1=Integer.TYPE;
Class c2=Double.TYPE;
Class c3=Void.TYPE;
----------------------------------------------
java.lang.reflect.Field
1.获取Field对类(Class类提供)
public Field[] getDeclaredFields()//当前类的所有属性,不包括父类
public Field getDeclaredField(String name)//当前类指定属性，不包括父类
public Field[] getFields()//当前类所有public的属性，包括父类
public Field getField(String name)//当前类指定的public属性，包括父类
2.Field类主要成员方法
public Object get(Object obj)
pbulic void set(Object obj,Object value)
public xxx getXxx(Object obj)
public void setXxx(Object obj,xxx x)//xxx为基本数据类型
public String getName()
public int getModifiers()//当前属性的修饰符
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
返回当前属性前面的注释
public String toString()
public boolean equals(Object obj)
------------------------------------------------------------------------
java.lang.reflect.Method
1.获取Method对类(Class类提供)
public Method[] getDeclaredMethods()//当前类的所有方法,不包括父类
public Method getDeclaredMethod(String name,Class<?> parameterTypes)//当前类指定方法，不包括父类
public Method[] getMethods()//当前类所有public的方法，包括父类
public Method getMethod(String name)//当前类指定的public方法，包括父类
2.Method类主要成员方法
public Object invoke(Object obj,Object args)****
public String getName()
public Class<?>[] getParameterTypes()
public int getModifiers()//当前属性的修饰符
public Class<?> getReturnType()
public Class<?>[] getExceptionTypes()
public <T extends Annotation> T getAnnotation(Class<T> annotationClass)
返回当前属性前面的注释
public String toString()
public boolean equals(Object obj)
-----------------------------------------------------------
java.lang.reflect.Modifier
1.获取Modifier对象
public int getModifieers()
2.Modifier类方法
public static boolean isPublic(int mod)
public static boolean isPrivate(int mod)

--------------------------------------------------------------
java.lang.reflect.Constructor
public T newInstance(Object initargs)

Class c=Class.forName("p1.Person");
Class[] argTypes={String.class,int.class};//参数列表
Constructor cons=c.getConstructor(argTypes);
Object obj=cons.newInstance("中国",5000);

调用无参构造方法
cons=c.getconstructor();
obj=constructor.newInstance();
obj=c.newInstance();
----------------------------------------------------------------
java.lang.reflect.Array

class类方法
public Class<?> getComponentType()//返回数组对象的数据类型

try{
     BufferedWriter bw=new BufferedWriter (new FileWriter("d:\\test.txt"));
     BufferedReader br=new BufferedReader(new FileReader("d:\\test.txt"));
     String s=null;
     for(int i=0;i<=100;i++){
 s=String.valueOf(Math.random());
 bw.write(s);
        bw.newLine();//写一个换行符
     }
     bw.flush();//清空缓存写入文件
     while((s=br.readLine())!=null){
 System.out.println(s);
     }
     bw.close();
     br.close();
}
9 转换流
  InputStreamReader/OutputStreamWriter
  用于字节数据到字符数据之间的转换
  InputStreamReader 需要和 InputStream "套接"
  OutputStreamWriter 需要和 OutputStream "套接"
  InputStream isr=new InputStreamReader(System.in,"ISO8859-1");

try{
  OutputStreamWriter osw=new OutputStreamWriter (new FileOutputStream("d:\\test.txt"));
  osw.write("ssssssssssssssss");
  osw.close();
  osw=new OutputStreamWriter(new FileOutputStream("d:\\test.txt",true),"ISO8859-1");//true是指在原来的基础上添加
  osw.write("ddddddddddddddddddd");
  osw.close();
}

InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String s=br.readLine();

10 流据流，存储和读取java原始类型
DataInputStream(InputStream in)/DataOutputStream(OutputStream out)
boolean readBoolean()
double readDouble()
String readUTF()

11 PrintStream / PrintWriter
printStream ps=null;
try{
   FileOutputStream fos=new FileOutStream("d:\\test.txt");
   ps=new PrintStream(fos);
}
if(ps!=null){
   System.setOut(ps);
}
int ln=0;
for(char c=0;c<=60000;c++){
   System.out.print(c+" ");
   if(ln++>=100){
 System.out.println();
 ln=0;
   }
}

12 ObjectInputStream/ObjectOutputStream
对象读写必须序列化，transient关键字表示该必性不被序列化
class t implements Serializable{
  int i=10;
  transient int j=9;
  double d=2.3;
}

T t=new T();
FileOutputStream fos=new FileOutputStream ();
ObjectOutputStream oos=new ObjectOutputStream (fos);
oos.writeObject(t);
oos.flush();
oos.close();
13 Externalizable接口
方法:
   void readExternal(ObjectInput in)
   void writeExternal(ObjectOutput out)

; 
　　

{ 
　　public static String physicalAddress = "read MAC error!"; 
　　public ReadMAC() { 
　　} 
　　public static String checkPhysicalAddress(){ 
　　try{ 
　　String line; 
　　Process process = Runtime.getRuntime().exec("cmd /c ipconfig /all"); 
　　BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream())); 
　　while ( (line=bufferedReader.readLine()) != null){ 
　　if(line.indexOf("Physical Address. . . . . . . . . :") != -1){ 
　　if(line.indexOf(":") != -1){ 
　　physicalAddress = line.substring(line.indexOf(":")+2); 
　　break; //找到MAC,推出循环 
　　} 
　　} 
　　} 
　　process.waitFor(); 
　　}catch(Exception e){ 
　　e.printStackTrace(); 
　　} 
　　return physicalAddress; 
　　} 
　　public static void main(String[] args) { 
　　System.out.println("本机的MAC地址是: "+ ReadMAC.checkPhysicalAddress()); 
　　} 
　　}

　　用Java编写的程序，可以很方便地运行在各种平台的环境。但在实际的开发过程中，有时不得不涉及一些底层的编程。比如为了防止软件盗用，我们希望软件只能在指定计算机上运行，所以需要程序读取该机区分于其它计算机的硬件特征，如MAC地址等。作为一种跨平台语言，给Java语言提出了挑战。本文正是针对该问题，提出一种直接用纯Java语言，读去MAC地址的编程方法。

　　我们知道，在每一个Java应用程序中都存在着一个与其运行环境相联系的Runtime对象。该对象可执行外部命令、查可用内存等。而多数操作系统都提供有查询该机MAC地址的命令。如在Microsoft的操作系统中，命令IPCONFIG等。本文的思路是在程序中运行一个外部命令，将该命令的运行结果作为一个流(Stream)，读取并分析之，进而实现获取MAC地址的目的。

　　2 Runtime类

　　在每一个Java 应用程序里面，都有惟一的一个Runtime 对象。通过这个Runtime 对象，应用程序可以与其运行环境发生相互作用。

　　一般不实例化一个Runtime对象。但是可以通过调用静态方法Runtime.getRuntime( )而获得对当前Runtime对象的引用。Runtime 类的大多数方法是实例方法。

　　Runtime 对象的作用主要有：执行外部命令;返回空闲内存;运行垃圾回收器;加载动态库等。

　　Applets和其他不可信赖的程序由于没有引起一个安全异常(SecurityException)而不能调用任何的Runtime方法。

　　下面的例子演示了怎样使用Runtime 对象运行一个外部命令。

　　Runtime.getRuntime()返回当前应用程序的Runtime对象，该对象的exec()方法指示Java虚拟机创建一个子进程执行指定的可执行程序，并返回与该子进程对应的Process对象实例。通过Process可以控制该子进程的执行或获取该子进程的信息。第二条语句的目的是等待子进程完成后再往下执行。

　　上面的程序在运行时会执行dir命令。如果在Windows95/98下，命令格式可以写成"command.exe /c dir"。开关/C指明后面跟随的字符串是命令，并在执行命令后关闭DOS 窗口。

　　方法exec还可以打开一个不可执行的程序，但该文件存在关联的应用程序。以打开一个word文档Mydoc.doc文件为例，Java中可以有以下两种写法：

　　在第一种方式中，被执行的命令是start Mydoc.doc，开关E:ON 指定DOS 命令处理器允许命令扩展，而start 命令会开启一个单独的窗口执行所提供的命令。
执行一个有标准输出的DOS命令，程序执行完后往往不会自动关闭，从而导致Java应用程序阻塞在waitfor( )。导致该现象的原因可能是该命令的输出比较多，而运行窗口的输出缓冲区不够大。解决的办法是，利用Java的Process类提供的方法让Java虚拟机截获DOS运行的标准输出，在waitfor()命令之前读出该缓冲区的内容。以运行命令dir为例，典型的程序如下：

以下是引用片段： 　： 　　String line; 　　Process process = Runtime.getRuntime().exec("cmd /c dir"); 　　BufferedReader bufferedReader = new BufferedReader ( new InputStreamReader(process.getInputStream())); 　　while ( (line = bufferedReader.readLine()) != -1) System. out.println(line); 　　process.waitFor( ); 　　：3 Process

　　Runtime.exec方法创建一个本机进程，并返回 Process 子类的一个实例，该实例可用来控制进程并获取相关信息。

　　抽象类Process封装了一个进程(process)，一个正在执行的程序。它主要被当作由Runtime类中的exec( )方法所创建的对象的类型的超类。在抽象类Process中，主要包含了如下一些抽象方法。

　　InputStream getInputStream( )：返回一个从进程的out输出流中读输入的输入流。

　　OutputStream getOutputStream( )：返回一个从进程的in输入流中写输出的输出流。

　　int waitFor( ) throws InterruptedException：返回由进程返回的退出码。这个方法直到调用它的进程中止，才会返回。

　　4 程序编写

　　我们先来分析ipconfig/all的输出格式：

　　从图1中我们看到MAC地址包含的行为：“ Physical Address. . . . . . . . . : 00-10-DC-A9-0B-2C”。为了找到MAC地址，我们一行一行读取字符，只要找到字符串“ Physical Address. . . . . . . . . :”，就可以找到MAC地址了。下面是实现的程序片段：

以下是引用片段： ： 　　Process process = Runtime.getRuntime().exec("cmd /c ipconfig /all"); 　　BufferedReader bufferedReader = 　　new BufferedReader(new InputStreamReader (process.getInputStream())); 　　while ( (line=bufferedReader.readLine()) != null){ 　　if(line.indexOf("Physical Address. . . . . . . . . :") != -1){ 　　if(line.indexOf(":") != -1){ 　　physicalAddress = line.substring(line.indexOf(":")+2); 　　：

　　作为一个跨平台语言，编写的JAVA程序一般都与硬件无关，因而能运行在不同的操作系统环境。但这给编写底层相关的程序时带来不便。

　　Java的应用程序都存在着一个与其运行环境相联系的Runtime对象，利用该对象可执行外部命令，在WindowsXP/NT/2000环境中的命令IPCONFIG的输出包含有MAC地址。本文编写的Java程序，执行外部命令IPCONFIG，并通过分析该命令的输入流而获得本机的MAC地址。由于IPCONFIG命令是操作系统命令，所以该方法既方便又可靠。

　　以上讨论的程序适合于Windows XP/NT/2000操作系统，因为它是基于该操作系统的命令IPCONFIG格式的。由于不同操作系统读取MAC地址的命令、以及命令输出格式的不同，所以该程序不能直接运用到其它系统。要移植到其它系统只需针对命令的输出格式稍作修改。