BlogJava-poower's java-文章分类-j2ee学习笔记http://www.blogjava.net/poower/category/33387.htmlzh-cnTue, 23 Mar 2010 18:30:39 GMTTue, 23 Mar 2010 18:30:39 GMT60java 多线程同步http://www.blogjava.net/poower/articles/316205.htmlpoowerpoowerMon, 22 Mar 2010 12:05:00 GMThttp://www.blogjava.net/poower/articles/316205.htmlhttp://www.blogjava.net/poower/comments/316205.htmlhttp://www.blogjava.net/poower/articles/316205.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/316205.htmlhttp://www.blogjava.net/poower/services/trackbacks/316205.htmlhttp://blog.csdn.net/phinecos/archive/2010/03/13/5377915.aspx

多线程的同步依靠的是对象锁机制，synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。

下面以一个简单的实例来进行对比分析。实例要完成的工作非常简单，就是创建10个线程，每个线程都打印从0到99这100个数字，我们希望线程之间不会出现交叉乱序打印，而是顺序地打印。

先来看第一段代码，这里我们在run()方法中加入了synchronized关键字，希望能对run方法进行互斥访问，但结果并不如我们希望那样，这是因为这里synchronized锁住的是this对象，即当前运行线程对象本身。代码中创建了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。

代码
package com.vista;

class MyThread implements java.lang.Runnable
{
    private int threadId;

    public MyThread(int id)
    {
        this.threadId = id;
    }
    @Override
    public synchronized void run() 
    {
        for (int i = 0; i < 100; ++i)
        {
            System.out.println("Thread ID: " + this.threadId + " : " + i);
        }
    }
}
public class ThreadDemo
{
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException
    {
        for (int i = 0; i < 10; ++i)
        {
            new Thread(new MyThread(i)).start();
            Thread.sleep(1);
        }
    }
}

      从上述代码段可以得知，要想实现线程的同步，则这些线程必须去竞争一个唯一的共享的对象锁。

      基于这种思想，我们将第一段代码修改如下所示，在创建启动线程之前，先创建一个线程之间竞争使用的Object对象，然后将这个Object对象的引用传递给每一个线程对象的lock成员变量。这样一来，每个线程的lock成员都指向同一个Object对象。我们在run方法中，对lock对象使用synchronzied块进行局部封锁，这样就可以让线程去竞争这个唯一的共享的对象锁，从而实现同步。

代码
package com.vista;

class MyThread implements java.lang.Runnable
{
    private int threadId;
    private Object lock;
    public MyThread(int id, Object obj)
    {
        this.threadId = id;
        this.lock = obj;
    }
    @Override
    public  void run() 
    {
        synchronized(lock)
        {
            for (int i = 0; i < 100; ++i)
            {
                System.out.println("Thread ID: " + this.threadId + " : " + i);
            }
        }
    }
}
public class ThreadDemo
{
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException
    {
        Object obj = new Object();
        for (int i = 0; i < 10; ++i)
        {
            new Thread(new MyThread(i, obj)).start();
            Thread.sleep(1);
        }
    }
}

从第二段代码可知，同步的关键是多个线程对象竞争同一个共享资源即可，上面的代码中是通过外部创建共享资源，然后传递到线程中来实现。我们也可以利用类成员变量被所有类的实例所共享这一特性，因此可以将lock用静态成员对象来实现，代码如下所示：

代码
package com.vista;

class MyThread implements java.lang.Runnable
{
    private int threadId;
    private static Object lock = new Object();
    public MyThread(int id)
    {
        this.threadId = id;
    }
    @Override
    public  void run() 
    {
        synchronized(lock)
        {
            for (int i = 0; i < 100; ++i)
            {
                System.out.println("Thread ID: " + this.threadId + " : " + i);
            }
        }
    }
}
public class ThreadDemo 
{
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException
    {
        for (int i = 0; i < 10; ++i)
        {
            new Thread(new MyThread(i)).start();
            Thread.sleep(1);
        }
    }
}

再来看第一段代码，实例方法中加入sychronized关键字封锁的是this对象本身，而在静态方法中加入sychronized关键字封锁的就是类本身。静态方法是所有类实例对象所共享的，因此线程对象在访问此静态方法时是互斥访问的，从而可以实现线程的同步，代码如下所示：

代码
package com.vista;

class MyThread implements java.lang.Runnable
{
    private int threadId;
    
    public MyThread(int id)
    {
        this.threadId = id;
    }
    @Override
    public  void run() 
    {
        taskHandler(this.threadId);
    }
    private static synchronized void taskHandler(int threadId)
    {
        for (int i = 0; i < 100; ++i)
        {
            System.out.println("Thread ID: " + threadId + " : " + i);
        }
    }
}
public class ThreadDemo
{
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException
    {
        for (int i = 0; i < 10; ++i)
        {
            new Thread(new MyThread(i)).start();
            Thread.sleep(1);
        }
    }
}


