iLeichun

　　在Photoshop中新建一个白色背景的文档，设置字体为Arial Black，字号36，输入字符“F”。
　　设置前景色为#4E5500，背景色为#E9EBCE。
　　新建立一个图层，选择青草笔刷。

　

用青草画笔创建一些图形。

　　然后旋转90度调整到如下图所示位置：

　　复制上面的图层，接着调整如下图：

　　再次复制图层继续调整，水平翻转：

　　重复上面操作，方法很简单，在这里不详细说调整方法了，注意删除一些多余的：

　　最终效果：

　　我们用Photoshop来绘制巧克力融化效果的特效字，放在情人节的贺卡里面，应该别有味道。

关于2010年6月全国大学英语四、六级考试、日语四级、日语六级、德语四级、德语六级考试以及俄语、法语四级考试成绩发布时间的通知:

2010年6月19日全国大学英语四、六级考试、日语四级、日语六级、德语四级、德语六级考试以及俄语、法语四级考试成绩将于2010年8月27日上午9点发布。

成绩查询方式

网上免费查分：

网址: cet.99sushe.com

运营商：99宿舍网
客服电话: 010-58699163转867

收费短信查分：

中国移动、联通、电信手机用户:
发送A加15位准考证号（如A123456789012345）到 1066335577 (1元/条，不含通信费）

特别注意:
河北省的中国移动手机用户发送 8 加 15位准考证号（如8123456789012345）到 10661660（1元/条，不含通信费）

运营商：空中网
客服电话: 010-68083018

2010年6月网考成绩发布方式和日期另行通知。

查分当天沪江网会网友互助查分活动，请大家关注。

最近研究ajax，在界面上text中输入中文，发送出去后返回乱码。经过一个晚上的测试，以及得到满意答案，代码如下：

HTML：
    ……
    //实际上这里的charset=utf-8 也是可以的，因为在中文平台下
    //用了GB2312
    

JS：
    我用了两个方法提交：GET 和 POST。
    在服务器端要对应不同的提交方式转换不同的编码。
   ……
    //要传递的参数
   var queryString = "firstName=" + firstName + "&lastName=" + lastName
                          + "&birthday=" + birthday;    function  

    //GET方式提交
    doRequestUsingGET() {
        createXMLHttpRequest();
        var url = "GetAndPostExample?" + queryString + "&timeStamp="
                          + new Date().getTime();
        xmlHttp.onreadystatechange = handleStateChange;
        xmlHttp.open("GET", url, true);
        xmlHttp.send(null);
    }

    //POST方式提交
    function doRequestUsingPOST() {
        createXMLHttpRequest();
        var url = "GetAndPostExample?timeStamp=" + new Date().getTime();
        xmlHttp.open("POST", url, true);
        xmlHttp.onreadystatechange = handleStateChange;
        xmlHttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
        xmlHttp.send(queryString);
    }

servlet：
        response.setContentType("text/xml");

        //这个一定要设置，这里的设置应该跟HTML中的一样，但是我在这里
        //用了 uft-8， 结果也是一样。
        response.setCharacterEncoding("GB2312");
      
        //当用POST方法时，一定要设置成utf-8，否则乱码
        String firstName = new String(request.getParameter("firstName").getBytes("ISO-8859-1"), "utf-8");

        //当用GET方法时，要设置成GB2312，否则乱码。
        String lastName = new String(request.getParameter("lastName").getBytes("ISO-8859-1"), "GB2312");

测试结果：
因为界面上两个控件firstName 和  lastName都输入中文。
接收xmlHttp.responseText后，会发现其中一个为乱码，一个可以正常显示中文。

在网上还发现有人说用：
“老问题了，最简单的方法是，全部escape后发送。取回后unescape，绝对没有编码问题。”
我测试后发现escape后的东西全部变成null了。不知道有谁成功用过这个方法的，或者还有什么更好的解决乱码的方法，请拿出来共享一下吧 ：）
 

在使用JSP技术开发网站时，不强调使用Servlet。，这是为什么呢？Servlet的应用是没有问题的，它非常适合服务器端的处理和编程。但是如果用Servlet处理大量的HTML文本，那么将是一件及其繁琐的事情。这种事情更适合机器去做，否则就是浪费程序员的体力。所以Servlet更适合处理后端的事务，前端的效果用JSP来实现更为合适。

　　早期的JSP标准给出了两种使用JSP的方式。这些方式都可以归纳为JSP模式1和JSP模式2，主要的差别在于处理大量请求的位置不同。在模式1中，JSP页面独自响应请求并将处理结果返回客户。这里仍然有视图和内容的分离，因为所有的数据都依靠bean来处理。尽管模式1可以很好的满足小型应用的需要，但却不能满足大型应用的需要。大量使用模式1，常常会导致页面被嵌入大量的Script和Java代码。特别是当需要处理的商业逻辑很复杂时，情况会变得很严重。也许这对于Java程序员来说，这不是大问题。但是如果开发者是前台界面设计人员，在大型项目中，这是很常见的，则代码的开发和维护将出现困难。在任何项目中，这样的模式多少总是会导致定义不清的响应和项目管理的困难。下图是模式1的示意图：


　　JSP模式2是一种面向动态内容的实现，结合了Servlet和JSP技术。它利用两种技术原有的优点，采用JSP来表现页面，采用Servlet来完成大量的处理，Servlet扮演一个控制者的角色，并负责响应客户请求。接着，Servlet创建JSP需要的Bean和对象，再根据用户的行为，决定将哪个JSP页面发送给用户。特别要注意的是，JSP页面中没有任何商业处理逻辑，它只是简单的检索Servlet先前创建的Beans或者对象，再将动态内容插入预定义的模板。

　　从开发的观点来看，这一模式具有更清晰的页面表现，清楚的开发者角色划分，可以充分的利用开发小组中的界面设计人员。事实上，越是复杂的项目，使用模式2的好处就越突出。

　　使用模式2，JSP和Servlet可以在功能最大幅度的分开。正确的使用模式2，导致一个中心化的控制Servlet，以及只完成显示的JSP页面。另一方面，模式2的实现很复杂，因此，在简单应用中，可以考虑使用模式1。下面是模式2的示意图：


　　在Web的建设中到底使用哪一种模式是很重要的事前规划，只有积累了大量的经验才能作出正确而有效的选择。总之网站建设不光是技术的问题，总体的规划是很重要的，读者在学习JSP和Servlet的同时更应该注意从中吸取思想的精华，技术是会过时的，而思想却是永远有价值的。
 

MVC介绍

　　MVC其实是模、视图、控制的缩写，也就是说在使用jsp时，有相应的文件去实现相应的操作
通常jsp只负责view也就是只负责显示页面。业务逻辑等有bean(ejb)去实现。下面讨论的是不使用ejb的情况下实现。如果使用ejb,ejb负责M.C通常会由servlet去实现。
设计思路

　　当你构建一个Application时。你必须考虑界面的问题，而界面修改是非常平常的。如果你在jsp中实现所有的操作，一旦修改界面你麻烦大了。美工不懂jsp的，你必须自己去修改无数个文件，头不要太大，而此时一般时间都很紧，使用MVC则可以减少你的一些麻烦。在设计时候jsp只负责显示页面，也就是说jsp调用Bean(Struts,servlet)传过来的数据然后显示而Bean(Struts,servlet)负责收集jsp需要的数据，用ArrayList(Arttibute)传给jsp。假如需要提交表单，一般也直接提交给Struts,servlet,处理后以后再返回处理信息。而其中相应的业务逻辑由Bean去实现。
Bean的设计

　　在我使用时候Bean通常有三类，分别在manager,entry,database目录下面。

　　　manager下面的bean做商业逻辑

　　　entry下的bean就是封装数据，其实就是每个数据库表对应会有一个bean。jsp得到的也全部是类。

　　　database下的bean就是操作数据库，执行如insert,update,delete,load(查询一条记录),batchload(查询多条记录)。
他们之间的关系是entry负责封装数据，作为database的调用参数，返回结果。

经常看到jsp的初学者问tomcat下如何配置jsp、servlet和bean,数据库连接池,虚拟目录等问题，于是总结了一下如何tomcat下配置jsp、servlet和bean,连接池，虚拟目录希望对那些初学者有所帮助。
　　
　　 一、开发环境配置
　　
　　 第一步：下载j2sdk和tomcat：到sun官方站（http://java.sun.com/j2se/1.5.0/download.jsp）下载j2sdk，注意下载版本为Windows Offline Installation的SDK，同时最好下载J2SE 1.5.0 Documentation，然后到tomcat官方站点（http://jakarta.apache.org/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%libdt.jar;%JAVA_HOME%lib    ools.jar;（.;一定不能少，因为它代表当前路径)
path=%JAVA_HOME%in
　　 接着可以写一个简单的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.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。
　　
　　 2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:    omcat)：
　　
　　 CATALINA_HOME=c:    omcat
　　 CATALINA_BASE=c:    omcat
　　
　　 然后修改环境变量中的classpath，把tomat安装目录下的commonlib下的(可以根据实际追加)servlet.jar追加到classpath中去，修改后的classpath如下：
　　
classpath=.;%JAVA_HOME%libdt.jar;%JAVA_HOME%lib    ools.jar;%CATALINA_HOME%commonlibservlet.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"
　　 "http://java.sun.com/dtd/web-app_2_3.dtd";>
　
　　 My Web Application
　　
　　　 A application for test.

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

