BlogJava-Gemscorpio-文章分类-JSPhttp://www.blogjava.net/gemscorpio/category/3066.html目前的目标是做一名合格的Java程序员，为此我要a Za a Za fightingzh-cnTue, 27 Feb 2007 23:34:27 GMTTue, 27 Feb 2007 23:34:27 GMT60常用的ant的操作http://www.blogjava.net/Gemscorpio/articles/13983.htmlMudFishMudFishSun, 25 Sep 2005 03:32:00 GMThttp://www.blogjava.net/Gemscorpio/articles/13983.htmlhttp://www.blogjava.net/Gemscorpio/comments/13983.htmlhttp://www.blogjava.net/Gemscorpio/articles/13983.html#Feedback0http://www.blogjava.net/Gemscorpio/comments/commentRss/13983.htmlhttp://www.blogjava.net/Gemscorpio/services/trackbacks/13983.html主要的内容有：

    (1)建立一个项目
    (2)建立属性
    (3)对数据库的操作
    (4)javac编译 
    (5)删除目录 
    (6)建立目录 
    (7)拷贝文件群 
    (8)jar为一个包 
    (9)拷贝单个文件 
    (10)运行
  有更多更好的常用的,我没想到的,希望大家补充。  
  
  <!--(1)建立一个项目，默认的操作为target=all. -->
  <project name="proj" default="all" basedir=".">

    <!--(2)建立一些属性，以供下边的操作用到 -->
    <property name="root"  value="./" />
    <property name="deploy_path"  value="d:/deploy" />
    <property name="srcfile"  value="d:/srcfile" />  
  
    <target name="all" depends="compile,deploy"/>

    <!--(3)对数据库的操作 demo.ddl中写的是sql语句 driver,url,userid,password
随具体情况设置-->  
    <!-- Oracle -->
    <target name="db_setup_oracle" description="Database setup for Oracle
">
      <antcall target="check_params_results"/>
      <sql driver="oracle.jdbc.driver.OracleDriver"
       url="jdbc:oracle:thin:@192.168.0.1:1521:oa" 
       userid="oa" password="oa"
       onerror="continue" 
       print="yes"
       src="./demo.ddl"/>
    </target>

    <!--(4)javac编译 -->  
    <target name="compile">   
    <javac srcdir="${srcfile}"
      destdir="${root}/oa/"
      includes="*.java"
      classpath="${CLASSPATH};${CLIENT_CLASSES}/utils_common.jar"   <!--CLASSPATH
和CLIENT_CLASSES是环境变量-->
      />
    </target>
 
    <target name="deploy" depends="compile">
      <!-- Create the time stamp -->
      <tstamp/>
    
      <!--(5)删除目录-->    
      <!--(6)建立目录-->
      <delete dir="${root}/dist/"/>    
      <mkdir dir="${root}/dist/"/>      

      <delete dir="${deploy_path}"/> 
    <mkdir dir="${deploy_path}"/>     
  
    <!--(7)拷贝文件群-->
    <copy todir="${root}/dist/">     
            <fileset dir="${root}/oa/">
                <include name="*.class"/>
            </fileset>
    </copy>
    
    <!--(8)jar为一个包-->    
    <jar jarfile="${deploy_path}/classjar.jar" basedir="${root}/dist" update
="yes"></jar>  
  
    <!--(9)拷贝单个文件(上边是文件群,这是单个文件)-->
    <copy file="${deploy_path}/classjar.jar" todir="${root}/dist/"/> 

    </target>
 
     <!--(10)运行(args中是参数,随应用程序的具体情况有所不同)->
   <target name="simplesql"  depends="compile,db_setup_oracle"> 
    <java classname="examples.jdbc.oracle.simplesql"
      fork="yes" failonerror="yes"
      args="-user zrb 
            -password zrb 
            "/>

  </project> 

MudFish 2005-09-25 11:32 发表评论
]]>关于Java栈与堆的思考http://www.blogjava.net/Gemscorpio/articles/13982.htmlMudFishMudFishSun, 25 Sep 2005 03:27:00 GMThttp://www.blogjava.net/Gemscorpio/articles/13982.htmlhttp://www.blogjava.net/Gemscorpio/comments/13982.htmlhttp://www.blogjava.net/Gemscorpio/articles/13982.html#Feedback0http://www.blogjava.net/Gemscorpio/comments/commentRss/13982.htmlhttp://www.blogjava.net/Gemscorpio/services/trackbacks/13982.html动管理栈和堆，程序员不能直接地设置栈或堆。 