poower 2010-03-22 20:05 发表评论
]]>tomcat6.0数据源配置http://www.blogjava.net/poower/articles/239083.htmlpoowerpoowerThu, 06 Nov 2008 10:07:00 GMThttp://www.blogjava.net/poower/articles/239083.htmlhttp://www.blogjava.net/poower/comments/239083.htmlhttp://www.blogjava.net/poower/articles/239083.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/239083.htmlhttp://www.blogjava.net/poower/services/trackbacks/239083.html注意一定要复制到这里，而不能复制到项目文件夹的WEB-INF\lib目录下，即不能在IDE中直接导入，因为tomcat只能从%TOMCAT_HOME%\lib在读取数据源的驱动程序）

    步骤二：在mysql中的test数据库中建表取名test,建一字段name,值为tomcat，使用root帐户,密码为123

   步骤二：配置%TOMCAT_HOME%\conf\context.xml（我最常用的IDE是netbeans,现在已经到6.1了，可以直接在ide中的context.xml文件中配）具体配置如下：

    在<Context></Context>之间添加如下内容：
    <Resource name="jdbc/myDataSource" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="30" maxWait="10000"
               username="root" password="123" driverClassName="com.mysql.jdbc.Driver"
               url="jdbc:mysql://localhost:3306/test"/>

   步骤三：（java ee 5要求做如下声明，实际上可以省，所以出了问题别找这里的麻烦）

    在web.xml文件根元素下添加内容如下:

    <resource-ref>
        <description>db connection</description>
        <res-ref-name>jdbc/myDataSource</res-ref-name>
        <res-type>javax.sql.DataSource</res-type>
        <res-auth>Container</res-auth>
    </resource-ref>

    步骤四：在jsp中测试成功与否

    建一个test.jsp文件，内容如下：

    <%@page contentType="text/html" pageEncoding="UTF-8" %>
    <%@page import="java.sql.*"%>
    <%@page import="javax.sql.DataSource"%>
    <%@page import="javax.naming.*"%>
    <html>
      <body>
            <%
              Connection connection = null;
                Context context = null;
                DataSource dataSource = null;
                context = new InitialContext();
                dataSource = (DataSource) context.lookup("java:/comp/env/jdbc/myDataSource");
                if (dataSource != null) {
                        connection = dataSource.getConnection();
                }
                Statement s = connection.createStatement();
                ResultSet rs = s.executeQuery("select * from test");
              rs.next();
                out.println(rs.getString(1));
            %>
        </body>
    </html>

    运行之，可以看到页面显示tomcat，就说明配置成功。

    注意：上述配置的数据源只能在容器内使用，所以不能在main方法中测试，我试过在容器外配置使用，惭愧，没有成功，请知道的不吝指教~

    我的配置环境具体如下：

    windowsxp xp2

   tomcat6.0

   mysql5.0

   驱动程序：mysql-connector-java-5.1.5-bin.jar



poower 2008-11-06 18:07 发表评论
]]>给出OSI七层模型与TCP/IP五层模型http://www.blogjava.net/poower/articles/239080.htmlpoowerpoowerThu, 06 Nov 2008 09:56:00 GMThttp://www.blogjava.net/poower/articles/239080.htmlhttp://www.blogjava.net/poower/comments/239080.htmlhttp://www.blogjava.net/poower/articles/239080.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/239080.htmlhttp://www.blogjava.net/poower/services/trackbacks/239080.html给出OSI七层模型与TCP/IP五层模型

OSI七层模型

OSI中的层 功能 TCP/IP协议族
应用层 文件传输，电子邮件，文件服务，虚拟终端 TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet
表示层 数据格式化，代码转换，数据加密 没有协议
会话层 解除或建立与别的接点的联系 没有协议
传输层 提供端对端的接口 TCP，UDP
网络层 为数据包选择路由 IP，ICMP，RIP，OSPF，BGP，IGMP
数据链路层 传输有地址的帧以及错误检测功能 SLIP，CSLIP，PPP，ARP，RARP，MTU
物理层 以二进制数据形式在物理媒体上传输数据 ISO2110，IEEE802，IEEE802.2
点击在新窗口中浏览此图片

TCP/IP五层模型的协议
应用层
传输层
网络层
数据链路层
物理层
点击在新窗口中浏览此图片

物理层：中继器、集线器、还有我们通常说的双绞线也工作在物理层
数据链路层：网桥（现已很少使用）、以太网交换机（二层交换机）、网卡（其实网卡是一半工作在物理层、一半工作在数据链路层）
网络层：路由器、三层交换机
传输层：四层交换机、也有工作在四层的路由器


除了层的数量之外，开放式系统互联（OSI）模型与TCP/IP协议有什么区别？
　　开放式系统互联模型是一个参考标准，解释协议相互之间应该如何相互作用。TCP/IP协议是美国国防部发明的，是让互联网成为了目前这个样子的标准之一。开放式系统互联模型中没有清楚地描绘TCP/IP协议，但是在解释TCP/IP协议时很容易想到开放式系统互联模型。两者的主要区别如下：

　　·TCP/IP协议中的应用层处理开放式系统互联模型中的第五层、第六层和第七层的功能。

　　·TCP/IP协议中的传输层并不能总是保证在传输层可靠地传输数据包，而开放式系统互联模型可以做到。TCP/IP协议还提供一项名为UDP（用户数据报协议）的选择。UDP不能保证可靠的数据包传输。

TCP/UDP协议
TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；而UDP则不为IP提供可靠性、流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用。TCP支持的应用协议主要有：Telnet、FTP、SMTP等；UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系统）、TFTP（通用文件传输协议）等.
TCP/IP协议与低层的数据链路层和物理层无关，这也是TCP/IP的重要特点


