程序手记

程序是我毕生的追求......
随笔 - 19, 文章 - 0, 评论 - 9, 引用 - 0
数据加载中……

2008年8月3日

JSP基础 （文件上传） 第二十二天

    把一个指定的文件上传到服务器，通常依靠JSP技术完成，需要使用到两个JSP页面。第一个JSP页面是选择要上传的文件，第二个JSP页面是从客户端获取该文件里面的信息，并把这些信息以客户端相同的格式保存在服务器端，该页面主要为功能处理页面。
    第一个页面的实现必须含有FILE类型的表单，并且表单的enctype的属性必须为"muldtipart/form-data"。
    第二个页面要使用内置对象request调用方法getInputStream()获得一个输入流，通过这个输入流读取客户上传的全部信息，如上传文件的 名字，文件的大小，文件的类型。根据request所获得的信息创建一个数据输出流对象，把信息写到一个指定的文件内

    第一个文件内容如下：
        <body>
            <form method="post" action="file_14.jsp" enctype="multipart/form-data">
                <input type="file" name="file1" size="50" /><br>
                <input type="submit" value="上传" />
            </form>

    第二个文件内容如下：
        <%@ page contentType="text/html; charset='utf-8'" %>
        <%@ page import="java.io.*" %>
        <%@ page import ="java.util.*"%>
        <%@ page import="javax.servlet.*"%>
        <%@ page import = "javax.servlet.http.*" %>
        <body>
        <%
            int MAX_SIZE = 102400 * 102400;    //定义上传文件的最大字节
            String rootPath;    //创建跟路径的保存变量
            DataInputStream in = null;    //声明文件读入类
            FileOutpubStream fileOut = null;    //
            String remoteAddr = request.getRemoteAddr();    //取得客户端的网络地址
            String servName = request.getServerName();    //获得服务器的名字
            out.print("serverName=" + serverName + "<br>");
            out.print("request.getServletPath() = " + request.getServletPath() + "<br>")

posted @ 2008-08-22 00:29 程序手记 阅读(235) | 评论 (0) | 编辑 收藏

JavaBean基础 （javabean简介） 第二十一天

    JavaBean是一个可重复使用、且跨平台的软件组件(SoftWare Component)，它可以在软件开发工具如：Borland JBuilder \ Oracle JDeveloper 或是 Sun ONE Studio 等等里，以可视化的开发方式来开发。
    首先，你可以将JAVABEAN视为一个黑盒子(Black Box)，虽然知道这个软件组件所具备的功能，却不知其内部是如何运作的。笔者提供给读者一个假象的情况：有一个黑盒子，只知道它上面有一个按钮，你只要按下去经过十分钟，就会掉下一张一千元的钞票，不过你看不见其内部任何的构造，而这就是JAVABEAN最重要的特性，它将许多的信息都封装了起来，用户无需知道黑盒子如何产生出钞票，只需知道按下那个按钮，然后等十分钟，超片就会自动产生出来。
    一般而言，JAVABEAN可分为：有用户接口(user interface)的javabean和没有用户接口的javabean，通常JSP是搭配没有UI的JAVABEAN，因此后面所提到的JAVABEAN都知识单纯处理一些食物，如：数据运算，连接数据库和数据处理，等等，至于有用户接口的JAVABEAN部分，请读者自己参考JAVABEAN的相关书籍。
    通常一个标准的JAVABEAN有如下几项特性：
    (1)javabean是一个公开的(public)类；
    (2)javabean类必须有一个无传入参数(zero-argument)的构造函数(constructor)；
    (3)取得或设置属性时，必须使用getXXX方法或setXXX方法。

例子：
    package tw.com.javaworld.CH8;
    
    import java.io.*;
    
    public class SimpleBean{
        public SimpleBean(){
        }
        private String name;
        private String number;
        
        public void setNumber(String number){
            this.number = number;
        }
        public String getName(){
            return name;
        }
    }

