• 如果用request，要注意request的范围仅限于同一个request对象；如果使用了form的"action"或者response.sendRedirect("xxx.jsp")等调转，则不再是同一个request对象，即用request.getAttribute("name")将取不到值。
• 换成request.getRequestDispatcher("xxx.jsp").forward(request,response);
  才能共享request中数据
  

• 如果用session，程序太慢，存在效率问题。

页面间传递数据:

客户端向服务器:
post方式(form,隐藏域)和get方式(URL,aa.jsp?param1=abc);

服务器端:
request,session,cookie,application

URL和aa.jsp?paraml=abc是一回事，后者是前者的一个例子.同样的隐藏字段也是指包含在form中的隐藏字段

还有：可以用javabean一次性把前个界面的值自动赋到另一个界面。

request.getParameterValues("shrdCategory")取得同名的复选框的各个value值

，然后数组遍历，取出各个shrdCategory[i]即可；

代码如下所示：

环境保护<input type="checkbox" name="shrdCategory" value="环境保护">
国民经济<input type="checkbox" name="shrdCategory" value="国民经济">

String[] shrdCategory＝request.getParameterValues("shrdCategory");
for (int i=0;i<shrdCategory.Length;i++){
System.out.println(shrdCategory[i]);
}

但是要注意，上面这段代码jsp运行时报505错误！！为什么呢？
因为刚进入页面时，没有复选框无值，shrdCategory为null，这时不能使用

shrdCategory[i]；

解决：
加上非null判断：
String[] shrdCategory＝request.getParameterValues("shrdCategory");
if (shrdCategory!=null){
for (int i=0;i<shrdCategory.Length;i++){
  System.out.println(shrdCategory[i]);
  }
}

ok!

J2EE到底是什么？

板桥里人 http://www.jdon.com 2003/02/12

目前所有的B/S系统应用可以分为：有状态(statefull)和无状态(stateless)两大类别。 有状态是指在整个系统的处理过程中要保留记住一些信息，而无状态则相反，每次request都是独立的连接，不需要在每个request之间共享数据等等。

对于这两种应用，通常第一考虑是性能要最优，性能是我们选择IT技术的主要依据之一。

为达到最大化的性能，对于Java系统，以前通常的作法是使用对象池，这样节约对象生成时的性能开销，也就是说系统启动时，预先生成一定数目的对象实例在内存中，需要使用时，从对象池中取出实例，用完，归还对象池，对于有状态的应用，可以使用相关持久化（persistence）策略来保存状态。

下一步，如何并行访问对象池将是非常重要，java的多线程技术为我们提供了实现可能，线程的创建销毁也是可能非常耗时的，那么，无疑象使用对象池一样，我们必须使用线程池来实现多线程并行计算的最优化。

使用线程池和对象池，每次客户端请求发生一次就从线程池中借用一个线程，处理完这个请求就将线程返回线程池，同样，使用线程快速的访问对象，对象也是从对象池中借用，用完就还回对象池。 整个这样的架构设计在性能上是最优的。

有了性能保证，安全机制、事务机制、集群(cluster)技术也将是选择IT技术的主要依据。

J2EE就是这样一个实现上述多种考量的综合标准框架系统，在具体使用中，也许我们对所有这些考量的要求并不都一样重视，比如：如果纯粹追求性能是第一，可以忽视事务机制，那么，完整的J2EE技术也许就并不适合你。

那么我们先看看J2EE是如何从性能上保证我们的应用系统以最快速度运行的，也就是说J2EE中必然应该有上述线程池和对象池的实现技术，servlet实际是基于线程池的更好的线程容器；EJB是基于对象池的更好的对象容器。

看看Servler的架构图：

当client1发生请求时servlet容器会从线程池中分配一个线程给这个request.

再看看EJB的架构图：

instance Pool作为一个对象实例池，维持着EJB实例，当然这个对象池是用生命周期的，简单的说 EJB=对象池+远程对象池

但是，EJB还整合了相当的其它增强功能，如安全 事务机制等，这些对于一般应用都是必需的，当然你还必须根据你的需要来选择是否使用J2EE，如果你的应用对安全 事务机制没有要求，直接使用线程池和对象池技术肯定获得最好的性能。

