<security-constraint>
		<web-resource-collection>
			<web-resource-name>资源名称</web-resource-name>
			<url-pattern>/*</url-pattern>
		</web-resource-collection>
		<auth-constraint>
			<role-name>tomcat用户角色名</role-name>
		</auth-constraint>
	</security-constraint>
	<!-- BASIC 基本安全方式 -->
	<login-config>
		<auth-method>BASIC</auth-method>
		<realm-name>登陆欢迎语</realm-name>
	</login-config>

public String string2Json(String s) {         
	        StringBuffer sb = new StringBuffer();         
	        for (int i=0; i<s.length(); i++) {   
	            char c = s.charAt(i);     
	             switch (c){   
	             case '\"':         
	                 sb.append("\\\"");         
	                 break;         
	             case '\\':         
	                 sb.append("\\\\");         
	                 break;         
	             case '/':         
	                 sb.append("\\/");         
	                 break;         
	             case '\b':         
	                 sb.append("\\b");         
	                 break;         
	             case '\f':         
	                 sb.append("\\f");         
	                 break;         
	             case '\n':         
	                 sb.append("\\n");         
	                 break;         
	             case '\r':         
	                 sb.append("\\r");         
	                 break;         
	             case '\t':         
	                 sb.append("\\t");         
	                 break;         
	             default:         
	                 sb.append(c);      
	             }   
	         }       
	        return sb.toString();      
	        } 

public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.setContentType("application/json ");
		response.setCharacterEncoding("utf-8");
		PrintWriter out = response.getWriter();
		
		String nameValue = "an&%\\&\"$#t";
		String jsonName = "results";
		StringBuilder json = new StringBuilder();
		json.append("{\""+jsonName+"\":[");
		
		for(int i=0;i<10000;i++)
		{
			json.append("{");
			json.append("\"id\":\"1"+i+"\",\"name\":\"ant阿斯顿"+i+"\"");
			json.append("},");
		}
		json.append("{");
		json.append("\"id\":\"1\",\"name\":\""+string2Json(nameValue)+"\"");
		json.append("}");
		
		json.append("]}");
		out.write(json.toString());
	}

servlet:
package com.fit.demo.struts.servlet;

public class OVrefreshCacheServlet extends HttpServlet {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = -5306253391267755510L;
	
	/**
	 * ServletConfig:可以获得在web.xml里面配置的servlet的参数
	 */
	public void init(ServletConfig config) throws ServletException {
		long currentTime = System.currentTimeMillis();
		Long refreshTime =Long.parseLong(OVloadProperties.getInstance().getProperties("refreshTime"));
		Timer timer = new Timer();
		
		OVrefreshCache cache = new OVrefreshCache();
		
		timer.schedule(cache, currentTime, refreshTime);
	}
	
	public void destroy() {
		super.destroy(); 
	}

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

	}



package com.fit.demo.struts.util;

import java.util.TimerTask;

public class OVrefreshCache extends TimerTask {

	public void run() {
		cache();
	}
	
	public void cache()
	{
		System.out.println("refreshCache begin =========================================");
		
		System.out.println("refreshCache end =========================================");
		
	}

}

var exportForm = document.getElementById("exportExcelForm");alert(11);
  		exportForm.action="<%=path%>/upload.do?method=exportExcel";alert(exportForm.action);
  		exportForm.method="post";
  		exportForm.target="_Self";alert(22);
  		exportForm.submit();

1.ActionForm：
public class UploadFileForm extends ActionForm {
	private transient FormFile inputFile;

	public FormFile getInputFile() {
		return inputFile;
	}

	public void setInputFile(FormFile inputFile) {
		this.inputFile = inputFile;
	}
}
2.jsp：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean"%>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP 'index.jsp' starting page</title>
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
  </head>
  <script type="text/javascript">
  	function exportExcel()
  	{
  		var exportForm = document.getElementById("exportExcelForm");alert(11);
  		exportForm.action="<%=path%>/upload.do?method=exportExcel";alert(exportForm.action);
  		exportForm.method="post";
  		exportForm.target="_Self";alert(22);
  		exportForm.submit();
  	}
  	
  	function redirectForward()
  	{
  		window.open();
  	}
  </script>
  
  <body>
    this is my test pages!<br/>111111111111111111111
    <form action="<%=request.getContextPath()%>/login.do?method=loginToEcare" method = "post">
      <table align="center" border = "2">
      	<tr>
      		<td><bean:message key = "login.userName"/></td>
      		<td>
      			<input type = "text" id = "userName" name = "userName" />
      		</td>
      	</tr>
      	<tr>
      		<td>"<bean:message key = "login.password"/></td>
      		<td>
      			<input type = "password" id = "password" name = "password" />
      		</td>
      	</tr>
      	<tr><td colspan="2" align="center">
      		<input type = "submit" id = "login" name = "login" value = "login"/>
      	</td></tr>
      </table>
    </form>
    <hr/>
    <html:form action="/upload.do?method=uploadData" method="post" enctype="multipart/form-data"> 
    	<table>
    		<tr><td>file upload:(enctype="multipart/form-data":entype:表单HTTP方法的编码类型)</td></tr>
    		<tr><td>
    			<html:file property="inputFile"></html:file>
    			<html:submit value="submit"></html:submit>
    		</td></tr>
    	</table>
    </html:form>
    <br/>
    <a href="<%=path%>/upload.do?method=downLoadData">downLoad</a>
    
    <form action="" id="exportExcelForm">
    	<input type="button" value="Export" onclick="exportExcel()" />
    </form>
    
    
    <a href="<%=path%>/loginjsp/loginSuccess.jsp" onclick="redirectForward()">testForward</a>
    
    <hr/>
    <table border="0" style="width: 60%">
    	<tr>
    		<td>
    			<span style="background-color: red;width: 50%;border-color: black;border: 1px;"><a style="text-decoration: " href="#">123</a></span>
    		</td>
    		<td>
    			<span style="">123</span>
    		</td>
    		<td>
    			<span style="">123</span>
    		</td>
    	</tr>
    	<u>
    	<tr style="padding-bottom: 0px;margin-bottom: 0px;text-decoration: underline">
    		<td style="width: 20%">
    			<span style="width: 100%">123      </span>
    		</td>
    		<td>
    			<span style="">123</span>
    		</td>
    		<td>
   				<span style="">123</span>
   			</td>
    	</tr>
    	</u>
    	<tr style="height: 2px;border-bottom-color: red;border-bottom: 1px;padding-top: 0px;margin-top: 0px">
    		<td colspan="3" style="height: 1px;padding-top: 0px;margin-top: 0px">
    			<hr style="color: red;"/>
    		</td>
    	</tr>
    	<tr>
    		<td>
    			<span style="">123</span>
    		</td>
    		<td>
    			<span style="">123</span>
    		</td>
    		<td>
   				<span style="">123</span>
   			</td>
    	</tr>
    </table>
    <a>asdaaaaaaaaaaaaa</a>
  </body>