　　2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是
，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享
，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器
，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动
态分配内存，存取速度较慢。

　　3. Java中的数据类型有两种。

　　一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float
, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通
过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是
，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。
如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的
数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块
退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时
定义：

int a = 3; 
int b = 3； 

　　编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有
没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向
3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字
面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

　　特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用
同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个
对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导
致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与b的值
后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就
会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有
了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

　　另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包
装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，
在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。 4. String
是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创
建，也可以用String str = "abc"；的形式来创建(作为对比，在JDK 5.0之前，你从
未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在
JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer
(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类
的实例，全部通过new()的形式来创建。Java中的有些类，如DateFormat类，可以通
过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然
。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来
创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = "abc"；
中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。

　　5. 关于String str = "abc"的内部工作。Java内部将此语句转化为以下几个步
骤：

　　(1)先定义一个名为str的对String类的对象引用变量：String str；

　　(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值
为"abc"的地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地
址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址
，则查找对象o，并返回o的地址。

　　(3)将str指向对象o的地址。

　　值得注意的是，一般String类中字符串值都是直接存值的。但像String str = 
"abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！

　　为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。

String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true 

　　注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串
的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返
回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都
指向了这个对象。

　　我们再来更进一步，将以上代码改成：

String str1 = "abc";
String str2 = "abc";
str1 = "bcd";
System.out.println(str1 + "," + str2); //bcd, abc
System.out.println(str1==str2); //false 

　　这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！
而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈
中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值
指向这个地址。

　　事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，
可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回
给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间
。在对时间要求比较敏感的环境中，会带有一定的不良影响。

　　再修改原来代码：

String str1 = "abc";
String str2 = "abc";

str1 = "bcd";

String str3 = str1;
System.out.println(str3); //bcd

String str4 = "bcd";
System.out.println(str1 == str4); //true 

　　str3这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象
)。当str1改完其值后，再创建一个String的引用str4，并指向因str1修改值而创建
的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共
享。

　　我们再接着看以下的代码。

String str1 = new String("abc");
String str2 = "abc";
System.out.println(str1==str2); //false 

　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

String str1 = "abc";
String str2 = new String("abc");
System.out.println(str1==str2); //false 

　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。

　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字
符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

　　6. 数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的数
据类型包装类都不能更改其内部的值。 7. 结论与建议：

　　(1)我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为
，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯
定的是，指向String类的引用被创建了。至于这个引用到底是否指向了一个新的对象
，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因此
，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对
象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难
以发现的bug是很有帮助的。

　　(2)使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度
，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String
 str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值
是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是享元模
式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。

　　(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类
的引用是否指向同一个对象时，用==。

　　(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考
虑使用StringBuffer类，以提高程序效率。


MudFish 2005-09-25 11:27 发表评论
]]>彻底明白Java的IO系统http://www.blogjava.net/Gemscorpio/articles/13981.htmlMudFishMudFishSun, 25 Sep 2005 03:24:00 GMThttp://www.blogjava.net/Gemscorpio/articles/13981.htmlhttp://www.blogjava.net/Gemscorpio/comments/13981.htmlhttp://www.blogjava.net/Gemscorpio/articles/13981.html#Feedback0http://www.blogjava.net/Gemscorpio/comments/commentRss/13981.htmlhttp://www.blogjava.net/Gemscorpio/services/trackbacks/13981.html一． Input和Output
1. stream代表的是任何有能力产出数据的数据源，或是任何有能力接收数据的接收
源。在Java的IO中，所有的stream（包括Input和Out stream）都包括两种类型：
1.1 以字节为导向的stream
以字节为导向的stream，表示以字节为单位从stream中读取或往stream中写入信息。
以字节为导向的stream包括下面几种类型：
1) input　stream：
1) ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
2) StringBufferInputStream：把一个String对象作为InputStream
3) FileInputStream：把一个文件作为InputStream，实现对文件的读取操作
4) PipedInputStream：实现了pipe的概念，主要在线程中使用
5) SequenceInputStream：把多个InputStream合并为一个InputStream
2) Out　stream
1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中
2) FileOutputStream：把信息存入文件中
3) PipedOutputStream：实现了pipe的概念，主要在线程中使用
4) SequenceOutputStream：把多个OutStream合并为一个OutStream
1.2 以Unicode字符为导向的stream
以Unicode字符为导向的stream，表示以Unicode字符为单位从stream中读取或往stream
中写入信息。以Unicode字符为导向的stream包括下面几种类型：
1) Input　Stream
1) CharArrayReader：与ByteArrayInputStream对应
2) StringReader：与StringBufferInputStream对应
3) FileReader：与FileInputStream对应
4) PipedReader：与PipedInputStream对应
2) Out　Stream
1) CharArrayWrite：与ByteArrayOutputStream对应
2) StringWrite：无与之对应的以字节为导向的stream
3) FileWrite：与FileOutputStream对应
4) PipedWrite：与PipedOutputStream对应
以字符为导向的stream基本上对有与之相对应的以字节为导向的stream。两个对应类
实现的功能相同，字是在操作时的导向不同。如CharArrayReader：和ByteArrayInputStream
的作用都是把内存中的一个缓冲区作为InputStream使用，所不同的是前者每次从内
存中读取一个字节的信息，而后者每次从内存中读取一个字符。
1.3 两种不现导向的stream之间的转换
InputStreamReader和OutputStreamReader：把一个以字节为导向的stream转换成一
个以字符为导向的stream。
2. stream添加属性
2.1 “为stream添加属性”的作用
运用上面介绍的Java中操作IO的API，我们就可完成我们想完成的任何操作了。但通
过FilterInputStream和FilterOutStream的子类，我们可以为stream添加属性。下面
以一个例子来说明这种功能的作用。
如果我们要往一个文件中写入数据，我们可以这样操作：
FileOutStream fs = new FileOutStream(“test.txt”);
然后就可以通过产生的fs对象调用write()函数来往test.txt文件中写入数据了。但
是，如果我们想实现“先把要写入文件的数据先缓存到内存中，再把缓存中的数据写
入文件中”的功能时，上面的API就没有一个能满足我们的需求了。但是通过FilterInputStream
和FilterOutStream的子类，为FileOutStream添加我们所需要的功能。
2.2 FilterInputStream的各种类型
2.2.1 用于封装以字节为导向的InputStream
1) DataInputStream：从stream中读取基本类型（int、char等）数据。
2) BufferedInputStream：使用缓冲区
3) LineNumberInputStream：会记录input stream内的行数，然后可以调用getLineNumber
()和setLineNumber(int)
4) PushbackInputStream：很少用到，一般用于编译器开发
2.2.2 用于封装以字符为导向的InputStream
1) 没有与DataInputStream对应的类。除非在要使用readLine()时改用BufferedReader
，否则使用DataInputStream
2) BufferedReader：与BufferedInputStream对应
3) LineNumberReader：与LineNumberInputStream对应
4) PushBackReader：与PushbackInputStream对应
2.3 FilterOutStream的各种类型
2.2.3 用于封装以字节为导向的OutputStream
1) DataIOutStream：往stream中输出基本类型（int、char等）数据。
2) BufferedOutStream：使用缓冲区
3) PrintStream：产生格式化输出
2.2.4 用于封装以字符为导向的OutputStream
1) BufferedWrite：与对应
2) PrintWrite：与对应
3. RandomAccessFile
1) 可通过RandomAccessFile对象完成对文件的读写操作
2) 在产生一个对象时，可指明要打开的文件的性质：r，只读；w，只写；rw可读写