OSI是Open System Interconnect的缩写，意为开放式系统互联。
OSI七层参考模型的各个层次的划分遵循下列原则：

1、同一层中的各网络节点都有相同的层次结构，具有同样的功能。

2、同一节点内相邻层之间通过接口（可以是逻辑接口）进行通信。

3、七层结构中的每一层使用下一层提供的服务，并且向其上层提供服务。

4、不同节点的同等层按照协议实现对等层之间的通信。

第一层：物理层（PhysicalLayer)，规定通信设备的机械的、电气的、功能的和过程的特性，用以建立、维护和拆除物理链路连接。具体地讲，机械特性规定了网络连接时所需接插件的规格尺寸、引脚数量和排列情况等；电气特性规定了在物理连接上传输bit流时线路上信号电平的大小、阻抗匹配、传输速率距离限制等；功能特性是指对各个信号先分配确切的信号含义，即定义了DTE和DCE之间各个线路的功能；规程特性定义了利用信号线进行bit流传输的一组操作规程，是指在物理连接的建立、维护、交换信息是，DTE和DCE双放在各电路上的动作系列。

在这一层，数据的单位称为比特（bit）。

属于物理层定义的典型规范代表包括：EIA/TIA RS-232、EIA/TIA RS-449、V.35、RJ-45等。

第二层：数据链路层（DataLinkLayer):在物理层提供比特流服务的基础上，建立相邻结点之间的数据链路，通过差错控制提供数据帧（Frame）在信道上无差错的传输，并进行各电路上的动作系列。　　

数据链路层在不可靠的物理介质上提供可靠的传输。该层的作用包括：物理地址寻址、数据的成帧、流量控制、数据的检错、重发等。

在这一层，数据的单位称为帧（frame）。

数据链路层协议的代表包括：SDLC、HDLC、PPP、STP、帧中继等。

第三层是网络层

在计算机网络中进行通信的两个计算机之间可能会经过很多个数据链路，也可能还要经过很多通信子网。网络层的任务就是选择合适的网间路由和交换结点， 确保数据及时传送。网络层将数据链路层提供的帧组成数据包，包中封装有网络层包头，其中含有逻辑地址信息- -源站点和目的站点地址的网络地址。

如果你在谈论一个IP地址，那么你是在处理第3层的问题，这是“数据包”问题，而不是第2层的“帧”。IP是第3层问题的一部分，此外还有一些路由协议和地址解析协议（ARP）。有关路由的一切事情都在第3层处理。地址解析和路由是3层的重要目的。网络层还可以实现拥塞控制、网际互连等功能。

在这一层，数据的单位称为数据包（packet）。

网络层协议的代表包括：IP、IPX、RIP、OSPF等。

第四层是处理信息的传输层。第4层的数据单元也称作数据包（packets）。但是，当你谈论TCP等具体的协议时又有特殊的叫法，TCP的数据单元称为段（segments）而UDP协议的数据单元称为“数据报（datagrams）”。这个层负责获取全部信息，因此，它必须跟踪数据单元碎片、乱序到达的数据包和其它在传输过程中可能发生的危险。第4层为上层提供端到端（最终用户到最终用户）的透明的、可靠的数据传输服务。所为透明的传输是指在通信过程中传输层对上层屏蔽了通信传输系统的具体细节。

传输层协议的代表包括：TCP、UDP、SPX等。

第五层是会话层

这一层也可以称为会晤层或对话层，在会话层及以上的高层次中，数据传送的单位不再另外命名，统称为报文。会话层不参与具体的传输，它提供包括访问验证和会话管理在内的建立和维护应用之间通信的机制。如服务器验证用户登录便是由会话层完成的。

第六层是表示层

这一层主要解决拥护信息的语法表示问题。它将欲交换的数据从适合于某一用户的抽象语法，转换为适合于OSI系统内部使用的传送语法。即提供格式化的表示和转换数据服务。数据的压缩和解压缩， 加密和解密等工作都由表示层负责。

第七层应用层，应用层为操作系统或网络应用程序提供访问网络服务的接口。

应用层协议的代表包括：Telnet、FTP、HTTP、SNMP等。

　  通过 OSI 层，信息可以从一台计算机的软件应用程序传输到另一台的应用程序上。例如，计算机 A 上的应用程序要将信息发送到计算机 B 的应用程序，则计算机 A 中的应用程序需要将信息先发送到其应用层（第七层），然后此层将信息发送到表示层（第六层），表示层将数据转送到会话层（第五层），如此继续，直至物理层（第一层）。在物理层，数据被放置在物理网络媒介中并被发送至计算机 B 。计算机 B 的物理层接收来自物理媒介的数据，然后将信息向上发送至数据链路层（第二层），数据链路层再转送给网络层，依次继续直到信息到达计算机 B 的应用层。最后，计算机 B 的应用层再将信息传送给应用程序接收端，从而完成通信过程。下面图示说明了这一过程。

　　OSI 的七层运用各种各样的控制信息来和其他计算机系统的对应层进行通信。这些控制信息包含特殊的请求和说明，它们在对应的 OSI 层间进行交换。每一层数据的头和尾是两个携带控制信息的基本形式。

　　对于从上一层传送下来的数据，附加在前面的控制信息称为头，附加在后面的控制信息称为尾。然而，在对来自上一层数据增加协议头和协议尾，对一个 OSI 层来说并不是必需的。

