Java webservice详解

转x33g5p2x  于2022-02-24 转载在 Java  
字(12.5k)|赞(0)|评价(0)|浏览(396)

1 webservice概述

webservice 即 web 服务，因互联网而产生，通过 webservice 这种 web 服务，我们可以实现互联网应用之间的资源共享，比如我们想知道 手机号码归属地，列车时刻表，天气预报，省市区邮政编码等信息，由于我们自己的数据库中并没有这些信息，那么我们可以调用第三方提供的 webservice服务，获取这些信息；

webservice 是一种系统之间进行调用的技术，系统之间调用的技术有：httpClient、hessian、dubbo、webservice 等；WebService 是一种跨越编程语言，跨越操作系统，跨越终端的远程调用技术，比如一个系统是 Java 语言开发的，另一个系统是 PHP 语言开发的，他们之间要实现信息交互，则可以使用 webservice 进行数据交互；

??所以 webservice 实现了异构系统之间的通信，不管是采用什么语言编写的，不管部署在什么操作系统平台上，使用 webservice 都可以实现信息的交换；

2 webservice核心要素

2.1 SOAP

SOAP 英文全称为：Simple Object Access Protocol，即简单对象访问协议，它是基于 xml 格式的消息交换协议；

OAP 定义了信息交换的格式，它包含一个重要的信封 envelope，使用信封envelope 来包装要传递的信息，使用命名空间 namespace 来区分传递的信息；简单来说，在 WebService 中传递的信息就是一封信，SOAP 就是信的通用格式，它定义了一封信应该有信封，信封里装着信的内容；

信封（envlope）的格式是固定的，而信的内容（要传递的数据）可以自己定义；SOAP 协议传输的数据采用 xml 格式进行封装，采用 http 协议进行传输，即soap=xml+http；

2.2 WSDL

WSDL 英文全称为 Web Service Description Language，即 Web Service 描述语言；它使用 xml 对 Web Service 进行描述，比如提供服务的方法、参数、返回值、数据类型等信息进行描述；简单来说，wsdl 就是 webservice 服务的使用说明书；

3 webservice的使用场景

1、应用系统集成
多个应用系统集成在一起，则需要信息交换或通信，那么可以采用 webservice进行通信；

2、异构系统之间通信
异构系统，主要是指编程语言不同的系统；不同系统之间，特别是开发语言不同的系统之间，可以通过 webservice 进行信息交换；

3、软件复用
webservice 可以作为一个公共的服务，供客户端调用，避免软件重复开发工作；

4 webservice的结构

服务端：提供服务，供客户端调用；
客户端：调用服务，获得服务的数据；

5 Java中的webservice

各种编程语言下都有 webservice 技术，比如 php、c#、Java 等；由于 webservice 定义交互的格式，所以不同编程语言之间可以实现相互调用，数据交换和通信；
Java 中的 webservice，即 Java API for XML-Based Webservices，简称JAX-WS 规范；

JAX-WS 是 sun 公司随 Java 5 发布的一项 webservice 规范，在此之前是JAX-RPC，JAX-RPC 不是很完善；由于 JAX-RPC 并不是很完善，所以在 Java 5 发布后，随即发布了 JAX-RPC2.0，该版本已经比较成熟和完善，后来为了和之前的规范进行区分，又将其改名为JAX-WS 2.0；

Java 5 对应 JAX-WS 2.0 版本；
Java 6 对应 JAX-WS 2.1 版本；
Java 7 对应 JAX-WS 2.2 版本；
目前 JAX-WS 是 2.2.9

5.1 webservice服务端

