如何用java做一个web服务器

1. 如何使用java做webservice

基于AXIS的web service： 1 比如要建一个Server.java类的web service public class Server { public String printInfo(String name){ return "Hello,"+name; } } 2 把Server.java改为Server.Jws放到 …\Tomcat 5.5\webapps\axis中，重启服务器 3 访问 4 在cmd中输入 cd D:\Program Files\Apache Software Foundation\Tomcat 5.5\webapps\axis\WEB-INF 输入命令：Java -Djava.ext.dirs=lib org.apache.axis.wsdl.WSDL2Java 5 找到…\Tomcat 5.5\webapps\axis\WEB-INF下生成的localhost文件夹复制到工程中 6 建一个Client端的类进行测试： public class Client { public static void main(String arg[]) throws ServiceException, RemoteException{ ServerService ss=new ServerServiceLocator(); Server s=ss.getServer(); System.out.println("............"+s.printInfo("shiyou")); } } 蓝屏

2. 如何用Java实现Web服务器

如何用Java实现Web服务器 一、HTTP协议的作用原理

WWW是以Internet作为传输媒介的一个应用系统，WWW网上最基本的传输单位是Web网页。WWW的工作基于客户机/服务器计算模型，由Web 浏览器（客户机）和Web服务器（服务器）构成，两者之间采用超文本传送协议（HTTP）进行通信。HTTP协议是基于TCP/IP协议之上的协议，是Web浏览器和Web服务器之间的应用层协议，是通用的、无状态的、面向对象的协议。HTTP协议的作用原理包括四个步骤：

（1） 连接：Web浏览器与Web服务器建立连接，打开一个称为socket（套接字）的虚拟文件，此文件的建立标志着连接建立成功。

（2） 请求：Web浏览器通过socket向Web服务器提交请求。HTTP的请求一般是GET或POST命令（POST用于FORM参数的传递）。GET命令的格式为：

GET 路径/文件名 HTTP/1.0

文件名指出所访问的文件，HTTP/1.0指出Web浏览器使用的HTTP版本。

（3） 应答：Web浏览器提交请求后，通过HTTP协议传送给Web服务器。Web服务器接到后，进行事务处理，处理结果又通过HTTP传回给Web浏览器，从而在Web浏览器上显示出所请求的页面。

例：假设客户机与www.mycompany.com：8080/mydir/index.html建立了连接，就会发送GET命令：GET /mydir/index.html HTTP/1.0.主机名为www.mycompany.com的Web服务器从它的文档空间中搜索子目录mydir的文件index.html.如果找到该文件，Web服务器把该文件内容传送给相应的Web浏览器。

为了告知 Web浏览器传送内容的类型，Web服务器首先传送一些HTTP头信息，然后传送具体内容（即HTTP体信息），HTTP头信息和HTTP体信息之间用一个空行分开。

常用的HTTP头信息有：

① HTTP 1.0 200 OK

这是Web服务器应答的第一行，列出服务器正在运行的HTTP版本号和应答代码。代码“200 OK”表示请求完成。

② MIME_Version：1.0

它指示MIME类型的版本。

③ content_type：类型

这个头信息非常重要，它指示HTTP体信息的MIME类型。如：content_type：text/html指示传送的数据是HTML文档。

④ content_length：长度值

它指示HTTP体信息的长度（字节）。

（4） 关闭连接：当应答结束后，Web浏览器与Web服务器必须断开，以保证其它Web浏览器能够与Web服务器建立连接。

二、Java实现Web服务器功能的程序设计

根据上述HTTP协议的作用原理，实现GET请求的Web服务器程序的方法如下：

（1） 创建ServerSocket类对象，监听端口8080.这是为了区别于HTTP的标准TCP/IP端口80而取的；

（2） 等待、接受客户机连接到端口8080，得到与客户机连接的socket；

（3） 创建与socket字相关联的输入流instream和输出流outstream；

（4） 从与socket关联的输入流instream中读取一行客户机提交的请求信息，请求信息的格式为：GET 路径/文件名 HTTP/1.0

（5） 从请求信息中获取请求类型。如果请求类型是GET，则从请求信息中获取所访问的HTML文件名。没有HTML文件名时，则以index.html作为文件名；

（6） 如果HTML文件存在，则打开HTML文件，把HTTP头信息和HTML文件内容通过socket传回给Web浏览器，然后关闭文件。否则发送错误信息给Web浏览器；