　　当数据在各层间传送时，每一层都可以在数据上增加头和尾，而这些数据已经包含了上一层增加的头和尾。协议头包含了有关层与层间的通信信息。头、尾以及数据是相关联的概念，它们取决于分析信息单元的协议层。例如，传输层头包含了只有传输层可以看到的信息，传输层下面的其他层只将此头作为数据的一部分传递。对于网络层，一个信息单元由第三层的头和数据组成。对于数据链路层，经网络层向下传递的所有信息即第三层头和数据都被看作是数据。换句话说，在给定的某一 OSI 层，信息单元的数据部分包含来自于所有上层的头和尾以及数据，这称之为封装。

　 例如，如果计算机 A 要将应用程序中的某数据发送至计算机 B ，数据首先传送至应用层。 计算机 A 的应用层通过在数据上添加协议头来和计算机 B 的应用层通信。所形成的信息单元包含协议头、数据、可能还有协议尾，被发送至表示层，表示层再添加为计算机 B 的表示层所理解的控制信息的协议头。信息单元的大小随着每一层协议头和协议尾的添加而增加，这些协议头和协议尾包含了计算机 B 的对应层要使用的控制信息。在物理层，整个信息单元通过网络介质传输。

　　计算机 B 中的物理层收到信息单元并将其传送至数据链路层；然后 B 中的数据链路层读取计算机 A 的数据链路层添加的协议头中的控制信息；然后去除协议头和协议尾，剩余部分被传送至网络层。每一层执行相同的动作：从对应层读取协议头和协议尾，并去除，再将剩余信息发送至上一层。应用层执行完这些动作后，数据就被传送至计算机 B 中的应用程序，这些数据和计算机 A 的应用程序所发送的完全相同 。

　　一个 OSI 层与另一层之间的通信是利用第二层提供的服务完成的。相邻层提供的服务帮助一 OSI 层与另一计算机系统的对应层进行通信。一个 OSI 模型的特定层通常是与另外三个 OSI 层联系：与之直接相邻的上一层和下一层，还有目标联网计算机系统的对应层。例如，计算机 A 的数据链路层应与其网络层，物理层以及计算机 B 的数据链路层进行通信。

OSI七层网络结构图与TCP/IP四层网络结构图


poower 2008-11-06 17:56 发表评论
]]>mysql jdbchttp://www.blogjava.net/poower/articles/233186.htmlpoowerpoowerWed, 08 Oct 2008 09:42:00 GMThttp://www.blogjava.net/poower/articles/233186.htmlhttp://www.blogjava.net/poower/comments/233186.htmlhttp://www.blogjava.net/poower/articles/233186.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/233186.htmlhttp://www.blogjava.net/poower/services/trackbacks/233186.htmlimport java.sql.*;

class Mysql{
 private String url="jdbc:mysql://localhost:3306/jdbcTest";
 private String username = "root";
 private String password = "139689";

 public Connection getConnection(){
  Connection con = null;
  try{
  
   Class.forName("com.mysql.jdbc.Driver");
   con = DriverManager.getConnection(url,username,password);
   return con;
  }catch(ClassNotFoundException e){
   System.out.println("加载类驱动错误");
   System.out.println(e);
  }catch(Exception e){
   System.out.println(e);
  }
  return null;
 }

 public ResultSet executeSql(String sql){
 
  Connection con;
  Statement stmt;

  try{
   con = getConnection();
   stmt = con.createStatement();
   ResultSet rs = stmt.executeQuery(sql);
   return rs;
  }catch(SQLException e){
   System.out.println("获取数据失败");
  }
  return null;
 }
}

public class jdbcTest{
 public static void main(String[] args){
  Mysql mysql = new Mysql();
  Connection con = null;
  ResultSet rs = null;
  rs = mysql.executeSql("select * from user");
  try{
   while(rs.next()){
    System.out.println(rs.getString("username"));
   }
  }catch(Exception e){
   System.out.println(e.getMessage());
  }
 }
}



poower 2008-10-08 17:42 发表评论
]]>网站http://www.blogjava.net/poower/articles/230325.htmlpoowerpoowerSun, 21 Sep 2008 17:50:00 GMThttp://www.blogjava.net/poower/articles/230325.htmlhttp://www.blogjava.net/poower/comments/230325.htmlhttp://www.blogjava.net/poower/articles/230325.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/230325.htmlhttp://www.blogjava.net/poower/services/trackbacks/230325.html

poower 2008-09-22 01:50 发表评论
]]>JAVA+TOMCAT网站部署(转)http://www.blogjava.net/poower/articles/229810.htmlpoowerpoowerThu, 18 Sep 2008 14:18:00 GMThttp://www.blogjava.net/poower/articles/229810.htmlhttp://www.blogjava.net/poower/comments/229810.htmlhttp://www.blogjava.net/poower/articles/229810.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/229810.htmlhttp://www.blogjava.net/poower/services/trackbacks/229810.htmlJAVA+TOMCAT网站部署第一天

       安装APACHE Tomcat 5.0，默认有Tomcat的服务程序运行，在ROOT目录加入Jsp文件，似乎无法运行。采用命令窗口方式运行。运行"E:\program files\Apache Software Foundation\Tomcat 5.0\bin\startup.bat"，

 

环境变量配置：

Tomcat的根目录CATALINA_HOME：

E:\program files\Apache Software Foundation\Tomcat 5.0