3) 可以直接跳到文件中指定的位置
4. I/O应用的一个例子
import java.io.*;
public class TestIO{
public static void main(String[] args)
throws IOException{
//1.以行为单位从一个文件读取数据
BufferedReader in = 
new BufferedReader(
new FileReader("F:nepalonTestIO.java"));
String s, s2 = new String();
while((s = in.readLine()) != null)
s2 += s + "n";
in.close();

//1b. 接收键盘的输入
BufferedReader stdin = 
new BufferedReader(
new InputStreamReader(System.in));
System.out.println("Enter a line:");
System.out.println(stdin.readLine());

//2. 从一个String对象中读取数据
StringReader in2 = new StringReader(s2);
int c;
while((c = in2.read()) != -1)
System.out.println((char)c);
in2.close();

//3. 从内存取出格式化输入
try{
DataInputStream in3 = 
new DataInputStream(
new ByteArrayInputStream(s2.getBytes()));
while(true)
System.out.println((char)in3.readByte()); 
}
catch(EOFException e){
System.out.println("End of stream");
}

//4. 输出到文件
try{
BufferedReader in4 =
new BufferedReader(
new StringReader(s2));
PrintWriter out1 =
new PrintWriter(
new BufferedWriter(
new FileWriter("F:nepalon TestIO.out")));
int lineCount = 1;
while((s = in4.readLine()) != null)
out1.println(lineCount++ + "：" + s);
out1.close();
in4.close();
}
catch(EOFException ex){
System.out.println("End of stream");
}

//5. 数据的存储和恢复
try{
DataOutputStream out2 = 
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("F:nepalon Data.txt")));
out2.writeDouble(3.1415926);
out2.writeChars("nThas was pi:writeCharsn");
out2.writeBytes("Thas was pi:writeByten");
out2.close();
DataInputStream in5 =
new DataInputStream(
new BufferedInputStream(
new FileInputStream("F:nepalon Data.txt")));
BufferedReader in5br =
new BufferedReader(
new InputStreamReader(in5));
System.out.println(in5.readDouble());
System.out.println(in5br.readLine());
System.out.println(in5br.readLine());
}
catch(EOFException e){
System.out.println("End of stream");
}