（7） 关闭与相应Web浏览器连接的socket字。

下面的程序是根据上述方法编写的、可实现多线程的Web服务器，以保证多个客户机能同时与该Web服务器连接。

程序1：WebServer.java文件

//WebServer.java 用JAVA编写Web服务器

import java.io.*；

import java.net.*；

public class WebServer {

public static void main（String args[]） {

int i=1， PORT=8080；

ServerSocket server=null；

Socket client=null；

try {

server=new ServerSocket（PORT）；

System.out.println（"Web Server is listening on port "+server.getLocalPort（））；

for （；；） {client=server.accept（）； //接受客户机的连接请求

new ConnectionThread（client，i）。start（）；

i++；

}

} catch （Exception e） {System.out.println（e）；}

}

}

/* ConnnectionThread类完成与一个Web浏览器的通信 */

class ConnectionThread extends Thread {

Socket client； //连接Web浏览器的socket字

int counter； //计数器

public ConnectionThread（Socket cl，int c） {

client=cl；

counter=c；

}

public void run（） //线程体

{try {

String destIP=client.getInetAddress（）。toString（）； //客户机IP地址

int destport=client.getPort（）； //客户机端口号

System.out.println（"Connection "+counter+"：connected to "+destIP+" on port "+destport+"."）；

PrintStream outstream=new PrintStream（client.getOutputStream（））；

DataInputStream instream=new DataInputStream（client.getInputStream（））；

String inline=instream.readLine（）； //读取Web浏览器提交的请求信息

System.out.println（"Received："+inline）；

if （getrequest（inline）） { //如果是GET请求

String filename=getfilename（inline）；

File file=new File（filename）；

if （file.exists（）） { //若文件存在，则将文件送给Web浏览器

System.out.println（filename+" requested."）；

outstream.println（"HTTP/1.0 200 OK"）；

outstream.println（"MIME_version：1.0"）；

outstream.println（"Content_Type：text/html"）；

int len=（int）file.length（）；

outstream.println（"Content_Length："+len）；

outstream.println（""）；

sendfile（outstream，file）； //发送文件

outstream.flush（）；

} else { //文件不存在时

String notfound="

Error 404-file not found
"；

outstream.println（"HTTP/1.0 404 no found"）；

outstream.println（"Content_Type：text/html"）；

outstream.println（"Content_Length："+notfound.length（）+2）；

outstream.println（""）；

outstream.println（notfound）；

outstream.flush（）；

}

http://java.chinaitlab.com/advance/519981.html

3. 用 java 编写一个 基于Web Service的软件

1.首先说一下两个开发webservices的工具包：axis 和XFire 本人首先接触的是axis。
两者比较如下：
相对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。
知道了这两个框架你研究起来也就不难了。
下面我就基于xfire说一下开发说明：
xfire对WebServices的开发非常方便，在Eclipse里开发就更方便了。总结起来有这么几点：
1.编写类，跟普通JAVABEAN没什么区别。
2.配置文件
如果是要深层次的去理解WebServices还需努力，下面是我给你找的一个网上的例子作为参考：

使用XFire+Spring构建Web Service
XFire是与Axis 2并列的新一代Web Service框架，通过提供简单的API支持Web Service各项标准协议，帮助你方便快速地开发Web Service应用。
相 对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。
XFire与Axis2相比具有如下特征：
l 支持一系列Web Service的新标准--JSR181、WSDL2.0 、JAXB2、WS-Security等；
l 使用Stax解释XML,性能有了质的提高。XFire采用Woodstox 作Stax实现；
l 容易上手，可以方便快速地从pojo发布服务；
l 支持Spring、Pico、Plexus、Loom等容器；
l 灵活的Binding机制，包括默认的Aegis,xmlbeans,jaxb2,castor；
l 高性能的SOAP 栈设计；
l 支持Spring、Pico、Plexus、Loom等容器。
XFire与Axis1性能的比较如下：
l XFire比Axis1.3快2-6倍；
l XFire的响应时间是Axis1.3的1/2到1/5。
XFire在WebService框逗誉架山芦段中开始较晚，它从现有的框架中借鉴了许多优秀的理念，力争将Web Service的应用开发难度降到最低。此外，还提供了各种绑定技术、支持多种传输协议，对WebService体系中许多新的规范提供了支持。
下面让我们来看一个XFire于Spring集成的helloWorld的简单例子。
一．实现的功能和特点
本例具有如下功能和特点：
1） 基于J2EE平台的Web Service服务；
2） 开发方便，配置简单；
3） 与spring无缝集成。
XFire是完全基于流数据处理进行工作的系统，这意味着XFire不是将整个SOAP文档缓存在内存中，而是以管道的方式接收SOAP流数据。这种工作方式的哗悔转变带来了可观的性能回报，同时节省了内存的占用。
XFire从 管道中接收一个SOAP请求到返回一个SOAP响应，会经历一系列的阶段。在管道调用的任何一个阶段，XFire都可以添加一些额外的Handler，在 对消息进行加工处理后再传入到下一个阶段中。在SOAP请求消息对Web Service发起真正调用之前，分别会经过传输、预转发、转发、策略实施、用户信息处理、预调用、服务调用等阶段。
二．开发环境
笔者的开发环境描述如下：
1） jdk: 1.5版本；
2） Tomcat：5.5.20；
3） MyEclipse:5.1.1 GA。
三．开发步骤

1. 工程与环境的建立
在MyEclipse 中新建Web工程，名为webservice_helloworld。选择该工程后，点击右键选择MyEclipse->Add Web Service Capabilities，弹出Add Web Service Capabilities对话框，点击“Next”，弹出Project Library Configuration对话框，默认选择Core Libraries，点击“Finish”按钮，完成XFire核心包的添加。为了后续的客户端的测试，还需读者加入commons- httpclient.jar包到WEB-INF/lib下。
部署后可看到此时WEB-INF/lib的jar包列表如下：
activation-1.1.jar、commons -beanutils-1.7.0.jar、commons-codec-1.3.jar、commons-httpclient.jar、 commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api-2.0.jar、jdom- 1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、saaj-impl- 1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、wstx-asl- 3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis-1.2.2.jar、 xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire-java5-1.2.2.jar、 xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire-spring- 1.2.2.jar、XmlSchema-1.1.jar
为了后续的开发和测试，在src目录下分别建立test和webservice目录，分别用于存放测试文件和webservice的相关类。
2．Web Service实现的编写
在本例中，我们只是做一个helloWorld的简单例子。Web Service服务端提供一个根据输入的名字信息回复相应的helloWorld信息的。例如，当名字为“阿蜜果”时，恢复信息为“hello，阿蜜果”。下面让我们一步一步来开始进行编码。
1）web.xml的配置
一 般情况下，我们通过HTTP作为Web Service的传输协议，这样我们只需启动一个Web服务器(如Tomcat，在本例中使用的是Tomcat5.5.20)，这样客户端就可以通过 HTTP访问到Web Service服务。为了集成Spring容器，XFire专门提供一个XFireSpringServlet，我们可以在web.xml中配置该 Servlet，将Spring容器中定义的Web Service在某个URI下发布。
为了能正确使用XFire，需在web.xml中进行相应配置，在该文件中配置XFire的servlet和servlet-mapping。同时因为本实例需要将XFire集成到Spring中，因而需要在web.xml文件中加载Spring的相应配置文件。在本实例中，我们首先在WEB-INF下建立两个配置Spring配置文件，一个为applicationContext.xml，该文件用来定义本工程的bean，一个为xfire-servlet.xml，用来配置XFire的相关bean。修改后的web.xml的内容如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>XFireService</display-name>
<!-- begin Spring配置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml</param-value>
</context-param>
<listener>
<listener-class> org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<listener>
<listener-class> org.springframework.web.util.IntrospectorCleanupListener
</listener-class>
</listener>
<!-- end Spring配置 -->

<!-- begin XFire 配置 -->
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>*.ws</url-pattern>
</servlet-mapping>
<servlet>
<!-- 配合Spring容器中XFire一起工作的Servlet-->
<servlet-name>xfireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.spring.XFireSpringServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>xfireServlet</servlet-name>
<!-- 在这个URI下开放Web Service服务 -->
<url-pattern>/service/*</url-pattern>
</servlet-mapping>
<!-- end XFire 配置 -->
</web-app>

2）Web Service的接口类HelloWorld.java和对应实现类HelloWorldImpl.java

为了用Web Service完成HelloWorld功能，我们首先在src/webservice目录下建立接口类HelloWold.java。它仅包含一个sayHelloWorld(String name)的方法，其详细内容如下：

package webservice;

/** *//**
*HelloWorld的接口类.
*/
publicinterface HelloWorld {
/** *//**
*对名字为name的人打招呼.
*@paramname名字
*@return返回打招呼的字符串
*/
String sayHelloWorld(String name);
}
我们还需要建立一个对应的实现类，来实现sayHelloWorld的功能，该实现类即为HelloWorldImpl.java。该类的详细内容如下：
package webservice;
/** *//**
*HelloWorld的实现类.
*/
publicclass HelloWorldImpl implements HelloWorld {
public String sayHelloWorld(String name) {
String helloWorld = "hello," + name;
return helloWorld;
}
}

3）Spring配置文件applicationContext.xml和xfire-servlet.xml的配置

首先我们在applicationContext.xml文件中配置对应的bean——HelloWorldBean，该xml文件的内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="HelloWorldBean" class="webservice.HelloWorldImpl"/>
</beans>
这个配置文件很简单，在此不详述。

XFire为Spring 提供了方便易用的导出器XFireExporter，借助该导出器的支持，我们可以在Spring容器中将一个POJO导出为Web Service。HelloWorld是业务服务类，在此拥有一个sayHelloWorld的方法，我们希望将此方法开放为Web Service。在实际应用中，如果某个类具有众多的方法，而其中的某些方法不需要开放为Web Service的情况下，我们可以定义一个窄接口，该接口中只需定义那些开放为Web Service的业务方法。

将一个业务类所有需要开放为Web Service的方法通过一个窄接口来描述是值得推荐的作法，这让Web Service的接口显得很“干净”。其次，XFire的导出器也需要服务接口的支持，因为它采用基于接口的动态代理技术。

窄接口中的方法在真实的系统中可能需要引用其它的业务类或DAO获取数据库中的真实数据，为了简化实例，我们在此简化了实例。

下面让我们看看在xfire-servlet.xml文件中导出器的设置，该文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- 引入XFire预配置信息 -->
<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />
<!—定义访问的url-->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="urlMap">
<map>
<entry key="/HelloWorldService.ws">
<ref bean="HelloWorldService" />
</entry>
</map>
</property>
</bean>

<!-- 使用XFire导出器 -->
<bean id="baseWebService" class="org.codehaus.xfire.spring.remoting.XFireExporter" lazy-init="false" abstract="true">
<!-- 引用xfire.xml中定义的工厂 -->
<property name="serviceFactory" ref="xfire.serviceFactory" />
<!-- 引用xfire.xml中的xfire实例 -->
<property name="xfire" ref="xfire" />
</bean>
<bean id="HelloWorldService" parent="baseWebService">
<!-- 业务服务bean -->
<property name="serviceBean" ref="HelloWorldBean" />
<!-- 业务服务bean的窄接口类 -->
<property name="serviceClass" value="webservice.HelloWorld" />
</bean>
</beans>

在 上面的配置中，我们可以看到，在该配置文件中引入了xfire.xml这个Spring配置文件。它是在XFire核心JAR包中拥有一个预定义的 Spring配置文件，它定义了XFire在Spring中必须用到的一些Bean和资源，需要引入这个预定义的配置文件。从该配置文件中可以看出，我们 通过XFireExporter将业务类导出为Web Service，对于任何导出器，我们都需要引入XFire环境，即serviceFactory和xfire，这是标准的配置。ServiceFactory是XFire的核心类，它可以将一个POJO生成为一个Web Service。

在本实例中，我们通过定义一个baseWebService，其余的webService配置都将该bean作为父bean，这样可以简化Spring的配置，不需要多次引入serviceFactory和xfire。

3. Web Service的测试

在上一步操作完成之后，我们的这个简单的Web Service已经编写完毕，下面让我们来看看自己的劳动成果吧。

在浏览器中输入地址：http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl，我们可以看到HelloWorldService对应的WSDL信息，阅读这个WSDL文档，我们可以知道HelloWorld的sayHelloWorld方法已经被成功地发布为Web Service了。只要拿到这个WSDL就可以开发相应的客户端调用程序了。

XFire为访问服务端Web Service提供了各种方便的方式：我们一般根据服务地址和窄接口类创建客户调用程序。

在不能获得服务窄接口类的情况下，XFire允许我们通过WSDL文件生成客户端调用程序，通过指定服务接口的方式调用服务。

1）通过WSDL文件生成客户端调用程序

首先我们通过http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl我们可以获得WSDL文件HelloWorldService.wsdl，并将其放在src目录下面，接着我们通过程序访问该WSDL文件，并调用需测试的方法。此时测试类WebServiceClientTest.java的内容如下所示：

package test;

import org.codehaus.xfire.client.Client;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import webservice.HelloWorld;

/** *//**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的测试类.
*@author<a href="mailto:[email protected]">AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) throws Exception {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() throws Exception {
String wsdl = "HelloWorldService.wsdl"; //对应的WSDL文件
Resource resource = new ClassPathResource(wsdl);
Client client = new Client(resource.getInputStream(), null); //根据WSDL创建客户实例

Object[] objArray = new Object[1];
objArray[0] = "阿蜜果";
//调用特定的Web Service方法
Object[] results = client.invoke("sayHelloWorld", objArray);
System.out.println("result: " + results[0]);
}
}
运行该类，可得到如下输出结果：

result: hello,阿蜜果

可看出运行结果正确。

2）根据服务地址创建客户端调用程序

接着让我们来看一个根据服务地址创建客户端调用程序的例子。我们可以通过测试类来测试Web Service的正确性，下面让我们来看一个简单的测试类，首先我们在src/test目录建立WebServiceClientTest.java文件，并在src目录下建立客户端调用的Spring配置文件client.xml。在client.xml配置文件中我们定义了一个testWebService的bean，该bean访问wsdlDocumentUrl为http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl的WSDL。该xml文件的详细内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="testWebService" class="org.codehaus.xfire.spring.remoting.XFireClientFactoryBean">
<property name="serviceClass">
<value>webservice.HelloWorld</value>
</property>
<property name="wsdlDocumentUrl">
<value>http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl</value>
</property>
</bean>
</beans>

在WebServiceClientTest.java文件中获得HelloWorld，并调用它的sayHelloWorld方法来完成测试，该类的详细内容如下所示：

package test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.;
import webservice.HelloWorld;

/** *//**
*HelloWorld的webservice的测试类.
*/
publicclass WebServiceClientTest {
HelloWorld helloWorld = null;

publicstaticvoid main(String[] args) {
WebServiceClientTest test = new WebServiceClientTest();
test.testClient();
}

publicvoid testClient() {
ApplicationContext ctx = new (
"client.xml");
helloWorld = (HelloWorld) ctx.getBean("testWebService");
System.out.println(helloWorld.sayHelloWorld("阿蜜果"));
}
}

在启动webservice_helloworld工程的情况下，运行WebServiceClientTest类，可看到控制台包含如下信息：

hello,阿蜜果

由此可看出调用Web Service成功。

四．总结

与Axis 相比，在实施Web Service时XFire更加简洁高效，并且XFire对Spring提供了强大的支持，可以非常方便地在Spring中使用XFire实施Web Service，因此XFire在短短的时间里成为了受Web Service开发者喜爱的框架。

XFire为客户端提供了多种访问Web Service的方式，如果可以获取客户端的窄接口类，则可以采用窄接口类调用Web Service。如果仅能获取WSDL，XFire也可以采用动态反射的机制调用Web Service。XFire为Eclipse提供了一个可以根据WSDL生成客户端存根代码的插件，相信XFire也将为其它非Java语言提供类似的插 件。

在Axis2中也开始使用Stax来处理XML，还有Xfire不支持WSDL2.0, 而Axis2支持WSDL2.0。
还可使用Xfire的后续版本，Apache CXF (相当于 Xfire2.0).

4. 如何用java开发一个web系统

开发web系统需要：

1. 需要的软件：数据库（mysql、oracle...）、IDE（eclipse、myeclipse...）、服务器（Apache、Tomcat、JBoss...）。

2. 
   

2.需要的技术：java基础、sql、jdbc、html、css、jsp、servlet（这里就不说一些框架了）

3.设计web系统数据库结构，用eclipse编写web系统</p><p>页面，编写javaservlet代码处理页面请求，jdbc连接数据库进行数据交互，最后将开发好的web系统部署到web服务器上启动，最后直接在IE或其他浏览器中进行访问。

4.不清楚你的情况，所以只是大概说下。没深入也没详细说

5. 如何把一个普通的JAVA类变成一个webService服务

ITjob远标教育

步骤：

1，新建一个普通JAVA类即可。

2，选择这个类，右键。new--->other，在对话框中选中MyEclipse下的Web Service，点击next

3，strategy选择 Create webService from Java class (Bottom-up scenario)，点击next

4，点击Browse

5，选择刚新建的普通JAVA类，点击OK

6，点击finish

7，项目目录中就会生成一个新的JAVA类

8，至此webService完成。

6. 如何用JAVA实现一个代理服务器

代理服务器的应用非常广泛。比如，在企业网内部，它可以用来控制员工在工作时浏览的Internet内容，阻止员工访问某些类型的内容或某些指定的网站。代理服务器实际上扮演着浏览器和Web服务器之间的中间人的角色，能够对浏览器请求进行各种各样的处理，能够过滤广告和Cookie，能够预先提取Web页面，使得浏览器访问页面的速度更快，等等。
一、基础知识
不管以哪种方式应用代理服务器，其监控HTTP传输的过程总是如下：
步骤一：内部的浏览器发送请求给代理服务器。请求的第一行包含了目标URL。
步骤二：代理服务器读取该URL，并把请求转发给合适的目标服务器。
步骤三：代理服务器接收来自Internet目标机器的应答，把应答转发给合适的内部浏览器。

例如，假设有一个企业的雇员试图访问www.cn.ibm.com网站。如果没有代理服务器，雇员的浏览器打开的Socket通向运行这个网站的Web服务器，从Web服务器返回的数据也直接传递给雇员的浏览器。如果浏览器被配置成使用代理服务器，则请求首先到达代理服务器；随后，代理服务器从请求的第一行提取目标URL，打开一个通向www.cn.ibm.com的Socket。当www.cn.ibm.com返回应答时，代理服务器把应答转发给雇员的浏览器。
当然，代理服务器并非只适用于企业环境。作为一个开发者，拥有一个自己的代理服务器是一件很不错的事情。例如，我们可以用代理服务器来分析浏览器和Web服务器的交互过程。测试和解决Web应用中存在的问题时，这种功能是很有用的。我们甚至还可以同时使用多个代理服务器（大多数代理服务器允许多个服务器链接在一起使用）。例如，我们可以有一个企业的代理服务器，再加上一个用java编写的代理服务器，用来调试应用程序。但应该注意的是，代理服务器链上的每一个服务器都会对性能产生一定的影响。
二、设计规划
正如其名字所示，代理服务器只不过是一种特殊的服务器。和大多数服务器一样，如果要处理多个请求，代理服务器应该使用线程。下面是一个代理服务器的基本规划：
等待来自客户（Web浏览器）的请求。
启动一个新的线程，以处理客户连接请求。
读取浏览器请求的第一行（该行内容包含了请求的目标URL）。
分析请求的第一行内容，得到目标服务器的名字和端口。
打开一个通向目标服务器（或下一个代理服务器，如合适的话）的Socket。
把请求的第一行发送到输出Socket。
把请求的剩余部分发送到输出Socket。
把目标Web服务器返回的数据发送给发出请求的浏览器。

当然，如果考虑细节的话，情况会更复杂一些。实际上，这里主要有两个问题要考虑：第一，从Socket按行读取数据最适合进一步处理，但这会产生性能瓶颈；第二，两个Socket之间的连接必需高效。有几种方法可以实现这两个目标，但每一种方法都有各自的代价。例如，如果要在数据进入的时候进行过滤，这些数据最好按行读取；然而，大多数时候，当数据到达代理服务器时，立即把它转发出去更适合高效这一要求。另外，数据的发送和接收也可以使用多个独立的线程，但大量地创建和拆除线程也会带来性能问题。因此，对于每一个请求，我们将用一个线程处理数据的接收和发送，同时在数据到达代理服务器时，尽可能快速地把它转发出去。
三、实例
在用java编写这个代理服务器的过程中，注意可重用性是很重要的。因为这样的话，当我们想要在另一个工程中以不同的方式处理浏览器请求时，可以方便地重用该代理服务器。当然，我们必须注意灵活性和效率之间的平衡。
图一显示了本文代理服务器实例（HttpProxy.java）的输出界面，当浏览器访问http://www-900.ibm.com/cn/时，代理服务器向默认日志设备（即标准输出设备屏幕）输出浏览器请求的URL。图二显示了SubHttpProxy的输出。SubHttpProxy是HttpProxy的一个简单扩展。
图一

图二

为了构造代理服务器，我从Thread基类派生出了HttpProxy类（文章正文中出现的代码是该类的一些片断，完整的代码请从本文最后下载）。HttpProxy类包含了一些用来定制代理服务器行为的属性，参见Listing 1和表一。
【Listing 1】
/*************************************
* 一个基础的代理服务器类
*************************************
*/
import java.net.*;
import java.io.*;
public class HttpProxy extends Thread {
static public int CONNECT_RETRIES=5;
static public int CONNECT_PAUSE=5;
static public int TIME-OUT=50;
static public int BUFSIZ=1024;
static public boolean logging = false;
static public OutputStream log=null;
// 传入数据用的Socket
protected Socket socket;
// 上级代理服务器，可选
static private String parent=null;
static private int parentPort=-1;
static public void setParentProxy(String name, int pport) {
parent=name;
parentPort=pport;
}
// 在给定Socket上创建一个代理线程。
public HttpProxy(Socket s) { socket=s; start(); }
public void writeLog(int c, boolean browser) throws IOException {
log.write(c);
}
public void writeLog(byte[] bytes,int offset,
int len, boolean browser) throws IOException {
for (int i=0;i<len;i++) writeLog((int)bytes[offset+i],browser);
}
// 默认情况下，日志信息输出到
// 标准输出设备，
// 派生类可以覆盖它
public String processHostName(String url, String host, int port, Socket sock) {
java.text.DateFormat cal=java.text.DateFormat.getDateTimeInstance();
System.out.println(cal.format(new java.util.Date()) + " - " +
url + " " + sock.getInetAddress()+"<BR>");
return host;
}

表一
变量/方法 说明
CONNECT_RETRIES 在放弃之前尝试连接远程主机的次数。
CONNECT_PAUSE 在两次连接尝试之间的暂停时间。
TIME-OUT 等待Socket输入的等待时间。
BUFSIZ Socket输入的缓冲大小。
logging 是否要求代理服务器在日志中记录所有已传输的数据（true表示“是”）。
log 一个OutputStream对象，默认日志例程将向该OutputStream对象输出日志信息。
setParentProxy 用来把一个代理服务器链接到另一个代理服务器（需要指定另一个服务器的名称和端口）。

当代理服务器连接到Web服务器之后，我用一个简单的循环在两个Socket之间传递数据。这里可能出现一个问题，即如果没有可操作的数据，调用read方法可能导致程序阻塞，从而挂起程序。为防止出现这个问题，我用setSoTimeout方法设置了Socket的超时时间（参见Listing 2）。这样，如果某个Socket不可用，另一个仍旧有机会进行处理，我不必创建一个新的线程。
【Listing 2】
// 执行操作的线程
public void run() {
String line;
String host;
int port=80;
Socket outbound=null;
try {
socket.setSoTimeout(TIMEOUT);
InputStream is=socket.getInputStream();
OutputStream os=null;
try {
// 获取请求行的内容
line="";
host="";
int state=0;
boolean space;
while (true) {
int c=is.read();
if (c==-1) break;
if (logging) writeLog(c,true);
space=Character.isWhitespace((char)c);
switch (state) {
case 0:
if (space) continue;
state=1;
case 1:
if (space) {
state=2;
continue;
}
line=line+(char)c;
break;
case 2:
if (space) continue; // 跳过多个空白字符
state=3;
case 3:
if (space) {
state=4;
// 只分析主机名称部分
String host0=host;
int n;
n=host.indexOf("//");
if (n!=-1) host=host.substring(n+2);
n=host.indexOf('/');
if (n!=-1) host=host.substring(0,n);
// 分析可能存在的端口号
n=host.indexOf(":");
if (n!=-1) {
port=Integer.parseInt(host.substring(n+1));
host=host.substring(0,n);
}
host=processHostName(host0,host,port,socket);
if (parent!=null) {
host=parent;
port=parentPort;
}
int retry=CONNECT_RETRIES;
while (retry--!=0) {
try {
outbound=new Socket(host,port);
break;
} catch (Exception e) { }
// 等待
Thread.sleep(CONNECT_PAUSE);
}
if (outbound==null) break;
outbound.setSoTimeout(TIMEOUT);
os=outbound.getOutputStream();
os.write(line.getBytes());
os.write(' ');
os.write(host0.getBytes());
os.write(' ');
pipe(is,outbound.getInputStream(),os,socket.getOutputStream());
break;
}
host=host+(char)c;
break;
}
}
}
catch (IOException e) { }
} catch (Exception e) { }
finally {
try { socket.close();} catch (Exception e1) {}
try { outbound.close();} catch (Exception e2) {}
}
}

和所有线程对象一样，HttpProxy类的主要工作在run方法内完成（见Listing 2）。run方法实现了一个简单的状态机，从Web浏览器每次一个读取字符，持续这个过程直至有足够的信息找出目标Web服务器。然后，run打开一个通向该Web服务器的Socket（如果有多个代理服务器被链接在一起，则run方法打开一个通向链里面下一个代理服务器的Socket）。打开Socket之后，run先把部分的请求写入Socket，然后调用pipe方法。pipe方法直接在两个Socket之间以最快的速度执行读写操作。
如果数据规模很大，另外创建一个线程可能具有更高的效率；然而，当数据规模较小时，创建新线程所需要的开销会抵消它带来的好处。
Listing 3显示了一个很简单的main方法，可以用来测试HttpProxy类。大部分的工作由一个静态的startProxy方法完成（见Listing 4）。这个方法用到了一种特殊的技术，允许一个静态成员创建HttpProxy类（或HttpProxy类的子类）的实例。它的基本思想是：把一个Class对象传递给startProxy类；然后，startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法确定该Class对象的哪一个构造函数接受一个Socket参数；最后，startProxy方法调用newInstance方法创建该Class对象。
【Listing 3】
// 测试用的简单main方法
static public void main(String args[]) {
System.out.println("在端口808启动代理服务器\n");
HttpProxy.log=System.out;
HttpProxy.logging=false;
HttpProxy.startProxy(808,HttpProxy.class);
}
}

【Listing 4】
static public void startProxy(int port,Class clobj) {
ServerSocket ssock;
Socket sock;
try {
ssock=new ServerSocket(port);
while (true) {
Class [] sarg = new Class[1];
Object [] arg= new Object[1];
sarg[0]=Socket.class;
try {
java.lang.reflect.Constructor cons = clobj.getDeclaredConstructor(sarg);
arg[0]=ssock.accept();
cons.newInstance(arg); // 创建HttpProxy或其派生类的实例
} catch (Exception e) {
Socket esock = (Socket)arg[0];
try { esock.close(); } catch (Exception ec) {}
}
}
} catch (IOException e) {
}
}

利用这种技术，我们可以在不创建startProxy方法定制版本的情况下，扩展HttpProxy类。要得到给定类的Class对象，只需在正常的名字后面加上.class（如果有某个对象的一个实例，则代之以调用getClass方法）。由于我们把Class对象传递给了startProxy方法，所以创建HttpProxy的派生类时，就不必再特意去修改startProxy。（下载代码中包含了一个派生得到的简单代理服务器）。
结束语
利用派生类定制或调整代理服务器的行为有两种途径：修改主机的名字，或者捕获所有通过代理服务器的数据。processHostName方法允许代理服务器分析和修改主机名字。如果启用了日志记录，代理服务器为每一个通过服务器的字符调用writeLog方法。如何处理这些信息完全由我们自己决定——可以把它写入日志文件，可以把它输出到控制台，或进行任何其他满足我们要求的处理。writeLog输出中的一个Boolean标记指示出数据是来自浏览器还是Web主机。
和许多工具一样，代理服务器本身并不存在好或者坏的问题，关键在于如何使用它们。代理服务器可能被用于侵犯隐私，但也可以阻隔偷窥者和保护网络。即使代理服务器和浏览器不在同一台机器上，我也乐意把代理服务器看成是一种扩展浏览器功能的途径。例如，在把数据发送给浏览器之前，可以用代理服务器压缩数据；未来的代理服务器甚至还可能把页面从一种语言翻译成另一种语言……可能性永无止境。

7. 如何用java开发一个web系统

1.
这个问题问的太广泛了，就跟问怎么赚钱一样。
2.
开发一个web系统，不管使不使用Java开发，首先需要确定这个系统的需求，就是这个系统的使用目的，是用来干嘛的？给谁使用？需要做出什么功能？
3.
再根据这个系统的需求，确定系统的设计，系统设计包括功能设计文档和数据库设计。
4.
再根据设计使用不同的Java框架或者技术实现需求。
5.
如果是比较大的项目需要迭代开发。
6.
开发分阶段进行，根据设计文档来进行系统的功能和性能测试。
7.
最终完成测试以后交付使用，提供测试和使用报告。
这就是JAVA开发的具体流程