所以，根据Servler和EJB的原理，我们已经可以规划我们的应用，什么可以放在servlet，或什么需要放在EJB中实现：

线程的本质决定了servlet只适合一些轻量的应用，如分析简单XML文档, 通过JDBC访问数据源，使用JMS或JavaMail处理简单的信息Message，或使用JTS/JTA处理简单的事务机制，注意这些用词都是"简单"的，一旦复杂了，就要使用EJB了。

下面从客户端和服务器端两个方面来具体考量这两个技术的使用，这里的客户端不一定是指最终客户端，因为J2EE是多层结构，中间层可能在多个服务器上实现，如果一个服务器上的服务是供另外一个服务器上的应用访问的，那么后者我们也称为客户端。

根据应用的复杂程度和要求不同，分下列情况：

1.在WEB层可以实现的一些应用

如果你的系统没有很复杂的事务处理，或访问很多企业原有的资源，那么可以借助javabean这样的一些Help性质的类来实现你的应用，但是，这样的方案不是最干净clean, 最有效efficient, 或最有扩展性的scalable。

否则，将所有核心计算放置入EJB中。

2.所有的复杂商务计算核心都在EJB中完成

如果你的客户端和服务器端之间有防火墙，那么目前能够无障碍通过防火墙的协议只有Http了(Web Service也是基于http就是这个道理)，既然使用http了，而Servlet是基于Http协议的，那么就需要通过servlet来访问EJB，这是我们最普遍的应用情况。

但是，如果你的客户端和服务器端可以放置在一个网络内，之间没有防火墙，那么就不必使用Servlet，直接使用Java调用RMI来访问EJB，这样性能是最好的，这时的Servlet大概只有用于控制Jsp的页面的输出了(MVC模式中的控制作用)。

如果是非java客户端，可以通过CORBA组件来访问EJB。

3.如果你的应用对速度要求很高，要求非常快，对于事务处理等方面几乎无要求

直接使用J2SE，加上线程池和对象池技术，将会使你的java系统性能发挥极致。Jakarta.Apache.org有这两种技术的源码，线程池可以从Servlet容器Tomcat的源码中发现。

2.       修改 MapServlet.java ：

给 search （）方法多添加一个参数 tableName ，把 tableName 的值传给需要它的 getViewData(String tableName) 函数；

实现 doGet() 方法，多接受一个参数 tableName ，把 tableName 传给 search （）函数 ;

（即： String tableName =request.getParameter(“tableName”); search(request,type,tableName ） );

3.       index2.jsp

把 type 和 tableName 的值传给 MapServlet ：

Var url=’ BasePlatform_project/servlet/MapServlet ’;

Var pars=’type= ’+par+’&tableName’=tableName;

( 注：路径为： url?pars; 即： /servlet/MapServlet ？ ’type= ’+par+’&tableName’=tableName )

问题：

Jsp,servlet,java 类之间的传递有待学习

1.       doGet() 和 doPost() 的区别：

参考资料 1 ： http://bbs.blueidea.com/viewthread.php?tid=891513&page=

l          servlet 它有一个 方法 默认 被执行 在接到 用户请求时 , 这个方法 就是 service()

它会 根据 用户端 具体的 请求类型 自动选择 使用哪种方法 反应 .

l          可以理解为针对 form 的 get ,post 来执行相应的 doGet,doPost 方法

l          form 的 get 和 post 有什么区别．．．这个是重点．．嘿～～谢了．．