//6. 通过RandomAccessFile操作文件
RandomAccessFile rf =
new RandomAccessFile("F:nepalon rtest.dat", "rw");
for(int i=0; i<10; i++)
rf.writeDouble(i*1.414);
rf.close();

rf = new RandomAccessFile("F:nepalon rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();

rf = new RandomAccessFile("F:nepalon rtest.dat", "rw");
rf.seek(5*8);
rf.writeDouble(47.0001);
rf.close();

rf = new RandomAccessFile("F:nepalon rtest.dat", "r");
for(int i=0; i<10; i++)
System.out.println("Value " + i + "：" + rf.readDouble());
rf.close();
}
}
关于代码的解释（以区为单位）：
1区中，当读取文件时，先把文件内容读到缓存中，当调用in.readLine()时，再从缓
存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
1b区中，由于想以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准
IO（System.in）转换成字符导向的stream，再进行BufferedReader封装。
2区中，要以字符的形式从一个String对象中读取数据，所以要产生一个StringReader
类型的stream。
4区中，对String对象s2读取数据时，先把对象中的数据存入缓存中，再从缓冲中进
行读取；对TestIO.out文件进行操作时，先把格式化后的信息输出到缓存中，再把缓
存中的信息输出到文件中。
5区中，对Data.txt文件进行输出时，是先把基本类型的数据输出屋缓存中，再把缓
存中的数据输出到文件中；对文件进行读取操作时，先把文件中的数据读取到缓存中
，再从缓存中以基本类型的形式进行读取。注意in5.readDouble()这一行。因为写入
第一个writeDouble()，所以为了正确显示。也要以基本类型的形式进行读取。
6区是通过RandomAccessFile类对文件进行操作。


MudFish 2005-09-25 11:24 发表评论
]]>Tomcat的配置http://www.blogjava.net/Gemscorpio/articles/11319.htmlMudFishMudFishSat, 27 Aug 2005 07:50:00 GMThttp://www.blogjava.net/Gemscorpio/articles/11319.htmlhttp://www.blogjava.net/Gemscorpio/comments/11319.htmlhttp://www.blogjava.net/Gemscorpio/articles/11319.html#Feedback0http://www.blogjava.net/Gemscorpio/comments/commentRss/11319.htmlhttp://www.blogjava.net/Gemscorpio/services/trackbacks/11319.html如何tomcat下配置jsp、servlet和bean
(这是我配置成功的，还有许多地方不合理，欢迎大家指教)
第一步：下载j2sdk和tomcat：
到sun官方站点（http://java.sun.com/j2se/1.5.0/download.jsp）下载j2sdk，注意下载版本为Windows Offline Installation的SDK，同时最好下载J2SE  Documentation，
然后到tomcat官方站点（http://www.apache.org/dist/jakarta/tomcat-5/）下载tomcat（下载最新版本的tomcat）；
（这里我下的是jdk 1.5.0，tomcat 5.59）