　　 Now time is:

　　 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:    est下，使用如下命令编译：
　　
　　 C:Test>javac Test.java
　　
　　然后在c:Test下会产生一个编译后的servlet文件：Test.class
　　
　　 3 .将结构testTest.class剪切到%CATALINA_HOME%webappsmyappWEB-INFclasses下，也就是剪切那个test目录到classes目录下，如果classes目录不存在，就新建一个。 现在webappsmyappWEB-INFclasses下有testTest.class的文件目录结构
　　
　　 4 .修改webappsmyappWEB-INFweb.xml，添加servlet和servlet-mapping
　　
　　编辑后的web.xml如下所示，红色为添加的内容:
　　

　　 PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
　　 "http://java.sun.com/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){
　　　 this.name=strName_p;
　　 }
　　 public void setName(String strName_p){
　　　 this.name=strName_p;
　　 }
　　 public String getName(){
　　　 return this.name;
　 }
}　
　　 2 .编译
　　
　　将TestBean.java放在c:    est下，使用如下命令编译：
　　
　　 C:Test>javac TestBean.java
　　
　　然后在c:Test下会产生一个编译后的bean文件：TestBean.class
　　
　　 3 .将TestBean.class文件剪切到 %CATALINA_HOME%webappsmyappWEB-INFclasses    est下，
　　
　　 4 .新建一个TestBean.jsp文件，文件内容为：

　　 5 .好了，重启Tomcat，启动浏览器，输入http://localhost:8080/myapp/TestBean.jsp ;如果看到输出Java bean name is: This is a test java bean.就说明编写的Bean成功了。
　　
　　这样就完成了整个Tomcat下的jsp、servlet和javabean的配置。接下来需要做的事情就是多看书、多读别人的好代码，自己多动手写代码以增强自己在这方面开发的能力了。

配置TOMCAT5.5.X连接池(sqlserver版)