</html>
3.Java代码：
package com.fit.demo.struts.upload;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import jxl.Workbook;
import jxl.format.UnderlineStyle;
import jxl.write.WritableCellFormat;
import jxl.write.WritableFont;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;
import jxl.write.WriteException;
import jxl.write.biff.RowsExceededException;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;

public class UploadFileAction extends DispatchAction {
	
	/**
	 * 上传到文件
	 * @return
	 */
	public ActionForward init(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		UploadFileForm formFile = (UploadFileForm)form; 
		String fileName = formFile.getInputFile().getFileName();
		//获得服务器的绝对路径
		File newFile = new File("d:\\upload\\1.txt");
		FileOutputStream out = null; 
		try {
			out = new FileOutputStream(newFile);
			out.write(formFile.getInputFile().getFileData());
		} catch (Exception e) {
			e.printStackTrace();
		}finally
		{
			if(out!=null)
			{
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return mapping.findForward("success");
	}
	/**
	 * 获得上传文件的内容
	 * @param mapping
	 */
	public ActionForward uploadData(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) {
		UploadFileForm formFile = (UploadFileForm)form; 
		String fileName = formFile.getInputFile().getFileName();
		InputStreamReader inreader = null;
		BufferedReader reader=null;
		try {
			inreader = new InputStreamReader(formFile.getInputFile().getInputStream());
			reader = new BufferedReader(inreader);
			String str = null;
			int i=0;
			while((str = reader.readLine())!=null)
			{
				System.out.println(fileName+"--第"+i+"行:"+str);
				i++;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally
		{
			if(inreader!=null)
			{
				try {
					inreader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			
			if(reader!=null)
			{
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return mapping.findForward("success");
	}
	
	/**
	 * 文件下载
	 * @return
	 */
	public ActionForward downLoadData(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) 
	{
		String path="d:\\upload\\1.txt";
		//从服务器上获取绝对路径的方法
		//String realPath = servlet.getServletContext().getContextPath();
		File serviceFile = new File(path);
		FileReader freader =null;
		BufferedReader read = null;
		
		OutputStream out = null;
		try {
			freader = new FileReader(serviceFile);
			read = new BufferedReader(freader);
			 response.reset();   
			out = response.getOutputStream();
			
			//response.setContentType("text/plain,charset=UTF-8");
			response.setHeader("Content-disposition",
                    "attachment;filename=" + URLEncoder.encode(path, "utf-8"));
			String str=null;
			while((str=read.readLine())!=null)
			{
				out.write(str.getBytes());
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally
		{
			try {
				freader.close();
				read.close();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}
	
	/**
	 * 文件导出EXCEL
	 * java.lang.UnsupportedClassVersionError: Bad version number in .class file异常，检查了一下我的myEclipse，发现不知道啥时候不小心将编译器
	 * 改成JDK6.0了，那个工程是从同事的机上拷贝过来的，用的编译器是JDK5.0
	 */
	public void exportExcel(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) 
	{
		try {
			request.setCharacterEncoding("UTF-8");
			response.setContentType("text/html;charset=UTF-8");
			response.setHeader("Content-disposition","attachment;filename=exportExcel.xls");
			OutputStream out = response.getOutputStream();
			
			String[][] excelNum = {{"id","name","description"},{"123454","123154.1","1321212312.23"},{"20101101","20101101","20101101"},{"01","test","123456"}};
			this.fileExcel(excelNum, out);
			
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public OutputStream fileExcel(String[][] excelNum,OutputStream out) 
	{
		WritableWorkbook wwb = null;
		try {
			//建立工作文件
			wwb = Workbook.createWorkbook(out);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if(wwb!=null)
		{
			//建立一个sheet，2个参数，前面是要操作的sheet名，后面是要操作的sheet号
			WritableSheet ws = wwb.createSheet("sheet1", 0);
			
			//添加字体样式
			jxl.write.WritableFont wf = new jxl.write.WritableFont(WritableFont.TIMES,18,WritableFont.BOLD,true);
//			jxl.write.WritableFont wf2 = new jxl.write.WritableFont(jxl.format.Colour.RED,UnderlineStyle.NO_UNDERLINE);
			jxl.write.WritableCellFormat wcff = new jxl.write.WritableCellFormat(wf);
			//添加format number对象
			jxl.write.NumberFormat nf = new jxl.write.NumberFormat("###,###.##");
			jxl.write.WritableCellFormat numf = new jxl.write.WritableCellFormat(nf);
			//添加日期格式化对象
			jxl.write.DateFormat df = new jxl.write.DateFormat("yyyy-MM-dd");
			jxl.write.WritableCellFormat ddf = new jxl.write.WritableCellFormat(df);
			
			int row=0;
			int excelLength = excelNum.length;
			while(row<excelLength)
			{
				int colLength = excelNum[row].length;
				for(int i=0;i<colLength;i++)
				{
					//第一个代表列数，第二个代表行数，第三个代表要输入的内容，第四个是个可选项，可输入这个lable的样式
					try 
					{
						if(row==0)
						{	//表头：第一行增加字体
							jxl.write.Label lableC = new jxl.write.Label(i,row,excelNum[row][i],wcff);
							ws.addCell(lableC);
						}else if(row==1)
						{
							jxl.write.Number number = new jxl.write.Number(i,row,Double.parseDouble(excelNum[row][i]),numf);
							ws.addCell(number);
						}
						//日期的格式化后以字符串的形式读取进去
//						else if(row==2)
//						{
//							jxl.write.DateTime datef = new jxl.write.DateTime(i,row,excelNum[row][i],ddf);
////							jxl.write.DateTime labelDTF = new jxl.write.DateTime(i, row, new java.util.Date(), ddf); 
//
//						}
						else
						{
							jxl.write.Label lableC = new jxl.write.Label(i,row,excelNum[row][i]);
							ws.addCell(lableC);
						}
					} catch (RowsExceededException e) {
						e.printStackTrace();
					} catch (WriteException e) {
						e.printStackTrace();
					}
				}
				row++;
			}
			try {
				wwb.write();
				wwb.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		return out;
	}
	
	
	public ActionForward testForward(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response) 
	{
		
		return mapping.findForward("success");
	}
	
	
	
	
}

package com.fit.demo.struts.test;

public class subStringStr {
	/**
	 * 写一个函数，2 个参数，1 个字符串，1 个字节数，返回截取的字符串，要
	求字符串中的中文不能出现乱码：如（“我ABC”，4）应该截为“我AB”，输入（“我
	ABC 汉DEF”，6）应该输出为“我ABC”而不是“我ABC+汉的半个”。
	 * @param testStr
	 * @param b
	 * @return
	 */
	public String test(String testStr,int b)
	{
		int bt = 0;
		for(int i=0;i<testStr.length();i++)
		{
			if(bt == b)
			{
				return testStr.substring(0, i);
			}
			char c = testStr.charAt(i);
			if(c<256)
			{
				bt = bt + 1;
			}else
			{
				bt = bt + 2;
				if(bt - 1 == b)
				{
					return testStr.substring(0, i);
				}
			}
		}
		
		return "";
	}

	public static void main(String[] args) {
		subStringStr t = new subStringStr();
		String s=t.test("as按时大师的asd", 6);
		System.out.println(s);
	}

}

package com.fit.demo.struts.test;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 源文件为：
 *  zhangsan
	lisi
	wangwu
	zhaoliu
 * 输出为：
 *  wangwu 3
	zhangsan 4
	lisi 4
	zhaoliu 1
 * @author Administrator
 *
 */
public class ShowAllUsers {

	public static void main(String[] args) {
		FileInputStream in = null;
		FileOutputStream out = null;
		
		try {
			in = new FileInputStream("d://2.txt");
			out = new FileOutputStream("d://3.txt");
			InputStreamReader a = new InputStreamReader(in);
			BufferedReader read = new BufferedReader(a);
			
			List resList = new ArrayList();
			Map resMap = null;
			String str = "";
			while((str = read.readLine())!=null)
			{
				if(resList != null && resList.size() > 0)
				{
					boolean flag = false;
					for(int i=0;i<resList.size();i++)
					{
						resMap = (Map) resList.get(i);
						if(str.equals(resMap.get("userName")))
						{
							String countStr = (String) resMap.get("count");
							int count = Integer.parseInt(countStr);
							resList.remove(i);
							resMap = new HashMap();
							resMap.put("userName", str);
							resMap.put("count", String.valueOf(count+1));
							resList.add(resMap);
							flag = true;
							break;
						}
					}
					if(!flag)
					{
						resMap = new HashMap();
						resMap.put("userName", str);
						resMap.put("count", String.valueOf(1));
						resList.add(resMap);
					}
				}else
				{
					resMap = new HashMap();
					resMap.put("userName", str);
					resMap.put("count", "1");
					resList.add(resMap);
				}
			}
			//输出
			String outStr = "";
			for(int j = 0; j<resList.size();j++)
			{
				resMap = (Map) resList.get(j);
				//换行符：System.getProperties("line.separator");
				outStr = (String)resMap.get("userName")+" "+(String)resMap.get("count")+"\r\n";
				out.write(outStr.getBytes());
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

package com.fit.demo.struts.test;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 * D盘的一个文件“1.txt”如下存储：
     zhangsan 0010 20101102
	 lisi 0005 20101112
	 aa 0006 20101112
   读入并输出到E盘：（按学号排序）
	aa 0006 2010-11-12
	lisi 0005 2010-11-12
    ii 0002 2010-11-12
 * @author Administrator
 *
 */
public class CopyFile {

	public static void main(String[] args) { 
		SimpleDateFormat df = new SimpleDateFormat("yyyyMMdd");
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		FileInputStream in = null;
		FileOutputStream out = null;
		try {
			in = new FileInputStream("D://1.txt");
			out = new FileOutputStream("d://copy3.txt");
			InputStreamReader a = new InputStreamReader(in);
			BufferedReader read = new BufferedReader(a);
			String str = null;
			Map resultMap = null;
			List resultList = new ArrayList();
			String[] number = null;
			String numberStr = "";
			int i = 0;
			while((str = read.readLine()) != null)
			{
				resultMap = new HashMap();
				String outString = "";
				String[] outStr = str.split(" ");
				if(outStr.length == 3)
				{
					Date joinDate = df.parse(outStr[2]);
					String joinDateString = format.format(joinDate);
					//获得换行符
					//outString = outStr[0]+" "+outStr[1]+" "+joinDateString+"\r\n";
					outString = outStr[0]+" "+outStr[1]+" "+joinDateString+System.getProperty("line.separator");
					numberStr = numberStr+outStr[1]+"#";
					resultMap.put("outKey", outStr[1]);
					resultMap.put("outValue", outString);
					resultList.add(resultMap);
				}
//				out.write(outString.getBytes());
			}
			number = numberStr.substring(0, numberStr.length()-1).split("#");
			// 数组排序
			for(int j=0;j<number.length-1;j++)
			{
				for(int k=j+1;k<number.length;k++)
				{
					if(Integer.parseInt(number[j]) < Integer.parseInt(number[k]))
					{
						String temp = number[j];
						number[j] = number[k];
						number[k] = temp;
					}
				}
			}
			//按照数组的排序输出相应的MAP 里面的内容
			for(int m=0;m<number.length;m++)
			{
				System.out.println(number[m]);
				Map outMap =null;
				for(int n=0;n<resultList.size();n++)
				{
					outMap = (Map) resultList.get(n);
					String s = "";
					if(outMap.get("outKey").equals(number[m]))
					{
					    s = (String) outMap.get("outValue");
						out.write(s.getBytes());
					}
				}
			}	
		} catch (Exception e) {
			e.printStackTrace();
		}finally
		{
			if(in != null)
			{
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(out != null)
			{
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

1.config配置文件：   
IsSSO = true
IsServer =192.168.1.1
refreshTime =30000

2.JAVA类：
package com.fit.demo.struts.util;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Properties;

public class OVloadProperties {
	
	private static HashMap<String,String> map; 
	private static OVloadProperties instance;
	
	//获取实例
	public static OVloadProperties getInstance()
	{
		if(instance == null)
		{
			map = new HashMap<String,String>();
			instance = new OVloadProperties();
			return instance;
		}
		return instance;
	}
	
	public String getProperties(String key)
	{
                   //config.properties：配置文件存放的路径
		String fileName = "config.properties";
		return getProperties(fileName,key);
	}
	
	public String getProperties(String fileName,String key)
	{
		if(!map.containsKey(key))
		{
			doget(fileName,key);
		}
		return map.get(key);
	}
	
	public void doget(String fileName,String key)
	{
		String a = loadProperties(fileName,key);
		map.put(key, a);
	}
	
	public String loadProperties(String fileName,String key)
	{
		String result =null;
		InputStream in = null;
		
		Properties pro = new Properties();
		try {
			in = OVloadProperties.class.getClassLoader().getResourceAsStream(fileName);
			if(in == null)
			{
				in = new FileInputStream(fileName);
			}
			pro.load(in);
			result = pro.getProperty(key);
		} catch (Exception e) {
			e.printStackTrace();
		}finally
		{
			if(in != null)
			{
				try {
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}
	
}

http://www.pudn.com/downloads109/sourcecode/java/detail450920.html

Axis 开发WebService
2008-01-24 10:23
       最近一直在集成基础事业部开发的一个报表工具，昨天做登录的时候，需要用到webservice 。我们部门用的是Axis2 ，而报表这边用的是Axis。 没用过一，又不想把二的报都导入到报表中， 就试了试用一。看了看文档，生成客户端代码很容易就完成了，但是发现和二生成的不一样，最后没有耐心了，也没有继续研究下去，还是用了Axis2。 

      下文是我在学习Axis的时候，看到的一个比较好的帖子，贴上来和大家分享，共同学习进步。



一、环境准备
1 、从axis网站下载相关内容：http: //apache.justdn.org/ws/axis/1_3/ 
2 、解压后，参考webapps\axis，为了使你的web应用axis开发web service，需要做的事情如下: 
     a. 将webapps\axis\WEB- INF\lib下的相关jar包拷贝到你自己web应用的lib目录下。另外需要activation.jar、 mail.jar两个支持包。
     b.修改web.xml，加载axis的servlet。
< listener> 
< listener- class > org.apache.axis.transport.http.AxisHTTPSessionListener< / listener- class > 
< / listener> 

< servlet> 
< servlet- name> AxisServlet< / servlet- name> 
< display- name> Apache- Axis Servlet< / display- name> 
< servlet- class > 
org.apache.axis.transport.http.AxisServlet
< / servlet- class > 
< / servlet> 

< servlet- mapping> 
< servlet- name> AxisServlet< / servlet- name> 
< url- pattern> / servlet/ AxisServlet< / url- pattern> 
< / servlet- mapping> 

< servlet- mapping> 
< servlet- name> AxisServlet< / servlet- name> 
< url- pattern> * .jws< / url- pattern> 
< / servlet- mapping> 

< servlet- mapping> 
< servlet- name> AxisServlet< / servlet- name> 
< url- pattern> / services/* < / url- pattern> 
< / servlet- mapping> 

二、开发service
服务器端的service为普通的java类：com.hnisi.axis.BookOrder

public class BookOrder {
public String getName(String name) {
System.out.println("start execute ..." );
return "book name: " + name;
}

public Book setPrice(Book book){
book.setPrice(10 );
return book;
}
}

com.hnisi.axis.Book为简单的值对象，包含两个属性name,price。

三、发布service
1 、手工修改server- config.wsdd文件（在已有server- config.wsdd文件的情况下）
添加service：

< service name= "BookOrder" provider= "java:RPC" > 
< parameter name= "allowedMethods" value= "*" / > 
< parameter name= "className" value= "com.hnisi.axis.BookOrder" / > 
< / service> 

allowedMethods是调用的服务的方法，如果有多个方法的话可以用空格分开,当用* 的时候表示全部。

2 、写deploy.wsdd文件，使用axis提供的AdminClient工具，自动生成server- config.wsdd。deploy.wsdd文件如下：

< deployment xmlns= "http://xml.apache.org/axis/wsdd/" 
xmlns: java= "http://xml.apache.org/axis/wsdd/providers/java" > 
< service name= "BookOrder" provider= "java:RPC" > 
< parameter name= "className" value= "com.hnisi.axis.BookOrder" / > 
< parameter name= "allowedMethods" value= "*" / > 
< / service> 
< / deployment> 

deploy.wsdd文件位于/ web- inf目录下。
使用AdminClient发布该service，在/ web- inf目录下新建deploy.bat文件: 

set LIB_HOME= ./ lib
set CPATH= .;% LIB_HOME% \axis.jar;% LIB_HOME% \jaxrpc.jar;% LIB_HOME% \commons- logging- 1 .0 .2 .jar;% LIB_HOME% \commons- discovery- 0 .2 .jar;% LIB_HOME% \saaj.jar;% LIB_HOME% \activation.jar;% LIB_HOME% \mail.jar
java - classpath % CPATH% org.apache.axis.client.AdminClient - lhttp: //localhost:8080/test/services/AdminService deploy.wsdd 
pause

执行deploy.bat，会生成server- config.wsdd文件。成功生成的几个必要条件：
a. axis相关jar包存在于/ web- inf/ lib下
b. 你的tomcat必须启动，同时留意deploy.bat文件的第三行"http://localhost:8080/test/services/AdminService" ,根据具体情况修改。
否则会报"java.net.ConnectException: Connection refused: connect" 异常。

综合上述，在第一次发布service的情况下，需用方式2 生成server- config.wsdd，后续开发过程中，使用方式1 直接修改server- config.wsdd文件。

发布后，执行http: //localhost:8080/test/services，能看到当前web应用的所有web service. 
http: //localhost:8080/test/services/BookOrder?wsdl 为ServerService对应WSDL. 
还可以通过IE浏览器直接调用服务，方法是在服务URL后加"method=xxx" ，其中xxx是要调用的方法名称: 
http: //localhost:8080/test/services/BookOrder?method=getName&name=HH 

四、调用service
有两种方式可以调用service。
1 、使用org.apache.axis.client.Call直接调用

package com.hnisi.axis;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;

public class CallService {
public static void main(String[] args) {
try {
String endpoint = "http://localhost:8080/test/services/BookOrder" ; 
Service service = new Service();
Call call = (Call) service.createCall();

call.setTargetEndpointAddress( new java.net.URL(endpoint) );
call.setOperationName("getName" );

String ret = (String) call.invoke(new Object[] {"yehailong" });
System.out.println("return value is " + obj[0 ]);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}

2 、根据wsdl生成客户端java代码
在/ web- inf目录下新建make.bat文件: 

set LIB_HOME= ./ lib
set CPATH= .;% LIB_HOME% \axis.jar;% LIB_HOME% \jaxrpc.jar;% LIB_HOME% \commons- logging- 1 .0 .2 .jar;% LIB_HOME% \commons- discovery- 0 .2 .jar;% LIB_HOME% \saaj.jar;% LIB_HOME% \activation.jar;% LIB_HOME% \mail.jar;% LIB_HOME% \wsdl4j- 1 .5 .1 .jar;% LIB_HOME% \log4j- 1 .2 .6 .jar;./ classes

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

pause


生成java代码在包com.hnisi.axis.client下面，封装了调用的接口。

然后，使用以上生成的java代码,编写调用service的测试类com.hnisi.axis.client.CallService: 

package com.hnisi.axis.client;

public class CallService {
public static void main(String[] args) {
try {
BookOrderService service = new BookOrderServiceLocator();
BookOrder_PortType client = service.getBookOrder();
String retValue = client.getName("zhangsan" );
System.out.println(retValue);
} catch (Exception e) {
System.err.println("Execution failed. Exception: " + e);
}
}
}

五、对象的序列化和返序列化
在以上代码的基础上，试图调用BookOrder的setPrice服务，会报这样的异常：
faultString: java.io.IOException: No serializer found for class com.hnisi.axis.Book in registry

由于SOAP中值的类型就是XML Schema中的基本类型，默认只支持简单类型和数组。所以在进行对象传递的过程中，需要进行序列化和反序列化。
Axis为提供了大量的序列化/ 反序列化器，能够基本满足大部分应用：
1 、基本类型，如int 、double 等，转换成基本对象类型java.lang.Integer、java.lang.Double。
2 、常用集合对象的转换
java.util.List == > java.lang.Object[]
java.util.Vector == > java.util.Vector
3 、普通JavaBean（简单值对象）的序列化和反序列化
首先，在web service部署端，修改server- config.wsdd文件，在具体的service配置，增加如下代码：
< beanMapping languageSpecificType= "java:com.hnisi.axis.Book" qname= "ns1:Book" 
         xmlns: ns1= "urn:BeanService" / > 
languageSpecificType属性指定JavaBean类文件位置,qname属性指定JavaBean类的名字。当然，一个service可以绑定多个bean对象。

其次，在客户端，完成对象的注册。
对于调用方法一中，需要新增如下代码以完成注册：
QName qn = new QName("urn:BeanService" ,"Book" ); 
call.registerTypeMapping(Book.class , qn,
new BeanSerializerFactory(Book.class , qn),
                    new BeanDeserializerFactory(Book.class , qn));
而对于调用方法二，重新根据wsdl生成java代码，已完成必要的对象注册过程，CallService中可以直接传递Book对象了。
4 、复杂java对象的序列化
需要自行开发一个序列化/ 反序列化器，请参考http: //kb.csdn.net/java/Articles/200506/73d6aea4-0d38-4e21-a188-473790c9ef57.html 

六、axis和spring的集成
spring容器管理的业务层服务bean，可以做为web service发布。整合的方法有两种：
1 、直接发布
将spring容器中预定义的service直接做为web service对外发布。
为此，web服务的提供类必须有spring管理，在调用web服务时需要从web应用环境（ServletContext）中去获取服务类的bean实例。
具体的实现原理请参考http: //blog.csdn.net/liumyong/archive/2004/12/09/210043.aspx 
2 、间接发布
spring业务层servcie不直接做为web service对外发布，提供一个中间的接口（类）来调用spring service。
对外发布成web service的接口需要从Axis的contextAxis得到Spring的contextSpring：
        HttpServlet servlet = (HttpServlet) MessageContext.getCurrentContext().getProperty(HTTPConstants.MC_HTTP_SERVLET);
        ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(servlet.getServletContext());

以上两种方式各有优缺点：
方式1 ：
需要继承扩展axis的相关代码，重载实现org.apache.axis.transport.http.AxisServlet，并提供一个 SpringBeanProvider类来处理web service bean与spring service bean的关联。
优点是，spring service直接做为web service发布，直接配置，无需任何附加中间接口。
方式2 ：
需要为每个web service提供一个中间接口来调用spring service。
在单一的spring service不能满足web服务需求时，可使用中间接口类综合调用多个spring service，然后集中做为一个web service发布出去。

综合上述，在实际的开发过程中，结合具体的应用灵活采取

七、Document/ Literal 样式 
前文所使用的都是RPC/ ENCODED样式发布service，axis根据一定的规则完成JAVA对象和XML文件的转化，即序列化和反序列化过程。
采用此方式，发布和调用的过程都很简单，服务发布方和调用方都是直接面向JAVA对象，而其缺点也相当明显: 
客户端需要使用服务器端的辅助JAVA对象(尽管这些JAVA代码可以自动根据WSDL生成)，服务提供者和客户之间的紧密耦合，任何对接口的更改都会导致服务和客户间联系的中断。

Document样式和上面的RPC样式最主要的不同就是，前者中客户在一个规范的XML文档中向服务器发送服务参数，而代替了后者中的一组离散的方法的参数值。这使得Document样式比RPC样式有更加松散的耦合关系。
Web服务提供者处理规范的XML文档，执行操作并向客户端作出响应，返回的也是一个规范的XML文档。在服务器对象（参数，方法调用等）和XML数据值之间并没有一种直接的映射关系。应用程序负责映射XML数据值。
Document样式中SOAP消息在它的SOAP体中包含了一个或者更多的XML文档。协议并没有约束文档需要如何组织构成；这完全是在程序级处理的。另外，Document样式web服务遵循异步处理范例。

//TODO 给出document方式的实例 

八、安全性问题
参考《实现安全的AXIS Web服务》。

九、开发工具
1 、ant支持
Axis为支持Ant构建，提供了一个axis- ant.jar文件。
该文件包含三个可选任务(task)的定义和实现：axis- wsdl2java，axis- java2wsdl和axis- admin。
可以在项目的build.xml文件中引入如上三个任务
< taskdef resource= "axis-tasks.properties" classpathref= "lib.class.path" / > 
确保axis- ant.jar文件在你的build path中。
axis- wsdl2java: 由wsdl（本地wsdl文件或internet输出）生成客户端java代码。
axis- java2wsdl: 由服务接口类java代码生成对应的wsdl描述文件。
axis- admin: 服务的发布＆取消发布管理。
各task的具体属性配置请参考axis包\docs\ant。

2 、eclipse wtp
纯eclipse开发环境没有开发web service的功能，使用wtp- all- in- one- sdk- 1 .0 开发环境能方便地发布web service。
右键点击服务接口文件，选择webServices，有以下功能：生成web Service等。
右键点击wsdl文件，选择webServices，有以下功能：发布wsdl文件，生成客户端代码等。
在第一次生成web service时，会自动下载axis相关jar包并完成构建(web.xml自动修改，加载AxisServlet)，无需任何人工干预。
同时eclipse提供了友好的界面操作，如测试的时候，提供界面让你输入参数，而不必该改程序。

以上操作在一个新建的web project中顺利实现.
当在已存在的eecmis工程中，做以上web service生成操作，无法在当前web应用集成发布web service，会自动发布到一个独立的web应用（默认名WebServiceProject）。
在系统实际部署时，可以将这两个web应用打成ear包一起部署

用Java 开发 WebService Axis简单实例
 在开发之前, 先了解一下AXIS,axis目前出现的2版本以其灵活性,快速开发工具的集成高于xfire而使用者居其上.用Eclipse开发,一开始就会想到xfire,它是集成与Eclipse的.所以
开发起来非常方便,现在我们来看看axis的开发是怎么样的? 看完本文后,你可以相互比较一下xfire与它的差别.
 
首先,创建axis环境 ．(注:我事先说明.这是对此版本的基本功能与简单实例的描术)
 
本人的开发环境eclipse3.2 ,tomcat5.0.28 ,jdk1.4 axis_1.4目前最新版
这里主要讲一下webservice的一个开发过程,
1.         下载axis1.4最新版本http://apache.mirror.phpchina.com/ws/axis/1_4/
2.         将解压后的axis-1_4文件下的webapps目录下的axis目录考到
%TOMCAT_HOME%Webapps/目录下
3.         启动tomcat的.输入路径http://localhost:8080/axis - 打开axis主界面
4.        点击页面上的Validation ->查看一下你的axis 是否添加了完整的jar文件,注意,这
里要仔细看一下,自已少了什么 样的  jar文件,有时缺少了文件axis将无法正常工
作.补充一下:这里的xmlsec.jar文件如果缺少的话.  可以到这里
下载 http://xml.apache.org/security/dist/java-library/ c++的与java两个目录.
下载后把xmlsec-1.4.0.jar考到axis的lib目录下.
上面的步骤如果进行正常将会在Validation页面中就看不到有Error与Warning的
信息.好了,接下来我们开始编写代码
Axis支持三种web service的部署和开发，分别为：
1、Dynamic Invocation Interface ( DII)
2、Stubs方式
3、Dynamic Proxy方式
这里主要讲一下我的开发过程,通过这样过程，你也将初步的掌握axis 开发Webservice 
的整体过程．
第一种Dynamic Invocation InterFace(DII)　开发方式
步骤1:打开eclipse创建一个新项目编写一个类.代码如下:
               public class SayHello {//这个类没有包,注意了.
                   public String say(String name){
                        return " Hello ~~" + name;
                    }
                }
步骤2:
编写好上面的类(SayHello.java)后,将源代码copy到%tomcat_home%webapps
/axis/目录下.这里要注意了,只需要把类考备到这个目录下
,然后重命名为:SayHello.jws
步骤3:
打开你的浏览器:http://localhost:8080/axis/SayHello.jws  打开页面后你会看到
  Click to see the WSDL   <--点击链接,如果你上面的步骤都正常,类也没有带
包的话,那么就生成了wsdl了.
恭喜你！到这里DII方式的服务器端编写完成了.接下来我们来看一下客户端是怎么调
用的
步骤4:DII方式的客户端的调用.
 首先将axis/web-inf/lib/目录下的axis.jar,commons-discovery-0.2.jar,
comm.ons-logging-1.0.4.jar导入到刚才的项目中,因为编写客户端时
要用到这些包.客户端代码如下:
  package com.huwd.web;
  import org.apache.axis.client.Call;
          import org.apache.axis.client.Service;
  public class ToClient {
                public static void main(String args[]) throws Exception {
  
                           String urlname = "http://localhost:8080/axis/SayHello.jws";
                            //这是wsdl的绝对路径.也可以直接写成如下 ,这个没有区别．
//String urlname=”http://localhost:8080/axis/SayHello.jws?wsdl”
                           Service s = new Service();
  
                            Call call = (Call)s.createCall();
  
                          call.setOperationName("say");//注意。这里是要调用的方法名
  
                          call.setTargetEndpointAddress(urlname);//设置调用的目标url
  
                           String val = (String)call.invoke(new Object[]{"我是Blue’s Boy!"});                  //设置调用方法中的参数
  
                           System.out.println("这是webservice服务器返回给你的:>>>>"+val);
  
                     }
               }
运行结果输出:Hello ~~我是Blue’s Boy;
到此DII调用方式完成!接下来要讲的是第二种方式的调用.请继续学习第二种方式
第二种:Stubs　开发方式(stubs 故名思意，存根的方式)
  Stubs 方式相对要复杂一点．不过如果学会了这种方式，嘿嘿，那你开发的时候
　就会明显比第一种方式快了，接下来，跟我一起学吧．
 步骤1:
创建环境变量，设置AXIS的环境变量.
这种方式的编码，先要设置一下命令行的环境．右键我的电脑――＞属性――＞
选择高级选项卡――＞新建用户变量――＞输入用户变量如下:
  变量名:AXIS_LIB
   变量值: E:\tomcat5.28\Tomcat 5.0\webapps\axis\WEB-INF\lib(这是本人的)
   变量名:CLASSPATH
变量值: .;%AXIS_LIB%\axis.jar;
%AXIS_LIB%\activation.jar;
%AXIS_LIB%\axis-ant.jar;
%AXIS_LIB%\commons-discovery-0.2.jar;
%AXIS_LIB%\commons-logging-1.0.4.jar;
%AXIS_LIB%\jaxrpc.jar;
%AXIS_LIB%\log4j-1.2.8.jar;
%AXIS_LIB%\mail.jar;
%AXIS_LIB%\saaj.jar;
%AXIS_LIB%\wsdl4j-1.5.1.jar;
%AXIS_LIB%\xmlsec-1.4.0.jar;
%AXIS_LIB%\dom4j-1.6.1.jar;
    变量名:AXIS_HOME
    变量值:E:\tomcat5.28\Tomcat 5.0\webapps\axis
  新建好上述的三个变量后．确定退出．
步骤2:
 编码开始!这里要稍讲得详细并复杂一点了，我们上面看到了，只设置了一个普通
 的参数，这里我就写一下自定义数据类型参数的传递．网上很多文章只讲到了
普通数据类型做参数传递.
　服务器端的编写，代码与注释如下：
 　首先定义自定义参数类（第一个类）
    package com.web.test;
 
publicclass UserBean {//自定义数据类型.
     //很简单,只有一个String 与int 型
    private String name="";
    privateint age ;
    publicint getAge() {
       returnage;
    }
 
    publicvoid setAge(int age) {
       this.age = age;
    }
 
    public String getName() {
       returnname;
    }
 
    publicvoid setName(String name) {
       this.name = name;
    }
    
}
 其次编写第二个类Webservice服务器端类
package com.web.test;
 
publicclass Server {//服务器端
    //服务端,传递的是一个自定义的数据类型. UserBean
    public String getBeanStr(UserBean bean){
       return"You Name:"+bean.getName() +
              " , You Age:" + bean.getAge();
    }
}
    最后编写一个deploy．wsdd文件如下:
<deployment xmlns="http://xml.apache.org/axis/wsdd/"
           xmlns:java="http://xml.apache.org/axis/wsdd/providers/java">
<!—这里的stubs为wsdd描述符中的ServiceNamespace à
<service name="stubs" provider="java:RPC">
<!—这里的ClassName就是我的服务类了，这个服务主要功能就是传递一个自定义的对象 à
<parameter name="className" value="com.web.test.Server"/>
<!—这里描术的意思是，此服务类中的方法全部享出来.value值为*号　如果你只想让你的
客户端只能调用其中一个方法时，value值改为方法名就可以了．à
<parameter name="allowedMethods" value="*"/>
<!—这个typeMapping 是类型映射，使传递的参数序列化用反序列化，一个自定义类型
在要网络上传递，那就一定得让他序列化． -->
 <typeMapping 
     <!—下面是反序列化类配置à
deserializer="org.apache.axis.encoding.ser.BeanDeserializerFactory"
        encodingStyle=http://schemas.xmlsoap.org/soap/encoding/
       <!—这是Qname名称的定义．à
        qname="ns1:user"
　　　＜!――序列化类配置――＞
       serializer="org.apache.axis.encoding.ser.BeanSerializerFactory"
     <!—我的数据参数类型类路径à
        type="java:com.web.test.UserBean"
      <!—Qname对映的keyà
        xmlns:ns1="urn:BeanService"
 />
</service>
</deployment>
到这一步，我们的服务端配置完成，整理一下思路，stubs方式调用需要
         (这里主要是为了讲述自定义类的对像传递)
　　　　１．一个自定义类.2,一个服务端类，３．一个wsdd文件服务描术符．OK接着看.
将上面写好的两个类的class文件复制到/axis/web-inf/class目录下,只要把整个包复制过来就
行了,然后在把deploy.wsdd文件复制到/axis/web-inf/目录下.
打开控制台进入你的axis目录:
   >cd E:\tomcat5.28\Tomcat 5.0\webapps\axis\WEB-INF (我的目录)
  >java org.apache.axis.client.AdminClient 
–lhttp://localhost:8080/axis/services/stubs deploy.wsdd 
(说明: stubs就是刚才我们在deploy.wsdd文件里配置的<service name="stubs" )
这里是关键．这个命令就是发布这个服务.你只需这样理解它.发布成功后，你在看下你的
Axis/web-inf/目录下，多了一个server-config.wsdd文件，你可打开它看下里成的描述符
是不是跟我们写的deploy.wsdd相类似呢?
如果发布失败,那么在控制台下你将会看到一些错误信息，并仔细的解决它．
(注:一般错误的原因有这么几点，我个人在开发学习时，可能是类路径没有写对，也
可能是你的<service name="stubs"　这个名称有点错误，你要么改成别的名称试试
也有可能是你的wsdd文件里面写得不规范，最后可能就是你的命令无效，
ClassNotFoundException　错误，这个错误是因为你没有配置好axis的环境造
成的.)
发布成功后在控制台下会有提示: 
Processing file deploy.wsdd
<Admin>Done processing</Admin>
ＯＫ当您发布成功后．可以开始往下写了．
步骤3:
 嘿．完成了上面两个步骤，接下来的工作就是很轻松的了，我们来生成一个客户端
 >cd E:\tomcat5.28\Tomcat 5.0\webapps\axis\WEB-INF (我的目录)控制台命令
 >java org.apache.axis.wsdl.WSDL2Java –p client http://localhost:8080/axis/
   services/stubs?wsdl
打开axis/web-inf/目录下可以看到生成了一个client目录,OK，复制client目录，到你
的项目中.这个client就是我们的客户端代码了.
Client目录生成了:
   Server.java
ServerService.java
ServerServiceLocator.java
StubsSoapBindingStub.java
User.java
java文件;
接下来的工作就是编写一个调用类测试.代码与注释如下
 
package myclient;
 
import java.net.URL;
 
import javax.xml.namespace.QName;
 
import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.ser.BeanDeserializerFactory;
import org.apache.axis.encoding.ser.BeanSerializerFactory;
 
publicclass Test {
 
    publicstaticvoid main(String []args) throws Exception {
       
       QName qname = new QName("urn:BeanService","user");
       
       Service s = new Service();
       
       Call call = (Call)s.createCall();
       //注册这个bean为可序列化的.传递参数
       call.registerTypeMapping(User.class, qname, new BeanSerializerFactory(User.class,qname), new BeanDeserializerFactory(User.class,qname));
       
       //设置一下调用方法名.不设置肯定会报错的哦
       call.setOperationName("getBeanStr");
       
       //设置一下这个服务的绝对路径.
       call.setTargetEndpointAddress(new URL("http://localhost:8080/axis/services/stubs?wsdl"));
       
       //实例化一个User,这个User是生成出来的User哦.,不是原先那个,
       User u = new User();
       
       u.setAge(23);
       
       u.setName("do WebService!");
       //通知方法,并返回结果
       String str = (String)call.invoke(new Object[]{u});
       
       System.out.println(str);
       
       //out.print ==> You Name:do WebService! , You Age:23
    }
}
好了，这下完成了stubs的方式．看起来很累，其实当你开发第二个例子的时候
就不会这么累了．我已经满头大汗了，公司没开空调.
 
      接下来就是第三种方式了，其实第三种方式更简单了，我这里还是稍微讲一下:
第三种: Dynamic Proxy方式 (代理方式)
这个例子就以第一种方式为基础，因这服务端类的编写是一样的.
那么服务端类就是第一种方式的类了，(完成第一种方式的3个步骤)
主要讲一下客户端通过代理接口的方式调用．
 
接口这义
 import java.rmi.Remote;
import java.rmi.RemoteException;
publicinterface SayHelloInter extends Remote{
    public String say(String name) throws RemoteException;
}
 
//客户端的调用类如下:
import java.net.URL;
 
import javax.xml.namespace.QName;
import javax.xml.rpc.Service;
import javax.xml.rpc.ServiceFactory;
 
 
publicclass Test2 {
 
publicstaticvoid main(String []args) throws Exception{
       
String wsdlname = "http://localhost:8080/axis/SayHello.jws?wsdl";
       //服务路径
String namespaceUrl = "http:// localhost:8080/axis/SayHello.jws";
       
       //服务名
       String serviceName = "SayHelloService";
       //服务
       String portName = "SayHello";
       
       //创建代理对像
       ServiceFactory service = ServiceFactory.newInstance();
       
       //创建远程服务
       Service s = service.createService(new URL(wsdlname), new QName(namespaceUrl,serviceName));
       
       //向上转型为接口
           AxisWebInter inter = (AxisWebInter)s.getPort(new QName(namespaceUrl,portName), AxisWebInter.class
              );
       
       System.out.println(inter.getName("Blue boy!"));
    }
}
//Out.print Hi~~ Blue boy!
好了，到现在为止三种调用方式都描术完了，不知道你有没有学会．如果还有什么问题，可
以给我留言，我会给你及时回复．如有不对的地方请指出．Thank you !