1、定义一个服务接口及实现，并将实现类注解为@WebService，标注了该注解的类的方法就变为 webservice 方法；

  1. public interface UserService {
  3.     public String sayHi (String name);
  5.     public String work (String work);
  7.     public User getUser (User user);
  9. }
  1. /**
  2.  * 标注了该@WebService注解的类的方法就变为webservice方法
  3.  */
  4. @WebService
  5. public class UserServiceImpl implements UserService {
  7.     @Override
  8.     public String sayHi(String name) {
  9.         return "Hi, " + name;
  10.     }
  12.     @Override
  13.     public String work (String work) {
  14.         return "He is working " + work;
  15.     }
  17.     @Override
  18.     public User getUser (User user) {
  19.         user.setName(user.getName() + "-service");
  20.         return user;
  21.     }
  22. }
  1. public class User {
  3.     private int id;
  5.     private String name;
  7.     private Date birthday;
  9.     public int getId() {
  10.         return id;
  11.     }
  13.     public void setId(int id) {
  14.         this.id = id;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public Date getBirthday() {
  26.         return birthday;
  27.     }
  29.     public void setBirthday(Date birthday) {
  30.         this.birthday = birthday;
  31.     }
  32. }

2、通过 Endpoint 的 publish 方法，将上一步定义的服务发布出去；

  1. public class Server {
  3.     public static void main(String[] args) {
  4.         //发布webservice
  5.         String wsAddress = "http://localhost:6868/01-ws-java-server/ws";
  6.         Endpoint endpoint = Endpoint.publish(wsAddress, new UserServiceImpl());
  7.         System.out.println("webservice发布成功：" + endpoint.isPublished());
  8.     }
  9. }

3、运行 main 方法；

4、 在 浏 览 器 里 输入 http://localhost:6868/01-ws-java-server/ws?wsdl 将 会 看 到webservice 的 wsdl 信息；有了服务端的 webservice 描述文件 wsdl，就可以根据这个描述文件开发客户端调用程序

5.2 webservice客户端

1、根据服务端的 wsdl 文件生成客户端调用代码：
在命令行输入命令（需要配置了 Java 环境变量）：
wsimport -encoding [编码] -keep -p [包名] [发布的服务地址?wsdl]
比如：

  1. wsimport -encoding utf8 -keep -p com.ws.stub -Xnocompile http://localhost:6868/01-ws-java-server/ws?wsdl

其中：
wsimport 命令
-encoding 指定生成代码的编码格式
-keep 保存生成的代码
-p 指定包名
-Xnocompile 表示生成的代码不编译

2、使用生成的代码调用服务端提供的服务；

  1. public class Client {
  3.     public static void main(String[] args) {
  5.         //1.创建一个webservice的客户端
  6.         UserServiceImplService userServiceImplService = new UserServiceImplService();
  8.         //2.获取远程服务接口对象
  9.         UserServiceImpl userService = userServiceImplService.getUserServiceImplPort();
  11.         //3.直接调用远程服务接口对象的方法
  12.         String hi= userService.sayHi("张三丰");
  13.         System.out.println(hi);
  15.         String work = userService.work("Java");
  16.         System.out.println(work);
  18.         User user = new User();
  19.         user.setId(100);
  20.         user.setName("张无忌");
  21.         user.setBirthday(DateUtils.dateToXmlDate(new Date()));
  22.         User userServer = userService.getUser(user);
  23.         System.out.println(userServer.getId() + "--" + userServer.getName() + "--" + userServer.getBirthday());
  24.     }
  25. }

注意Date类型要使用工具类特殊处理

  1. public class DateUtils {
  3.     /**
  4.      * 将Date类转换为XMLGregorianCalendar
  5.      *
  6.      * @param date
  7.      * @return
  8.      */
  9.     public static XMLGregorianCalendar dateToXmlDate(Date date){
  10.         Calendar cal = Calendar.getInstance();
  11.         cal.setTime(date);
  12.         DatatypeFactory dtf = null;
  13.         try {
  14.             dtf = DatatypeFactory.newInstance();
  15.             XMLGregorianCalendar dateType = dtf.newXMLGregorianCalendar();
  16.             dateType.setYear(cal.get(Calendar.YEAR));
  17.             //由于Calendar.MONTH取值范围为0~11,需要加1
  18.             dateType.setMonth(cal.get(Calendar.MONTH)+1);
  19.             dateType.setDay(cal.get(Calendar.DAY_OF_MONTH));
  20.             dateType.setHour(cal.get(Calendar.HOUR_OF_DAY));
  21.             dateType.setMinute(cal.get(Calendar.MINUTE));
  22.             dateType.setSecond(cal.get(Calendar.SECOND));
  24.             return dateType;
  25.         } catch (DatatypeConfigurationException e) {
  26.             e.printStackTrace();
  27.         }
  28.         return null;
  29.     }
  31.     /**
  32.      * 将XMLGregorianCalendar转换为Date
  33.      *
  34.      * @param cal
  35.      * @return
  36.      */
  37.     public static Date xmlDate2Date(XMLGregorianCalendar cal){
  38.         return cal.toGregorianCalendar().getTime();
  39.     }
  40. }

6 WDSL文件说明

service

  • 整个 webservice 的服务信息，比如服务名，包括所有的服务；

binding

  • 定义每个服务接口的消息格式和协议细节；

portType

  • 描述整个 webservice 可以被执行的操作及相关信息；

message

  • 定义操作的一个或多个数据参数；

types

  • 定义 webservice 使用的全部数据类型；

7 webservice 请求与响应监控

webservice 的请求和响应是 soap 格式的 xml,可以采用一个端口监听工具 TCPMon，通过这个工具，我们可以非常方便地监听目标端口请求与响应的数据；

TCPMon 相当于一个“ 拦截器”，所有我们向目标服务器发送的数据包和服务器返回的数据包都要经过这个拦截器（也可以叫作代理服务器），进而拦截到请求和响应的数据包；

如上图，如果不使用监控工具，我们是通过 http://xxx.xxx.xxx:8080 访问服务端的服务；如果使用监控工具，则通过访问监控工具，由监控工具请求服务端的,服务，然后再把结果返回给我们，则访问请求变为：http://xxx.xxx.xxx:9000
需要访问9000重新生成WDSL，并替换掉之前的WDSL,然后重新发起请求。

8 webservice 在Tomcat中发布

1、添加相关依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.ws</groupId>
  8.     <artifactId>03-ws-web-server</artifactId>
  9.     <version>1.0.0</version>
  11.     <dependencies>
  12.         <dependency>
  13.             <groupId>com.sun.xml.ws</groupId>
  14.             <artifactId>jaxws-rt</artifactId>
  15.             <version>2.2.10</version>
  16.         </dependency>
  18.         <dependency>
  19.             <groupId>javax.servlet</groupId>
  20.             <artifactId>javax.servlet-api</artifactId>
  21.             <version>3.1.0</version>
  22.         </dependency>
  24.     </dependencies>
  26.     <build>
  27.         <plugins>
  28.             <plugin>
  29.                 <groupId>org.apache.maven.plugins</groupId>
  30.                 <artifactId>maven-compiler-plugin</artifactId>
  31.                 <configuration>
  32.                     <source>1.8</source>
  33.                     <target>1.8</target>
  34.                 </configuration>
  35.             </plugin>
  36.         </plugins>
  37.     </build>
  39. </project>

2、编写服务接口

  1. public interface UserService {
  3.     public String sayHi(String name);
  5.     public String work(String work);
  7.     public User getUser(User user);
  9. }

3、添加服务实现类，并标注@webservice注解

  1. /**
  2.  * 标注了该@WebService注解的类的方法就变为webservice方法
  3.  */
  4. @WebService
  5. public class UserServiceImpl implements UserService {
  7.     @Override
  8.     public String sayHi(String name) {
  9.         return "Hi, " + name;
  10.     }
  12.     @Override
  13.     public String work (String work) {
  14.         return "He is working " + work;
  15.     }
  17.     @Override
  18.     public User getUser (User user) {
  19.         user.setName(user.getName() + "-service");
  20.         return user;
  21.     }
  22. }

4、在WEB-INF文件夹下创建webservice配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">
  4.     <!-- 服务路径http://网站路径/ws/userService -->
  5.     <endpoint name="userService"
  6.               implementation="com.ws.service.impl.UserServiceImpl"
  7.               url-pattern="/ws/userService" />
  9. </endpoints>

5、在web,xml中添加WSServlet，servlet3.0也可以不添加如下配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xmlns="http://java.sun.com/xml/ns/javaee"
  4.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.          id="WebApp_ID" version="3.0">
  7.     <!-- Servlet 3.0或者以上不需要配置 -->
  8.     <servlet>
  9.         <servlet-name>jaxws</servlet-name>
  10.         <servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
  11.         <load-on-startup>1</load-on-startup>
  12.     </servlet>
  13.     <servlet-mapping>
  14.         <servlet-name>jaxws</servlet-name>
  15.         <url-pattern>/ws/*</url-pattern>
  16.     </servlet-mapping>
  18. </web-app>

调用和之前一样

9 在Spring中使用webservice

1、导入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.ws</groupId>
  8.     <artifactId>05-ws-spring-web-server</artifactId>
  9.     <version>1.0.0</version>
  11.     <dependencies>
  13.         <dependency>
  14.             <groupId>org.springframework</groupId>
  15.             <artifactId>spring-web</artifactId>
  16.             <version>4.3.13.RELEASE</version>
  17.         </dependency>
  19.         <dependency>
  20.             <groupId>org.jvnet.jax-ws-commons.spring</groupId>
  21.             <artifactId>jaxws-spring</artifactId>
  22.             <version>1.9</version>
  23.         </dependency>
  25.     </dependencies>
  27.     <build>
  28.         <plugins>
  29.             <plugin>
  30.                 <groupId>org.apache.maven.plugins</groupId>
  31.                 <artifactId>maven-compiler-plugin</artifactId>
  32.                 <configuration>
  33.                     <source>1.8</source>
  34.                     <target>1.8</target>
  35.                 </configuration>
  36.             </plugin>
  37.         </plugins>
  38.     </build>
  40. </project>

2、编写服务接口
3、编写接口的实现类，并添加@webservice注解,需要让spring将该类加载为一个bean，所以需要加上@servcice或者@Component注解

  1. /**
  2.  * 标注了该@WebService注解的类的方法就变为webservice方法
  3.  */
  4. @Component
  5. @WebService
  6. public class UserServiceImpl implements UserService {
  8.     @Override
  9.     public String sayHi(String name) {
  10.         return "Hi, " + name;
  11.     }
  13.     @Override
  14.     public String work (String work) {
  15.         return "He is working " + work;
  16.     }
  18.     @Override
  19.     public User getUser (User user) {
  20.         user.setName(user.getName() + "-service");
  21.         return user;
  22.     }
  23. }

4、添加spring配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <import resource="applicationContext-jaxws.xml"/>
  8. </beans>

5、配置spring的jax-ws配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:ws="http://jax-ws.dev.java.net/spring/core"
  6.        xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  8. 		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  9. 		http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core.xsd
  10. 		http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet.xsd">
  12.     <context:component-scan base-package="com.ws.service.impl" />
  14.     <!-- 绑定webservice地址，需要与web.xml的地址对应 -->
  15.  	<!-- 访问：http://localhost:8080/webservice-server-spring-web//ws/userService"?wsdl -->
  16.     <!--alt + enter-->
  17.     <wss:binding url="/ws/userService">
  18.         <wss:service>
  19.             <ws:service bean="#userServiceImpl" />
  20.         </wss:service>
  21.     </wss:binding>
  23. </beans>

6、配置web.xml文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xmlns="http://java.sun.com/xml/ns/javaee"
  4.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.          id="WebApp_ID" version="3.0">
  7.     <!-- needed for ContextLoaderListener -->
  8.     <context-param>
  9.         <param-name>contextConfigLocation</param-name>
  10.         <param-value>classpath:applicationContext.xml</param-value>
  11.     </context-param>
  13.     <!-- Bootstraps the root web application context before servlet initialization -->
  14.     <listener>
  15.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  16.     </listener>
  18.     <!-- 用于配置地址栏请求路径 -->
  19.     <servlet>
  20.         <servlet-name>JaxWsServlet</servlet-name>
  21.         <servlet-class>com.sun.xml.ws.transport.http.servlet.WSSpringServlet</servlet-class>
  22.     </servlet>
  23.     <servlet-mapping>
  24.         <servlet-name>JaxWsServlet</servlet-name>
  25.         <url-pattern>/ws/*</url-pattern>
  26.     </servlet-mapping>
  28. </web-app>

调用和之前一样

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_43842093/article/details/123079151

内容来源于网络，如有侵权，请联系作者删除！

Javaxml开发语言webservice

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com