l          get 是地址栏参数传递 , 并且没有正文体内容 , 它仅仅由一个方法语句和不同的请求标题域
组成 .
例如 :
GET /login.html?userName=Iori&passWord=12345 HTTP/1.0
User-Agent:Mozilla/4.51[en](WinNT;1)
Accept:image/gif,image/jpeg.image/pjpeg,*/*
上面是表单 选择方法为 get 时 点击提交事件 自动添加到 地栏的 , 当然 你也可以这自己写
这样的东东 .
post 的不同 在于 参数信息 保存在 正文体中 对用户 是不可见的 .
不像 get 方法 , 不能通过改写浏览器地址 来发送一个 post 请求 而前者可以 . 这样不安全的
一个 post 请求的 例子 如下 :
POST /login.html HTTP/1.0
User-Agent:Mozilla/4.51 [en] (WinNT;1)
Accept:image/gif,image/jpeg,image/pjpeg,*/*
Content-Length:34
Content-Type:application/x-www-form-urlencoded
userName=Iori&passWord=12345

看到了吧 数据被存到 正文体中了 这就是它们之间 最大的区别 .

参考资料 2 ： http://book.77169.org/data/web5409/20050328/20050328__3854464.html

问题：

1，  servlet 中处理的方法，有 doPost （） doGet （） 中的方法，它们都有共同的参数，那就是 HttpServletRequest HttpservletResponse 对象，可是我不知道这两个方法有什么区别，什么该用 doPost() 什么时候该用 doGet() 呢？？

2，  servlet 中的 service （）方法又是干什么的呢？？它和 doPost() doGet() 又有什么关系呢？

回答：

l         get 、 post 等那些是指浏览器传给 Servlet 的方法，可以在 form 的 action 中指定，如 action="post",action="get" 之类的，默认使用 get ，如在浏览器直接输入 xxx?param1=xx&param2=xx ，这种方式是 get 。

l         service() 和 doGet(),doPost() 的关系是： servlet 先调用默认执行的 service() 方法，由它决定调用哪个处理方法。

l         我来解释一下什么是Get、Post吧：
1.Post方式就是通过表单的submit()方法提交到服务器的，当然servlet调用的是doPost();
2.Get方式就是自定义路径传参数，比如：../servlets/XX.jsp?parameterName=parameterValue&...
这种形式提交到服务器的，对应的是doGet()方法。这种方式一般有长度限制，打的参数多了提交不上去。

一般在servlet里面是不用管以哪知形式提交的，可以定义一个公共方法，在doPost()和doGet()方法里面都去调用，或者：doPost(){ doGet() }

l         get 方法我们可以在地址栏中直接输入参数也可以的
但 post 方法在地址栏中直接输入就不可以了 , 显示不出页面的

问题：

1. servlet 是一个接口吗？是不是接口就必须对其所有方法实例化，也就是说，一一实例化 init(),service(),doGet(),doPost() 和 destroy() 方法？

2. doGet() 和 doPost() 方法什么时候可以统一调用？比如 doPost(){ doGet();}. 既然使用 doPost() 方法不能从地址栏里输入参数访问，那么为什么 doPost() 可以直接使用 doGet() 方法呢？反过来， doGet() 可是使用 doPost() 方法吗？

3. servlet 的方法有哪些？除了 init(),service(),doGet(),doPost() 和 destroy() 方法之外还有别的吗？如果只有这五个方法，那么是不是说，写一个 servlet ，就是要实现 doGet() 和 doPost() 方法？（因为 service 方法是默认一定启动的）

4. java 中接口和 c++ 中虚函数的区别是什么？

参考资料 1 ： http://www.51dibs.com/html/2006/article/info4/a_11af20782d07b7b7.htm

什么是接口？

在 Java中，接口是不相关的对象相互交互的设备。Java接口与
协议很相似。实际上，其它面向对象语言也有Java的接口的
功能，但是它们称为协议。

Java接口定义了一套方法，但没有实现它们。一个实现接口的
类可以实现定义在这个接口中的所有方法，因此可以实现一定
的行为。

定义：接口是方法定义（而不实现）的被命名的集合。接口也
可以包括常量定义。

参考资料 2 ： http://www.umlchina.com/best/g30/u1144079.htm#1144178

l        Java中的接口和抽象类的区别，在于接口中没有属性，而且所有的方法都是抽象的，而抽象类可以有属性，而且可以有抽象方法，也可以有实现的方法。但两者都不能被实例化。

使用的时候，一个类可以继承多个接口，但只能继承一个抽象类。