JAVA的类路径[第一个点”.;”表示当前路径] CLASSPATH：

.;M:\Java\Demos;C:\j2sdk1.4.2_04;C:\j2sdk1.4.2_04\lib\tools.jar;C:\j2sdk1.4.2_04\lib\dt.jar;C:\j2sdk1.4.2_04\lib\tools.jar;C:\j2sdk1.4.2_04\lib\htmlconverter.jar; C:\j2sdk1.4.2_04\lib\servlet.jar;M:\Java

JAVA根目录JAVA_HOME：

C:\j2sdk1.4.2_04

在PATH环境变量中加入C:\j2sdk1.4.2_04\bin;这样直接运行javac.exe，java.exe就能找到JAVA对应的可执行文件了。

对winXP，系统环境变量不需要重新启动系统就能起作用，但是需要重新打开应用程序，用户变量需要重新启动系统才能生效。

 

Edit Plus中Java环境配置：

原来曾用过JCreator进行Java代码编写，而且是J2ME摩托罗拉手机程序编写的配置，复杂得多，可以参考：

写手机程序请用JCreator pro     sunyuzhe114 [原作]

http://dev.csdn.net/Develop/article/13/13625.shtm

这里Edit Plus主要是在Tools/Configure User Tools …里面添加命令。这里简单的配置如下：

Group Name … ：Java Tools

功能：编译Java文件，生成class到Java文件所在目录

Menu Text: Java Compile

Command: C:\j2sdk1.4.2_04\bin\javac.exe

Argument: $(FileName)

Initial Directory: $(FileDir)

 

功能：运行生成的class文件

Menu Text: Java Run

Command: C:\j2sdk1.4.2_04\bin\java.exe

Argument: $(FileNameNoExt)

Initial Directory: $(FileDir)

 

功能：[打开class文件]用JAD直接进行反编译，生成Java文件到class文件所在目录

Menu Text: JAD Decompile

Command: M:\Java\Tools\jad_win\jad.exe

Argument: -o -d .\ -s java $(FileNameNoExt).class

Initial Directory: $(FileDir)

 

功能：用Edit Plus打开反编译生成的java文件

Menu Text: Open Decompile File

Command: E:\program files\EditPlus 2\editplus.exe

Argument: $(FileNameNoExt).java

Initial Directory: $(FileDir)

 

加入自定义工具以后，直接用Ctrl+1[~N]运行自定义工具。

 

/* 以下所说[根目录]为

* E:\program files\Apache Software Foundation\Tomcat 5.0\webapps\ROOT

*/

Java Bean 部署过程：

1. [根目录]/ WEB-INF\classes\test\下面新建FAQ.txt，改名为FAQ.java

2. FAQ.java输入内容：

package test;

public class FAQ{

public FAQ () {

         System.out.println(“FAQ Construction Method”);

  }

  public sayHello(){

         System.out.println(“FAQ : Hello World!”);

  }

}

       3. 编译以上内容，在[根目录]/ WEB-INF\classes\test\生成*.class文件。

       4. [根目录]/test/下面新建faq.txt，改名为faq.jsp

       5. faq.jsp输入内容：

<%

workM.sayHello();

%>

      6. 现象：sayHello将在Tomcat的命令行窗口输出” FAQ : Hello World!”；在JSP文件中使用System.out.println同样输出到命令行窗口，out.println则直接输出到浏览器。

       7.  Java Bean的使用方法二：在JSP中加入引用

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

              调用的时候，

faq myfaq = new faq();

myfaq.sayHello();

              这种方法的好处是，每个JSP中可以多次定义对象。

 

Servlet 部署过程：

1.       在[根目录]/ WEB-INF/classes/test/下面新建FaqServlet.txt，改名为FaqServlet.java

2.       FaqServlet.java输入内容：

package test;

import java.io.*;

import javax.servlet.http.*;

import javax.servlet.*;

 

public class FaqServlet extends HttpServlet

{

  public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException,ServletException{

         response.setContentType("text/xml");

         PrintWriter out = response.getWriter();

         out.println(" Hello World! ");

  }

}

Servlet 是一个从HttpServlet派生的所有对象的统称。主要处理doGet，doPost两个方法，doGet就是一般情况，浏览器从服务器取网页,doPost就是浏览器通过Post的方法从服务器取数据，比如网页中form的method=”post”提交到服务器。

3.       [根目录]/ WEB-INF/web.xml的节点下面添加内容：

    

        FaqServletL

        test.FaqServlet

   

    根据url-pattern来获取servlet-name,再根据servlet-name来获取servlet-class">

        FaqServletL

        /servlet/FaqServlet

    

主要含义应该是：当URL中是http://[ROOT]/servlet/FaqServlet的时候使用的servlet的名称是FaqServletL，服务器根据FaqServlet找到名称为FaqServletL的Servlet，并通过servlet-class test.FaqServlet来定位Servlet的位置。

4.       现象：浏览地址http://127.0.0.1:8080/servlet/FaqServlet，浏览器打开一个页面，效果和xml一样，因为上面response.setContentType("text/xml");如果需要用text/html，则是html页面了，不过需要补全html代码了。

5.       似乎Servlet可以不用部署就可以用的，暂时还不知道，具体以后学习。

 

Taglib 部署过程：

1.       [根目录]/ WEB-INF/classes/test/hello/下面新建HelloTag.java