posted @ 2008-08-21 23:09 程序手记 阅读(499) | 评论 (0) | 编辑 收藏

JSP基础 （JSP动作元素） 第二十一天

    与JSP指令元素不同的是，JSP动作元素在请求处理阶段起作用。JSP动作元素是试用XML语法写成的，它可以采用以下两种格式：
    <prefix:tag attribute = value attribute-list.../>
或者
    <prefix:tag attribute = value attribute-list.../>
    ...
    </prefix.tag>
SERVLET容器在处理JSP时，每当遇到这种动作元素，都根据它的标记进行特殊处理。
JSP规范定义了一系列的标准动作，它用JSP作为前缀。这些标准的动作不去惯容器是如何实现的，但是每个WEB容器都必须提供这些操作类型。标准动作为网页设计者提供了基本的功能，其他的厂商可以自由提供其他的非标准动作以增强功能。
    标准动作有：
<jsp:useBean>
<jsp:setProperty>
<jsp:getProperty>
<jsp:param>
<jsp:include>
<jsp:forward>
<jsp:plugin>
<jsp:fallback>
<jsp:attribute>
<jsp:body>
<jsp:invoke>
<jsp:doBody>
<jsp:element>
<jsp:output>
<jsp:scriptelet>
<jsp:declaration>等
在标准动作中，有许多是XML语法的动作元素，比如<jsp:scriptelet> <jsp:declaration>但他们的使用并不广泛，下面介绍JSP中主要的动作元素。

文件导入标记<jsp:include>
include用于允许在请求时间内在县城的JSP页面里包含静态或者动态资源。被包含的对象只有对JSPWRITER对象的访问权，并且它不能设置头或者COOKIE，如果页面输出是缓冲的，那么缓冲区的刷新要有限于包含的刷新。此指令在运行的效率上比<%@ page include %>指令的效率低，但是可以动态增加内容。用户可以通过一下的格式来使用文件导入标记
    <jsp:include page="{relativeURL | <%=expression%>}" flush="true" />
    <jsp:include page="{relativeURL | <%=expression%>}" flush = "true" >
        <jsp:param name="parameterName" value="{parameterValue | <%=expression%>}"
    </jsp:include>

    例如:
    <jsp:include page="admin/login.jsp" />
    <jsp:include page="copyright.html" />
    <jsp:include page="admin/login.jsp">
        <jsp:parame name = "username" value="JackLong" />
    </jsp:include>

页面转向标记<jsp:forward />
实例：
    <jsp:forword page="showinfo.jsp" >
        <jsp:param name = "username" value = "<%=request.getParameter("username")%>"/>
        <jsp:param name = "telephone" value = "<%=request.getParameter("telephone")%>"/>
    </jsp:forword>

posted @ 2008-08-21 05:20 程序手记 阅读(472) | 评论 (0) | 编辑 收藏

JSP基础 (获取当前时间) 第二十一天

    下面的代码用于显示当前时间，并根据当前是几点输出相应的提示信息，其中，使用java.util.Date thisday=new java.util.Date();语句来取得当前时间，然后通过相应的方法取得年，月，日，时和分的信息并输出：

