2:  java org.apache.axis.wsdl.WSDL2Java -p com.hnisi.axis.client http://192.168.3.42:8080/test/services/BookOrder?wsdl

前提：AXIS环境配好

在本文中，我们下载的JBoss版本为：4.2.1.GA。

下载地址：

www.jboss.org

在如上的下载页中下载JBoss-4.2.1.GA.zip文件。

下载完成后，将其解压缩后即可完成安装，解压缩后将其放置到一个不带空格的目录(若目录带有空格，例如：C:"Program Files，日后可能会产生一些莫名的错误)，eg：E:"JBoss4.2.1。同时在“环境变量设置”中设置名为JBOSS_HOME的环境变量，值为JBoss的安装路径，如下图所示：

在此，JBoss的安装工作已经结束，可通过如下方式测试安装是否成功：

运行JBoss安装目录"bin"run.bat，如果窗口中没有出现异常，且出现：10:16:19,765 INFO [Server] JBoss (MX MicroKernel) [4.2.1.GA (build: SVNTag=JBoss_4_2_1_GA date=200707131605)] Started in 30s:828ms字样，则表示安装成功。

我们可以通过访问： http://localhost:8080/ 进入JBoss的欢迎界面，点击JBoss Management下的JMX Console可进入JBoss的控制台。

若启动失败，可能由以下原因引起：

1）              JBoss所用的端口（8080，1099，1098，8083等）被占用。一般情况下为8080端口被占用（例如，Oracle占用了8080端口），此时需要修改JBoss的端口，方法为进入JBoss安装目录"server"default"deploy"jboss-web.deployer目录，修改其下的server.xml目录，在此文件中搜索8080，将其改成你想要的端口即可（例如8088）；

2）              JDK安装不正确；

3）              JBoss下载不完全。

二．             JBoss 的目录结构说明

三．             JBoss 的配置

1.       日志文件设置

若需要修改JBoss默认的log4j设置，可修改JBoss安装目录"server"default"conf下的jboss-log4j.xml文件，在该文件中可以看到，log4j的日志输出在JBoss安装目录"server"default"log下的server.log文件中。对于log4j的设置，读者可以在网上搜索更加详细的信息。

2.       web 服务的端口号的修改

这点在前文中有所提及，即修改JBoss安装目录"server"default"deploy"jboss-web.deployer下的server.xml文件，内容如下：

<Connector port="8080" address="${jboss.bind.address}"   

         maxThreads="250" maxHttpHeaderSize="8192"

         emptySessionPath="true" protocol="HTTP/1.1"

         enableLookups="false" redirectPort="8443" acceptCount="100"

         connectionTimeout="20000" disableUploadTimeout="true" />

将上面的8080端口修改为你想要的端口即可。重新启动JBoss后访问：http://localhost/:新设置的端口，可看到JBoss的欢迎界面。

3.       JBoss 的安全设置

1） jmx-console 登录的用户名和密码设置

默认情况访问 http://localhost:8080/jmx-console 就可以浏览jboss的部署管理的一些信息，不需要输入用户名和密码，使用起来有点安全隐患。下面我们针对此问题对jboss进行配置，使得访问jmx-console也必须要知道用户名和密码才可进去访问。步骤如下：

i) 找到JBoss安装目录/server/default/deploy/jmx-console.war/WEB-INF/jboss-web.xml文件，去掉<security-domain>java:/jaas/jmx-console</security-domain>的注释。修改后的该文件内容为：

<jboss-web>

   <!-- Uncomment the security-domain to enable security. You will

      need to edit the htmladaptor login configuration to setup the

      login modules used to authentication users.-->

      <security-domain>java:/jaas/jmx-console</security-domain>

</jboss-web>

ii）修改与i）中的jboss-web.xml同级目录下的web.xml文件，查找到<security-constraint/>节点，去掉它的注释，修改后该部分内容为：