1. 进入tomcat目录下的conf文件夹目录里,找到Server.xml
在tomcat的Server.xml文件中在标签与标签里,定议连接语句,格式如下;
debug="5" reloadable="true" crossContext="true">
maxActive="100" maxIdle="30" maxWait="10000"
username="javauser" password="javadude"
driverClassName=" com.microsoft.jdbc.sqlserver.SQLServerDriver "
url=" jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=KB_Rate""/>
 

配置完成后,在DBTest目录下添加一个Test文件,如下:
<%
Connection conn = null;
Context initCtx = new InitialContext();
if (initCtx == null)
throw new Exception("不能获取Context!");
Context ctx = (Context) initCtx.lookup("java:comp/env");
Object obj = (Object) ctx.lookup("/Default_JDBC ");//获取连接池对象
javax.sql.DataSource ds = (javax.sql.DataSource) obj; //类型转换
conn = ds.getConnection();
Statement stmt = conn.createStatement();
PreparedStatement ps=conn.prepareStatement("select * from FinalOrderdata");
ResultSet rs=ps.executeQuery();
while(rs.next()){
out.println(rs.getString(1)+"
");
i++;
}
rs.close();
stmt.close();
conn.close();
out.println("连接池测试成功"+i);

到于TOMCAT5.0版本的设置也是差不多,不过在Server.xml中添加连接池设置语句上有所有不,可参考
http://jakarta.apache.org/tomcat/tomcat-5.0-doc/jndi-datasource-examples-howto.html
其它操作也是差不多,
debug="5" reloadable="true" crossContext="true">
debug="5" reloadable="true" crossContext="true">
prefix="localhost_DBTest_log." suffix=".txt"
timestamp="true"/>
auth="Container"
type="javax.sql.DataSource"/>

factory
org.apache.commons.dbcp.BasicDataSourceFactory

maxActive
100

maxIdle
30

maxWait
10000

username
javauser

password
javadude

driverClassName
com.mysql.jdbc.Driver

url
jdbc:mysql://localhost:3306/javatest?autoReconnect=true

有不足的地方,请各为指正!

如何配置Tomcat的虚拟目录

ROOT是tomcat的默认虚拟目录，如果要改成自己的虚拟目录怎么办呢？请继续往下看吧。
要改成自己的虚拟目录，就要请出server.xml来了，该文件是一个配置文件，在Tomcatconf目录下，使用任何文本编辑软件都能打开它，我们先找到下面一句：
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"
acceptCount="100" debug="0" connectionTimeout="20000"
useURIValidationHack="false" disableUploadTimeout="true" />
这里的port="8080"就是端口，我们完全可以用别的端口来代替，但不能是被系统占用的端口（0--1023），这里简单提一下。
下面我们再往下找，会发现以下的语句：

我们就应该找到这两个语句，如果不懂E文，您就认定这两个语句好了。然后我们将该语句更改如下：

这里的path="/myjsp"就是我们就配置的虚拟目录了，以后在地址栏中输入http://localhost:8080/myjsp即可。而docBase="e:/myjsp" 则是机器本地路径，他们通过这个语句形成一个映射关系，其它照抄。
将上面的First.jsp文件放到e:/myjsp目录下，输入http://localhost:8080/myjsp/First.jsp，是不是有一种喜上眉梢的感觉？
在论坛里我见得最多的就是很多人不知道javaBean文件放到哪里，老实说开始我也不知道，更令人不解的是，十个人有九种不同的说法，这更让我们茫然。其实这问题也不是我们想像的那么复杂，我们以一个例子说明：
先建立一个java程序，代码如下：
package hall;
public class SimpleBean {
private String message = "No message specified";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}
}
保存为SimpleBean.java，编译后会生成一个包，其实就相当于一个目录，也就是SimpleBean.class会存放在hall目录中，暂且保存起来，将来备用。
再输入以下代码：
 

Message:

保存在我们刚才建立的虚拟目录e:/myjsp下面，并命名为：BeanTest.jsp。
现在我们应该将hall（包）目录放在哪儿呢？别急，我们先在e:/myjsp下建立一个文件夹WEB-INF，然后再在WEB-INF下建立一个classes文件夹，最后将hall目录放到classes下，当然，hall下的字节码文件SimpleBean.class也一并要移过来，而SimpleBean.java就和BeanTest.jsp放到同一目录吧（可以不需要放的，自己试试）。
好了，大功告成了，重新启动机器（如果您试了好多次都不行，这一步一定要做），在浏览器中输入：http://localhost:8080/myjsp/BeanTest.jsp，您看到了什么？呵，别告诉我您什么都没看到，那肯定是您设置的问题了。
 

你时常被客户抱怨JSP页面响应速度很慢吗？你想过当客户访问次数剧增时，你的WEB应用能承受日益增加的访问量吗？本文讲述了调整JSP和 servlet的一些非常实用的方法，它可使你的servlet和JSP页面响应更快，扩展性更强。而且在用户数增加的情况下，系统负载会呈现出平滑上长的趋势。在本文中，我将通过一些实际例子和配置方法使得你的应用程序的性能有出人意料的提升。其中，某些调优技术是在你的编程工作中实现的。而另一些技术是与应用服务器的配置相关的。在本文中，我们将详细地描述怎样通过调整servlet和JSP页面，来提高你的应用程序的总体性能。在阅读本文之前，假设你有基本的servlet和JSP的知识。

　　方法一：在servlet的init()方法中缓存数据

　　当应用服务器初始化servlet实例之后，为客户端请求提供服务之前，它会调用这个servlet的init()方法。在一个servlet的生命周期中，init()方法只会被调用一次。通过在init()方法中缓存一些静态的数据或完成一些只需要执行一次的、耗时的操作，就可大大地提高系统性能。