2.       HelloTag.java输入内容：

  package test.hello;

  import javax.servlet.jsp.JspException;

  import javax.servlet.jsp.JspTagException;

  import javax.servlet.jsp.tagext.TagSupport;

  public class HelloTag extends TagSupport {

    public HelloTag() {

    }

    public int doEndTag() throws JspException{

      try{

        pageContext.getOut().print("Hello World!");

      }catch(Exception ex){

        ex.printStackTrace();

      }

      return SKIP_BODY;

    }

    public void release(){

      super.release();

    }

  }

TagLib应该就是都该从TagSupport派生出来的了。

3.       [根目录]/ WEB-INF/目录下面新建mytaglib.tld

4.       mytaglib.tld输入内容：

 

   1.0

   1.1

   mytablib

   /mytaglib

  

    hello

    test.hello.HelloTag

    empty

    Just Says Hello

  

 

里面觉得主要的两个内容是将在jsp中引用的时候用到，tag/tagclass是TagLib对应class的引用，和上面Java的package对应。

5.       [根目录]/ test/下面新建helloTag.jsp，并输入内容：

  <%@ taglib uri="/mytaglib" prefix="mm" %>

 

这样就行了。通过mm来调用taglib里面的类，函数。看起来似乎Java Bean也可以实现同样的功能，而且似乎Java Bean更加灵活，初学，需要以后进一步认识。

6.       现象：浏览地址http://[ROOT]/test/helloTag.jsp，页面显示：”Hello World!”

7.       tld中似乎有直接对TagLib类中的static函数进行部署的方法，暂时没有尝试出来。这种方法在Java Bean中应该没有可替代的方法吧！

 

 

小结：

1.                JAVA中的网站建设可以这么多层次，明显增加了灵活性，可使用JAVA所有类库的，这样做出来的网站，无疑功能可以是非常强大的。

2.                使用JAD等反编译工具，可以将Java 的目标文件class反编译出来，这样要学习别人的成果，变得非常容易，但是也同样自己的代码也不安全了。

3.                JAVA在不同系统中的支持，增加了程序的可复用性，实现同样功能，用不同的类库，语言写几次实在不爽。

4.                JAVA包括派生出来的工具环境的配置纷繁复杂，还真是麻烦。J Builder挺好用，为了更透彻了解JAVA，了解一下不同的部署步骤还是必要的。

转:http://blog.csdn.net/hahu/archive/2004/07/18/44545.aspx

poower 2008-09-18 22:18 发表评论
]]>主题：表单验证：使用struts中的validator框架http://www.blogjava.net/poower/articles/222377.htmlpoowerpoowerFri, 15 Aug 2008 16:28:00 GMThttp://www.blogjava.net/poower/articles/222377.htmlhttp://www.blogjava.net/poower/comments/222377.htmlhttp://www.blogjava.net/poower/articles/222377.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/222377.htmlhttp://www.blogjava.net/poower/services/trackbacks/222377.html
我们在struts-config.xml里：
Java代码 复制代码
  1. <action-mappings >    
  2. <action    
  3. attribute="logForm"    
  4. input="/form/log.jsp"    
  5. name="logForm"    
  6. path="/log"    
  7. scope="request"    
  8. type="com.yourcompany.struts.action.LogAction"    
  9. validate="true"    
  10. <forward name="s" path="/form/MyJsp.jsp" />    
  11. </action>   
里面必须加上validate="true"这么句代码，否则，验证机制将可能不会运行。
另外，配置文件中还须加入以下代码，表示使用插件：
Java代码 复制代码
  1. <plug-in className="org.apache.struts.validator.ValidatorPlugIn">   
  2.         <set-property property="pathnames"  
  3.             value="/WEB-INF/validator-rules.xml,   
  4.                                               /WEB-INF/validation.xml" />   
  5. </plug-in>   