<% page contentType="text/html; charset=utf-8" import="java.util.*" %>
<body>
<%
//获取当前的时间
java.util.Date thisday = new java.util.Date();
%>
当前时间：
<%=thisday.getYear()+1900%>年
<%=thisday.getMonth()+1%>月
<%=thisday.getDate()%>日
<%=thisday.getHours()%>时
<%=thisday.getMinutes()%>分
<%
String str = "欢迎访问："
int num = this.getHours();
switch(num){
    case 8:
    case 9:
    case 10:
    case 11:
    {
        out.print("欢迎你的访问，上午好！");
        break;
    }
    case 12:
    {
        out.print("中午好!");
        break;
    }
    case 13:
    case 14:
    case 15:
    case 16:
    case 17:
    case 18:
    {
        out.print("下午好!");
        break;
    }
</body>

posted @ 2008-08-21 04:23 程序手记 阅读(1248) | 评论 (0) | 编辑 收藏

JSP基础 (高级计数器实例) 第二十天

                                                                           countFile.java
public class countFile{
    public static void writeFile(String filename,long count){
        PrintWriter out = new PrintWriter(new FileWriter(filename));
        out.println(count);
        out.close();
    }
    public static void readFile(String filename){
        File f = new File(filename);
        if(!f.exists()){
            writeFile(filename,0);
        }
        BufferedReader in = new BufferedReader(new FileReader(f));
        long count = Long.parseLong(in.readline());
        return count;
    }
    public static String tranform(long count){
        String countNumber = ""+count;
        String newstring = "";
        for(int i=0;i<countNumber.length;i++){
            newstring+="<img src='images/"+countNumber.charAT(i)+".gif' >";
        }
        return newstring;
    }
}

posted @ 2008-08-20 05:19 程序手记 阅读(170) | 评论 (0) | 编辑 收藏

TOMCAT基础 (设定站点) 第十三天

    在Tomcat 上建立一个 JSPBook站点时，我们需要修改Tomcat的server.xml文件，server.xml位于{Tomcat_Install}\conf\server.xml（例如：e:\apache software foundation\tomcat 5.0\conf\server.xml）。

    server.xml
    
    ......
    <!--Tomcat Root Context-->

    <!--
        <Context path="" docBase="ROOT" debug="0">
    -->
    <Context path="/JSPBook" docBase="JSPBook" debug="0" crosscontext = "true" reloadable="true" >
    </Context>
    </Host>
    </Engine>
    </Service>
    </server>

    这部分主要是设定JSPBOOK站点，其中 path="/jspbook"代表网站名称，即 http://ip_domainName/jspbook;
docBase = "jspbook" 代表站点的目录位置，debug则是设定debug lerel,0表示提供最少的信息，9表示提供最多的信息； reloadable则表示tomcat在执行时，当class ,web.xml被更新过时，都会自动重新加载，不需要重新启动tomcat。

posted @ 2008-08-13 17:36 程序手记 阅读(154) | 评论 (0) | 编辑 收藏

JAVA基础 （JAVA中的STATIC块） 第十三天（对浪费的前10天表示悔恨）

Java 程序中时常用些 static{}这样的结构。
这样的结构叫 static块，一般是一个类初始化时运行的代码。注意，是类的初始化，不是对象的初始化。
也就是你在定义对象时，他运行的初始化代码，并且只有第一次定义时才运行。之后就不再运行初始化了。
一个类中可以有很多static块。static块按顺序执行。

看以下代码：
public class TestStatic{
    static{
        System.out.println(1);
    }
    static {
        System.out.println(2);
    }
    static {
        Stystem.out.println(3);
    }
    public static void main(String args[]){
        System.out.println(5);
    }
    static {
        System.out.println(4);
    }
}
执行结果是：
1
2
3
4
5
一目了然，首先调用的是static静态块的代码，然后调用启动方法，而STATIC块的执行顺序是由代码的编写顺序执行的过程，STATIC块大家用的比较少，其实就是在对象生成之际产生的一系列的STATIC变量。

posted @ 2008-08-13 16:22 程序手记 阅读(335) | 评论 (0) | 编辑 收藏

JAVA WEB开发 （First Servlet Samlet Code） 第四天

HelloServlet.java

package tw.com.javaworld.CH2;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;

public class HelloServlet extends HttpServlet{
    //Initialize global variables
    public void init(ServletConfig config) throws ServletException{
        super.init(config);
    }
    
    //Process the HTTP Get request
    public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=GB2312");
        PrintWrite out = response.getWrite();
        out.println("<html>");
        out.println("<body>");
        out.println("Hello World<br>");
        out.println("大家好");
        out.println("</body>");
        out.println("</html>");
        out.close();
    }

    //Get Servlet information
    public String getServletInfo(){
        return "tw.com.javaworld.CH2.HelloServlet Information";
    }
}