　　例如，通过在init()方法中建立一个JDBC连接池是一个最佳例子，假设我们是用jdbc2.0的DataSource接口来取得数据库连接，在通常的情况下，我们需要通过JNDI来取得具体的数据源。我们可以想象在一个具体的应用中，如果每次SQL请求都要执行一次JNDI查询的话，那系统性能将会急剧下降。解决方法是如下代码，它通过缓存DataSource，使得下一次SQL调用时仍然可以继续利用它：

public class ControllerServlet extends HttpServlet
{
　private javax.sql.DataSource testDS = null;
　public void init(ServletConfig config) throws ServletException
　{
　　super.init(config);
　　Context ctx = null;
　　try
　　{
　　　ctx = new InitialContext();
　　　testDS = (javax.sql.DataSource)ctx.lookup("jdbc/testDS");
　　}
　　catch(NamingException ne)
　　{
　　　ne.printStackTrace();
　　}
　　catch(Exception e)
　　{
　　　e.printStackTrace();
　　}
　}

　public javax.sql.DataSource getTestDS()
　{
　　return testDS;
　}
　...
　...
}

　　方法 2:禁止servlet和JSP 自动重载(auto-reloading)

　　Servlet/JSP提供了一个实用的技术，即自动重载技术，它为开发人员提供了一个好的开发环境，当你改变servlet和JSP页面后而不必重启应用服务器。然而，这种技术在产品运行阶段对系统的资源是一个极大的损耗，因为它会给JSP引擎的类装载器(classloader)带来极大的负担。因此关闭自动重载功能对系统性能的提升是一个极大的帮助。

　　方法 3: 不要滥用HttpSession

　　在很多应用中，我们的程序需要保持客户端的状态，以便页面之间可以相互联系。但不幸的是由于HTTP具有天生无状态性，从而无法保存客户端的状态。因此一般的应用服务器都提供了session来保存客户的状态。在JSP应用服务器中，是通过HttpSession对像来实现session的功能的，但在方便的同时，它也给系统带来了不小的负担。因为每当你获得或更新session时，系统者要对它进行费时的序列化操作。你可以通过对HttpSession的以下几种处理方式来提升系统的性能：

　　? 如果没有必要，就应该关闭JSP页面中对HttpSession的缺省设置： 如果你没有明确指定的话，每个JSP页面都会缺省地创建一个HttpSession。如果你的JSP中不需要使用session的话，那可以通过如下的JSP页面指示符来禁止它：

＜%@ page session="false"%＞  

　　? 不要在HttpSession中存放大的数据对像：如果你在HttpSession中存放大的数据对像的话，每当对它进行读写时，应用服务器都将对其进行序列化，从而增加了系统的额外负担。你在HttpSession中存放的数据对像越大，那系统的性能就下降得越快。

　　? 当你不需要HttpSession时，尽快地释放它：当你不再需要session时，你可以通过调用HttpSession.invalidate()方法来释放它。

　　? 尽量将session的超时时间设得短一点：在JSP应用服务器中，有一个缺省的session的超时时间。当客户在这个时间之后没有进行任何操作的话，系统会将相关的session自动从内存中释放。超时时间设得越大，系统的性能就会越低，因此最好的方法就是尽量使得它的值保持在一个较低的水平。

　方法 4: 将页面输出进行压缩

　　压缩是解决数据冗余的一个好的方法，特别是在网络带宽不够发达的今天。有的浏览器支持gzip(GNU zip)进行来对HTML文件进行压缩，这种方法可以戏剧性地减少HTML文件的下载时间。因此，如果你将servlet或JSP页面生成的HTML页面进行压缩的话，那用户就会觉得页面浏览速度会非常快。但不幸的是，不是所有的浏览器都支持gzip压缩，但你可以通过在你的程序中检查客户的浏览器是否支持它。下面就是关于这种方法实现的一个代码片段：

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
　OutputStream out = null
　String encoding = request.getHeader("Accept-Encoding");
　if (encoding != null && encoding.indexOf("gzip") != -1)
　{
　　request.setHeader("Content-Encoding" , "gzip");
　　out = new GZIPOutputStream(request.getOutputStream());
　}
　else if (encoding != null && encoding.indexOf("compress") != -1)
　{
　　request.setHeader("Content-Encoding" , "compress");
　　out = new ZIPOutputStream(request.getOutputStream());
　}
　else
　{
　　out = request.getOutputStream();
　}
　...
　...
}  

　　方法 5: 使用线程池

　　应用服务器缺省地为每个不同的客户端请求创建一个线程进行处理，并为它们分派service()方法，当service()方法调用完成后，与之相应的线程也随之撤消。由于创建和撤消线程会耗费一定的系统资源，这种缺省模式降低了系统的性能。但所幸的是我们可以通过创建一个线程池来改变这种状况。另外，我们还要为这个线程池设置一个最小线程数和一个最大线程数。在应用服务器启动时，它会创建数量等于最小线程数的一个线程池，当客户有请求时，相应地从池从取出一个线程来进行处理，当处理完成后，再将线程重新放入到池中。如果池中的线程不够地话，系统会自动地增加池中线程的数量，但总量不能超过最大线程数。通过使用线程池，当客户端请求急剧增加时，系统的负载就会呈现的平滑的上升曲线，从而提高的系统的可伸缩性。

　　方法 6: 选择正确的页面包含机制

　　在JSP中有两种方法可以用来包含另一个页面：1、使用include指示符(＜%@ includee file=”test.jsp” %＞)。 2、使用jsp指示符(＜jsp:includee page=”test.jsp” flush=”true”/＞)。在实际中我发现，如果使用第一种方法的话，可以使得系统性能更高。

　　方法 7:正确地确定javabean的生命周期

　　JSP的一个强大的地方就是对javabean的支持。通过在JSP页面中使用＜jsp:useBean＞标签，可以将javabean直接插入到一个JSP页面中。它的使用方法如下：