第二步：安装和配置你的j2sdk和tomcat：
执行j2sdk和tomcat的安装程序，然后一路Next即可。(安装tomcat的时候要提示你输入Admin的密码，记得把自己输的密码记下来)1.安装j2sdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量
JAVA_HOME=H:\Java\jdk1.5.0
classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径)
path=%JAVA_HOME%\bin
(这里我的安装目录是H:\Java\jdk1.5.0，我只是根据自己的安装目录来讲配置，当然，你可以有一个更傻瓜的取得安装目录的方法，直接从我的电脑进到你的安装目录，然后复制地址栏里的地址即可^_^)
接着，我们来测试你的java开发环境是否已经配好，以经典的HelloWorld开始吧：
public class HelloWorld {
        public static void main(String [] args) {
                System.out.println("HelloWorld!");
        }
}
将上面这段程序另存为HelloWorld.java。进入cmd，然后cd到HelloWorld.java所在的目录，键入如下命令javac HelloWorld.java接着java HelloWorld此时你应该看到输出的是HelloWorld!，说明java环境配置成功^_^;

2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量
这里我的安装目录是H:\Tomcat 5.5，以我的为例说
CATALINA_HOME=H:\Tomcat 5.5;
CATALINA_BASE=H:\Tomcat 5.5;
然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的servlet.jar追加到classpath中去
以下是修改后的classpath：
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet-api.jar;%CATALINA_HOME%\common\lib\mssqlserver.jar;
接着可以启动tomcat，在IE中访问http://localhost:8080，如果看到tomcat的那支小猫话说明安装成功了。

第三步：建立自己的jsp app目录
1.到Tomcat的安装目录的webapps目录，可以看到ROOT，examples, tomcat-docs之类Tomcat自带的的目录；
2.在webapps目录下新建一个目录，起名叫myapp； 
3.在myapp下新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：
<%@page contentType="text/html;charset=gb2312" language="java"%>
<html>
<body>
<center>
<%
      out.println("HelloWorld!");
      out.println("你好!世界!");
%>
</center>
</body>
</html>
4.重启Tomcat
5.打开浏览器，输入http://localhost:8080/myapp/index.jsp 看到
HelloWorld! 你好!世界!
的话说明就成功了。

第四步：建立自己的Servlet：
1.在webapps目录下新建一个目录，起名叫HelloWorld；

2.用你最熟悉的编辑器（建议使用有语法检查的java ide）新建一个servlet程序，文件名为HelloWorld.java，文件内容如下：
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;


public class HelloWorld extends HttpServlet {
    public void doGet(HttpServletRequest request,HttpServletResponse response)
   throws IOException, ServletException {
    response.setContentType("text/html");
    PrintWriter writer = response.getWriter();
    writer.println("Hello World!");
   }
} 

3 .编译
将HelloWorld.java编译
然后在会产生一个编译后的servlet文件：HelloWorld.class 
4 .将结构HelloWorld.class剪切到%CATALINA_HOME%\webapps\HelloWorld\WEB-INF\classes下，如果WEB-INF\classes目录不存在，就新建一个。 现在webapps\HelloWorld\WEB-INF\classes下有HelloWorld.class的文件.(注意：要注意文件夹和文件名的大小写！)
5 .在webapps\HelloWorld\WEB-INF下新建web.xml文件，添加servlet和servlet-mapping
编辑后的web.xml如下所示：

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="2.4"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee  
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">


<display-name>HelloWorld</display-name>
<description>
HelloWorld
</description>
<servlet>
<servlet-name>HelloWorld</servlet-name>
<display-name>HelloWorld</display-name>
<description>HelloWorld</description>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/Hello</url-pattern>
</servlet-mapping>
</web-app>
这段话中的servlet这一段声明了你要调用的Servlet，而servlet-mapping则是将声明的servlet“映射”到地址/Hello上 
6 .好了，启动Tomcat，启动浏览器，输入http://localhost:8080/HelloWorld/Hello 如果看到输出Hello World! .就说明编写的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
3 .将TestBean.class文件剪切到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes\test下，
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的配置。接下来需要做的事情就是多看书、多读别人的好代码，自己多动手写代码以增强自己在这方面开发的能力了。



MudFish 2005-08-27 15:50 发表评论
]]>