posted @ 2008-08-04 18:15 程序手记 阅读(231) | 评论 (0) | 编辑 收藏

Java WEB开发 （TomCat配置） 第四天

Tomacat是一个WEB容器，所有的J2EE WEB程序可以在此处运行。常见的WEB容器还有WebLogic、WebSphere。

Tomcat的默认端口号是8080，这个数值可以在安装过程中修改也可以在conf/server.xml中修改。

Tomcat是根据系统的%JAVA_HOME%变量值选择系统中的JDK。

Tomcat目录主要文件夹作用

  • bin目录：存放启动和关闭Tomcat的脚本
  • conf目录：存放不同配置文件，其中比较重要的是server.xml（Tomcat的主要配置文件）和web.xml
  • work目录：存放JSP编译后的.class文件
  • webapps目录：存放WEB应用程序
  • lib目录：存放所有需要的各种jar包

配置Tomcat方式有两种：手工配置--修改conf/server.xml文件、管理控制台配置

  • 注意：修改server.xml之后要重新启动Tomcat服务器才能使配置生效

配置虚拟目录的要求

 

 

  • 修改server.xml文件
  • 虚拟目录的结构要符合要求
    • WebRoot
      • WEB-INF
        • web.xml
    • 其中web.xml的内容一般为：

       


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

      Welcome to Tomcat

      Welcome to Tomcat

  • 创建好虚拟目录之后要在server.xml中之前添加一句 (大小写敏感，修改完之后应该重新启动Tomcat服务器使配置生效)

若设置虚拟目录后访问目录提示404错误而可以运行目录下的jsp文件则说明是目录权限被禁用，可以修改conf/web.xml文件找到 将下面一行中的false改成true

jsp文件的运行过程： *.jsp  -->  *.java  -->  *.class  -->  运行显示 

  • *.class是第一次运行生成后存放在work目录下的，所以jsp文件第一次或者修改后首次运行比较慢而后来再运行的速度很快

posted @ 2008-08-04 16:39 程序手记 阅读(310) | 评论 (0) | 编辑 收藏

JAVA基础 （嵌套类） 第四天

    Java允许将类的定义方在其他类的内部，形成嵌套类。嵌套类使逻辑关系紧密的类组成一个整体，嵌套类可以用于访问其所在的类的作用域。

嵌套类可以访问外部类似有成员。
    // OuterNested1.java
public class OuterNested1{
    private int size;
    public class Nested{
        public int doStuff(){
            //嵌套类可以访问OuterNested1类的似有成员 size 变量
            return(size++);
        }
    }
    public int testTheNested(){
        Nested i = new Nested();
        return(i.doStuff());
    }
}

//TestOuterNested1.java
public class TestOuterNested1 {
    public static void main(String[] args){
        outerNested1 outer = new OuterNested1();
        System.out.println(outer.testTheNested());
    }
}

posted @ 2008-08-04 15:21 程序手记 阅读(168) | 评论 (0) | 编辑 收藏

JAVA基础 （包 与 Java API） 第二天 第四天

    建立Java包，布局源文件和设置classpath参数之间相互影响。也相互关联。正确建立和导入JAVA包，合理布局源文件，准确设置CLASSPATH参数，才能保证应用程序顺利执行，并有效管理应用程序。

包的建立方法
    Java包通过package语句建立，基本语法是：
        package cn.edu.jmu.graphis;
    在定义类或接口的源文件开始处，通过package语句，可以将相应的类或接口放入package所声明的包里。包是相关类和接口的集合，提供了访问级别控制和命名控件管理。

包的使用方法
    每个源文件只能有一个包声明，并且一定要求放在源文件的开始位置。如果一个源文件没有包语句，则源文件所定义的类或接口呗系统放入默认包中。包有层次，层次间由点分隔。
    例如有一组与图形相关的类，包括Circles,Rectangles,Lines和points类等，描述了画图所用到的各种图形组件，另有抽象类Graphic标识图形组件的共性，接口Draggable表示用户可以通过鼠标拖拽成图的图形组件。在这种情况下，我们不仅需要，而且也应该将这些相关类和接口组成包，可命名为graphics如：