l        抽象类与接口的重大区别就在于它能提供一部分实现，包括方法和属性。在某些情况下这是非常有用的，比如在 template method模式中。
你说“有了单纯的接口，就不应该使用抽象类了”，这种说法未免过于绝对了。
在逻辑上，抽象类表示了抽象的概念，它们的一部分行为需要在具体的子类中定义，但同时又定义了子类的一部分分共性的行为和属性。

l        我认为抽象类基本就是个“实现机制”。

我们在分析的时候会去管一个类是不是抽象类吗？不会吧？
它的意义在于提供了一个安全的机制，把一些类的共同行为抽象到一个“半成品”类中，又组织人们使用这个“半成品”类。

自己的理解：（结合例子来理解）

理解接口：

接口中没有属性，而且所有的方法都是抽象的； 比如说Servlet都是通过实例化接口实现的，servlet接口定义了init(),service(),doGet(),doPost(),destroy()方法，但是只是定义，没有去实现它们，实现一个servlet类时一一实现servlet接口定义的方法。

理解抽象类：

l         抽象类可以有属性，而且可以有抽象方法，也可以有实现的方法。

l        逻辑上，抽象类表示了抽象的概念，它们的一部分行为需要在具体的子类中定义，但同时又定义了子类的一部分分共性的行为和属性。

l        感觉是，接口没有属性也没有已经实现的方法，适合与servlet这种类型的类似的协议的机制；而抽象类提供了一个抽象和半成品的概念，定义了所有子类的共有属性，并实现了所有子类的共有方法，子类只需要在此基础上实现自己的特有属性和方法，更安全，更方便。比如一个典型的例子，关于“车”类，定义成一个抽象类，并把所有车的共有属性和方法都定义并实现了，子类（比如car）就可以在此基础上继承并定义和实现自己特有的属性和方法就可以了。没必要定义为接口，把共有的属性和方法也要依次各自实现。

5. java 中为什么没有多继承？你是如何理解的？

6.extends 与 implent 的区别？

This means that if you try to connect to 127.0.0.1, you are immediately looped back to your own machine.

If you telnet, ftp, etc... to 127.0.0.1, you are connected to your own machine.

In other words, 127.0.0.1 is you.

For example, if your system was named "joker", and you attempted to telnet to 127.0.0.1, you would see:

# telnet 127.0.0.1
Trying 127.0.0.1...
Connected to joker
Escape character is '^]'.
Convincing newbie's to connect to 127.0.0.1 is a frequent joke on the Internet.

Another name for 127.0.0.1 is localhost.

Although 127.0.0.1 is the most commonly utilized address for localhost, any IP address in the 127.*.*.* range should also function in the same manner.

一、 开发环境配置

第一步：下载 j2sdk 和 tomcat ；

第二步：安装和配置你的 j2sdk 和 tomcat ，并分别设置环境变量；

第三步：建立自己的 jsp app 目录
1. 到 Tomcat 的安装目录的 webapps 目录，可以看到 ROOT ， examples, tomcat-docs 之类 Tomcat 自带的的目录；
2. 在 webapps 目录下新建一个目录，起名叫 myapp ；
3.myapp 下新建一个目录 WEB-INF ，注意，目录名称是区分大小写的；
4.WEB-INF 下新建一个文件 web.xml ，内容如下：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
</web-app>
5. 在 myapp 下新建一个测试的 jsp 页面，文件名为 index.jsp ，文件内容如下：
<html><body><center>
Now time is: <%=new java.util.Date()%>
</center></body></html>
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("<html><body><h1>This is a servlet test.</h1></body></html>");
out.flush();
}
}
2 . 编译
将 Test.java 放在 c:\test 下，使用如下命令编译：
C:\Test>javac Test.java
然后在 c:\Test 下会产生一个编译后的 servlet 文件： Test.class

注意： 如果出现无法 import javax.servlet.* 那么就是应该把 C:\Tomcat\common\lib 里面的 servlet-api.jar 文件拷贝到％ JAVA_HOME ％ \jre\lib\ext 中，再次编译，就没有问题了！

