Java连接oracle数据库实例

建立和分析java程序和oracle数据库交互的两种方法。

第一种应该是比较古老的方法了。

Windows下采用JDBC－ODBC Bridge连接oracle数据库

1、 安装oracle客户端程序，在tnsnames.ora中配置好相应的数据库连接串文件，此处设连接串名为“dbora”。

2、 在windows的控制面板－>“数据库源ODBC”中，建立相应的用户或者系统DSN，具体方法：在安装的数据源的驱动程序选择“Microsoft ODBC for Oracle”。

点击“完成”，在弹出的对话框中，填入如下信息：

数据源名称：dbjdbc
描述：jdbc数据源
用户名称：manager －此为数据库用户名
服务器：dbora －此即为连接串名
其中“dbjdbc”是在java程序中要引用的名字，至此数据源dbjdbc已建立。

3、 建立如下的java程序

// 使用本地的jdbc连接串，查询oracle数据库表
import java.sql.*;
public class lookup {
public static void main(String[] args)
throws SQLException, ClassNotFoundException {
//定义了数据库连接串
String dbUrl = "jdbc:odbc:dbjdbc";
//数据库的用户名
String user = "manager";
//数据库的用户口令
String password = "ora912";
// 加载jdbc-odbc bridge驱动程序
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// 与url指定的数据源建立连接
Connection c = DriverManager.getConnection(dbUrl, user, password);
//采用Statement进行查询
Statement s = c.createStatement();
ResultSet r = s.executeQuery("SELECT empno,name from emp");
while(r.next()) {
// 打印字段信息
System.out.println(r.getString("empno") + ",
" + r.getString("name ") );
}
// 关闭Statement，其上的ResultSet也将关闭
s.close();
}
}
在jdbc中查询的语句有3类：Statement、PreparedStatement、CallableStatement。

jdbc的thin方式

此种方法不需要安装Oracle的客户端，也不需要配置odbc，故此种方法用得比较普遍。

此方法在使用时需要将oracle的jar包加到classpath变量中，此包可以在oralce客户端程序的$ORACLE_HOME/jdbc/lib/classes12.jar找到。

import java.sql.*;
public class jdbcthin {
//dbUrl数据库连接串信息，其中“1521”为端口，“ora9”为sid
String dbUrl = "jdbc:oracle:thin:@10.10.20.15:1521:ora9";
//theUser为数据库用户名
String theUser = "sman";
//thePw为数据库密码
String thePw = "sman";
//几个数据库变量
Connection c = null;
Statement conn;
ResultSet rs = null;
//初始化连接
public jdbcthin() {
try {
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
//与url指定的数据源建立连接
c = DriverManager.getConnection(dbUrl, theUser, thePw);
//采用Statement进行查询
conn = c.createStatement();
} catch (Exception e) {
e.printStackTrace();
}
}
//执行查询
public Res

ultSet executeQuery(String sql) {
rs = null;
try {
rs = conn.executeQuery(sql);
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
public void close() {
try {
conn.close();
c.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ResultSet newrs;
jdbcthin newjdbc = new jdbcthin();
newrs = newjdbc.executeQuery("select * from eventtype");
try {
while (newrs.next()) {
System.out.print(newrs.getString("event_type"));
System.out.println(":"+newrs.getString("content"));
}
} catch (Exception e) {
e.printStackTrace();
}
newjdbc.close();
}
}

java tomcat配置 收藏
经常看到jsp的初学者问tomcat下如何配置jsp、servlet和bean的问题，于是总结了一下如何tomcat下配置jsp、servlet和ben，希望对那些初学者有所帮助。

一、开发环境配置

第一步：下载j2sdk和tomcat：到sun官方站（/j2se/1.5.0/download.jsp）下载j2sdk，注意下载版本为Windows Offline Installation的SDK，同时最好下载J2SE 1.5.0 Documentation，然后到tomcat官方站点（/site/downloads/downloads_tomcat-5.cgi）下载tomcat（下载最新5.5.9版本的tomcat）；

第二步：安装和配置你的j2sdk和tomcat：执行j2sdk和tomcat的安装程序，然后按默认设置进行安装即可。

1.安装j2sdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的j2sdk安装在c:\j2sdk1.5.0）：

JAVA_HOME=c:\j2sdk1.5.0
classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径)
path=%JAVA_HOME%\bin

接着可以写一个简单的java程序来测试J2SDK是否已安装成功：

public class Test{
public static void main(String args[]){
System.out.println("This is a test program.");
}
}

将上面的这段程序保存为文件名为Test.java的文件。

然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令

javac Test.java
java Test

此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。

Java_搭建eclipse+tomcat开发环境


方法/步骤1.下载准备

jdk：/technetwork/java/javase/downloads/index.html

tomcat：

eclipse：/downloads/download.php (J2EE)

tomcatPlugin：/tomcatPlugin.html

2.安装

jdk：默认安装到C:\Program Files\Java

tomcat：解压到任意位置，如D:\apache-tomcat-7.0.33

eclipse：解压到任意位置，如D:\eclipse

tomcatPlugin：解压到到eclipse\plugins目录，如D:\eclipse\plugins

3.配置Java环境变量

以Win7为例，计算机》属性》高级系统设置》高级》环境变量，系统变量》新建，新建系统变量

输入变量名：

[plain]view plaincopyprint?JAVA_HOME

JAVA_HOME
输入变量值：
[plain]view plaincopyprint?C:\Program Files\Java\jdk1.7.0_09

C:\Program Files\Java\jdk1.7.0_09
点确定保存。

编辑path变量，在上一个分号“;”后增加：
[plain]view plaincopyprint?%JAVA_HOME%\bin;

%JAVA_HOME%\bin;
点确定保存path修改，点确定保存环境变量修改。
4.测试运行tomcat

运行CMD命令行（可以直接在bin目录下运行startup.bat，下面在命令行中启动可以防止输出的错误信息一闪而过），输入以切换到bin目录：

[plain]view plaincopyprint?d: cd D:\apache-tomcat-7.0.33\bin

d: cd D:\apache-tomcat-7.0.33\bin输入以启动tomcat：
[plain]view plaincopyprint?startup.bat

startup.bat启动后不要关闭Tomcat命令行窗口。[注]startup.bat一般在开发测试时使用，可运行bin目录下的service.bat生成系统服务随系统启动自动运行

打开浏览器，输入以打开测试网站：


[plain]view plaincopyprint?http://localhost:8080

http://localhost:8080
可以打开预置的Tomcat默认网站说明配置成功。
5.tomcat知识补充

tomcat默认端口为8080，更改端口在conf目录下的server.xml的Connector配置节修改port[端口]即可。


[html]view plaincopyprint?



webapps目录：把项目文件夹拷贝到这个目录，浏览器中通过http://localhost:8080/项目文件夹，可以访问，比如，一个名为Test的项目，则路径为:http://localhost:8080/TestROOT目录：预置了tomcat的默认网站，如果把自己的项目覆盖在此目录，可以直接在浏览器输入http://localhost:8080访问。
6.配置eclipse


菜单中点击：window》Preferences》tomcat

选择Tomcat version：Version 7.X

选择Tomcat home：D:\apache-tomcat-7.0.33

Contexts directory：默认D:\apache-tomcat-7.0.33\conf\Catalina\localhost即可

点击OK保存并关闭Preferences窗口




2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat)：

CATALINA_HOME=c:\tomcat
CATALINA_BASE=c:\tomcat

然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的(可以根据实际追加)servlet.jar追加到classpath中去，修改后的classpath如下：

classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet.jar;

接着可以启动tomcat，在IE中访

问http://localhost:8080，如果看到tomcat的欢迎页面的话说明安装成功了。

第三步：建立自己的jsp app目录

1.到Tomcat的安装目录的webapps目录，可以看到ROOT，examples, tomcat-docs之类Tomcat自带的的目录；
2.在webapps目录下新建一个目录，起名叫myapp；
3.myapp下新建一个目录WEB-INF，注意，目录名称是区分大小写的；
4.WEB-INF下新建一个文件web.xml，内容如下：


PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"/dtd/web-app_2_3.dtd">

My Web Application

A application for test.



5.在myapp下新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：

Now time is: <%=new java.util.Date()%>


6.重启Tomcat

7.打开浏览器，输入http://localhost:8080/myapp/index.jsp 看到当前时间的话说明就成功了。

第四步：建立自己的Servlet：

1.用你最熟悉的编辑器（建议使用有语法检查的java ide）新建一个servlet程序，文件名为Test.java，文件内容如下：

package test;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class Test extends HttpServlet {
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out=response.getWriter();
out.println("

This is a servlet test.

");
out.flush();
}
}

2 .编译
将Test.java放在c:\test下，使用如下命令编译：

C:\Test>javac Test.java

然后在c:\Test下会产生一个编译后的servlet文件：Test.class

3 .将结构test\Test.class剪切到%CATALINA_HOME%\webapps\myapp\WEB-INF\classes下，也就是剪切那个test目录到classes目录下，如果classes目录不存在，就新建一个。 现在webapps\myapp\WEB-INF\classes下有test\Test.class的文件目录结构

4 .修改webapps\myapp\WEB-INF\web.xml，添加servlet和servlet-mapping

编辑后的web.xml如下所示，红色为添加的内容:


PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"/dtd/web-app_2_3.dtd">

>My Web Application

A application for test.


Test
Test
A test Servlet
test.Test


Test
/Test



这段话中的servlet这一段声明了你要调用的Servlet，而servlet-mapping则是将声明的servlet"映射"到地址/Test上

5 .好了，重启动Tomcat，启动浏览器，输入http://localhost:8080/myapp/Test 如果看到输出This is a servlet test.就说明编写的servlet成功了。

注意：修改了web.xml以及新加了class，都要重启Tomcat

第四步：建立自己的Bean：

1.用你最熟悉的编辑器（建议使用有语法检查的java ide）新建一个java程序，文件名为TestBean.java，文件内容如下：

package test;
public class TestBean{
private String name = null;
public TestBean(String strName_p){
=strName_p;
}
public void setName(String strName_p){
=strName_p;
}
public String getName(){
return ;
}
}

2 .编译

将TestBean.java放在c:\test下，使用如下命令编译：

C:\Test>javac TestBean.java

然后在c:\Test下会产生一个编译后的bean文件：TestBean.class

3 .将TestBean.class文件剪切到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes\test下，

4 .新建一个TestBean.jsp文件，文件内容为：

<%@ page import="test.TestBean" %>

<%
TestBean testBean=new TestBean("This is a test java bean.");
%>
Java bean name is: <%=testBean.getName()%>


5 .好了，重启Tomcat，启动浏览器，输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean.就说明编写的Bean成功了。

这样就完成了整个Tomcat下的jsp、servlet和javabean的配置。接下来需要做的事情就是多看书、多读别人的好代码，自己多动手写代码以增强自己在这方面开发的能力了。

jvm应填写到
c:\j2sdk\bin

给你一个简单的配置：：：：

JSP环境配置心得

首先要说的是，使用jdk+tomcat完全可以配置我们的jsp服务器，不再需要其实任何东东，有很多文章介绍了Apache，其实根本用不着，一般的学习调试tomcat完全可以胜任了。

安装jdk后，tomcat在安装之前会自动找到jdk的安装路径，一路点

击"下一步"，经过一段时间的文件复制，最后"close"，完成comcat的安装。

您最好去下载一个版本较高的tomcat，比如4.1以上的，因为它不需要设置太多的系统变量，右击"我的电脑"，选择"属性"->"高级"->"环境变量"->"系统变量"，新建一个TOMCAT_HOME，值设置成你的tomcat所在的路径，比如：D:\Program Files\Apache Group\Tomcat 5.5，配置完成。
JAVA_HOME和TOMCAT_HOME JavaTomcatServlet应用服务器EJB .
12月13日
为什么要设置 JAVA_HOME, TOMCAT_HOME 等环境变量?
来源：/topic/146/579837.html

你可能把tomcat装在c:\tomcat里，也可能把tomcat装在d:\jerrymouse里，tomcat怎么知道自己的文件都在哪儿呢? 在Windows里面程序可以到registry里查，java是跨平台的，不应该读registry，而应该利用更通用的途径，比如象 tomcat_home这样的操作系统环境变量。

为了保持独立与操作系统的特性，java程序并不能直接读到操作系统环境变量。如果不用任何诡计，java程序只能“求”你在启动程序的时候利用java的-D参数把变量告诉它。比如java -Djava_home=%java_home % start_the_servlet_engine.你一定很讨厌每次都打如-D...那些东西，所以通常这种东西都放在一个.bat文件或是 unix的.sh文件里。

实际上tomcat就是这样利用java_home的，用这个办法找到java编译器，然后调用java编译器来编译jsp和servlet程序。至于tomcat_home，可能只是.bat文件里用的。因为.bat文件里不应该写c:\tomcat\bin\ start_engine这样的话，以防你的tomcat躲在d:\jerrymouse里，所以它写成%tomcat_home%\bin\ start_engine。(我不记得具体的程序名，可能不是"start_engine"是别的什么东东，但是这个道理。

java程序怎样读-D参数给的变量? 用System.getProperty("变量名")。

如果你想读到Windows的那些环境变量(在cmd窗口里用set看到的那些)，就要用一些阴谋诡计，那样的程序通常很丑陋。

tomcat 文件夹里面没有java编译器，除非自己你装进去，但是要运行tomcat，你的电脑里一定要有java编译器，并且把路径通过java_home告诉 tomcat。如果你的电脑里java在c:\jdk1.4.0里面，java_home就应该设成c:\jdk1.4.0。

你写的那些 servlet，tomcat都要先用java编译器编译过才能运行，其实运行也是用java_home里的java虚拟机，tomcat只不过是通过 Process的get...Stream方法同servlet交互再把结果通过普通的java socket传给浏览器。

jsp由tomcat转换成servlet的java源程序，再用%java_home%\bin\javac编译。所以，jsp和servlet的最终class文件结构上没有什么不同。

java 下的Classpath 配置

和Java 类路径（classpath）打交道的过程中，开发者偶尔会遇到麻烦。这是因为，类装载器实际装入的是哪一个类有时并不显而易见，当应

用程序的 classpath包含大量的类和目录时，情况尤其严重。本文将提供一个工具，它能够显示出被装入类文件的绝对路径名。


一、Classpath基础


Java虚拟机（JVM）借助类装载器装入应用程序使用的类，具体装入哪些类根据当时的需要决定。CLASSPATH环境变量告诉类装载器到哪里去寻找第三方提供的类和用户定义的类。另外，你也可以使用JVM命令行参数-classpath分别为应用程序指定类路径，在-classpath中指定的类路径覆盖CLASSPATH环境变量中指定的值。


类路径中的内容可以是：文件的目录（包含不在包里面的类），包的根目录（包含已打包的类），包含类的档案文件（比如.zip文件或者.jar文件）。在Unix家族的系统上，类路径的各个项目由冒号分隔，在MS Windows系统上，它们由分号分隔。


类装载器以委托层次的形式组织，每一个类装载器有一个父类装载器。当一个类装载器被要求装载某个类时，它在尝试自己寻找类之前会把请求先委托给它的父类装载器。系统类装载器，即由安装在系统上的JDK或JRE提供的默认类装载器，通过CLASSPATH环境变量或者-classpath这个JVM命令行参数装入第三方提供的类或者用户定义的类。系统类装载器委托扩展类装载器装入使用Java Extension机制的类。扩展类装载器委托自举类装载器（bootstrap class loader）装入核心JDK类。


你可以自己开发特殊的类装载器，定制JVM如何动态地装入类。例如，大多数Servlet引擎使用定制的类装载器，动态地装入那些在classpath指定的目录内发生变化的类。


必须特别注意的是（也是令人吃惊的是），类装载器装入类的次序就是类在classpath中出现的次序。类装载器从classpath的第一项开始，依次检查每一个设定的目录和压缩文件，尝试找出待装入的类文件。当类装载器第一次找到具有指定名字的类时，它就把该类装入，classpath中所有余下的项目都被忽略。


看起来很简单，对吧？

二、可能出现的问题


不管他们是否愿意承认，初学者和富有经验的Java开发者都一样，他们都曾经在某些时候（通常是在那些最糟糕的情形下）被冗长、复杂的classpath欺骗。应用程序所依赖的第三方类和用户定义类的数量逐渐增长，classpath也逐渐成了一个堆积所有可能的目录和档案文件名的地方。此时，类装载器首先装载的究竟是哪一个类也就不再显而易见。如果classpath中包含重复的类入口，这个问题尤其突出。前面已经提到，类装载器总是装载第一个它在classpath 中找到的具有合适名字的类，从实际效果看，它“隐藏”了其他具有合适名字但在classpath中优先级较低的

类。


如果不小心，你很容易掉进这个classpath的陷阱。当你结束了一天漫长的工作，最后为了让应用程序使用最好、最新的类，你把一个目录加入到了 classpath，但与此同时，你却忘记了：在classpath的另一个具有更高优先级的目录下，存放着该类的另一个版本！


三、一个简单的classpath工具


优先级问题是扁平路径声明方法与生俱来固有的问题，但它不是只有Java的classpath才有的问题。要解决这个问题，你只需站到富有传奇色彩的软件巨构的肩膀上：Unix操作系统有一个which命令，在命令参数中指定一个名字，which就会显示出当这个名字作为命令执行时执行文件的路径名。实际上，which命令是分析PATH变量，然后找出命令第一次出现的位置。对于Java的类路径管理来说，这应该也是一个好工具。在它的启发之下，我着手设计了一个Java工具JWhich。这个工具要求指定一个Java类的名字，然后根据classpath的指引，找出类装载器即将装载的类所在位置的绝对路径。


下面是一个JWhich的使用实例。它显示出当Java类装载器装载com.clarkware.ejb.ShoppingCartBean类时，该类第一次出现位置的绝对路径名，查找结果显示该类在某个目录下：


> java JWhich com.clarkware.ejb.ShoppingCartBean

Class ′com.clarkware.ejb.ShoppingCartBean′ found in
′/home/mclark/classes/com/clarkware/ejb/ShoppingCartBean.class′


下面是第二个JWhich的使用实例。它显示出当Java类装载器装载javax.servlet.http.HttpServlet类时，该类第一次出现位置的绝对路径名，查找结果显示该类在某个档案文件中：

> java JWhich javax.servlet.http.HttpServlet

Class ′javax.servlet.http.HttpServlet′ found in
′file:/home/mclark/lib/servlet.jar!/javax/servlet/http/HttpServlet.class′


四、JWhich的工作过程
要精确地测定classpath中哪一个类先被装载，你必须深入到类装载器的思考方法。事实上，具体实现的时候并没有听起来这么复杂——你只需直接询问类装载器就可以了！

1: public class JWhich {
2:
3: /**
4: * 根据当前的classpath设置，
5: * 显示出包含指定类的类文件所在
6: * 位置的绝对路径
7: *
8: * @param className <类的名字>
9: */
10: public static void which(String className) {
11:
12: if (!className.startsWith("/")) {
13: className = "/" + className;
14: }
15: className = className.replace(′.′, ′/′);
16: className = className + ".class";
17:
18: .URL classUrl =
19: new JWhich().getClass().getResource(className);
20:
21: if (classUrl != null) {
22: System.out.println("\nClass ′" + className +
23: "′ found in \n′" + classUrl.getFile() + "′");
24: } else {
25: System.out.println("\nClass ′" + className

+
26: "′ not found in \n′" +
27: System.getProperty("java.class.path") + "′");
28: }
29: }
30:
31: public static void main(String args[]) {
32: if (args.length > 0) {
33: JWhich.which(args[0]);
34: } else {
35: System.err.println("Usage: java JWhich ");
36: }
37: }
38: }

首先，你必须稍微调整一下类的名字以便类装载器能够接受（12-16行）。在类的名字前面加上一个“/”表示要求类装载器对classpath中的类名字进行逐字精确匹配，而不是尝试隐含地加上调用类的包名字前缀。把所有“.”转换为“/”的目的是，按照类装载器的要求，把类名字格式化成一个合法的 URL资源名。

接下来，程序向类装载器查询资源，这个资源的名字必须和经过适当格式化的类名字匹配（18-19行）。每一个 Class对象维护着一个对装载它的ClassLoader对象的引用，所以这里是向装载JWhich类的类装载器查询。 Class.getResource()方法实际上委托装入该类的类装载器，返回一个用于读取类文件资源的URL；或者，当指定的类名字不能在当前的 classpath中找到时，Class.getResource()方法返回null。


最后，如果当前的classpath 中能够找到指定的类，则程序显示包含该类的类文件所在位置的绝对路径名（21-24行）。作为一种调试辅助手段，如果当前classpath中不能找到指定的类，则程序获取java.class.path系统属性并显示当前的classpath（24-28行）。

很容易想象，在使用 Servlet引擎classpath的Java Servlet中，或者在使用EJB服务器classpath的EJB组件中，上面这段简单的代码是如何运作。例如，如果JWhich类是由Servlet引擎的定制类装载器装入，那么程序将用Servlet引擎的类装载器去寻找指定的类。如果 Servlet引擎的类装载器不能找到类文件，它将委托它的父类装载器。一般地，当JWhich被某个类装载器装入时，它能够找出当前类装载器以及所有其父类装载器所装入的所有类。

【结束语】如果需要是所有发明之母，那么帮助我们管理Java类路径的工具可以说迟到了很长时间。 Java新闻组和邮件列表中充塞着许多有关classpath的问题，现在JWhich为我们提供了一个简单却强大的工具，帮助我们在任何环境中彻底玩转 Java类路径。
从开始菜单中找到tomcat选项，一般打开顺序是：开始->程序->Apache Tomcat 5.5，选择"Start Tomcat"，让jsp服务器开始运行，此时会打开一个类似Dos的窗口，会显示一些相关的信息。

Tomcat最初是由Sun的软件构架师詹姆斯·邓肯·戴维森开发的。后来他帮助将其变为开源项目，并由Sun贡献给Apache软件基金会。由于大部分开源项目O'Reilly都会出一本相关的书，并且将其封面设计成某个动物的素描，因此他希望将此项

目以一个动物的名字命名。因为他希望这种动物能够自己照顾自己，最终，他将其命名为Tomcat（英语公猫或其他雄性猫科动物）。而O'Reilly出版的介绍Tomcat的书籍（ISBN 0-596-00318-8）[1]的封面也被设计成了一个公猫的形象。而Tomcat的Logo兼吉祥物也被设计成了一只公猫。
目前Tomcat最新版本为7.0.39。
编辑本段版本差异


Apache Tomcat (18张)· 支持web应用中的外部内容的直接引用
· 重构 (connectors, lifecycle)及很多核心代码的全面梳理
· 性能优化和减少垃圾回收动作
· 重构程序部署，通过一个可选的独立部署程序，允许在将一个web应用放进产品前验证和编译它
· 基于JMX的服务器全面监视及web程序管理
· 提高Taglibs的支撑能力，包括改进的数据池和tag插件
· 改进平台集成性，包括Windows和Unix
· 基于JMX的嵌入
· 增强的安全管理支撑
· 集成session集群

Apache Tomcat 4.x
是目前的开发焦点。它在汲取了Tomcat 4.0.x优点的基础上，实现了对于Servlet 3.0、JSP 2.2和EL 2.2等特性的支持。除此以外的改进列表如下：
· Web应用内存溢出侦测和预防
· 增强了管理程序和服务器管理程序的安全性
· 一般 CSRF保护
· 性能优化和减少垃圾回收动作
· 重构程序部署，通过一个可选的独立部署程序，允许在将一个web应用放进产品前验证和编译它
· 基于JMX的服务器全面监视及web程序管理
· 提高Taglibs的支撑能力，包括改进的数据池和tag插件
· 改进平台集成性，包括Windows和Unix
· 基于JMX的嵌入
· 增强的安全管理支撑
· 集成session集群

Apache Tomcat 6.x
在汲取 Tomcat 5.5.x优点的基础上，实现了Servlet 2.5和JSP 2.1等特性的支持。除此以外的改进列表如下：
· 内存使用优化
· 更大的IO容量
· 重构聚类
· 性能优化和减少垃圾回收动作
· 重构程序部署，通过一个可选的独立部署程序，允许在将一个web应用放进产品前验证和编译它
· 基于JMX的服务器全面监视及web程序管理
· 提高Taglibs的支撑能力，包括改进的数据池和tag插件
· 改进平台集成性，包括Windows和Unix
· 基于JMX的嵌入
· 增强的安全管理支撑
· 集成session集群
Apache Tomcat 5.x
Apache Tomcat 5.5.x 和Apache Tomcat 5.0.x 对于Servlet和JSP的支持是一样的。大量底层代码里的重大修改，带来性能的提升、稳定性的提升及整体成本。详请参照Apache Tomcat 5.5的更新日志。
Apache Tomcat 5.0.x在Apache Tomcat 4.1的基础上做了很多改动，包括：
· 性能优化和减少垃圾回收动作
· 重构程序部署，通过一个可选的独立部署程序，允许在将一个web应用放进产品前验证和编译它
· 基于JMX的服务器全面监视及web程序管理
· 提高Taglibs的支撑能力，包括改进

的数据池和tag插件
· 改进平台集成性，包括Windows和Unix
· 基于JMX的嵌入
· 增强的安全管理支撑
· 集成session集群