//Graphics.java
package graphics;
public abstract class Graphic{
    ...
}

//Circle.java
package graphics;
public class Circle extends Graphic implements Draggable {
    ...
}

//Rectangle.java
package graphics;
public class Rectangle extends Graphic implements Draggable {
    ...
}

//Draggable.java
package graphics;
public interface Draggable{
    ...
}
    通过创建和使用包，程序员不仅可以很容易地确定哪些类和接口是相关的，也可以很容易地找到提供特定功能的类和接口，例如，与画图有关的类和接口在graphics包中。

包的访问权限
    通过声明类的访问级别，可以控制对类的访问权限。
    类的访问级别分为默认级和public级。定义类的默认访问级别不需要任何关键字，呗声明为默认级的类只对同一个包中的类是可视的。也就是说只有同一个包内的类实例可以访问这个类，外界不能访问它。如果用关键字public定义类，不但同一个包里的其他类可以访问这个类，其他包中的类也可以访问它。换句话说，同一个包中的类，相互之间有不受限制的访问权限。而在不同包中，只有public类可以被访问。
    public修饰符不知用于定义类的访问控制级别，也可以应用于接口，方法或变量。public 接口同public类一样，可以由应用程序中的任何类访问。而public方法或public属性对任何可以访问他的类或接口都是可视的。
    除public修饰符之外，用于访问控制的修饰符还有protected 和 private。
protected 或 private 仅用来定义方法或变量的访问控制级别。protected 方法或protected变量仅对同一个包内的类或不同包中的子类来说是可视的。
private方法和pvivate变量对外部定义的类均不可视。

包的命名方式
    包提供了心的命名控件，即使所定义的类使用与其他包中的类相同的名字，只要包类所属的包不同名，就不会引起冲突。原因是这些类的全程限定名称不同。类的全程限定包含了类的各层包名。这实质上是应用了面向对象的概念，将类封装入包中。

包的访问权限
    通过声明类的访问级别，可以控制对类的访问权限。
    类的访问级别分为默认级和public级。定义类的默认访问级别不需要任何关键字，贝声明为默认级的类只对同一个包中的类是可视的。也就是说，只有同一个包内的类实例可以访问这个类，外界不能访问它。如果用关键字public 定义类，不但同一个包里的其他类可以访问这个类，其他包中的类也可以访问它。换句话说，同一个包中的类，相互之间有不受限制的访问权限。而在不同的包中，只有public类可以被访问。
    public 修饰符不只用于定义类的访问控制级别，也可以应用于接口，方法和变量。public接口同public类一样，可以由应用程序中的任何类访问。而public方法或public变量对任何可以访问他的类或接口都是可视的。
    除public 修饰符之外，用于访问控制的修饰符还有 protected 和private 。 protected或private仅用来定义方法或变量的访问控制级别。protected方法或protected变量仅对同一个包内的类或不同包中的子类来说是可视的。private方法和private变量对外部定义的类均不可视。需要说明的是，通常不建议用默认方式定义方法或成员变量的访问级别。

                      
    对于没有指定包名的java源文件，系统认为他们都属于同一个默认的包。如果没有把自己的Java类放入某个包中，那么任何默认包里的对象都可以访问它，并且不局限于同一个子目录下，因此通常应该在每个Java源文件的项目顶部使用 package语句，指明它所属的包。