注意加入<plug-in>标签的位置，该标签应该放在struts配置文件中的最后，具体位置在元素<struts-config></struts-config>内部，在<message-resources parameter="com.blog.struts.ApplicationResources" />之后，切记要注意位置，不然报错。
其次，在写法上，value的内容中/WEB-INF/validator-rules.xml是默认的，因为在项目使用struts框架时该文件已经在此目录层次下面了，那么之后的/WEB-INF/validation.xml"又是什么呢？这里需要我们手动在WEB-INF目录下新建validation.xml文件，这个文件有什么用？先看下其中写的什么。
Java代码 复制代码
  1. <form-validation>   
  2.     <global>   
  3.     </global>   
  4.     <formset>   
  5.         <form name="userForm">   
  6.             <field property="userName"  
  7.                 depends="required,minlength,maxlength">   
  8.                 <arg0 key="userForm.userName" />   
  9.                 <arg1 name="minlength" key="${var:min}"  
  10.                     resource="false" />   
  11.                 <arg1 name="maxlength" key="${var:max}"  
  12.                     resource="false" />   
  13.                 <var>   
  14.                     <var-name>min</var-name>   
  15.                     <var-value>6</var-value>   
  16.                 </var>   
  17.                 <var>   
  18.                     <var-name>max</var-name>   
  19.                     <var-value>20</var-value>   
  20.                 </var>   
  21.             </field>   
  22.             <field property="password"  
  23.                 depends="required,minlength,maxlength,mask">   
  24.                 <arg0 key="userForm.password" />   
  25.                 <arg1 name="minlength" key="${var:min}"  
  26.                     resource="true" />   
  27.                 <arg1 name="maxlength" key="${var:max}"  
  28.                     resource="true" />   
  29.                 <var>   
  30.                     <var-name>min</var-name>   
  31.                     <var-value>6</var-value>   
  32.                 </var>   
  33.                 <var>   
  34.                     <var-name>max</var-name>   
  35.                     <var-value>20</var-value>   
  36.                 </var>   
  37.                 <var>   
  38.                     <var-name>mask</var-name>   
  39.                     <var-value>^\w+$</var-value>   
  40.                 </var>   
  41.             </field>   
  42.             <field property="email" depends="required,email">   
  43.                 <arg0 key="userForm.email" />   
  44.             </field>   
  45.             <field property="name" depends="required,maxlength">   
  46.                 <arg0 key="userForm.name" />   
  47.                 <arg1 name="maxlength" key="${var:max}"  
  48.                     resource="false" />   
  49.                 <var>   
  50.                     <var-name>max</var-name>   
  51.                     <var-value>20</var-value>   
  52.                 </var>   
  53.             </field>             
  54.             <field property="tel" depends="required,mask">   
  55.                 <arg0 key="userForm.tel" />   
  56.                 <var>   
  57.                     <var-name>mask</var-name>   
  58.                     <var-value>^\(?(\d{3,4})\)?[-|]?(\d{7,8})$</var-value>   
  59.                 </var>   
  60.             </field>   
  61.             <field property="address" depends="required">   
  62.                 <arg0 key="userForm.address" />   
  63.             </field>   
  64.         </form>   
  65.         <form name="categoryForm">   
  66.             <field property="categoryName" depends="required">   
  67.                 <arg0 key="categoryForm.categoryName" />   
  68.             </field>   
  69.         </form>   
  70.     </formset>   
  71. </form-validation>  

Validation.xml：该配置文件是专供应用程序使用的，其中所描述的是特定ActionForm会用到validation-rule.xml文件中的哪些验证器。

1.<form-validation>元素
<form-validation>元素是validation.xml文件的根元素，它包含两个子元素：<global>和<formset>元素。其中<global>元素可以出现零次或多次，<formset>元素可以出现一次或多次。

2.<global>元素
<global>元素中通过<constant>子元素来定义常量表达式，每个<constant>子元素定义一个常量表达式，如果有多个常量表达式要定义则可以配置多个<constant>来实现。

3.<formset>元素
<formset>元素包括两个子元素<constant>和<form>。<constant>元素可以出现零次或多次，<form>元素可以出现一次或多次。
这里需要注意的是，在<form>标签中有包括<field>子元素。

4.<field>元素
<field>元素通过property属性指定字段的名字，通过depends属性指定具体的验证规则，验证规则来源于validation-rule.xml中所写的验证方法，这里我们要简单介绍一下validation-rule.xml里面的验证规则是默认，那如果我们有需要定义自己的验证规则也可以写在里面。<field>元素可包含的子元素为<msg>,<arg>,<var>。

第二步
把validator框架使用的消息文本添加到应用的Resource Bundle中，如在ApplicationResources.properties中加入例如：
Java代码 复制代码
  1. errors.header=<b><font color=ff0000><ul>   
  2. errors.footer=</ul></font></b>   
  3. errors.prefix=<li>   
  4. errors.suffix=</li>   
  5.   
  6. error.isexit=\u7528\u6237\u540d\u5df2\u5b58\u5728\uff0c\u8bf7\u91cd\u65b0\u6ce8\u518c\uff01   
  7. error.username=\u7528\u6237\u540d\u4e0d\u5408\u6cd5\uff0c\u8bf7\u91cd\u65b0\u586b\u5199\u7528\u6237\u540d\uff01   
  8. error.password=\u5bc6\u7801\u4e0d\u5408\u6cd5\uff0c\u8bf7\u91cd\u65b0\u586b\u5199\u5bc6\u7801\uff01   
  9.   
  10. errors.required={0}\u4e3a\u5fc5\u586b\u5b57\u6bb5   
  11. errors.minlength={0}\u7684\u957f\u5ea6\u4e0d\u80fd\u5c0f\u4e8e{1}    
  12. errors.maxlength={0}\u7684\u957f\u5ea6\u4e0d\u80fd\u5927\u4e8e{1}    
  13. errors.email={0}\u5fc5\u987b\u4e3a\u6709\u6548\u90ae\u4ef6\u5730\u5740   
  14.   
  15. userForm.userName=\u7528\u6237\u540d;   
  16. userForm.password=\u5bc6\u7801;   
  17. userForm.email=Email;   
  18. userForm.name=\u59d3\u540d;   
  19. userForm.sex=\u6027\u522b;   
  20. userForm.tel=\u8054\u7cfb\u7535\u8bdd;   
  21. userForm.address=\u8054\u7cfb\u5730\u5740;   
  22. userForm.userType=\u7528\u6237\u7c7b\u522b;   
  23.   
  24. categoryForm.categoryName=\u7c7b\u522b\u540d\u79f0  



第三步
将Form的extends ActionForm改为extends ValidatorForm


第四步
在jsp页面当中，如果我们要创建一个在服务器端验证的页面，我们只需要在控件之后添加<html:errors property="password"/>，即：
<tr>
<td>密码：</td>
<td><html:password property="password" /><html:errors property="password"/></td>
</tr>
注意<html:errors property="password"/>之中的property对应的是form中定义的属性。

