j2ee jar包

* ant/ant.jar, ant/ant-launcher.jar, ant-trax.jar, ant-junit.jar
- Ant 1.6.5 (http://ant.apache.org)
- used to build the framework and the sample apps

* antlr/antlr-2.7.6.jar
- ANTLR 2.7.6 (http://www.antlr.org)
- required for running PetClinic (by Hibernate3)

--aop联盟 包含在 spring.jar和spring-aop.jar 中 建立framework框架必须的架包
* aopalliance/aopalliance.jar  
- AOP Alliance 1.0 (http://aopalliance.sourceforge.net)
- required for building the framework
- included in spring.jar and spring-aop.jar

--面向切面编程 自动代理必须使用的jar 就是自动代码生成器 同xdoclet
* asm/asm*-2.2.3.jar
- ObjectWeb ASM 2.2.3 (http://asm.objectweb.org)
- required for building the framework
- required at runtime when using parameter name discovery with AspectJ

* aspectj/aspectjweaver.jar, aspectj/aspectjrt.jar, (aspectj/aspectjtools.jar)
- AspectJ 1.5.3 (http://www.aspectj.org)
- required for building the framework
- required at runtime when using Spring's AspectJ support

NOTE: aspectjtools.jar is not included in the Spring distribution because of its size.
It needs to be taken from the AspectJ distribution or from Spring CVS. Note that this
is only necessary if you want to rebuild the Spring jars including the AspectJ aspects.

* axis/axis.jar, axis/saaj.jar, axis/wsdl4j.jar
- Apache Axis 1.4 (http://ws.apache.org/axis)
- required for building the framework
- required for running JPetStore

　全称：Apache EXtensible Interaction System 阿帕奇可扩展交互系统
　　Axis本质上就是一个SOAP引擎，提供创建服务器端、客户端和网关SOAP操作的基本框架。Axis目前版本是为Java编写的，不过为C++的版本正在开发中。但Axis并不完全是一个SOAP引擎，它还包括：
　　是一个独立的SOAP服务器。
　　是一个嵌入Servlet引擎（例如Tomcat）的服务器。
　　支持WSDL。
　　提供转化WSDL为Java类的工具。
　　提供例子程序。
　　提供TCP/IP数据包监视工具。
　　apache wsAxis是第三代Apache SOAP，从2000年起，SOAP v2开发小组开始讨论如何让Axis更加灵活、可配置，以及能够处理SOAP和来自W3C的各种XML标准。通过不断地讨论和代码编写，Axis目前取得了如下成果：
　　速度提高。 Axis通过基于事件的SAX对XML文档进行处理，从而在速度和效率上比Apache SOAP有所提高。
　　灵活性提高。
　　稳定性提高。
　　提供面向组件的部署。
　　提供一个简洁的传输抽象框架。其核心引擎完全于传输方式独立。从而使基于何种协议传输的选择更加灵活。
　　支持WSDL。包括到处WSDL和客户代理生成等。
　　在目前发行1.1版本中有什么东西？
　　SOAP1.1/1.2引擎。
　　灵活的配置和部署系统。
　　支持及时自动生成SOAP服务（JWS）。
　　支持所有的基本数据类型，为自定义串行操作提供类型映射系统。
　　JavaBean的自动串行操作，包括将自定义属性类型映射到XML的属性和元素。
　　RPC和基于消息的SOAP服务提供者。
　　从部署好的服务自动生成WSDL。
　　WSDL2Java工具可以从WSDL描述文件中产生相应的客户和服务器端SOAP操作框架。
　　初步提供安全扩展，能够与Servlet2.2安全集成。
　　通过HTTP Cookie和与传输无关的SOAP头信息提供会话跟踪。
　　初步支持带附件的SOAP消息。
　　在EJB方面提供把EJB作为Web服务的访问途经。
　　基于Servlet的HTTP传输。
　　基于JMS的传输。
　　独立的服务器（但需要HTTP 服务器和Servlet容器支持）。
　　提供客户端、服务器端相关应用程序的样例。
　　Axis的运行需要如下组件包
　　axis.jar
　　jaxrpc.jar
　　saaj.jar
　　commons-logging.jar
　　commons-discovery.jar
　　wsdl4j.jar
　　符合JAXP-1.1的XML处理器。
　　Axis的安装和使用

* bsh/bsh-2.0b4.jar
- BeanShell 2.0 beta 4 (http://www.beanshell.org)
- required for building the framework
- required at runtime when using Spring's BeanShell support

* c3p0/c3p0-0.9.1.1.jar
- C3P0 0.9.1.1 connection pool (http://sourceforge.net/projects/c3p0)
- required for building the framework
- required at runtime when using Spring's C3P0NativeJdbcExtractor
- required for running Image Database

* caucho/hessian-3.0.20.jar
- Hessian/Burlap 3.0.20 (http://www.caucho.com/hessian)
- required for building the framework
- required at runtime when using Spring's Hessian/Burlap remoting support

* cglib/cglib-nodep-2.1_3.jar
- CGLIB 2.1_3 with ObjectWeb ASM 1.5.3 (http://cglib.sourceforge.net)
- required for building the framework
- required at runtime when proxying full target classes via Spring AOP

* commonj/commonj-twm.jar
- CommonJ TimerManager and WorkManager API 1.1 (http://dev2dev.bea.com/wlplatform/commonj/twm.html)
- required for building the framework
- required at runtime when using Spring's CommonJ support

* concurrent/backport-util-concurrent.jar
- Dawid Kurzyniec's JSR-166 backport, version 3.0 (http://dcl.mathcs.emory.edu/util/backport-util-concurrent)
- required for building the framework
- required at runtime when using Spring's backport-concurrent support

* dom4j/dom4j-1.6.1, dom4j/jaxen-1.1-beta-7.jar
- DOM4J 1.6.1 XML parser (http://www.dom4j.org)
- required for running PetClinic (by Hibernate)

* easymock/easymock.jar, easymock/easymockclassextension.jar
- EasyMock 1.2 (JDK 1.3 version) (http://www.easymock.org)
- required for building and running the framework test suite

* ehcache/ehcache-1.2.4.jar
- EHCache 1.2.4 (http://ehcache.sourceforge.net)
- required for building the framework
- required at runtime when using Spring's EHCache support
- required for running PetClinic (by Hibernate)

* freemarker/freemarker.jar
- FreeMarker 2.3.10 (http://www.freemarker.org)
- required for building the framework
- required at runtime when using Spring's FreeMarker support

* glassfish/glassfish-clapi.jar
- GlassFish ClassLoader API extract (http://glassfish.dev.java.net)
- required for building the framework

* groovy/groovy-1.0.jar
- Groovy 1.0 final (http://groovy.codehaus.org)
- required for building the framework
- required at runtime when using Spring's Groovy support

* hibernate/hibernate2.jar
- Hibernate 2.1.8 (http://www.hibernate.org)
- required for building the framework
- required at runtime when using Spring's Hibernate 2.1 support

* hibernate/hibernate3.jar
- Hibernate 3.2.4 (http://www.hibernate.org)
- required for building the framework
- required at runtime when using Spring's Hibernate 3.x support

* hibernate/hibernate-annotation.jar
- Hibernate Annotations 3.3.0 (http://www.hibernate.org)
- required for building the "tiger" part of the framework
- required at runtime when using Spring's Hibernate Annotations support

* hibernate/hibernate-entitymanager.jar
- Hibernate EntityManager 3.3.0 (http://www.hibernate.org)
- required for building the "tiger" part of the framework
- required at runtime when using Spring's Hibernate-specific JPA support

* hibernate/jboss-archive-browsing.jar
- JBoss Archive Browsing 5.0.0 alpha
- required at runtime when using Hibernate EntityManager

* hsqldb/hsqldb.jar
- HSQLDB 1.8.0.1 (http://hsqldb.sourceforge.net)
- required for running JPetStore and PetClinic

* ibatis/ibatis-2.3.0.677.jar
- iBATIS SQL Maps 2.3.0 b677 (http://ibatis.apache.org)
- required for building the framework
- required at runtime when using Spring's iBATIS SQL Maps 2.x support

* itext/itext-1.4.8.jar
- iText PDF 1.4.8 (http://www.lowagie.com/itext)
- required for building the framework
- required at runtime when using Spring's AbstractPdfView

* j2ee/activation.jar
- JavaBeans Activation Framework 1.1 (http://java.sun.com/products/javabeans/glasgow/jaf.html)
- required at runtime when using Spring's JavaMailSender on JDK < 1.6

* j2ee/common-annotations.jar
- JSR-250 Common Annotations (http://jcp.org/en/jsr/detail?id=250)
- required at runtime when using Spring's Common Annotations support on JDK < 1.6

* j2ee/connector.jar
- J2EE Connector Architecture 1.5 (http://java.sun.com/j2ee/connector)
- required for building the framework

* j2ee/ejb.jar
- Enterprise JavaBeans API 2.0 (http://java.sun.com/products/ejb)
- required for building the framework
- required at runtime when using Spring's EJB support

* j2ee/el-api.jar
- JSP 2.1's EL API (http://java.sun.com/products/jsp), as used by JSF 1.2
- required for building the framework
- required at runtime when using Spring's JSF 1.2 support

* j2ee/jaxrpc.jar
- JAX-RPC API 1.1 (http://java.sun.com/xml/jaxrpc)
- required for building the framework
- required at runtime when using Spring's JAX-RPC support

* j2ee/jms.jar
- Java Message Service API 1.1 (java.sun.com/products/jms)
- required for building the framework
- required at runtime when using Spring's JMS support

* j2ee/jsf-api.jar
- JSF API 1.1 (http://java.sun.com/j2ee/javaserverfaces)
- required for building the framework
- required at runtime when using Spring's JSF support

* j2ee/jsp-api.jar
- JSP API 2.0 (http://java.sun.com/products/jsp)
- required for building the framework
- required at runtime when using Spring's JSP support

* j2ee/jstl.jar
- JSP Standard Tag Library API 1.1 (http://java.sun.com/products/jstl)
- required for building the framework
- required at runtime when using Spring's JstlView

* j2ee/jta.jar
- Java Transaction API 1.1 (http://java.sun.com/products/jta)
- required for building the framework
- required at runtime when using Spring's JtaTransactionManager

* j2ee/mail.jar
- JavaMail 1.4 (http://java.sun.com/products/javamail)
- required for building the framework
- required at runtime when using Spring's JavaMailSender

* j2ee/persistence.jar
- Java Persistence API 1.0 (http://www.oracle.com/technology/products/ias/toplink/jpa)
- required for building the framework
- required at runtime when using Spring's JPA support

* j2ee/rowset.jar
- JDBC RowSet Implementations 1.0.1 (http://java.sun.com/products/jdbc)
- required at runtime when using Spring's RowSet support on JDK < 1.5

* j2ee/servlet-api.jar
- Servlet API 2.4 (http://java.sun.com/products/servlet)
- required for building the framework
- required at runtime when using Spring's web support

* jakarta-commons/commons-attributes-api.jar, jakarta-commons/commons-attributes-compiler.jar
- Commons Attributes 2.2 (http://jakarta.apache.org/commons/attributes)
- commons-attributes-api.jar has a patched manifest (not declaring QDox and Ant as required extensions)
- required for building the framework
- required at runtime when using Spring's Commons Attributes support

* jakarta-commons/commons-beanutils.jar
- Commons BeanUtils 1.7 (http://jakarta.apache.org/commons/beanutils)
- required for running JPetStore's Struts web tier

* jakarta-commons/commons-collections.jar
- Commons Collections 3.2 (http://jakarta.apache.org/commons/collections)
- required for building the framework
- optional for using linked/identity maps in Spring core (on JDK < 1.4)
- required for running PetClinic, JPetStore (by Commons DBCP, Hibernate)

* jakarta-commons/commons-dbcp.jar
- Commons DBCP 1.2.2 (http://jakarta.apache.org/commons/dbcp)
- required for building the framework
- required at runtime when using Spring's CommonsDbcpNativeJdbcExtractor
- required for running JPetStore

* jakarta-commons/commons-digester.jar
- Commons Digester 1.6 (http://jakarta.apache.org/commons/digester)
- required for running JPetStore's Struts web tier

* jakarta-commons/commons-discovery.jar
- Commons Discovery 0.2 (http://jakarta.apache.org/commons/discovery)
- required for running JPetStore (by Axis)

* jakarta-commons/commons-fileupload.jar
- Commons FileUpload 1.2 (http://jakarta.apache.org/commons/fileupload)
- required for building the framework
- required at runtime when using Spring's CommonsMultipartResolver

* jakarta-commons/commons-httpclient.jar
- Commons HttpClient 3.0.1 (http://jakarta.apache.org/commons/httpclient)
- required for building the framework
- required at runtime when using Spring's CommonsHttpInvokerRequestExecutor

* jakarta-commons/commons-io.jar
- Commons IO 1.3.1 (http://jakarta.apache.org/commons/io)
- required at runtime when using Spring's CommonsMultipartResolver (by Commons FileUpload)

* jakarta-commons/commons-lang.jar
- Commons Lang 2.2 (http://jakarta.apache.org/commons/lang)
- required at runtime when using Spring's OpenJPA support (by OpenJPA)

* jakarta-commons/commons-logging.jar
- Commons Logging 1.1 (http://jakarta.apache.org/commons/logging)
- required for building the framework
- required at runtime, as Spring uses it for all logging

* jakarta-commons/commons-pool.jar
- Commons Pool 1.3 (http://jakarta.apache.org/commons/pool)
- required for running JPetStore and Image Database (by Commons DBCP)

* jakarta-commons/commons-validator.jar
- Commons Validator 1.1.4 (http://jakarta.apache.org/commons/validator)
- required for running JPetStore's Struts web tier on servers that eagerly load tag libraries (e.g. Resin)

* jakarta-taglibs/standard.jar
- Jakarta's JSTL implementation 1.1.2 (http://jakarta.apache.org/taglibs)
- required for running JPetStore, PetClinic, Countries

* jamon/jamon-2.4.jar
- JAMon API (Java Application Monitor) 2.4 (http://www.jamonapi.com)
- required for building the framework
- required at runtime when using Spring's JamonPerformanceMonitorInterceptor

* jasperreports/jasperreports-1.3.3.jar
- JasperReports 1.3.3 (http://jasperreports.sourceforge.net)
- required for building the framework
- required at runtime when using Spring's JasperReports support

--提供独立事务的应用
* jdo/jdo2-api.jar
- JDO API 2.0 (http://db.apache.org/jdo)
- required for building the framework
- required at runtime when using Spring's JDO support (or jdo.jar for JDO 1.0)

* jexcelapi/jxl.jar
- JExcelApi 2.5.7 (http://jexcelapi.sourceforge.net)
- required for building the framework
- required at runtime when using Spring's AbstractJExcelView

* jmx/jmxri.jar
- JMX 1.2.1 reference implementation
- required at runtime when using Spring's JMX support on JDK < 1.5

* jmx/jmxremote.jar
- JMX Remote API 1.0.1 reference implementation
- required at runtime when using Spring's JMX support on JDK < 1.5

* jmx/jmxremote_optional.jar
- JMXMP connector (from JMX Remote API 1.0.1 reference implementation)
- required at runtime when using the JMXMP connector (even on JDK 1.5)

* jotm/jotm.jar
- JOTM 2.0.10 (http://jotm.objectweb.org)
- required for building the framework
- required at runtime when using Spring's JotmFactoryBean

* jotm/xapool.jar
- XAPool 1.5.0 (http://xapool.experlog.com, also included in JOTM)
- required for building the framework
- required at runtime when using Spring's XAPoolNativeJdbcExtractor

* jruby/jruby.jar
- JRuby 0.9.8 (http://jruby.codehaus.org)
- required for building the framework
- required at runtime when using Spring's JRuby support

* junit/junit.jar
- JUnit 3.8.1 (http://www.junit.org)
- required for building the framework's test suite

* log4j/log4j-1.2.14.jar
- Log4J 1.2.14 (http://logging.apache.org/log4j)
- required for building the framework
- required at runtime when using Spring's Log4jConfigurer

* oc4j/oc4j-clapi.jar
- Oracle OC4J 10.1.3.1 ClassLoader API extract (http://www.oracle.com/technology/tech/java/oc4j)
- required for building the framework

* openjpa/openjpa-0.9.7-incubating.jar
- OpenJPA 0.9.7 (http://incubator.apache.org/openjpa)
- required for building the framework
- required at runtime when using Spring's JPA support with OpenJPA as provider

* poi/poi-2.5.1.jar
- Apache POI 2.5.1 (http://jakarta.apache.org/poi)
- required for building the framework
- required at runtime when using Spring's AbstractExcelView

* portlet/portlet-api.jar
- Portlet API 1.0 (http://jcp.org/aboutJava/communityprocess/final/jsr168)
- required for building the framework
- required at runtime when using Spring's Portlet support

* qdox/qdox-1.5.jar
- QDox 1.5 (http://qdox.codehaus.org)
- used by Commons Attributes 2.2 to parse source-level metadata in the build process
- required for building the framework and the attributes version of JPetStore

* quartz/quartz-all-1.6.0.jar
- Quartz 1.6.0 (http://www.opensymphony.com/quartz)
- required for building the framework
- required at runtime when using Spring's Quartz scheduling support

* serp/serp-1.12.1.jar
- Serp 1.12.1 (http://serp.sourceforge.net)
- required at runtime when using OpenJPA

* struts/struts.jar
- Apache Struts 1.2.9 (http://jakarta.apache.org/struts)
- required for building the framework
- required at runtime when using the Struts support or TilesView
- required for running JPetStore's Struts web tier

* tomcat/catalina.jar, tomcat/naming-resources.jar
- Apache Tomcat 5.5.23 (http://tomcat.apache.org)
- required for building the Tomcat-specific weaver

* toplink/toplink-api.jar
- Oracle TopLink 10.1.3 API (http://www.oracle.com/technology/products/ias/toplink)
- required for building the framework
- replaced with full toplink.jar at runtime when using Spring's TopLink support

* toplink/toplink-essentials.jar
- Oracle TopLink Essentials v2 b41 (http://www.oracle.com/technology/products/ias/toplink/jpa)
- required for building the framework
- required at runtime when using Spring's JPA support with TopLink as provider

* velocity/velocity-1.5.jar
- Velocity 1.5 (http://jakarta.apache.org/velocity)
- required for building the framework
- required at runtime when using Spring's VelocityView

* velocity/velocity-tools-view-1.3.jar
- Velocity Tools 1.3 (http://jakarta.apache.org/velocity/tools)
- required for building the framework
- required at runtime when using VelocityView's support for Velocity Tools

--xa连接池 一般不会用到
xapool.jar

--在使用json数据专成xml数据的时候会用到
xom-1.1.jar

--
jaas.jar

Java Authentication Authorization Service（JAAS，Java验证和授权API）提供了灵活和可伸缩的机制来保证客户端或服务器端的Java程序。Java早期的安全框架强调的是通过验证代码的来源和作者，保护用户避免受到下载下来的代码的攻击。JAAS强调的是通过验证谁在运行代码以及他／她的权限来保护系统面受用户的攻击。它让你能够将一些标准的安全机制，例如Solaris NIS（网络信息服务）、Windows NT、LDAP（轻量目录存取协议），Kerberos等通过一种通用的，可配置的方式集成到系统中。

你是否曾经需要为一个应用程序实现登录模块呢？如果你是一个比较有经验的程序员，相信你这样的工作做过很多次，而且每次都不完全一样。你有可能把你的登录模块建立在Oracle数据库的基础上，也有可能使用的是NT的用户验证，或者使用的是LDAP目录。如果有一种方法可以在不改变应用程序级的代码的基础上支持上面提到的所有这一些安全机制，对于程序员来说一定是一件幸运的事。

现在你可以使用JAAS实现上面的目标。JAAS是一个比较新的的Java API。在J2SE 1.3中，它是一个扩展包；在J2SE 1.4中变成了一个核心包。在本文中，我们将介绍JAAS的一些核心概念，然后通过例子说明如何将JAAS应用到实际的程序中。本文的例子是根据我们一个基于Web的Java应用程序进行改编的，在这个例子中，我们使用了关系数据库保存用户的登录信息。由于使用了JAAS，我们实现了一个健壮而灵活的登录和身份验证模块。

客户端和服务器端的JAAS

开发人员可以将JAAS应用到客户端和服务器端。在客户端使用JAAS很简单。在服务器端使用JAAS时情况要复杂一些。目前在应用服务器市场中的JAAS产品还不是很一致，使用JAAS的J2EE应用服务器有一些细微的差别。例如JBossSx使用自己的结构，将JAAS集成到了一个更大的安全框架中；而虽然WebLogic 6.x也使用了JAAS，安全框架却完全不一样。

现在你能够理解为什么我们需要从客户端和服务器端的角度来看JAAS了。我们将在后面列出两种情况下的例子。为了使服务器端的例子程序更加简单，我们使用了Resin应用服务器。

核心JAAS类

在使用JAAS之前，你首先需要安装JAAS。在J2SE 1.4中已经包括了JAAS，但是在J2SE 1.3中没有。如果你希望使用J2SE 1.3，你可以从SUN的官方站点上下载JAAS。当正确安装了JAAS后，你会在安装目录的lib目录下找到jaas.jar。你需要将该路径加入Classpath中。（注：如果你安装了应用服务器，其中就已经包括了JAAS，请阅读应用服务器的帮助文档以获得更详细的信息）。在Java安全属性文件java.security中，你可以改变一些与JAAS相关的系统属性。该文

件保存在＜jre_home＞/lib/security目录中。

在应用程序中使用JAAS验证通常会涉及到以下几个步骤：
　　1. 创建一个LoginContext的实例。
　　2. 为了能够获得和处理验证信息，将一个CallBackHandler对象作为参数传送给LoginContext。
　　3. 通过调用LoginContext的login（）方法来进行验证。
　　4. 通过使用login（）方法返回的Subject对象实现一些特殊的功能（假设登录成功）。

下面是一个简单的例子：

LoginContext lc = new LoginContext("MyExample");
try {
lc.login();
} catch (LoginException) {
// Authentication failed.
}
// Authentication successful, we can now continue.
// We can use the returned Subject if we like.
Subject sub = lc.getSubject();
Subject.doAs(sub, new MyPrivilegedAction());

--使用hibernate的时候才用
jacc-1_0-fr.jar
http://www.blogjava.net/ktoo/archive/2007/08/19/137970.html

Hibernate3.2 核心包作用
包 作用 说明
jta.jar 标准的JTA API 必要
commons-logging.jar 日志功能 必要
commons-collections.jar 集合类 必要
antlr.jar ANother Tool for Language Recognition(antlr) 必要
dom4j.jar XML配置和映射解释器 必要　
Hibernate3.jar 核心库 必要
asm.jar ASM字节码库 如果使用“cglib”则必要
asm-attrs.jar ASM字节码库 如果使用“cglib”则必要
ehcache.jar EHCache缓存 如果没有其它的缓存，则它是必要的
cglib.jar CGLIB 字节码解释器 如果使用“cglib”则必要
      以下包可选
versioncheck.jar 版本检查  
swarmcache.jar    
jboss-cache.jar TreeCache  
jgroups.jar    
xml-apis.jar JAXP API  
c3p0-0.9.1.jar C3PO JDBC链接池  
connector.jar JCA API  
jboss-system.jar   使用TreeCache时必要
jacc-1_0-fr.jar JACC 库  
checkstyle-all.jar    
junit.jar    
javassist.jar Javassist 字节码解释器  
ant-lanuncher.jar    
jaas.jar JAAS API  
jdbc2_0-stdext.jar JDBC扩展API  
ant-antlr.jar Ant antlr支持  
jboss-jmx.jar    
cleanimports.jar cleanimports  
xerces.jar SAX parser JDK版本低于1.4时必要
jaxen-1.1-beta-7.jar Jaxen 如果想提高启动性能则去使用
ant-junit.jar Ant junit support  
ant-swing.jar ant swing support  
ant.jar    
proxool.jar Proxool JDBC连接池  
concurrent.jar   使用TreeCache需要
syndiag2.jar 

          最近搞SSH和一个框架的整合，结果总是出许多莫名奇妙的错误，刚开始基本都是jar包的配置有问题，一会少包，一会多包，

一会又版本冲突。令我很是头疼，搞了我两天，现在还是有配置文件的错误。郁闷之情难以言表。无意中在网上见到了讲jar包功能的随笔

，于是贴过来，做个记录。

了解这些内容有助于我们减小发布包的大小，同时也可以增加对Spring架构的了解。

spring.jar 是包含有完整发布模块的单个jar 包。但是不包括mock.jar, aspects.jar, spring-

portlet.jar, and spring-hibernate2.jar。

spring-src.zip就是所有的源代码压缩包。

除了spring.jar 文件，Spring 还包括有其它21 个独立的jar 包，各自包含着对应的Spring组件，用

户可以根据自己的需要来选择组合自己的jar 包，而不必引入整个spring.jar 的所有类文件。

spring-core.jar
这个jar 文件包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其

它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。
外部依赖Commons Logging， (Log4J)。

spring-beans.jar
这个jar 文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion of

Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，

引入spring-core.jar 及spring-beans.jar 文件就可以了。
外部依赖spring-core，(CGLIB)。

spring-aop.jar
这个jar 文件包含在应用中使用Spring 的AOP 特性时所需的类和源码级元数据支持。使用基于AOP 的

Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个

jar包。
外部依赖spring-core， (spring-beans，AOP Alliance， CGLIB，Commons Attributes)。

spring-context.jar
这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的

全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。
外部依赖spring-beans, (spring-aop)。

spring-dao.jar
这个jar 文件包含Spring DAO、Spring Transaction 进行数据访问的所有类。为了使用声明型事务支

持，还需在自己的应用里包含spring-aop.jar。
外部依赖spring-core，(spring-aop， spring-context， JTA API)。

spring-jdbc.jar
这个jar 文件包含对Spring 对JDBC 数据访问进行封装的所有类。
外部依赖spring-beans，spring-dao。

spring-support.jar
这个jar 文件包含支持UI模版（Velocity，FreeMarker，JasperReports），邮件服务，脚本服务

(JRuby)，缓存Cache（EHCache），任务计划Scheduling（uartz）方面的类。
外部依赖spring-context, (spring-jdbc, Velocity, FreeMarker, JasperReports, BSH, Groovy,

JRuby, Quartz, EHCache)

spring-web.jar
这个jar 文件包含Web 应用开发时，用到Spring 框架时所需的核心类，包括自动载入Web Application

Context 特性的类、Struts 与JSF 集成类、文件上传的支持类、Filter 类和大量工具辅助类。
外部依赖spring-context, Servlet API, (JSP API, JSTL, Commons FileUpload, COS)。

spring-webmvc.jar
这个jar 文件包含Spring MVC 框架相关的所有类。包括框架的Servlets，Web MVC框架，控制器和视图

支持。当然，如果你的应用使用了独立的MVC 框架，则无需这个JAR 文件里的任何类。
外部依赖spring-web, (spring-support，Tiles，iText，POI)。

spring-portlet.jar
spring自己实现的一个类似Spring MVC的框架。包括一个MVC框架和控制器。
外部依赖spring-web， Portlet API，(spring-webmvc)。

spring-struts.jar
Struts框架支持，可以更方便更容易的集成Struts框架。
外部依赖spring-web，Struts。

spring-remoting.jar
这个jar 文件包含支持EJB、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方

面的类。
外部依赖spring-aop， (spring-context，spring-web，Hessian，Burlap，JAX-RPC，EJB API)。

spring-jmx.jar
这个jar包提供了对JMX 1.0/1.2的支持类。
外部依赖spring-beans，spring-aop， JMX API。

spring-jms.jar
这个jar包提供了对JMS 1.0.2/1.1的支持类。
外部依赖spring-beans，spring-dao，JMS API。

spring-jca.jar
对JCA 1.0的支持。
外部依赖spring-beans，spring-dao， JCA API。

spring-jdo.jar
对JDO 1.0/2.0的支持。
外部依赖spring-jdbc， JDO API， (spring-web)。

spring-jpa.jar
对JPA 1.0的支持。
外部依赖spring-jdbc， JPA API， (spring-web)。

spring-hibernate2.jar
对Hibernate 2.1的支持，已经不建议使用。
外部依赖spring-jdbc，Hibernate2，(spring-web)。

spring-hibernate3.jar
对Hibernate 3.0/3.1/3.2的支持。
外部依赖spring-jdbc，Hibernate3，(spring-web)。

spring-toplink.jar
对TopLink框架的支持。
外部依赖spring-jdbc，TopLink。

spring-ibatis.jar
对iBATIS SQL Maps的支持。
外部依赖spring-jdbc，iBATIS SQL Maps。

另外的两个包。

spring-mock.jar
这个jar 文件包含Spring 一整套mock 类来辅助应用的测试。Spring 测试套件使用了其中大量mock 类

，这样测试就更加简单。模拟HttpServletRequest 和HttpServletResponse 类在Web 应用单元测试是

很方便的。并且提供了对JUnit的支持。
外部依赖spring-core。

spring-aspects.jar
提供对AspectJ的支持，以便可以方便的将面向方面的功能集成进IDE中，比如Eclipse AJDT。
外部依赖。

WEAVER JARS (dist/weavers)说明。

spring-agent.jar
Spring的InstrumentationSavingAgent (为InstrumentationLoadTimeWeaver)，一个设备代理包，可以

参考JDK1.5的Instrumentation功能获得更多信息。
外部依赖none (for use at JVM startup: "-javaagent:spring-agent.jar")。

spring-tomcat-weaver.jar
扩展Tomcat的ClassLoader，使其可以使用instrumentation（设备）类。
外部依赖none (for deployment into Tomcat's "server/lib" directory)。

如果需要使用JSP语言作为Spring's web MVC tags的参数，则需要JSP 2.0的支持。或者选择Jakarta的

JSTL (standard.jar)。

如何选择这些发布包，决定选用哪些发布包其实相当简单。如果你正在构建Web 应用并将全程使用

Spring，那么最好就使用单个全部的spring.jar 文件；如果你的应用仅仅用到简单的Inversion of

Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar与spring-beans.jar 即

可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar 文件了。采用

独立的发布包你可以避免包含自己的应用不需要的全部类。
当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的

Spring 依赖类，然后合并所需的类与包就可以了。Eclispe 有个插件叫ClassPathHelper 可以帮你找

找所依赖的类

Hibernate一共包括了23个jar包，令人眼花缭乱。下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到

一个hibernate2.jar和lib目录下有22个jar包：

　　hibernate2.jar:
　　Hibernate的库，没有什么可说的，必须使用的jar包

　　cglib-asm.jar:
　　CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包

　　dom4j.jar:
　　dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java

XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以

在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行

的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使

用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的

是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

　　odmg.jar:
　　ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

　　commons-collections.jar：
　　Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使

用的jar包。

　　commons-beanutils.jar：
　　Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。

　　commons-lang.jar:
　　Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar

包。

　　commons-logging.jar:
　　Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple

Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有

，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出

现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经

接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的

功能比log4j差的很远，性能也一般。

　　后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar

写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的

Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于

System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你

准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也

是必须的jar包。

　　使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。

　　ant.jar:
　　Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，

那么就没有什么用，可选的jar包

　　optional.jar：
　　Ant的一个辅助包。

　　c3p0.jar：
　　C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就

需要这个jar包。

　　proxool.jar：
　　也是一个连接池，同上。

　　commons-pool.jar, commons-dbcp.jar:
　　DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。

　　实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在

Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外

强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则

容器管理事务不起作用。

　　connector.jar:
　　JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际

上一般App Server肯定会带上这个包，所以实际上是多余的包。

　　jaas.jar:
　　JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

　　jcs.jar：
　　如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

　　jdbc2_0-stdext.jar:
　　JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的

。

　　jta.jar：
　　JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

　　junit.jar:
　　Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。

　　xalan.jar, xerces.jar, xml-apis.jar:
　　Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，

JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读

取配置文件，性能没什么紧要的，所以也是多余的。

 
TopLink 是位居第一的 Java 对象关系可持续性体系结构，原署WebGain公司的产品，现在被Oracle收购，并重新包装为 Oracle AS TopLink。TOPLink为在关系数据库表中存储 Java 对象和企业 Java 组件 (EJB) 提供高度灵活和高效的机制。TopLink 为开发人员提供极佳的性能和选择，可以与任何数据库、任何应用服务器、任何开发工具集和过程以及任何 J2EE 体系结构协同工作。本文仍然以业界已广为使用的TOPLink 3.5为参考版本，简单讲述TOPLink的使用要点。本文并不是一个Step by Step的入门实例教程，而是着眼与TOPLink的一些基本概念，总结了一些使用要点，从中也可以窥探TOPLink的使用方式和它的设计原理。
　　一、连接数据库
　　? Create a login object
　　project.getLogin()
　　new DatabaseLogin()
　　? Specifying database and driver information
　　//project.getLogin().useOracle();
　　project.getLogin().setDriverClass(oracle.jdbc.driver.OracleDriver.class);
　　project.getLogin().setConnectionString(“jdbc:oracle:thin@dbserver:1521:orc1”)
　　? Setting login parameters
　　project.getLogin().setUserName(“scott”);
　　project.getLogin().setPassword(“tiger”);
　　? 实例代码1
　　DatabaseLogin.setLicensePath(“c:\\Program Files\\Common Files\\WebGain Shared\\”)
　　Project project = new MyProject();
　　project.getLogin().setUserName(“userid”);
　　project.getLogin().setPassword(“passwd”);
　　DatabaseSession session = project.createDatabaseSession();
　　session.login();
　　? 实例代码2
　　DatabaseLogin.setLicensePath(...);
　　DatabaseLogin login = new DatabaseLogin();
　　login.set...
　　...
　　Project project = new Project(login);
　　DatabaseSession session = project.createDatabaseSession();
　　session.login();
　　二、DatabaseSession的使用
　　一个应用必须创建一个DatabaseSession，其中存储了如下内容：
　　1. 一个Project、DatabaseLogin实例（存储了数据库登录、配置信息）
　　2. 一个DatabaseAccessor实例（包装了JDBC连接，处理数据库访问）
　　3. 应用的所有持久类的descriptors
　　4. 作为cache的一个对象Map
　　DatabaseSession的实例必须由Project的实例创建得到，project对象必须由正确的数据库配置参数初始化，比如JDBC Driver、DB Url。
　　? 注册descriptors(在login前，login后也可但要注册的应不同于任何已注册的descriptor)
　　DatabaseSession.addDescriptors(Vector) or DatabaseSession.addDescriptor(Descriptor)
　　? 连接数据库
　　DatabaseSession.login()，连接后就可以使用此Session访问数据库了，使用“Query Framework”
　　? 缓存
　　可使用initializeIdentityMaps()方法来刷新缓存。注意：使用前要确认缓存中的对象没有被使用。
　　? 登出数据库
　　DatabaseSession.logout()，再次登入时不需要注册descriptors
　　可以通过下面代码指定DatabaseSession的例外处理过程：
　　session.setExceptionHandler(new ExceptionHandler(){
　　 public handleException(RuntimeException ex){
　　 if((ex instanceof DatabaseException) && (ex.getMessage().equals(“connection reset by peer”)){
　　 ex.getAccessor().reestablishConnection(ex.getSession());
　　 return ex.getSession().executeQuery(ex.getQuery());
　　 }
　　 }
　　});
　　三、一段使用TOPLink的完整的实例代码
　　import TOPLink.Public.Sessions.*;
　　DatabaseLogin.setLicensePath(“”);
　　DatabaseLogin loginInfo = new DatabaseLogin();
　　loginInfo.useJDBCODBCBridge();
　　loginInfo.useSQLServer();
　　loginInfo.setDataSourceName(“dbserver”);
　　loginInfo.setUserName(“”);
　　loginInfo.setPassword(“”);
　　Project project = new Project(loginInfo);
　　DatabaseSession session = project.createDatabaseSession();
　　session.addDescriptors(this.buildAllDescriptors());
　　try {
　　 session.login();
　　} catch(DatabaseException exception){
　　 throw new RuntimeException(“Database error occurred at login: “+exception.getMessage());
　　 System.out.println(“Login failed.”);
　　}
　　...
　　session.logout();
　　四、查询框架（Query Framework）
　　直接调用DatabaseSession对象提供的方法，完成查询、更新等操作。在更新操作时，会使用UnitOfWork，以提供优化的性能。
　　? 示例代码
　　Employee employee = (Employee)session.readObject(Employee.class,
　　 new ExpressionBuilder().get(“lastName”).equals(“Smith”));
　　Vector employees = session.readAllObjects(Employee.class,
　　 new ExpressionBuilder().get(“salary”).greaterThan(“1000”));
　　五、使用Expression
　　Toplink提供一种叫Expression的机制允许基于对象模型的查询机制，Toplink翻译这些Expressions为SQL语句，再把查询结果转换为对象返回。
　　1. 创建Expression
　　Expression总是通过Expresson或ExpressionBuilder的.get()方法得到，ExpressionBuilder可看作一个所查询对象的替身。一般命名为相应对象的名字。
　　一个ExpressionBuilder的实例与一个特定的Query相关联，不要企图使用同一个Builder来生成多个Expression。
　　2. 子查询
　　ReportQuery是为了得到一个对象集的信息，而不是对象本身。常用方法：
　　addAttribute(String)，addAverage(String)，addCount(String)等。
　　1) 示例代码1
　　查询包含5个以上被管理职员的职员
　　ExpressionBuilder emp = new ExpressionBuilder();
　　ExpressionBuilder managedEmp = new ExpressionBuilder();
　　ReportQuery subQuery = new ReportQuery(Employee.class,managedEmp);
　　subQuery.addCount();
　　subQuery.addSelectionCriteria(managedEmp.get(“manager”).equals(emp)); //?
　　Expression exp = emp.subQuery(subQuery).greaterThan(5);
　　2) 示例代码2
　　查询住址在Ottawa的工资最高的职员
　　ExpressionBuilder emp = new ExpressionBuilder();
　　ExpressionBuilder ottawaEmp = new ExpressionBuilder();
　　ReportQuery subQuery = new ReportQuery(Employee.class,ottawaEmp);
　　subQuery.addMax(“salary”);
　　subQuery.setSelectionCriteria(ottawaEmp.get(“address”).get(“street”).equals(“Ottawa”));
　　Expression exp = emp.get(“salary”).equals(subQuery).
　　and(emp.get(“address”).get(“street”).equals(“Ottawa”));
　　3. Parallel Expressions
　　Parallel Expression必须拥有它自己的ExpressionBuilder，并且这个Builder的构造方法必须以一个class作为参数。只存在唯一的主 ExpressionBuilder，这个主Builder使用空参数的构造器，它的类将从Query中得到。
　　1) 实例代码
　　查询所有具有相同lastName不同性别的职员
　　ExpressionBuilder emp = new ExpressionBuilder(); //主Builder
　　ExpressionBuilder spouse = new ExpressionBuilder(Employee.class); // Parallel Builder
　　Expression exp = emp.get(“lastName”).equal(spouse.get(“lastName”)) //基于对象模型的思考
　　 .and(emp.get(“spouse”).equal(spouse.get(“spouse”))
　　 .and(emp.notEqual(spouse));
　　4. 参数化Expressions、finders
　　1) 参数化表达式示例
　　//构造查询用的表达式，注意带一个firstName的参数
　　ExpressionBuilder emp = new ExpressionBuilder();
　　Expression firstNameExpression =
　　emp.get(“firstName”).equal(emp.getParameter(“firstName”));
　　//生成一个ReadObjectQuery对象，设置Query的参考类、查询条件、参数
　　ReadObjectQuery query = new ReadObjectQuery();
　　query.setReferenceClass(Employee.class);
　　query.setSelectionCriteria(firstNameExpression);
　　query.setArgument (“firstName”);
　　//进行查询
　　Vector v = new Vector();
　　v.addElement(“Sarah”);
　　Employee e = (Employee) session.excuteQuery(query,v);
　　2) 嵌套参数化表达式示例
　　ExpressionBuilder emp = new ExpressionBuilder();
　　Expression addressExpression;
　　//生成嵌套的参数化表达式
　　addressExpression = emp.get (“address”).get (“city”).equal (
　　emp.getParameter (“employee”).get (“address”).get (“city”));//嵌套的表达式
　　 ReadObjectQuery query = new ReadObjectQuery (Employee.class);
　　 query.setSelectionCriteria (addressExpression);
　　 query.addArgument (“employee”); // ?
　　 //设置参数，执行查询
　　 Vector v = new Vector ();
　　 v.addElement (employee);
　　 Employee e = (Employee) session.excuteQuery (query,v);
　　Java 开发人员需要使用关系数据库获得可持续性。使用 TopLink 可以消除在构造持久层时所涉及的内在风险。TOPLink几乎能够处理持久性方面的任何情况。TopLink提供一个持久性基础架构，使开发人员能够将来自多种体系结构的数据（包括EJB（CMP和BMP）、常规的Java对象、servlet、JSP、会话bean和消息驱动bean）集成在一起。TopLink允许Java应用程序访问作为对象存储在关系数据库中的数据，从而极大地提高了开发人员的工作效率。TopLink还具有通过最大限度地降低数据库命中率和网络流量及利用由JDBC和数据库提供的最优化来提升应用程序性能的特性。TopLink是通过创建一个元数据"描述符"（映射）集来实现上述特性的，这些元数据描述符定义了以一个特定的数据库模式存储对象的方式。TopLink在运行时使用这些映射动态地生成所需的SQL语句。这些元数据描述符（映射）独立于语言和数据库，开发人员能够在无需对它们所表示的类进行重编译的情况下修改它们。