＜jsp:useBean id="name" scope="page|request|session|application" class=
"package.className" type="typeName"＞
＜/jsp:useBean＞

　　其中scope属性指出了这个bean的生命周期。缺省的生命周期为page。如果你没有正确地选择bean的生命周期的话，它将影响系统的性能。

　　举例来说，如果你只想在一次请求中使用某个bean，但你却将这个bean的生命周期设置成了session，那当这次请求结束后，这个bean将仍然保留在内存中，除非session超时或用户关闭浏览器。这样会耗费一定的内存，并无谓的增加了JVM垃圾收集器的工作量。因此为bean设置正确的生命周期，并在bean的使命结束后尽快地清理它们，会使用系统性能有一个提高。

　　其它一些有用的方法

　　? 在字符串连接操作中尽量不使用“＋”操作符：在java编程中，我们常常使用“＋”操作符来将几个字符串连接起来，但你或许从来没有想到过它居然会对系统性能造成影响吧？由于字符串是常量，因此JVM会产生一些临时的对像。你使用的“＋”越多，生成的临时对像就越多，这样也会给系统性能带来一些影响。解决的方法是用StringBuffer对像来代替“＋”操作符。

　　? 避免使用System.out.println()方法：由于 System.out.println()是一种同步调用，即在调用它时，磁盘I/O操作必须等待它的完成，因此我们要尽量避免对它的调用。但我们在调试程序时它又是一个必不可少的方便工具，为了解决这个矛盾，我建议你最好使用Log4j工具(http://Jakarta.apache.org )，它既可以方便调试，而不会产生System.out.println()这样的方法。

　　? ServletOutputStream 与 PrintWriter的权衡:使用PrintWriter可能会带来一些小的开销，因为它将所有的原始输出都转换为字符流来输出，因此如果使用它来作为页面输出的话，系统要负担一个转换过程。而使用ServletOutputStream作为页面输出的话就不存在一个问题，但它是以二进制进行输出的。因此在实际应用中要权衡两者的利弊。

　　总结

　　本文的目的是通过对 servlet和JSP的一些调优技术来极大地提高你的应用程序的性能，并因此提升整个J2EE应用的性能。通过这些调优技术，你可以发现其实并不是某种技术平台（比如J2EE和.NET之争）决定了你的应用程序的性能，重要是你要对这种平台有一个较为深入的了解，这样你才能从根本上对自己的应用程序做一个优化！

由于近来在本站看见N人问中文问题，为了帮大家解决。现将解决中文问题方法列出如下，*注：并非原创，此乃平时用时收集*。
一、中文问题的来源
    计算机最初的操作系统支持的编码是单字节的字符编码，于是，在计算机中一切处理程序最初都是以单字节编码的英文为准进行处理。随着计算机的发展，为了适应世界其它民族的语言（当然包括我们的汉字），人们提出了UNICODE编码，它采用双字节编码，兼容英文字符和其它民族的双字节字符编码，所以，目前，大多数国际性的软件内部均采用UNICODE编码，在软件运行时，它获得本地支持系统（多数时间是操作系统）默认支持的编码格式，然后再将软件内部的UNICODE转化为本地系统默认支持的格式显示出来。Java的JDK和JVM即是如此，我这里说的JDK是指国际版的JDK，我们大多数程序员使用的是国际化的JDK版本，以下所有的JDK均指国际化的JDK版本。我们的汉字是双字节编码语言，为了能让计算机处理中文，我们自己制定的gb2312、GBK、GBK2K等标准以适应计算机处理的需求。所以，大部分的操作系统为了适应我们处理中文的需求，均定制有中文操作系统，它们采用的是GBK,GB2312编码格式以正确显示我们的汉字。如：中文Win2K默认采用的是GBK编码显示，在中文WIN2k中保存文件时默认采用的保存文件的编码格式也是GBK的，即，所有在中文WIN2K中保存的文件它的内部编码默认均采用GBK编码，注意：GBK是在GB2312基础上扩充来的。
    由于Java语言内部采用UNICODE编码，所以在JAVA程序运行时，就存在着一个从UNICODE编码和对应的操作系统及浏览器支持的编码格式转换输入、输出的问题，这个转换过程有着一系列的步骤，如果其中任何一步出错，则显示出来的汉字就会出是乱码，这就是我们常见的JAVA中文问题。
    同时，Java是一个跨平台的编程语言，也即我们编写的程序不仅能在中文windows上运行，也能在中文Linux等系统上运行，同时也要求能在英文等系统上运行（我们经常看到有人把在中文win2k上编写的JAVA程序，移植到英文Linux上运行）。这种移植操作也会带来中文问题。
    还有，有人使用英文的操作系统和英文的IE等浏览器，来运行带中文字符的程序和浏览中文网页，它们本身就不支持中文，也会带来中文问题。
    有，几乎所有的浏览器默认在传递参数时都是以UTF-8编码格式来传递，而不是按中文编码传递，所以，传递中文参数时也会有问题，从而带来乱码现象。
    总之，以上几个方面是JAVA中的中文问题的主要来源，我们把以上原因造成的程序不能正确运行而产生的问题称作：JAVA中文问题。
2、JAVA编码转换的详细过程
    我们常见的JAVA程序包括以下类别：
     *直接在console上运行的类(包括可视化界面的类)
     *JSP代码类（注：JSP是Servlets类的变型）
     *Servelets类
     *EJB类
     *其它不可以直接运行的支持类
    这些类文件中，都有可能含有中文字符串，并且我们常用前三类JAVA程序和用户直接交互，用于输出和输入字符，如：我们在JSP和Servlet中得到客户端送来的字符，这些字符也包括中文字符。无论这些JAVA类的作用如何，这些JAVA程序的生命周期都是这样的：
    *编程人员在一定的操作系统上选择一个合适的编辑软件来实现源程序代码并以.java扩展名保存在操作系统中，例如我们在中文win2k中用记事本编辑一个java源程序；
     *编程人员用JDK中的javac.exe来编译这些源代码，形成.class类(JSP文件是由容器调用JDK来编译的)；
     *直接运行这些类或将这些类布署到WEB容器中去运行，并输出结果。
    那么，在这些过程中，JDK和JVM是如何将这些文件如何编码和解码并运行的呢？
    这里，我们以中文win2k操作系统为例说明JAVA类是如何来编码和被解码的。
    第一步，我们在中文win2k中用编辑软件如记事本编写一个Java源程序文件(包括以上五类JAVA程序)，程序文件在保存时默认采用了操作系统默认支持GBK编码格式(操作系统默认支持的格式为file.encoding格式)形成了一个.java文件，也即，java程序在被编译前，我们的JAVA源程序文件是采用操作系统默认支持的file.encoding编码格式保存的，java源程序中含有中文信息字符和英文程序代码；要查看系统的file.encoding参数，可以用以下代码：
public class ShowSystemDefaultEncoding {
public static void main(String[] args) {
String encoding = System.getProperty("file.encoding");
System.out.println(encoding);
}}
    第二步，我们用JDK的javac.exe文件编译我们的Java源程序，由于JDK是国际版的，在编译的时候，如果我们没有用-encoding参数指定我们的JAVA源程序的编码格式，则javac.exe首先获得我们操作系统默认采用的编码格式，也即在编译java程序时，若我们不指定源程序文件的编码格式，JDK首先获得操作系统的file.encoding参数(它保存的就是操作系统默认的编码格式，如WIN2k，它的值为GBK)，然后JDK就把我们的java源程序从file.encoding编码格式转化为JAVA内部默认的UNICODE格式放入内存中。然后，javac把转换后的unicode格式的文件进行编译成.class类文件，此时.class文件是UNICODE编码的，它暂放在内存中，紧接着，JDK将此以UNICODE编码的编译后的class文件保存到我们的操作系统中形成我们见到的.class文件。对我们来说，我们最终获得的.class文件是内容以UNICODE编码格式保存的类文件，它内部包含我们源程序中的中文字符串，只不过此时它己经由file.encoding格式转化为UNICODE格式了。
    这一步中，对于JSP源程序文件是不同的，对于JSP，这个过程是这样的：即WEB容器调用JSP编译器，JSP编译器先查看JSP文件中是否设置有文件编码格式，如果JSP文件中没有设置JSP文件的编码格式，则JSP编译器调用JDK先把JSP文件用JVM默认的字符编码格式(也即WEB容器所在的操作系统的默认的file.encoding)转化为临时的Servlet类，然后再把它编译成UNICODE格式的class类，并保存在临时文件夹中。如：在中文win2k上，WEB容器就把JSP文件从GBK编码格式转化为UNICODE格式，然后编译成临时保存的Servlet类，以响应用户的请求。
    第三步，运行第二步编译出来的类，分为三种情况：
    A、 直接在console上运行的类
    B、 EJB类和不可以直接运行的支持类(如JavaBean类)
    C、 JSP代码和Servlet类
    D、 JAVA程序和数据库之间
    下面我们分这四种情况来看。
    A、直接在console上运行的类
    这种情况，运行该类首先需要JVM支持，即操作系统中必须安装有JRE。运行过程是这样的：首先java启动JVM，此时JVM读出操作系统中保存的class文件并把内容读入内存中，此时内存中为UNICODE格式的class类，然后JVM运行它，如果此时此类需要接收用户输入，则类会默认用file.encoding编码格式对用户输入的串进行编码并转化为unicode保存入内存（用户可以设置输入流的编码格式）。程序运行后，产生的字符串（UNICODE编码的）再回交给JVM，最后JRE把此字符串再转化为file.encoding格式(用户可以设置输出流的编码格式)传递给操作系统显示接口并输出到界面上。
    以上每一步的转化都需要正确的编码格式转化，才能最终不出现乱码现象。
    B、EJB类和不可以直接运行的支持类(如JavaBean类)
    由于EJB类和不可以直接运行的支持类，它们一般不与用户直接交互输入和输出，它们常常与其它的类进行交互输入和输出，所以它们在第二步被编译后，就形成了内容是UNICODE编码的类保存在操作系统中了，以后只要它与其它的类之间的交互在参数传递过程中没有丢失，则它就会正确的运行。
    C、JSP代码和Servlet类
    经过第二步后，JSP文件也被转化为Servlets类文件，只不过它不像标准的Servlets一校存在于classes目录中，它存在于WEB容器的临时目录中，故这一步中我们也把它做为Servlets来看。
    对于Servlets，客户端请求它时，WEB容器调用它的JVM来运行Servlet，首先，JVM把Servlet的class类从系统中读出并装入内存中，内存中是以UNICODE编码的Servlet类的代码，然后JVM在内存中运行该Servlet类，如果Servlet在运行的过程中，需要接受从客户端传来的字符如：表单输入的值和URL中传入的值，此时如果程序中没有设定接受参数时采用的编码格式，则WEB容器会默认采用ISO-8859-1编码格式来接受传入的值并在JVM中转化为UNICODE格式的保存在WEB容器的内存中。Servlet运行后生成输出，输出的字符串是UNICODE格式的，紧接着，容器将Servlet运行产生的UNICODE格式的串（如html语法，用户输出的串等）直接发送到客户端浏览器上并输出给用户，如果此时指定了发送时输出的编码格式，则按指定的编码格式输出到浏览器上，如果没有指定，则默认按ISO-8859-1编码发送到客户的浏览器上。
    D、Java程序和数据库之间
    对于几乎所有数据库的JDBC驱动程序，默认的在JAVA程序和数据库之间传递数据都是以ISO-8859-1为默认编码格式的，所以，我们的程序在向数据库内存储包含中文的数据时，JDBC首先是把程序内部的UNICODE编码格式的数据转化为ISO-8859-1的格式，然后传递到数据库中，在数据库保存数据时，它默认即以ISO-8859-1保存，所以，这是为什么我们常常在数据库中读出的中文数据是乱码。
    3、分析常见的JAVA中文问题几个必须清楚的原则
    首先，经过上面的详细分析，我们可以清晰地看到，任何JAVA程序的生命期中，其编码转换的关键过程是在于：最初编译成class文件的转码和最终向用户输出的转码过程。
    其次，我们必须了解JAVA在编译时支持的、常用的编码格式有以下几种：
    *ISO-8859-1，8-bit, 同8859_1,ISO-8859-1,ISO_8859_1等编码
    *Cp1252，美国英语编码，同ANSI标准编码
    *UTF-8，同unicode编码
    *GB2312，同gb2312-80,gb2312-1980等编码
    *GBK , 同MS936，它是gb2312的扩充
    及其它的编码，如韩文、日文、繁体中文等。同时，我们要注意这些编码间的兼容关体系如下：
    unicode和UTF-8编码是一一对应的关系。GB2312可以认为是GBK的子集，即GBK编码是在gb2312上扩展来的。同时，GBK编码包含了20902个汉字，编码范围为：0x8140-0xfefe，所有的字符可以一一对应到UNICODE2.0中来。
    再次，对于放在操作系统中的.java源程序文件，在编译时，我们可以指定它内容的编码格式，具体来说用-encoding来指定。注意：如果源程序中含有中文字符，而你用-encoding指定为其它的编码字符，显然是要出错的。用-encoding指定源文件的编码方式为GBK或gb2312，无论我们在什么系统上编译含有中文字符的JAVA源程序都不会有问题，它都会正确地将中文转化为UNICODE存储在class文件中。
    然后，我们必须清楚，几乎所有的WEB容器在其内部默认的字符编码格式都是以ISO-8859-1为默认值的，同时，几乎所有的浏览器在传递参数时都是默认以UTF-8的方式来传递参数的。所以，虽然我们的Java源文件在出入口的地方指定了正确的编码方式，但其在容器内部运行时还是以ISO-8859-1来处理的。
4、中文问题的分类及其建议最优解决办法
    了解以上JAVA处理文件的原理之后，我们就可以提出了一套建议最优的解决汉字问题的办法。
    我们的目标是：我们在中文系统中编辑的含有中文字符串或进行中文处理的JAVA源程序经编译后可以移值到任何其它的操作系统中正确运行，或拿到其它操作系统中编译后能正确运行，能正确地传递中文和英文参数，能正确地和数据库交流中英文字符串。
    我们的具体思路是：在JAVA程序转码的入口和出口及JAVA程序同用户有输入输出转换的地方限制编码方法使之正确即可。
    具体解决办法如下：
    1、 针对直接在console上运行的类
    对于这种情况，我们建议在程序编写时，如果需要从用户端接收用户的可能含有中文的输入或含有中文的输出，程序中应该采用字符流来处理输入和输出，具体来说，应用以下面向字符型节点流类型：
    对文件：FileReader，FileWrieter
        其字节型节点流类型为：FileInputStream，FileOutputStream
    对内存（数组）：CharArrayReader，CharArrayWriter
        其字节型节点流类型为：ByteArrayInputStream，ByteArrayOutputStream
    对内存（字符串）：StringReader，StringWriter
    对管道：PipedReader，PipedWriter
        其字节型节点流类型为：PipedInputStream，PipedOutputStream
    同时，应该用以下面向字符型处理流来处理输入和输出：
    BufferedWriter，BufferedReader
        其字节型的处理流为：BufferedInputeStream，BufferedOutputStream
    InputStreamReader，OutputStreamWriter
    其字节型的处理流为：DataInputStream，DataOutputStream
    其中InputStreamReader和InputStreamWriter用于将字节流按照指定的字符编码集转换到字符流，如：
    InputStreamReader in = new InputStreamReader(System.in，"GB2312")；
    OutputStreamWriter out = new OutputStreamWriter (System.out，"GB2312")；
    例如：采用如下的示例JAVA编码就达到了要求：
//Read.java
import java.io.*;
public class Read {
public static void main(String[] args) throws IOException {
String str = " 中文测试，这是内部硬编码的串"+" test english character";
String strin= "";
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in,"gb2312")); //设置输入接口按中文编码
BufferedWriter stdout = new BufferedWriter(new OutputStreamWriter(System.out,"gb2312")); //设置输出接口按中文编码
stdout.write("请输入:");
stdout.flush();
strin = stdin.readLine();
stdout.write("这是从用户输入的串："+strin);
stdout.write(str);
stdout.flush();
}}
    同时，在编译程序时，我们用以下方式来进行：
    javac -encoding gb2312 Read.java
    2、 针对EJB类和不可以直接运行的支持类(如JavaBean类)
    由于这种类它们本身被其它的类调用，不直接与用户交互，故对这种类来说，我们的建议的处理方式是内部程序中应该采用字符流来处理程序内部的中文字符串（具体如上面一节中一样），同时，在编译类时用-encoding gb2312参数指示源文件是中文格式编码的即可。
    3、 针对Servlet类
    针对Servlet，我们建议用以下方法：
    在编译Servlet类的源程序时，用-encoding指定编码为GBK或GB2312，且在向用户输出时的编码部分用response对象的setContentType("text/html;charset=GBK");或gb2312来设置输出编码格式，同样在接收用户输入时，我们用request.setCharacterEncoding("GB2312")；这样无论我们的servlet类移植到什么操作系统中，只有客户端的浏览器支持中文显示，就可以正确显示。如下是一个正确的示例：