解析： serlvet / jsp 属于 J2EE 的一部分，而不是 J2SE 的一部分。
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 如下所示，红色为添加的内容 :
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>My Web Application</display-name>
<description>
A application for test.
</description>
<servlet>
<servlet-name>Test</servlet-name>
<display-name>Test</display-name>
<description>A test Servlet</description>
<servlet-class>test.Test</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/Test</url-pattern>
</servlet-mapping>
</web-app>
这段话中的 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){
this.name=strName_p;
}
public void setName(String strName_p){
this.name=strName_p;
}
public String getName(){
return this.name;
}
}
2 . 编译
将 TestBean.java 放在 c:\test 下，使用如下命令编译：
C:\Test>javac TestBean.java
然后在 c:\Test 下会产生一个编译后的 bean 文件： TestBean.class

注释：自己的部署 StuInfoBean.java ：

eclipse 的工作空间目录为“ F:\workspace ”，工程名称为“ HelloWord” ，目录为 F:\workspace\HelloWord, 将 StuInfoBean.java 放在 F:\workspace\HelloWord\com\javaBean 下，（注： com 和 javaBean 是自己建的两个文件夹），使用如下命令编译：
F:\workspace\HelloWord\com\javaBean>javac StuInfoBean.java
然后在 F:\workspace\HelloWord\com\javaBean 下会产生一个编译后的 bean 文件： StuInfoBean.class ；

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

自己的部署：

将目录结构 com\javaBean\StuInfoBean.class 拷贝到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes 下；即将 StuInfoBean.class 文件剪切到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes\com\javaBean 下，（ classes,com,javaBean 都是自己建的文件夹），最后目录结构如下：

%CATALINA_HOME%\webapps\myapp\WEB-INF\classes\com\javaBean\StuInfoBean.class ；

4 . 新建一个 TestBean.jsp 文件，文件内容为：
<%@ page import="test.TestBean" %>
<html><body><center>
<%
TestBean testBean=new TestBean("This is a test java bean.");
%>
Java bean name is: <%=testBean.getName()%>
</center></body></html>
5 . 好了，重启 Tomcat ，启动浏览器，输入 http://localhost:8080/myapp/TestBean.jsp 如果看到输出 Java bean name is: This is a test java bean. 就说明编写的 Bean 成功了。
这样就完成了整个 Tomcat 下的 jsp 、 servlet 和 javabean 的配置。接下来需要做的事情就是多看书、多读别人的好代码，自己多动手写代码以增强自己在这方面开发的能力了。

1.       加载和启动

启动意味着创建一个或多个 servlet 。

2.       初始化

启动后，接着调用 servlet 的 init() 方法，这个方法用于 servlet 进行初始化，并处理随后到来的请求，如变量初始化或数据库连接。

3.       处理请求信息

javax.HttpServletRequest 对象实例中封装了详细的请求信息。然后 wl 将自动的调用 servlet 中的 service （）方法，然后 service() 方法会根据具体情况调用相应的方法，如处理 post 和 get 请求时，会调用相应的 doGet （）和 doPost() 方法。

4.       服务的结束

在响应 wl 控制台的命令，或者 wl server 关机时， wl 将调用 Destroy （）方法，删除 servlet 实例，从而结束一个 servlet 的运行。

参考资料：

1.       sun 网站上资料的翻译：

http://kinlili.spaces.msn.com/

      Servlet 的生命周期
       一个 Java servlet 具有一个生命周期，这个生命周期定义了一个 Servlet 如何被载入并被初始化，如何接收请求并作出对请求的响应，如何被从服务中清除。 Servlet 的生命周期被 javax.servlet.Servlet 这个接口所定义。
       所有的 Java Servlet 都会直接地或间接地执行 javax.servlet.Servlet 接口，这样它才能在一个 Servlet 引擎中运行。

      javax.servlet.Servlet 接口定义了在 Servlet 的生命周期中特定时间以及特定顺序被调用的方法。

2.        sun 原文资料： http://java.sun.com/products/servlet/2.1/servletspec-2.1.zip

所以：
applet：表示客户端小应用程序；
servlet：表示服务器端小程序。