访问包成员
    对于包来说，只有它的public成员可贝外界访问。若外界想要访问包的public类，有3种方式可以实现。
    (1)通过类的全程限定名访问该类。
    (2)通过import语句导入该类。
    (3)通过import语句导入整个包。
    如果某个类只贝访问一次，那么可以直接使用类的全名。例如访问cn.edu.jmu.graphics.Graphic类可以用一下方式：
    cn.edu.jmu.graphics.Graphic aGraph = new cn.edu.jmu.graphics.Graphic();
    这条语句创建了 cn.edu.jmu.graphics.Graphic类型的对象 aGraph。
    可以看到，即是指创建一个对象，在变量定义和初始化时也用到两次全名。当使用Java约定的包命名方式时，包名可能过长，此时用起来就更显得繁琐，容易出错，也影响可读性。
    通常都应该使用import语句直接导入所需类，或者导入该类所在的包。导入之后，程序中设计的这个类的地方就可以直接用类名访问。
    import 的基本语法形式为：
    import <包名>[.<子包名>].<类名>;    //导入指定类
或者：
    import <包名>[.<子包名>].*;    //导入整个包
例如:
    import cn.edu.jmu.javaprogs.Timel;
    import cn.edu.jmu.javaprogs.*;
    import java.awt.*;
    import java.awt.event.*;

    import语句在package 语句之后，所有的类声明之前。由于集中在程序首部，宜于直观地了解程序所需的包，有助于维护程序的可移植性。
    import 语句中的 * 用来匹配包中的所有类，但并不能用来匹配包中的所有类的某个子集。如语句
    import java.awt.*;
    导入java.awt包中的所有类。如果这样的语句
    import java.awt.A*;
    它无法导入java.awt句中首字母为A的所有子类，相反还会出现编译错误，也就是说，使用import语句一次只能导入包的单一成员，或者导入整个包。
    还有语句
    import java.awt.*;
    所导入的是java.awt包中的所有类，它包括接口。但不包括java.awt包中的子包。如果需要访问java.awt.event子包中的类，仍需要用 import语句导入 java.awt.event子包。所以常常使用如下形式：
    import java.awt.*;
    import java.awt.event.*;

  

包的布局
    类的全程受名称与类所在目录一一对应，例如：
    import graphics.Rectangle    等同于文件路径名：
    Graphics\Rectangle.java


classpath参数
    classpath参数用于设置Java包所在的顶级目录。也就是说，通过classpath可以为Java包建立所依存的目录列表。编译和运行Java 程序时，系统会自动从classpath环境变量中读取包所在的目录，文件所在目录由系统通过classpath中的目录和package语句中定义的目录合成。
    下面通过一个完整的实例程序，说明classpath参数的作用，同时展示源文件和字节码文件的一种建议布局模式。
    程序包含两个类 Time 和 TestTime,TestTime为主类。程序对用户输入的表示小时、分钟和秒钟的3个整型数，经过数据正确性验证，分别转换为通用时间表示格式和标准时间表示格式，通过对话框显示给用户，运行后如图：
                                                                      

    文件布局方式如下：创建 d:\javaSample 目录存放java程序，创建 d:\javaSample\src 子目录存放源文件，创建d:\javaSample\class 子目录存放编译后的字节码文件。 具体实现方式是将文件 TestTime.java 存放在 D:\javaSample\src 子目录下，为使 src 子目录的结构与 class 子目录结构相对应，创建 D:\javaSample\src\cn\edu\jmu\timer 子目录存放 Time.java文件。类Time和类TestTime的布局如图：
                              
    Time.java中的语句
    package cn.edu.jmu.timer;
    将Time类放入包cn.edu.jmu.timer中，源文件Time.java存放在与包相对应的目录结构下。在类TestTime.java中通过语句   import cn.edu.jmu.timer.Time;   导入Time类。
    需要设置classpath参数，规定程序中的包    cn.edu.jmu.timer 编译所依存的顶级目录为 d:\javaSample\class,如：
                set classpath = d:\javaSample\class;
    编译：
        javac -d d:\javaSample\class
        d:\javaSample\src\cn\edu\jmu\timer\Time.java 
        javac -d d:\javaSample\class d:\javaSample\src\TestTime.java
    运行：
        java TestTime

posted @ 2008-08-03 00:40 程序手记 阅读(352) | 评论 (0) | 编辑 收藏