//HelloWorld.java
package hello;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet
{
public void init() throws ServletException { }
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
{
request.setCharacterEncoding("GB2312"); //设置输入编码格式
response.setContentType("text/html;charset=GB2312"); //设置输出编码格式
PrintWriter out = response.getWriter(); //建议使用PrintWriter输出
out.println("

");
out.println("Hello World! This is created by Servlet!测试中文!");
out.println("

");
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException
{
request.setCharacterEncoding("GB2312"); //设置输入编码格式
response.setContentType("text/html;charset=GB2312"); //设置输出编码格式
String name = request.getParameter("name");
String id = request.getParameter("id");
if(name==null) name="";
if(id==null) id="";
PrintWriter out = response.getWriter(); //建议使用PrintWriter输出
out.println("

");
out.println("你传入的中文字串是：" + name);
out.println("

你输入的id是：" + id);
out.println("

");
}
public void destroy() { }
}
    请用javac -encoding gb2312 HelloWorld.java来编译此程序。
    测试此Servlet的程序如下所示：

如何成为一个成功的Jsp程序员？一个普通的错误是把JSP当作简化的 Java。它不是，（事实上, JSP 是简化的 servlets 。）程序员通常试着没有学习要求的支持技巧而 直接学习 JSP 。JSP 是一个衔接技术，并且成功地连接你需要理解的另外的技术。如果你已经知道 Java，HTML 和 Javascript，这意味着 JSP 将确实是简单的。

　　需要成为一个成功的 JSP 程序员可以参考这个时间表。请注意下列：

　　*忽略你已经熟悉的步骤。
　　*训练的时间只是代表学习好足够的基础时间，这样才能转移到下一步。

　　１、建立并且理解你的Web Server。
　　因为Apache 是免费的并且在大多数平台上工作，为训练目的推荐 Apache。
　　安装时间：2 天。

　　２、保证你理解 HTML / XHTML 。
　　你将需要了解html基础, 特别是 HTML 布局中的table的使用。XHTML 不久将代替 HTML ，学习 XHTML 的基础是一个好主意。许多程序员通过 HTML IDE 学习 HTML ( 集成开发环境 ) 。因为大多数 HTML IDE产生混乱的HTMl语法，所以花时间学习手工写作html是很有必要的。因 为你将会使用 JSP 和 HTML 混合编程，精通HTML语法是重要的。所以，你必须能流利地写 HTML 。
　　训练时间：2 ～ 4 个星期。

　　３、开始学习 Java 。
　　开始学习 Java 1.4 理解 Java 基础是很重要的。不用担心学习Swing或 Java 的图形方面，因为在JSP 中你不会使用这些特征。集中精力 在 Java 工作的细节，学习 Java 的逻辑，也在 Java Bean上花时间。学习Applet是好的, 但是就象Swing， JSP 的大多数应用将不使用小程 序。
　　训练时间：3 ～ 6 个星期。

　　4、学习 JavaScript
　　学习怎么将 JavaScript在HTML中验证输入的Form元素。也学习 JavaScript怎么能在一 HTML 页以内修改Form的元素。最后要求你能从一
　　HTML 页内的事件中触发 JavaScript Function。
　　训练时间：一～ 2 个星期。

　　5、学习并且理解你的Web Server的更好的细节。
　　熟悉Web Server的特征，这是很重要的。
　　训练时间：2 天。

　　6、建立你的 JSP Server
　　我推荐以Tomcat开始。它可以很好地运行JSP程序。当你不能在生产使用Tomcat时，学习尽可能多的知识以便于更好的运行程序。另外, 许多 JSP 程序员使用Tomcat。因此当你遇到一个问题时，你将容易发现帮助。
　　安装时间：1～ 2 天。

　　7、开始学习 JSP 。
　　基本的 JSP 学习通过的步骤 1到步骤6可以完成, 然后使用 JSP 对象和脚本写 JSP 程序来联系。学习 JSP 的另外一个方面可以学习怎么创建一个分布式的应用程序。
　　训练时间：4 ～ 6 个星期。

　　8、学习更多的 JSP server。
　　没有关于更多的 JSP Server当然也可以运行jsp程序。然而, 许多 JSP server都由自己特殊的特征，可以让你更好的理解你的JSP 工程。
　　学习更多的Jsp server如何处理jsp程序是有必要的。同样也可以优化你的 JSP 应用程序，并且使之运行得更快而不出任何问题。
　　训练时间：2 ～ 7 天。

　　9、 学习 JDBC 。
　　JSP 大多数应用将使用数据库，JDBC 被用于数据库连接。经常忽略的一个事实就是，每个 JDBC Driver 所支持的东西是相当不同的。了 解并熟悉在jsp工程上被使用的 JDBC driver的细节是很重要的。（有时这部分的学习被包含在前面 Java 或JSP的学习中了 。）
　　训练时间：1～ 2 个星期。

　　到现在，你已经成为了熟练的 JSP 程序员。仍然有很多需要学习，你可以考虑扩展你的知识比如 DHTML ， XML ，java证书， JSP Tag Libraries 或 Servlets , 看你想要造什么类型的网站而决定了。

　　这些训练是JSP 的核心。你不必都学习上面所有的, 取决于你在工程中分配到什么任务和你已经有什么知识。但是这是我成功地训练程序员 的时间表。关键的单元是时间。平均的说, 5 个月时间确实能够训练一个人 ( 从开始到完成 ) 成为一个对jsp熟悉程序员。5 个月时间似乎很长，但要成为一个资深的WEB程序员所学的东西远远不止这一些。

　　也许你认为这样学习一种语言花费的时间太长了，因为学 ASP 会更快、时间会更短。 但是学习 ASP 不需要学习java的。