那么如果我们要创建一个在客户端进行验证的页面，我们需要如下步骤：
1.在<html:form></html:form>的外面加上<html:javascript formName="userForm"/>
2.在<html:form>中加入属性onsubmit=”return validateCardForm(this);”,即;
<html:form action="/save_user" method="post" enctype="multipart/form-data" onsubmit="return validateUserForm(this);">
3.同服务器端验证一样<td><html:password property="password" /><html:errors property="password"/></td>
重点
使用validator进行表单验证的步骤如上，其中最为关键的一步是，validation.xml文件中为表单配置验证规则的写法。
注意事项如下：
<form-validation>
<global>
在<global>中定义的常量表达式，在文件的其余地方可以直接引用。
即，这里配置的常量表达式是全局的
写法为：
<constant>
<constant-name>phone</constant-name>
<constant-value>^\(?(\d{3})\)?[-|]?(\d{8})$<constant-value>
//定义一个名为：phone的正则表达式，3位区号+8位号码
</constant>
</global>
<formset>
<form name="userForm">
<field property="userName"
//这里的property要与form表单属性名对应
depends="required,minlength,maxlength">
//这里的depends用于指定对该属性使用什么验证规则，其规则来自于validator-rule.xml文件中所写的规则。指定多个验证器时，会依次调用，直到该表单通过所有验证。
<arg0 key="userForm.userName" />
//arg0对应的是ApplicationResources.property中的{0},即：
“errors.required={0}不能为空”，其作用是将arg0中key所对应的资源文件中的“userForm.userName=用户名”的文中或者说是值替换到“errors.required={0}不能为空”中的{0}，这样页面输出的是“用户名不能为空”;
下面的arg1同理{1}
Java代码 复制代码
  1.                 <arg1 name="minlength" key="${var:min}"  
  2.                     resource="false" />   
  3.                 <arg1 name="maxlength" key="${var:max}"  
  4.                     resource="false" />   
  5.                 <var>   
  6.                     <var-name>min</var-name>   
  7.                     <var-value>6</var-value>   
  8.                 </var>   
  9.                 //var对应key="${var:min}"中的min   
  10.                 <var>   
  11.                     <var-name>max</var-name>   
  12.                     <var-value>20</var-value>   
  13.                 </var>   
  14.             </field>   
  15. </form>   
  16.     </formset>   
  17. </form-validation>  


poower 2008-08-16 00:28 发表评论
]]>解决中文参数乱码http://www.blogjava.net/poower/articles/221715.htmlpoowerpoowerWed, 13 Aug 2008 06:33:00 GMThttp://www.blogjava.net/poower/articles/221715.htmlhttp://www.blogjava.net/poower/comments/221715.htmlhttp://www.blogjava.net/poower/articles/221715.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/221715.htmlhttp://www.blogjava.net/poower/services/trackbacks/221715.html     中<Connector port="80" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" URIEncoding="UTF-8"/>
2.在对应的应用中添加字符过滤器
    继承    javax.servlet.Filter

public void doFilter(ServletRequest request, ServletResponse response,
   FilterChain chain) throws IOException, ServletException {
  // TODO Auto-generated method stub

  request.setCharacterEncoding("utf-8");
  chain.doFilter(request, response);
 }


3.在对应的应用中web.xml中添加过滤器
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>cn.ywj.webexample.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

poower 2008-08-13 14:33 发表评论
]]>配置Tomcat管理员用户http://www.blogjava.net/poower/articles/218322.htmlpoowerpoowerTue, 29 Jul 2008 03:54:00 GMThttp://www.blogjava.net/poower/articles/218322.htmlhttp://www.blogjava.net/poower/comments/218322.htmlhttp://www.blogjava.net/poower/articles/218322.html#Feedback0http://www.blogjava.net/poower/comments/commentRss/218322.htmlhttp://www.blogjava.net/poower/services/trackbacks/218322.html 打开tomcat安装目录里面的conf/tomcat-users.xml文件
配置如下：
<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
    <role rolename="manager"/> 
    <role rolename="admin"/> 
    <user username="paul"password="huhuiyu"
                roles="manager,admin"/>
</tomcat-users>
重新启动Tomcat，打开下面的页面
http://127.0.0.1:8080/manager/html
输入前面配置的用户名和密码即可进入Tomcat管理页面。

端口配置:
conf/server.xml     <connector port=""  ......>

自动更新:
设置属性reloadable=true
你可以在server.xml里对不同的host设置也可以直接在context.xml里对所有项目设置

1。找到要修改的xml文件

.\conf\server.xml

2.增加新的属性

<Context path="/wk" docBase="wk" debug="0" reloadable="true" crossContext="true"></Context>

path：访问的路径 http://localhost:8080/wk

docBase：是相对于.\webapps\wk的相对路径；或者写绝对路径：e\work\wk

3. 然后重启Tomcat

4.当再次更新wk工程下面的类的时候，能够自动加载！


配置数据源:
/conf/context.xml
<Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource" maxActive="100"
              madIdle="30" maxWait="10000" username="root" password="139689"
              driverClassName="com.mysql.jdbc.Driver"
              url="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=GBK"/>
             

将数据库驱动程序加到tomcat6/lib下




poower 2008-07-29 11:54 发表评论
]]>