<!-- A security constraint that restricts access to the HTML JMX console

   to users with the role JBossAdmin. Edit the roles to what you want and

   uncomment the WEB-INF/jboss-web.xml/security-domain element to enable

   secured access to the HTML JMX console.-->

   <security-constraint>

     <web-resource-collection>

       <web-resource-name>HtmlAdaptor</web-resource-name>

       <description>An example security config that only allows users with the

         role JBossAdmin to access the HTML JMX console web application

       </description>

       <url-pattern>/*</url-pattern>

       <http-method>GET</http-method>

       <http-method>POST</http-method>

     </web-resource-collection>

     <auth-constraint>

       <role-name>JBossAdmin</role-name>

     </auth-constraint>

   </security-constraint>

   在此处可以看出，为登录配置了角色JBossAdmin。

 iii） 在第一步中的jmx-console安全域和第二步中的运行角色JBossAdmin都是在login-config.xml中配置，我们在JBoss安装目录/server/default/config下找到它。查找名字为：jmx-console的application-policy：

<application-policy name = "jmx-console">
       <authentication>
          <login-module code="org.jboss.security.auth.spi.UsersRolesLoginModule"
             flag = "required">
           <module-option name="usersProperties">props/jmx-console-users.properties</module-option>
           <module-option name="rolesProperties">props/jmx-console-roles.properties</module-option>
          </login-module>
       </authentication>
    </application-policy>

在此处可以看出，登录的角色、用户等的信息分别在props目录下的jmx-console-roles.properties和jmx-console-users.properties文件中设置，分别打开这两个文件。

其中jmx-console-users.properties文件的内容如下：

# A sample users.properties file for use with the UsersRolesLoginModule

admin=admin

该文件定义的格式为：用户名=密码，在该文件中，默认定义了一个用户名为admin，密码也为admin的用户，读者可将其改成所需的用户名和密码。

jmx-console-roles.properties的内容如下：

# A sample roles.properties file for use with the UsersRolesLoginModule

admin=JBossAdmin, HttpInvoker

该文件定义的格式为：用户名=角色，多个角色以“,”隔开，该文件默认为admin用户定义了JBossAdmin和HttpInvoker这两个角色。

配置完成后读者可以通过访问： http://localhost:8088/jmx-console/ ，输入jmx-console-roles.properties文件中定义的用户名和密码，访问jmx-console的页面。

2） web-console 登录的用户名和密码设置

默认情况下，用户访问JBoss的web-console时，不需要输入用户名和密码，为了安全起见，我们通过修改配置来为其加上用户名和密码。步骤如下：

i）找到JBoss安装目录"server"default"deploy"management"console-mgr.sar"web-console.war"WEB-INF"jboss-web.xml文件，去掉<security-domain>java:/jaas/web-console</security-domain>的注释，修改后的文件内容为：

<?xml version='1.0' encoding='UTF-8' ?>

<!DOCTYPE jboss-web

    PUBLIC "-//JBoss//DTD Web Application 2.3V2//EN"

    "http://www.jboss.org/j2ee/dtd/jboss-web_3_2.dtd">

<jboss-web>

   <!-- Uncomment the security-domain to enable security. You will

   need to edit the htmladaptor login configuration to setup the

   login modules used to authentication users.-->

   <security-domain>java:/jaas/web-console</security-domain>

   <!-- The war depends on the -->

   <depends>jboss.admin:service=PluginManager</depends>

</jboss-web>

ii）打开i）中jboss-web.xml同目录下的web.xml文件，去掉<security-constraint>部分的注释，修改后的该部分内容为：

<!-- A security constraint that restricts access to the HTML JMX console

   to users with the role JBossAdmin. Edit the roles to what you want and

   uncomment the WEB-INF/jboss-web.xml/security-domain element to enable

   secured access to the HTML JMX console.-->

   <security-constraint>

   <web-resource-collection>

   <web-resource-name>HtmlAdaptor</web-resource-name>

   <description>An example security config that only allows users with the

   role JBossAdmin to access the HTML JMX console web application

   </description>

   <url-pattern>/*</url-pattern>

   <http-method>GET</http-method>

   <http-method>POST</http-method>

   </web-resource-collection>

   <auth-constraint>

   <role-name>JBossAdmin</role-name>

   </auth-constraint>

   </security-constraint>

iii）打开JBoss安装目录"server"default"conf下的login-config.xml文件，搜索web-console，可找到如下内容：

<application-policy name = "web-console">

       <authentication>

          <login-module code="org.jboss.security.auth.spi.UsersRolesLoginModule"

             flag = "required">

             <module-option name="usersProperties">web-console-users.properties</module-option>

             <module-option name="rolesProperties">web-console-roles.properties</module-option>

          </login-module>

       </authentication>

    </application-policy>

在文件中可以看到，设置登录web-console的用户名和角色等信息分别在login-config.xml文件所在目录下的web-console-users.properties和web-console-roles.properties文件中，但因为该目录下无这两个文件，我们在JBoss安装目录"server"default"conf"props目录下建立这两个文件，文件内容可参考在“jmx-console登录的用户名和密码设置”中的两个相应的配置文件的内容，web-console-users.properties文件的内容如下：

# A sample users.properties file for use with the UsersRolesLoginModule

admin=admin

web-console-roles.properties文件的内容如下：

# A sample roles.properties file for use with the UsersRolesLoginModule

admin=JBossAdmin,HttpInvoker

因为此时这两个文件不与login-config.xml同目录，所以login-config.xml文件需进行少许修改，修改后的<application-policy name = "web-console">元素的内容为：

<application-policy name = "web-console">

       <authentication>

          <login-module code="org.jboss.security.auth.spi.UsersRolesLoginModule"

             flag = "required">

             <module-option name="usersProperties">props/web-console-users.properties</module-option>

             <module-option name="rolesProperties">props/web-console-roles.properties</module-option>

          </login-module>

       </authentication>

    </application-policy>

四．             在MyEclipse 中配置JBoss

笔者的MyEclipse版本：5.1.1 GA

JBoss版本：4.2.1 GA

JDK版本：1.5

进入Window-> Preferences-> MyEclipse -> Application Servers -> JBoss4，进行如下设置：
    

选择JBoss 4下的JDK设置所用的JDK.

设置完成后，部署程序时，会发现多出JBoss 4部署的选择，如下图所示：

同时在 中展开，可看到JBoss 4的启动图标。

方法有很多种！

比如：在getRequestDispatcher("/jsp/jsptoserv/hello.jsp").forward(request, response);之前修改

request的编码，那么在jsp/jsptoserv/hello.jsp中得到的参数值就是制定的编码的字符。

本文我们使用Filter来修改request的编码

1)首先编写filter类：
package myFilter;
import java.io.IOException;
import javax.servlet.*;
public class ChangeCharsetFilter implements Filter {
protected String encoding = null;/////要制定的编码，在web.xml中配置
protected FilterConfig filterConfig = null;
public void destroy() {
this.encoding = null;
this.filterConfig = null;
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
if (request.getCharacterEncoding() == null){
 String encoding = getEncoding();////得到指定的编码名字
 if (encoding != null)
 request.setCharacterEncoding(encoding);////设置request的编码
 }
chain.doFilter(request, response);///有机会执行下一个filter
}
 public void init(FilterConfig filterConfig) throws ServletException {
 this.filterConfig = filterConfig;
this.encoding = filterConfig.getInitParameter("encoding");///得到在web.xml中配置的编码
 }
 protected String getEncoding() {
 return (this.encoding);///得到指定的编码
}

}

2。编辑web.xml文件
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app
? PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
? "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<filter>
<filter-name>SetCharacterEncoding</filter-name>
 <filter-class>myFilter.ChangeCharsetFilter </filter-class>
 <init-param>
 <param-name>encoding</param-name>
<param-value>GB2312</param-value>//////指定编码为GB2312
</init-param>
 </filter>
<filter-mapping>
 <filter-name>SetCharacterEncoding</filter-name>
<url-pattern>/*</url-pattern>////////对于所有的request改变其编码
</filter-mapping>
</web-app>
///
3。写一个a.jsp

<%@ page contentType="text/html; charset=GB2312" %>
<html>
<head></head>
<body>
<%
String name=request.getParameter("name");///本来这里得到字符是iso-8859-1编码的，不能直接

在Console中输出的，但是现在改变了request的编码方式，此时的name的编码是GB2312,所以能正确在Console中显示的。

System.out.println(name);

%>
<form action="a.jsp" method="post">
<input type="text" name="name">
<input type="submit">
</form>
<%=name%>
</body>
</html>

完！

关于中文处理的问题就写这些了！

import javax.sql.DataSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class DataStore {
 
 DataSource dataSource = null;
 private static Connection conn = null;
 private Statement stmt = null;
 private boolean hadErrors = false;
 
 //construct
 public DataStore(DataSource dataSource) throws Exception{
  this.dataSource = dataSource;
  conn = dataSource.getConnection();
  stmt = conn.createStatement();
 }
 
 //invoke transaction
 public void beginTransaction() throws SQLException{
  conn.setAutoCommit(false);
 }
 
 //perform transaction
 public void commitTransaction() throws SQLException{
  //hadErrors = false
  if(!hadErrors){
   conn.commit();
  }
  else{  //hadErrors = true
   conn.rollback();
   hadErrors = false;
  }
  hadErrors = false;
  conn.setAutoCommit(true);
 }
 
 //mark error
 public void ErrorOccur(){
  hadErrors = true;
 }
 
 //execute insert,delete,update
 synchronized public void execute(String sql) throws SQLException{
  if(stmt != null)
   stmt.executeUpdate(sql);
  else{
   Log log = LogFactory.getLog("mylog");
   log.error("fail to execute sql");
  }
 }
 
 //execute select
 synchronized public ResultSet read(String sql) throws SQLException{
  if(stmt != null){
   ResultSet tmp = null;
   tmp = stmt.executeQuery(sql);
   return tmp;
  }else{
   return null;
  }
 }
 
 // count of result
 synchronized public int readCount(String sql) throws SQLException{
  int nCount = 0;
  try{
   if(stmt != null){
    ResultSet tmp = null;
    tmp = stmt.executeQuery(sql);
    if(tmp != null && tmp.next()){
     nCount = tmp.getInt(1);
    }else{
     nCount = 0;
    }
   }
  }catch(SQLException e){
   nCount = 0;
  }
  return nCount;
 }
 
 // close db
 synchronized public void stop(){
  try{
   if(conn != null){
    conn.close();
    stmt.close();
   }
  }catch(Exception e){
   Log log = LogFactory.getLog("mylog");
   log.error("fail to close db- DataStore.java");
  }finally{
   conn = null;
  }
 }
}

还在研究，貌似DCL的问题还存在。

 原理：
         在DataSource中事先建立多个数据库连接，保存在数据库连接池中。当程序访问数据库时，只用从连接池中取空闲状态的数据库连接即可，访问结束，销毁资源，数据库连接重新回到连接池，这与每次去直接访问数据库相比，会节省大量时间和资源。
         JNDI( Java Naming and Directory Interface )，是Java平台的一个标准扩展，提供了一组接口、类和关于命名空间的概念。如同其它很多Java技术一样，JDNI是provider-based的技术，暴露了一个 API和一个服务供应接口（SPI）。这意味着任何基于名字的技术都能通过JNDI而提供服务，只要JNDI支持这项技术。JNDI目前所支持的技术包括 LDAP、CORBA Common Object Service（COS）名字服务、RMI、NDS、DNS、Windows注册表等等。很多J2EE技术，包括EJB都依靠JNDI来组织和定位实体。可以把它理解为一种将对象和名字捆绑的技术，对象工厂负责生产出对象，这些对象都和唯一的名字绑在一起，外部资源可以通过名字获得某对象的引用。

          在javax.naming的包包中提供Context接口，提供了两个很好用的方法：
<1> void bind( String name , Object object )
        将名称绑定到对象。所有中间上下文和目标上下文（由该名称最终原子组件以外的其他所有组件指定）都必须已经存在。
<2>Object lookup( String name )
       检索指定的对象。如果 name为空，则返回此上下文的一个新实例（该实例表示与此上下文相同的命名上下文，但其环境可以独立地进行修改，而且可以并发访问）。

       外部资源访问对象工厂中的工程图:

例:
=================将以下代码段添加到server.xml中的<Host>中============

<!-- configure DataSource. Add the following code into server.xml -->

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

<!-- 数据源名称 -->
<Resource name="jdbc/BookDB"
               auth="Container"
               type="javax.sql.DataSource" />

<ResourceParams name="jdbc/BookDB">
    <parameter>
      <name>factory</name>
      <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
    </parameter>

    <!-- Maximum number of dB connections in pool. Make sure you
         configure your mysqld max_connections large enough to handle
         all of your db connections. Set to 0 for no limit.
         -->

<!-- 活动状态最大连接数 -->
    <parameter>
      <name>maxActive</name>
      <value>100</value>
    </parameter>

    <!-- Maximum number of idle dB connections to retain in pool.
         Set to 0 for no limit.
         -->

<!-- 空闲状态数据库连接最大数 -->
    <parameter>
      <name>maxIdle</name>
      <value>30</value>
    </parameter>

    <!-- Maximum time to wait for a dB connection to become available
         in ms, in this example 10 seconds. An Exception is thrown if
         this timeout is exceeded. Set to -1 to wait indefinitely.
        Maximum time to wait for a dB connection to become available
         in ms, in this example 10 seconds. An Exception is thrown if
         this timeout is exceeded. Set to -1 to wait indefinitely.
         -->

<!-- 数据库处于空闲状态的最长时间 -->
    <parameter>
      <name>maxWait</name>
      <value>10000</value>
    </parameter>

    <!-- MySQL dB username and password for dB connections -->

<!-- 指定连接数据库的用户名及密码 -->
    <parameter>
     <name>username</name>
     <value>dbuser</value>
    </parameter>
    <parameter>
     <name>password</name>
     <value>1234</value>
    </parameter>

    <!-- Class name for mm.mysql JDBC driver -->

<!-- 指定JDBC驱动 -->
    <parameter>
       <name>driverClassName</name>
       <value>com.mysql.jdbc.Driver</value>
    </parameter>

    <!-- The JDBC connection url for connecting to your MySQL dB.
         The autoReconnect=true argument to the url makes sure that the
         mm.mysql JDBC Driver will automatically reconnect if mysqld closed the
         connection. mysqld by default closes idle connections after 8 hours.
         -->

<!-- 指定连接数据库的URL -->
    <parameter>
      <name>url</name>
      <value>jdbc:mysql://localhost:3306/BookDB?autoReconnect=true</value>
    </parameter>
</ResourceParams>

</Context>

􀁺􀀃 1、 首先程序代码获取初始化的 JNDI 环境并且调用 Context.lookup() 方法从 JNDI 服务提供者那里获一个 DataSource 对象

􀁺􀀃 2、 中间层 JNDI 服务提供者返回一个 DataSource 对象给当前的 Java 应用程序这个 DataSource 对象代表了中间层服务上现存的缓冲数据源

􀁺􀀃  3、 应用程序调用 DataSource 对象的 getConnection() 方法

􀁺􀀃 4、 当 DataSource 对象的 getConnection() 方法被调用时，中间层服务器将查询数据库 连接缓冲池中有没有 PooledConnection 接口的实例对象。这个 PooledConnection 对象将被用于与数据库建立物理上的数据库连接

􀁺􀀃 5、 如果在缓冲池中命中了一个 PooledCoonection 对象那么连接缓冲池将简单地更 新内部的缓冲连接队列并将该 PooledConnection 对象返回。如果在缓冲池内没 有找到现成的 PooledConnection 对象，那么 ConnectionPoolDataSource 接口将会被 用来产生一个新的 PooledConnection 对象并将它返回以便应用程序使用

􀁺􀀃 6。 中间层服务器调用 PooledConnection 对象的 getConnection() 方法以便返还一个 java.sql.Connection 对象给当前的 Java 应用程序

􀁺􀀃 7、 当中间层服务器调用 PooledConnection 对象的 getConnection() 方法时， JDBC 数据 库驱动程序将会创建一个 Connection 对象并且把它返回中间层服务器

􀁺􀀃 8、 中间层服务器将 Connection 对象返回给应用程序 Java 应用程序，可以认为这个 Connection 对象是一个普通的 JDBC Connection 对象使用它可以和数据库建立。事 实上的连接与数据库引擎产生交互操作 。

􀁺􀀃 9、 当应用程序不需要使用 Connection 对象时，可以调用 Connection 接口的 close() 方 法。请注意这种情况下 close() 方法并没有关闭事实上的数据库连接，仅仅是释 放了被应用程序占用的数据库连接，并将它还给数据库连接缓冲池，数据库连接 缓冲池会自动将这个数据库连接交给请求队列中下一个的应用程序使用。

<%@page import="java.util.*,javax.naming.*,java.sql.*,javax.sql.*" %>
<%@page contentType="text/html;charset=BIG5"%>
<%    
    Context ctx = new InitialContext();      
    String strLookup = "java:comp/env/jdbc/test"; 
    DataSource ds =(DataSource) ctx.lookup(strLookup);
    Connection con = ds.getConnection();
    if (con != null){
        out.print("success");
    }else{
        out.print("failure");
    }       
%>

<resource-ref>
    <res-ref-name>jdbc/test</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
    <res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>

配置tomcat
这一步的目的就是告诉tomcat如何连接数据库
可以分为两种大的类型，每种类型又有很多种配置方式
配置类型一；
(直接配置的类型，这种方式最简单)

方法一：
直接在tomcat_home/conf/localhost/下建立一个xml文件，文件名是<yourAppName>.xml
例如我的工程名叫jndi，对应的名字叫jdni.xml
内容如下:

<Context>
 <Resource
          name="jdbc/test"
          type="javax.sql.DataSource"
          password="bb"
          driverClassName="com.mysql.jdbc.Driver"
          maxIdle="2"
          maxWait="50"
          username="root"
          url="jdbc:mysql://localhost:3306/test"
          maxActive="4"/>
</Context>

<context>
<Resource
          name="jdbc/test"
          type="javax.sql.DataSource"
          password="bb"
          driverClassName="com.mysql.jdbc.Driver"
          maxIdle="2"
          maxWait="50"
          username="root"
          url="jdbc:mysql://localhost:3306/test"
          maxActive="4"/>
</context>

说明：这种配置需要告诉tomcat resource的内容，resource应用于什么地方
第一种方法通过文件名知道了app的name
第二种方式本身就在app内部，所以name肯定知道
两种方式都要放在context中

配置类型二：
(配置全局resource，然后通过resourcelink来映射)

步骤一：配置全局resource（这一步对于所有的配置都是一样的）
打开tomcat_home/conf/server.xml加入

<Resource
          name="jdbc/test"
          type="javax.sql.DataSource"
          password="bb"
          driverClassName="com.mysql.jdbc.Driver"
          maxIdle="2"
          maxWait="50"
          username="root"
          url="jdbc:mysql://localhost:3306/test"
          maxActive="4"/>

步骤二：映射
(映射可以配置在多个地方，也就有多个配置方法：)

方法一：（对比类型一的配置理解）
直接在tomcat_home/conf/localhost/下建立一个xml文件，文件名是<yourAppName>.xml
例如我的工程名叫jndi，对应的名字叫jdni.xml加入如下内容

<Context>
<ResourceLink global="jdbc/test" name="jdbc/test" type="javax.sql.DataSource"/>
</Context>

<context>
<ResourceLink global="jdbc/test" name="jdbc/test" type="javax.sql.DataSource"/> 
</context>

方法三：(上边两种方法都是把全局的resource 映射给jndi这个web应用，第三种方法就是把这个
全局的resource直接公开给所有的应用)
在tomcat_home/conf/context.xml的<Context></context>之间加入
<ResourceLink global="jdbc/test" name="jdbc/test" type="javax.sql.DataSource"/>

运行测试：
打开ie，输入http://localhost:8080/jndi/index.jsp
看到success

常见错误：
1，Name jdbc is not bound in this Context
2，Cannot create JDBC driver of class '' for connect URL 'null' conf localhost
原因：
大多数是因为配置了全局的resource，但没有link造成的。
解决：
加入link就行了，link的方式见类型二的三种方法。

分析：
看到上边这么多方法，是否感觉眼花缭乱，其实不要死记配置，按照原理分析一下就好了。
你需要的是告诉tomcat哪个应用如何连接数据库。

类型一的方式对应一个应用单独使用这个配置的情况
就是直接告诉tomcat"应用名"  "连接数据库需要的参数"

类型二的方式对应多个应用共享一个配置的情况
这样先配置server.xml告诉tomcat全局范围的"连接数据库需要的参数"
然后映射，映射的时候
1,如果不知道"app name(应用名)"就只需要通过文件名来传递这个信息
2,如果"app name"都知道就只需要加入映射的内容
3,如果要配置成全局公用的，就不需要"app name"，本身放在tomcat的context.xml中

最后再次提醒一下：所有的配置必须放在<context></context>之间

　　Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，Java和JSP文件本身编译时产生的乱码问题和Java程序于其他媒介交互产生的乱码问题。

　　首先Java（包括JSP）源文件中很可能包含有中文，而Java和JSP源文件的保存方式是基于字节流的，如果Java和JSP编译成class文件过程中，使用的编码方式与源文件的编码不一致，就会出现乱码。基于这种乱码，建议在Java文件中尽量不要写中文（注释部分不参与编译，写中文没关系），如果必须写的话，尽量手动带参数－ecoding GBK或－ecoding gb2312编译；对于JSP，在文件头加上<%@ page contentType="text/html;charset=GBK"%>或<%@ page contentType="text/html;charset=gb2312"%>基本上就能解决这类乱码问题。

　　本文要重点讨论的是第二类乱码，即Java程序与其他存储媒介交互时产生的乱码。很多存储媒介，如数据库，文件，流等的存储方式都是基于字节流的，Java程序与这些媒介交互时就会发生字符(char)与字节(byte)之间的转换，例如从页面提交表单中提交的数据在Java程序里显示乱码等情况。

　　如果在以上转换过程中使用的编码方式与字节原有的编码不一致，很可能就会出现乱码。

　　二、解决方法

　　对于流行的Tomcat来说，有以下两种解决方法：

　　1) 更改 D:\Tomcat\conf\server.xml，指定浏览器的编码格式为“简体中文”：

　　方法是找到 server.xml 中的

    <Connector port="8080" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
    enableLookups="false" redirectPort="8443" acceptCount="100"
    connectionTimeout="20000" disableUploadTimeout="true" URIEncoding='GBK' />

　　标记，粗体字是我添加的。

　　可以这样验证你的更改是否成功：在更改前，在你出现乱码的页面的IE浏览器，点击菜单“查看｜编码”，会发现“西欧(ISO)”处于选中状态。而更改后，点击菜单“查看｜编码”，会发现“简体中文(GB2312)”处于选中状态。

　　b)更该 Java 程序，我的程序是这样的：

public class ThreeParams extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
      response.setContentType("text/html; charset=GBK");
      ...
  } 
}

　　粗体字是必需要有的，它的作用是让浏览器把Unicode字符转换为GBK字符。这样页面的内容和浏览器的显示模式都设成了GBK，就不会乱码了。

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;

import javax.activation.DataHandler;

import org.apache.axis.attachments.ManagedMemoryDataSource;
import org.apache.axis.types.URI;
import org.apache.struts.upload.FormFile;

import cn.com.chinatelecom.www.schema.ctcc.common.v2_1.SimpleReference;
import cn.com.chinatelecom.www.schema.ctcc.multimedia_messaging.v2_2.MessagePriority;
import cn.com.chinatelecom.www.wsdl.ctcc.multimedia_messaging.send.v2_2._interface.SendMessage;
import cn.com.chinatelecom.www.wsdl.ctcc.multimedia_messaging.send.v2_2.service.SendMessageServiceLocator;

import com.telecom.dao.DBLinker;
import com.telecom.util.AttachPart;
import com.telecom.util.Sequence;

public class MMS_send {
 public MMS_send() {

 }

 private AttachPart attachmentParts[];

 private static SimpleReference _receipt_request;

   public void saveMmsMessage(String filepath, AttachPart[] ap,String mmsRoad) {
  for (int i = 0; i < ap.length; i++) {
   AttachPart part = ap[i];
   try {
    String s=saveAttachmentMessage(part.getContent().getInputStream(), part
      .getContentType(), mmsRoad, filepath);
    System.out.println("last s:"+s);

   } catch (Exception e) {

    e.printStackTrace();

   }
  }

 }

 public String saveAttachmentMessage(InputStream in, String contentType,
   String fileName, String folderPath) throws Exception {
  System.out.println("FileName: "+fileName);
  // 打开多媒体库
  File file = new File(folderPath + "/mmsImage");
  // 如果媒体库不存在则建设多媒体库
  if (!file.exists()) {
   file.mkdirs();
  }
  // 将图片存放到多媒体库,并保存其信息到数据库
  String filePath = file.getAbsolutePath();

  BufferedInputStream bin = null;
  OutputStream os = null;

  try {
   bin = new BufferedInputStream(in);
   file = new File(filePath + "/" + fileName);
   if (!file.exists()) {
    file.createNewFile();
   }
   os = new FileOutputStream(file);
   byte[] bytes = new byte[1];
   int beginIndex = 0;
   int endIndex = beginIndex + 1;
   while (true) {
    int _read = bin.read(bytes, beginIndex, endIndex);
    if (_read == -1) {
     break;
    }
    os.write(bytes);
   }
   String contextPathFileName = "mmsImage/" + fileName;
   bin.close();
   in.close();
   os.close();
   return contextPathFileName;
  } catch (IOException e) {
   e.printStackTrace();
   throw new Exception();
  } catch (Exception e) {
   e.printStackTrace();
   throw new Exception();
  } finally {
   try {
    bin.close();
    in.close();
    os.close();
   } catch (IOException e) {
    throw new Exception();
   }

  }
 }

 public AttachPart buildEMAttachmentPartFromFile(FormFile mmsFile) {
  AttachPart attchmentPart = new AttachPart();
  try {
   InputStream in = mmsFile.getInputStream();
   String contentType = mmsFile.getContentType();
   if ("image/pjpeg".equals(contentType))
    contentType = "image/jpeg";
   ManagedMemoryDataSource source = new ManagedMemoryDataSource(
     mmsFile.getInputStream(), 16384, contentType, true);
   attchmentPart.setContent(source);
   attchmentPart.setContentType(mmsFile.getContentType());
   String fileName = mmsFile.getFileName();
   String suffix = fileName.substring(fileName.indexOf('.'));
   attchmentPart.setFileName(Sequence.getID("") + suffix);
  } catch (FileNotFoundException e) {
   e.printStackTrace();
  } catch (IOException e) {
   e.printStackTrace();
  }
  return attchmentPart;
 }

 public static void main(String[] args) {
  Sag_sms s = new Sag_sms();
  try {
   s.sendSmsBySAG("13977770119", "法律", "1004");
  } catch (Exception ex) {
   ex.printStackTrace();
  } finally {
  }

 }

}

<%
 EnterpriseNumForm enf = new EnterpriseNumForm();
 Connection conn = null;
 ResultSet rs = null;
 ResultSet rs2 = null;
 Statement sta = null;
 Statement sta2 = null;
 try {
  conn = (Connection) DBLinker.linkDB();
  String sql1 = "select distinct(strEnID) eid from tbEnterpriseNum";
  rs = null;
  sta = conn.createStatement();
  rs = sta.executeQuery(sql1);
  if (rs.next()) {
   enf.setEnID(rs.getString("eid"));
  }else{
  enf.setEnID("0000");
  }

  String sql2 = "select distinct(strPresentNum) pn from tbEnterpriseNum ";
  rs2 = null;
  sta2 = conn.createStatement();
  rs2 = sta2.executeQuery(sql2);
  Vector v = new Vector();
  
  while (rs2.next()) {
   v.add(rs2.getString("PN"));
  }
  String[] s=new String[v.size()];
  for(int i=0;i<v.size();i++){
  s[i]=v.elementAt(i).toString();
  }
  enf.setNums(s);
  System.out.println(v.size());
  //session.setAttribute("enf",enf);
 } catch (Exception e) {
 } finally {
  rs2.close();
  rs.close();
  sta.close();
  sta2.close();
  conn.close();
 }
%>

<html>
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
  <link rel="stylesheet" type="text/css" href="../include/style.css">
  <title>详细信息</title>
  <script language="javascript">

function checkNum(){
    selectAllMember(form1.nums);
    form1.submit();
   
  }
function selectAllMember(selection)
  {
   var ops=selection.options;
   for(var i=0;i<ops.length;i++)
   {
    ops[i].selected=true;
   }
  }
function deleteSelectedMember(selection)
  {
   var ops=selection.options;
   for(var i=0;i<ops.length;i++)
   {
    if(ops[i].selected==true)
    {
     selection.remove(i);
     i--;
    }
   }
  }
function other_add(){
        if(form1.otherNum.value==""){
  alert("不能为空");
  }else{
  additemNoRepeat(form1.otherNum.value,form1.otherNum.value,form1.nums);
  }
 
}

function additemNoRepeat(Otext,Ovalue,selectElement){//不重复的添加
 for(j=0;j<selectElement.options.length;j++){
  if(selectElement.options[j].value==Ovalue){
   var flag=1;
   alert(Otext+"已添加");
   break;
  }
 }
 if(flag!=1){
  selectElement.options[selectElement.options.length]=new Option(Otext,Ovalue);
 }
}
  
 

</script>
  <style type="text/css">
<!--
.style3 {FONT-WEIGHT: bold; FONT-SIZE: 14px; COLOR: #246bad; LINE-HEIGHT: 2 }
body {
 background-color: #E7F0FA;
}
-->
</style>
<meta http-equiv="pragma" content="no-cache">

<%response.setHeader("Pragma","No-cache"); 
        response.setHeader("Cache-Control","no-cache"); 
        response.addHeader("Expires","Thu, 01 Jan 1970 00:00:01 GMT"); 
        response.flushBuffer();%>

 </head>

 <body opener.location.reload()">

  <table width="100%">
   <tr>
    <td bgcolor="#ffffff">
     <table width="530" border="0" cellpadding="0" cellspacing="0"
      style="word-break:break-all; ">
      <tr>
       <td width="60" background="../linkman/images/s22.jpg">
        &nbsp;
       </td>
       <td width="447" background="../linkman/images/s23.jpg">
        &nbsp;
        <span class="style3">修改企业号码和主叫绑定号码</span>
       </td>
       <td width="6">
        <img src="../linkman/images/s24.jpg" width="6" height="58">
       </td>
       <td width="17"></td>
      </tr>

      <tr>
       <td colspan="4">
        <table width="100%" border="0" cellpadding="0" cellspacing="0">
         <tr>
          <td width="17">
           &nbsp;
          </td>
          <td bgcolor="#e7f0fa">
           <table width="94%" border="0" align="center" cellpadding="0"
            cellspacing="0">
            <form name="form1" method="post"
             action="../companyadmin/EditENF.do?method=SaveENF" >
            <tr>
             <td width="17%" height="25">
              企业号码：
             </td>
             <td width="100%" height="25">
             
              <input name="enID" type="text" id="enID"
               value="<%=enf.getEnID()%>">
             </td>
            </tr>
            <tr>
             <td width="17%" height="25">
              主叫绑定号码：
             </td>
             <td>
              <select name="nums" size="20" multiple id="nums"
               style="width:64%">
               <%
                String[] v = enf.getNums();
                System.out.println(v.length);
                if (v.length != 0) {

                 for (int k = 0; k < v.length; k++) {
                  String oldpn = new String();
                  oldpn = v[k];
                  System.out.println(oldpn);
               %>
               <option value="<%=oldpn%>">
                <%=oldpn%>
               </option>
               <%
                }
                }
               %>
              </select>

               <input type="button" name="Submit" value="删除号码"
               onClick="deleteSelectedMember(document.all.nums)">

             </td>
            </tr>
            <tr>
             <td height="30" scope="col">
              请输入号码:
             </td>
             <td>
              <input  type="text" id="otherNum">
              &nbsp;
              <input type="button" name="Submit" value="添加"
               onClick="other_add()">

             </td>
            </tr>

            </form>
           </table>
          </td>
          <td width="17">
           &nbsp;
          </td>
         </tr>
        </table>
       </td>
      </tr>

      <tr>
       <td height="30" colspan="4">
        <div align="center">
         <a href="javascript:checkNum();">保存设置</a>

        </div>
       </td>
      </tr>
     </table>
    </td>
   </tr>
  </table>

 </body>
</html>

1． 安装 axis ：将 axis 发布包（ webapps\axis ）复制到服务器部署的目录下 D:\Tomcat 5.0\webapps ，启动 tomcat ，访问 http://192.168.0.51:7070/axis/ ， axis 安装完成

2 . 添加必要的类包：将生成 webservice 所需的 jar 包拷贝至（ D:\Tomcat 5.0\webapps\axis\WEB-INF\lib ）目录下，并将类和配置文件等拷贝至 D:\Tomcat 5.0\webapps\axis\WEB-INF\classes 下

3. 设置部署环境变量 someclasspath ， someclasspath 中设置的是部署 webservice 过程中所需用到的 jar 包，它包含了 axis 下所有的类包和 tomcat 下的，具体为

D:\Tomcat5.0\webapps\axis\WEB-INF\lib\axis.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\axis-ant.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\commons-discovery.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\commons-logging.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\jaxrpc.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\log4j-1.2.8.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\saaj.jar;D:\Tomcat 5.0\webapps\axis\WEB-INF\lib\wsdl4j.jar;

4 ．设置部署 webservice 的部署文件 ( deploy.wsdd ) ，具体设置如下。将 deploy.wsdd文件放在c:\目录下

<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">

    <service name="SMS" provider="java:RPC">

        <!-- 指出要发布成web service的类 -->

        <parameter name="className" value="com.beyondbit.sms.port.SMSPort "/>

        <!-- 允许所有public方法可被调用 -->

        <parameter name="allowedMethods" value="*"/>     

    </service>

   </deployment>

在dos环境下运行部署命令，部署webservice

命令：

java -cp "%someclasspath%" org.apache.axis.client.AdminClient –p 7070 deploy.wsdd

发布成功，此时可通过 http://192.168.0.51:7070/axis/servlet/AxisServlet地址看到名字为sms的webservice已部署成功 (或者不用通过wsdd文件,直接去写server-config.wsdd.在相应区域添加例如下面的内容:
    <service name="TestWS" provider="java:RPC">
  <parameter name="allowedMethods" value="*"/>
   <parameter name="className" value="com.telecom.notify.DefaultSmsNotify"/>
 </service>
)

可通过点击webservice名字旁的描述文件链接，察看webservice的描述文件

5．在客户端生成调用webservice的java文件,命令如下java -cp "%someclasspath%" org.apache.axis.wsdl.WSDL2Java -p <测试用例包>  -t<url地址>

在dos环境下输入命令

java -cp "%someclasspath%" org.apache.axis.wsdl.WSDL2Java -p com.smsCase  -t http://192.168.0.51:7070/axis/services/sms?wsdl

系统执行该命令后会在c:\目录下生成com\smsCase文件夹，其中包含生成的类。利用ant等工具编译这些文件（编译过程中需要用到someclasspath中的jar包）。可通过以下例程调用webservice,

public String parseXml()

    {

        String xmlString = "";

        try

        {

            SMSPortServiceLocator service = new SMSPortServiceLocator();

            SMSServiceSoapBindingStub binding = (SMSServiceSoapBindingStub)new SMSPortServiceLocator().getSMSService();       

            binding = (SMSServiceSoapBindingStub)service.getSMSService();

            xmlString  = binding.toReceiveMsg("000","1234");

        }

        catch(Exception e)

        {

            e.printStackTrace();

        }

        return xmlString;

    }

此中调用webservice中的sms中的toReceiveMsg方法。

6．卸载weservice，设置卸载部署文件 undeploy.wsdd， 将 undeploy.wsdd文件放在c:\目录下

<undeployment xmlns="http://xml.apache.org/axis/wsdd/">

 <service name="sms"/>

</undeployment>

在dos环境下运行卸载webservice命令，卸载webservice

命令：

java -cp "%someclasspath%" org.apache.axis.client.AdminClient –p 7070 undeploy.wsdd

Pass.error.a=\u65e7\u5bc6\u7801\u4e0d\u5bf9
Pass.error.b=\u5bc6\u7801\u4e0d\u5339\u914d

2.将b放到src下,后缀为properties.在config文件配置其<message-resources parameter="b" null="false"/>

3.使用
   if (oldpass.equals("") || newpass.equals("")|| conpass.equals("")) {
   errors.add("fail_1", new ActionError("All.error.a"));
   saveErrors(request, errors);
   return mapping.findForward("fail");

4.打完收工，Easy~

时间：2006-07-26 作者：axman 浏览次数： 2070 本文关键字：java, equal, 基础

文章工具  推荐给朋友  打印文章

　　equals方法的重要性毋须多言,只要你想比较的两个对象不愿是同一对象,你就应该实现equals方法,让对象用你认为相等的条件来进行比较。

　　下面的内容只是API的规范,没有什么太高深的意义,但我之所以最先把它列在这儿,是因为这些规范在事实中并不是真正能保证得到实现。

1. 对于任何引用类型, o.equals(o) == true成立。
2. 如果 o.equals(o1) == true 成立,那么o1.equals(o)==true也一定要成立。
3. 如果 o.equals(o1) == true 成立且  o.equals(o2) == true 成立,那么o1.equals(o2) == true 也成立。
4. 如果第一次调用o.equals(o1) == true成立再o和o1没有改变的情况下以后的任何次调用都成立。
5. o.equals(null) == true 任何时间都不成立。

　　以上几条规则并不是最完整的表述,详细的请参见API文档。

　　对于Object类,它提供了一个最最严密的实现,那就是只有是同一对象是,equals方法才返回true,也就是人们常说的引用比较而不是值比较。这个实现严密得已经没有什么实际的意义,所以在具体子类(相对于Object来说)中,如果我们要进行对象的值比较,就必须实现自己的equals方法。

　　先来看一下以下这段程序:

    public boolean equals(Object obj)
    {
        if (obj == null) return false;
        if (!(obj instanceof FieldPosition))
            return false;
        FieldPosition other = (FieldPosition) obj;
        if (attribute == null) {
            if (other.attribute != null) {
                return false;
            }
        }
        else if (!attribute.equals(other.attribute)) {
            return false;
        }
        return (beginIndex == other.beginIndex
            && endIndex == other.endIndex
            && field == other.field);
    }

　　这是JDK中java.text.FieldPosition的标准实现,似乎没有什么可说的. 我相信大多数或绝大多数程序员认为,这是正确的合法的equals实现.毕竟它是JDK的API实现啊. 还是让我们以事实来说话吧:

package debug;
import java.text.*;
public class Test {
  public static void main(String[] args) {
    FieldPosition fp = new FieldPosition(10);
    FieldPosition fp1 = new MyTest(10);
    System.out.println(fp.equals(fp1));
    System.out.println(fp1.equals(fp));
  }
}
class MyTest extends FieldPosition{
  int x = 10;
  public MyTest(int x){
    super(x);
    this.x = x;
  }
  public boolean equals(Object o){
    if(o==null) return false;
    if(!(o instanceof MyTest )) return false;
    return ((MyTest)o).x == this.x;
  }
}

　　 运行一下看看会打印出什么:

System.out.println(fp.equals(fp1));打印true
System.out.println(fp1.equals(fp));打印flase

　　两个对象,出现了不对称的equals算法.问题出在哪里(脑筋急转弯：当然出在JDK实现的BUG)?

　　我相信有太多的程序员(除了那些根本不知道实现equals方法的程序员外)在实现equals方法时都用过instanceof运行符来进行短路优化的，实事求是地说很长一段时间我也这么用过。太多的教程，文档都给了我们这样的误导。而有些稍有了解的程序员可能知道这样的优化可能有些不对但找不出问题的关键。另外一种极端是知道这个技术缺陷的骨灰级专家就提议不要这样应用。

　　我们知道，"通常"要对两个对象进行比较，那么它们"应该"是同一类型。所以首先利用nstanceof运行符进行短路优化，如果被比较的对象不和当前对象是同一类型则不用比较返回false,但事实上，"子类是父类的一个实例"，所以如果 子类 o instanceof 父类，始终返回true,这时肯定不会发生短路优化，下面的比较有可能出现多种情况，一种是不能造型成子类而抛出异常，另一种是父类的private 成员没有被子类继承而不能进行比较，还有就是形成上面这种不对称比较。可能会出现太多的情况。

　　那么，是不是就不能用 instanceof运行符来进行优化？答案是否定的，JDK中仍然有很多实现是正确的，如果一个class是final的，明知它不可能有子类，为什么不用 instanceof来优化呢？

　　为了维护SUN的开发小组的声誉，我不说明哪个类中，但有一个小组成员在用这个方法优化时在后加加上了加上了这样的注释：

 if (this == obj)             // quick check
         return true;
      if (!(obj instanceof XXXXClass))  // (1) same object?
         return false;

　　可能是有些疑问，但不知道如何做（不知道为什么没有打电话给我......）

　　那么对于非final类，如何进行类型的quick check呢？

class Human{
 private String name;
 private int ago;
 private String sex;
        ....................
        public boolean equals(Object obj){
  quick check.......
  Human other = (Human)ojb;
  return this.name.equals(other.name) 
   && this.ago == ohter.ago
   && this.sex.equals(other.sex);
 }
}

 public boolean equals(Object obj){
  quick check.......
  Class c = this.getClass();
  Filed[] fds = c.getDeclaredFields();
  for(Filed f:fds){
   if(!f.get(this).equals(f.get(obj)))
    return false;
  }
  return true;
 }

public final class PhoneNumber {
    private final int areaCode;
    private final int exchange;
    private final int extension;
    public PhoneNumber(int areaCode, int exchange, int extension) {
        rangeCheck(areaCode, 999, "area code");
        rangeCheck(exchange, 99999999, "exchange");
        rangeCheck(extension, 9999, "extension");
        this.areaCode = areaCode;
        this.exchange = exchange;
        this.extension = extension;
    }
    private static void rangeCheck(int arg, int max, String name) {
        if(arg < 0 || arg > max)
            throw new IllegalArgumentException(name + ": " + arg);
    }
    public boolean equals(Object o) {
        if(o == this)
            return true;
        if(!(o instanceof PhoneNumber))
            return false;
        PhoneNumber pn = (PhoneNumber)o;
        return pn.extension == extension && pn.exchange == exchange && pn.areaCode == areaCode;
    }
}

    public static void main(String[] args) {
        Map hm = new HashMap();
        PhoneNumber pn = new PhoneNumber(123, 38942, 230);
        hm.put(pn, "I love you");
        PhoneNumber pn1 = new PhoneNumber(123, 38942, 230);
        System.out.println(pn);
        System.out.println("pn.equals(pn1) is " + pn.equals(pn1));
        System.out.println(hm.get(pn1));
        System.out.println(hm.get(pn));
    }

        SWT 在外观和性能上都超过了 awt/swing ，为什么这样说呢？下面简单的测试程序会让你一目了然。废话也不多说，让我们看程序。

    下面让我们写一个简单的程序来测试一下，程序只做一件事，就是用 Label 显示 ”Hello World!” ，我的测试环境是 JDK1.5.0+Eclipse3.1 。看看在 AWT 、 SWING 和 SWT 下分别实现该效果所需要的时间和内存消耗。

AWT_CODE:

import java.awt.Frame;

import java.awt.Label;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

public class awtTest {

       public static void main(String[] args) {

              long memory = 0L;

              long time = 0L;

              memory = Runtime.getRuntime().freeMemory();

              time = System.currentTimeMillis();

              Frame frame = new Frame();

              Label label = new Label();

              label.setText("Hello World!");

              frame.add(label);

              frame.setVisible(true);

              frame.addWindowListener(new WindowAdapter() {

                     public void windowClosing(WindowEvent we) {

                            System.exit(0);

                     }

              });

              frame.pack();

              System.out.println(System.currentTimeMillis() - time);

              System.out.println(memory - Runtime.getRuntime().freeMemory());

       }

}

运行效果及所用的时间和内存值：

SWING_CODE:

import javax.swing.JFrame;

import javax.swing.JLabel;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

public class swingTest {

       public static void main(String[] args) {

              long memory = 0L;

              long time = 0L;

              memory = Runtime.getRuntime().freeMemory();

              time = System.currentTimeMillis();

              JFrame frame = new JFrame();

              JLabel label = new JLabel();

              label.setText("Hello World!");

              frame.add(label);

              frame.setVisible(true);

              frame.addWindowListener(new WindowAdapter() {

                     public void windowClosing(WindowEvent we) {

                            System.exit(0);

                     }

              });

              frame.pack();

              System.out.print("Time:");

              System.out.println(System.currentTimeMillis() - time);

              System.out.print("Memory:");

              System.out.println(memory - Runtime.getRuntime().freeMemory());

       }

}

运行效果及所用的时间和内存值：

SWT_CODE:

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.SWT;

public class swtTest {

       public static void main(String[] args) {

              long memory = 0L;

              long time = 0L;

              memory = Runtime.getRuntime().freeMemory();

              time = System.currentTimeMillis();

              Display display = new Display();

              Shell shell = new Shell(display);

              Label label = new Label(shell, SWT.NONE);

              label.setText("Hello World!");

              shell.pack();

              label.pack();

              shell.open();

              System.out.print("Time:");

              System.out.println(System.currentTimeMillis() - time);

              System.out.print("Memory:");

              System.out.println(Runtime.getRuntime().freeMemory() - memory);

              while(!shell.isDisposed()) {

                     if(!display.readAndDispatch()) {

                            display.sleep();

                     }

              }

              display.dispose();

              label.dispose();

       }

}

运行效果及所用的时间和内存值：

如果你仔细看代码，你会发现在 SWT 的代码中，我注解为 ’***’ 代码处，与前两者有所不同，这也我疑惑的地方，在整个程序运行中，运行后的剩余内存居然比运行前的剩余内存值大。接着，我在调试该程序的时候，我发现在 Shell shell = new Shell(display) 语句执行后，内存值有明显的增加，如果你知道 SWT 底层是如何操作的，知道这是什么原因引起的，请你 联系我 并告诉我这是为什么，我好做出修正。

如果你是初学者，不知道怎么运行 SWT 程序，其实很简单的，只需要在你的工程的 Libraries 添加一个名为 org.eclipse.swt.win32.win32.x86_3.1.0.jar 包，该包的位置在你的 Eclipse 的安装目录下的 \plugins\ 文件夹里。

       "D:\\Program Files\\Microsoft Office\\Office10\\powerpnt.exe /s 1.pps");
   // "C:\\WINDOWS\\system32\\rundll32.exe jpg.jpg");

  } catch (Exception e) {
   e.printStackTrace();
  }

 }
}

第 1 步，安装 ADF 运行时库

此步骤与将运行时库安装到 OC4J 的步骤类似。在运行安装程序时请确保服务器处于停止状态。

第 2 步，创建与应用服务器的连接

按照前面所述创建一个新连接。您无法测试此连接。

第 3 步，创建部署描述文件

您唯一需要的描述文件就是 web.xml，它由 JDeveloper10g 在创建 web 页面时生成。

第 4 步，为每一层创建部署配置文件

编辑 web 客户端的部署配置文件。确保将目标连接设置为您在第 2 步中创建的 tomcat 连接。输入正确的 war 文件名。在 Tomcat 中，上下文根基于 web 应用程序的文件夹名称。

第 5 步，创建一个全局部署配置文件（仅限三层应用程序）

跳过此步骤。

第 6 步，部署应用程序

右键单击“webapp.deploy”。

选择“deploy to tomcat”

第 7 步，测试应用程序

通过在浏览器中键入 http://localhost:8080/[warfilename]/departments.jsp，测试应用程序的部署。

       javac –d . *.java

2：在%APP_HOME%/webapp/WEB-INF目录下创建server-config.wsdd（AXIS配置文件，所有web服务都要在该文件中注册）文件。形如：

<?xml version="1.0" encoding="UTF-8"?>
<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
          <globalConfiguration> 
                    <parameter name="adminPassword" value="admin"/> 
                    <parameter name="attachments.implementation" value="org.apache.axis.attachments.AttachmentsImpl"/> 
                    <parameter name="sendXsiTypes" value="true"/> 
                    <parameter name="sendMultiRefs" value="true"/> 
                    <parameter name="sendXMLDeclaration" value="true"/> 
                    <parameter name="axis.sendMinimizedElements" value="true"/> 
                    <requestFlow>  
                               <handler type="java:org.apache.axis.handlers.JWSHandler">   
                                         <parameter name="scope" value="session"/>  
                               </handler>  
                               <handler type="java:org.apache.axis.handlers.JWSHandler">   
                                         <parameter name="scope" value="request"/>   
                                         <parameter name="extension" value=".jwr"/>  
                               </handler> 
                    </requestFlow>
          </globalConfiguration>
          <handler name="LocalResponder" type="java:org.apache.axis.transport.local.LocalResponder"/>
          <handler name="URLMapper" type="java:org.apache.axis.handlers.http.URLMapper"/>
          <handler name="Authenticate" type="java:org.apache.axis.handlers.SimpleAuthenticationHandler"/>  
 
          <service name="login" provider="java:RPC"> 
                    <!-- 服务类名 -->    
                    <parameter name="className" value="com.test.service.loginService"/> 
                    <!-- 允许访问所有方法 --> 
                    <parameter name="allowedMethods" value="*"/>
          </service> 
          <transport name="http"> 
                    <requestFlow>  
                               <handler type="URLMapper"/>  
                               <handler type="java:org.apache.axis.handlers.http.HTTPAuthHandler"/> 
                    </requestFlow>
          </transport>
          <transport name="local"> 
                    <responseFlow>  
                               <handler type="LocalResponder"/> 
                    </responseFlow>
          </transport>
</deployment>

注：server-config.wsdd文件也可以通过编写deploy.wsdd文件生成，具体方法为，在%APP_HOME%/webapp/WEB-INF目录下创建deploy.wsdd文件（SOAP发布描述文件），形如：

<deployment xmlns="http://xml.apache.org/axis/wsdd/" xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
    <service name="login" provider="java:RPC">
        <parameter name="className" value="LoginService"/>
        <parameter name="allowedMethods" value="*"/>
    </service>
</deployment>
然后将相应服务器端class编译后在命令行输入：

java -cp %AXISCLASSPATH% org.apache.axis.client.AdminClient deploy.wsdd
将在当前目录下生成server-config.wsdd文件。

完成以上操作后，可在浏览器中通过http://localhost:8080/axis/services/login?wsdl 访问该服务。
 

3：JAVA客户端实现：

可以通过AXIS中的org.apache.axis.wsdl.WSDL2Java类将已发布的web服务进行客户端实例化，具体命令为：在%APP_HOME%/webapp/WEB-INF目录下命令行输入：

Java -Djava.ext.dirs=lib org.apache.axis.wsdl.WSDL2Java url[YiWang1]

命令执行后会在本地当前目录下生成以url为模版的package目录层次结构(如：local.axis.service.*),该目录中针对每个服务器端接口会自动生成4个本地类。

其中：

       inferface LoginService在客户端本地定义服务器接口的映射。

       interface LoginServiceService定义了用于获得web服务的getter方法。

       class LoginServiceServiceLocator具体实现LoginServiceService接口，保存了服务器的url等相关信息。

       class LoginSoapBindingStub 具体实现LoginService，负责服务器交互。

（部署了web服务之后，如果接口不变而url发生改变，可以直接在客户端更新LoginServiceServiceLocator中有关服务器地址的相关信息，或者用配置文件的形式修改）

编译以上几个类时需要axis.jar，jaxrpc.jar两个包，命令为：

  javac -classpath lib\axis.jar;lib\jaxrpc.jar –d . *.java
编译成class后可以通过jar命令打包作为接口部署在客户端。

客户端测试例程：

       如果通过java应用程序形式进行测试，命令为：

        java -Djava.ext.dirs=lib -cp . package.class

--------------------------------------------------------------------------------

 [YiWang1]服务器通过Wsdl形式发布的web服务的完整url地址。