面向服务的软件架构--WebService

最新推荐文章于 2022-04-30 19:56:48 发布
最新推荐文章于 2022-04-30 19:56:48 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： Java 文章标签： webservice
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39759664/article/details/115546384
版权

文章目录

1. 什么是web服务：

常见的web服务：淘宝、京东、天气预报、新闻。。。

1.1 简介：

  1. webservice即web服务，它是一种跨编程语言和跨操作系统平台的远程调用技术
    在这里插入图片描述
  2. java中共有三种WebService规范，分别是 JAX-WS（JAX-RPC）、JAXM&SAAJ、JAXRS
  3. webService的三要素：soap wsdl uddi

1.2 开发规范

webService的三种开发规范：

  • JAX-WS：
    JAX-WS（Java API For XML-WebService），JDK1.6 自带的版本为JAX-WS2.1，其底层支持为JAXB。JAX-WS（JSR 224）规范的API 位于javax.xml.ws.*包，其中大部分都是注解，提供API 操作Web 服务（通常在客户端使用的较多，由于客户端可以借助SDK 生成，因此这个包中的API 我们较少会直接使用）。使用的是soap协议
  • JAXM&SAAJ：
    JAXM（JAVA API For XML Message）主要定义了包含了发送和接收消息所需的API，相当于Web 服务的服务器端，其API 位于javax.messaging.*包，它是JAVA EE 的可选包，因此你需要单独下载。
    SAAJ（SOAP With Attachment API For Java，JSR 67）是与JAXM 搭配使用的API，为构建SOAP 包和解析SOAP 包提供了重要的支持，支持附件传输，它在服务器端、客户端都需要使用。这里还要提到的是SAAJ 规范，其API 位于javax.xml.soap.*包。如果你想控制SOAP 消息的更
    多细节，可以使用JAXM&SAAJ
  • JAX-RS：(现在相对流行的方式)
    JAX-RS 是JAVA 针对REST(RepresentationState Transfer)风格制定的一套Web 服务规范，由于推出的较晚，该规范（JSR 311，目前JAX-RS 的版本为1.0）并未随JDK1.6 一起发行，你需要到JCP 上单独下载JAX-RS 规范的接口，API 位于javax.ws.rs.*包。这里的JAX-WS 和JAX-RS 规范我们采用Apache CXF 作为实现，CXF 是Objectweb Celtix和Codehaus XFire 合并而成。CXF 的核心是org.apache.cxf.Bus（总线），类似于Spring 的ApplicationContext，Bus 由BusFactory 创建，默认是SpringBusFactory 类，可见默认CXF是依赖于Spring 的，Bus 都有一个ID，默认的BUS 的ID 是cxf。你要注意的是ApacheCXF

1.3 SOAP 协议

  • (1) SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML（标准通用标记语言下的一个子集）编码信息的轻量级协议。它有三个主要方面：XML-envelope为描述信息内容和如何处理内容定义了框架，将程序对象编码成为XML对象的规则，执行远程过程调用(RPC)的约定。SOAP可以运行在任何其他传输协议上。
  • (2) SOAP作为一个基于XML语言的协议用于有网上传输数据。
  • (3) SOAP = 在HTTP的基础上+XML数据。
  • (4) SOAP是基于HTTP的。
  • (5) SOAP的组成如下
    • a) Envelope – 必须的部分。以XML的根元素出现。
    • b) Headers – 可选的。
    • c) Body – 必须的。在body部分，包含要执行的服务器的方法。和发送到服务器的数
      据。

1.4 wsdl说明书

Web Service描述语言WSDL（SebService Definition Language）就是用机器能阅读的方式提供的一个正式描述文档而基于XML（标准通用标记语言下的一个子集）的语言，用于描述Web Service及其函数、参数和返回值。因为是基于XML的，所以WSDL既是机器可阅读的，又是人可阅读的。

  • WSD说明书
  1. 通过wsdl说明书，就可以描述webService服务端对外部的服务
  2. wsdl说明书是一个基于xml文件，通过xml语言描述整个服务
  3. 在wsdl说明中，描述了：
    对外发布的服务名称
    接口方法名称
    接口的参数
    服务返回的数据类型

1.5 UDDI

Web 服务提供商又如何将自己开发的 Web 服务公布到因特网上，
这就需要使用到 UDDI 了，UDDI的话，是一个跨产业，跨平台的开放性架构，可以帮助
Web 服务提供商在互联网上发布 Web 服务的信息。
UDDI 是一种目录服务，企业可以通过 UDDI 来注册和搜索 Web 服务。简单来时候话，UDDI 就是一个目录，只不过在这个目录中存放的是一些关于 Web 服务
的信息而已。并且 UDDI 通过SOAP 进行通讯，构建于 . Net 之上。UDDI 即 Universal Description，Discovery andIntegration，也就是通用的描述，发现
以及整合。
UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为
WebService提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

1.6 应用场景

Web Service 可以适用于应用程序集成、软件重用、跨防火墙通信等需求。不同的业务要求不同

  1. 跨防火墙通信
  2. 应用系统集成
  3. 软件和数据重用

1.6.1 优点：

  1. 异构平台的互通性
  2. 更广泛的软件复用
  3. 成本低、可读性强、应用范围广
  4. 迅捷的软件发行方式
  5. 客户端与服务端可能是用不同的语言开发的，但是，通过webservice提供服务接口，客户端与服务端之前可以传递对象

1.6.2 缺点

由于soap是基于xml传输，本身使用xml传输会传输一些无关内容从而影响效率，随着soap协议的完善，soap协议增加了许多内容，这样就导致了使用soap去完成简单的数据传输而携带的信息更多效率再受影响；Web Service作为web跨平台访问的标准技术，很多公司都限定要求使用Web Service，但如果是简单的接口可以直接使用http传输自定义数据格式，开发更快捷

2. 面向服务架构SOA

SOA(Service-OrientedArchitecture)面向服务架构是一种思想，它将应用程序的不同功能单元通过中立的契约（独立于硬件平台、操作系统和编程语言）联系起来，使得各种形式的功能单元更好的集成。目前来说，WebService 是SOA 的一种较好的实现方WebService 采用HTTP 作为传输协议，SOAP（Simple Object Access Protocol）作为传输消息的格式。但WebService 并不是完全符合SOA 的概念，因为SOAP 协议是WebService 的特有协议，并未符合SOA 的传输协议透明化的要求。SOAP 是一种应用协议，早期应用于RPC 的实现，传输协议可以依赖于HTTP、SMTP 等。
在这里插入图片描述在这里插入图片描述

3. ApacheCXF 框架介绍

3.1 关于 Apache CXF

Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTfulHTTP 或者 CORBA ，并且可以在多种传输协议上运行，比如：HTTP、JMS 或者 JBI，CXF 大大简化了 Services 的创建，同时它继承了 XFire 传统，一样可以天然地和 Spring 进行无缝集成。

3.2 功能特性

  • (1) 支持 Web Services 标准
  • (2) Frontends：CXF 支持多种“Frontend”编程模型
  • (3) 容易使用
  • (4) 支持二进制和遗留协议 比如：JSON 和 CORBA。

4. ApacheCXF 实现–WebService（Jax-ws）

4.1 服务端

  • 添加依赖：
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>01_jaxws_server</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>01_jaxws_server</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!-- 要进行jaxws 服务开发 -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxws</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 内置jetty web服务器  -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-transports-http-jetty</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 日志实现 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
  • 编写服务端的接口及实现类
package com.tjk.service;

import javax.jws.WebService;

/**
 *这个类是对外发布服务的接口
 */
@WebService//表示该类是一个webservice接口
public interface HelloService {

    /**
     * 对外发布服务的接口的方法
     */
    public  String sayHello(String name);


}




实现类：
package com.tjk.service.impl;

import com.tjk.service.HelloService;

public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return name+"Welcome to 面向服务";
    }
}
  • 测试服务发布结果
  1. 创建服务工厂
  2. 设置服务地址
  3. 设置服务类（实现类）
  4. 发布服务
package com.tjk;

import com.tjk.service.HelloService;
import com.tjk.service.impl.HelloServiceImpl;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;

public class ServiceTest {


    public static void main(String[] args) {
        //发布服务的工厂对象
        JaxWsServerFactoryBean factoryBean = new JaxWsServerFactoryBean();
        //设置服务地址
        factoryBean.setAddress("http://localhost:8000/ws/hello");
        //设置服务类
        factoryBean.setServiceBean(new HelloServiceImpl());
        //发布服务
        factoryBean.create();

        System.out.println("发布成功");

    }
}
  • 效果
    在这里插入图片描述

4.2 客户端

  • 添加依赖
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>01_jaxws_client</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>01_jaxws_client</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!-- 要进行jaxws 服务开发 -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxws</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 内置jetty web服务器  -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-transports-http-jetty</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 日志实现 -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
  • 添加服务类接口
package com.tjk.service;

import javax.jws.WebService;

/**
 *这个类是对外发布服务的接口
 */
@WebService//表示该类是一个webservice接口
public interface HelloService {

    /**
     * 对外发布服务的接口的方法
     */
    public  String sayHello(String name);


}
  • 测试客户端
    服务接口访问地址 http://localhost:8000/ws/hello
    1. 创建cxf代理工厂
    2. 设置远程访问服务端额的地址
    3. 设置接口类型
    4. 对接口生成代理对象
    5. 代理对象对象
    6. 远程访问服务方法
package com.tjk;

import com.tjk.service.HelloService;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;

public class client {
    public static void main(String[] args) {
        //服务接口访问地址 http://localhost:8000/ws/hello
        //创建cxf代理工厂
        JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();
        //设置远程访问服务端额的地址
        factoryBean.setAddress("http://localhost:8000/ws/hello");
        //设置接口类型
        factoryBean.setServiceClass(HelloService.class);
        //对接口生成代理对象
        HelloService helloService = factoryBean.create(HelloService.class);
        //代理对象对象
        System.out.println(helloService.getClass());
        //远程访问服务方法
        System.out.println(helloService.sayHello("tjk"));



    }
}
  • 效果：
    在这里插入图片描述

5. Spring 整合 ApacheCXF 实现 WebService（Jax-ws）

5.1 服务端

5.1.1 创建web项目

在这里插入图片描述

5.1.2 添加依赖

  • pom.xml
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>04_jaxws_spring_server</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>03_jaxws_spring_server Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>
  <dependencies>
    <!-- CXF WS开发  -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxws</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
      <!-- 运行tomcat7方法：tomcat7:run -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!-- 指定端口 -->
          <port>8080</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

5.1.3 web.xml 配置CXFServlet

<!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>
  <display-name>Archetype Created Web Application</display-name>
  <servlet>
    <servlet-name>cxfservlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>cxfservlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>
<!‐‐ webservice服务端，发布服务需要配置CXFServlet ‐‐>
<!‐‐ 这里配置的servlet路径，最为最终服务路径的一部分： ‐‐>
<!‐‐ 服务访问路径：http://localhost:8080/web.xml配置路径/spring配置的路
径 ‐‐>
  <!-- Spring容器初始化-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

5.1.4 服务接口、服务实现

在这里插入图片描述

5.1.5 Spring 整合 ApacheCXF

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cxf="http://cxf.apache.org/core"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd
        http://cxf.apache.org/jaxrs
        http://cxf.apache.org/schemas/jaxrs.xsd">


    <!--
       Spring整合cxf发布服务：关键点
       1. 服务地址
       2. 服务类
       服务的完整访问地址

    -->

    <jaxws:server address="/hello">
        <jaxws:serviceBean>
            <bean class="service.impl.HelloServiceImpl"></bean>

        </jaxws:serviceBean>
    </jaxws:server>

</beans>

5.1.6 启动服务，发布服务

在这里插入图片描述
结果：
在这里插入图片描述

5.2 客户端

5.2.1 创建项目

在这里插入图片描述

5.2.2 添加依赖

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>jaxws_spring_client</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>jaxws_spring_client</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- CXF WS开发  -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxws</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
      <!-- 运行tomcat7方法：tomcat7:run -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!-- 指定端口 -->
          <port>8080</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

5.2.3 添加service接口

package com.tjk.service;

import javax.jws.WebService;

/**
 * 这个类是对外发布服务的接口
 */
@WebService//表示该类是一个webservice接口
public interface HelloService {

    /**
     * 对外发布服务的接口的方法
     */
    public String sayHello(String name);
}

在这里插入图片描述

5.2.4 Spring 整合 ApacheCXF 配置

    Spring整合cxf客户端配置：
    1. 服务地址     http://localhost:8080/ws/hello
    2. 服务接口类型

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cxf="http://cxf.apache.org/core"
       xmlns:jaxws="http://cxf.apache.org/jaxws"
       xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/core
        http://cxf.apache.org/schemas/core.xsd
        http://cxf.apache.org/jaxws
        http://cxf.apache.org/schemas/jaxws.xsd
        http://cxf.apache.org/jaxrs
        http://cxf.apache.org/schemas/jaxrs.xsd">

    <!--
        Spring整合cxf客户端配置：
        1. 服务地址     http://localhost:8080/ws/hello
        2. 服务接口类型

    -->
    <jaxws:client
            id="helloService"
            serviceClass="com.tjk.service.HelloService"
            address="http://localhost:8080/ws/hello"></jaxws:client>

</beans>

5.2.5 测试结果

package com.tjk;

import com.tjk.service.HelloService;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class client {

        // 注入对象
        @Resource
        private HelloService helloService;

        @Test
        public void remote() {
            // 查看接口的代理对象类型
            // class com.sun.proxy.$Proxy45
            System.out.println(helloService.getClass());

            // 远程访问服务端方法
            System.out.println(helloService.sayHello("Jerry"));
        }
    }

6. restful 风格

  • GET用来获取资源，
  • POST用来新建资源，
  • PUT用来更新资源，
  • DELETE用来删除资源。

7. ApacheCXF 实现webservice（Jax-rs）

`ApacheCXF 实现webservice（Jax-rs）

7.1 服务端

7.1.1 创建项目

在这里插入图片描述

7.1.2 添加依赖

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>jaxrs_sever</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>jaxrs_sever</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxrs</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-transports-http-jetty</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-client</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-extension-providers</artifactId>
      <version>3.0.1</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jettison</groupId>
      <artifactId>jettison</artifactId>
      <version>1.3.7</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>

      </plugins>
    </pluginManagement>
  </build>
</project>

7.1.3 服务接口 实现 实体类

在这里插入图片描述
在这里插入图片描述

package com.tjk.service;

import java.util.List;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;

import com.tjk.entity.User;

//  访问当前服务接口对应的路径
@Path("/userService")
@Produces("*/*")  // 服务器支持的返回的数据格式类型
public interface IUserService {

	// 表示处理的请求的类型，post 对应的是insert新增操作
	@POST
	// 访问当前服务接口方法对应的路径。 【.../userService/user】
	@Path("/user")
	//  服务器支持的请求的数据格式类型
	@Consumes({ "application/xml", "application/json" })
	public void saveUser(User user);

	// 表示处理的请求的类型，put 对应的是update修改操作
	@PUT
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })
	public void updateUser(User user);

	// 表示处理的请求的类型，get 对应的是查询修改操作
	@GET
	@Path("/user")
	// 服务器支持的返回的数据格式类型
	@Produces({ "application/xml", "application/json" })
	public List<User> findAllUsers();

	@GET
	@Path("/user/{id}")
	@Consumes("application/xml")
	@Produces({ "application/xml", "application/json" })
	public User finUserById(@PathParam("id") Integer id);

	// 表示处理的请求的类型，delete 对应的是删除操作
	@DELETE
	@Path("/user/{id}")
	@Consumes({"application/xml", "application/json"})
	public void deleteUser(@PathParam("id") Integer id);
}


实现类
package com.tjk.service.impl;

import java.util.ArrayList;
import java.util.List;
import com.tjk.entity.Car;
import com.tjk.entity.User;
import com.tjk.service.IUserService;

public class UserServiceImpl implements IUserService {

	public void saveUser(User user) {
		System.out.println("save user:" + user);
	}

	public void updateUser(User user) {
		System.out.println("update user:" + user);
	}

	public List<User> findAllUsers() {
		List<User> users = new ArrayList<User>();
		User user1 = new User();
		user1.setId(1);
		user1.setUsername("小明");
		user1.setCity("北京");

		List<Car> carList1 = new ArrayList<Car>();
		Car car1 = new Car();
		car1.setId(101);
		car1.setCarName("保时捷");
		car1.setPrice(1000000d);
		carList1.add(car1);
		Car car2 = new Car();
		car2.setId(102);
		car2.setCarName("宝马");
		car2.setPrice(400000d);
		carList1.add(car2);
		user1.setCars(carList1);

		users.add(user1);

		User user2 = new User();
		user2.setId(2);
		user2.setUsername("小丽");
		user2.setCity("上海");
		users.add(user2);

		return users;
	}

	public User finUserById(Integer id) {
		if (id == 1) {
			User user1 = new User();
			user1.setId(1);
			user1.setUsername("小明");
			user1.setCity("北京");
			return user1;
		}
		return null;
	}

	public void deleteUser(Integer id) {
		System.out.println("delete user id :" + id);
	}

}

// 访问当前服务接口对应的路径
@Path("/userService")
@Produces("/") // 服务器支持的返回的数据格式类型
// 表示处理的请求的类型，post 对应的是insert新增操作
@POST
// 访问当前服务接口方法对应的路径。 【…/userService/user】
@Path("/user")
// 服务器支持的请求的数据格式类型
@Consumes({ “application/xml”, “application/json” })
// 服务器支持的返回的数据格式类型
@Produces({ “application/xml”, “application/json” })

  • bean

/**

  • @XmlRootElement 指定根元素，作用：客户端与服务端传递对象数据时候，序列化为
    xml或json的根元素的名称
  • 客户端与服务端传递XML:
  • 这里的根元素Car是由name="Car"指定的
  • 客户端与服务端传递JSON:
  • {“Car”: {“id”:100,“name”:"",“price”:100}}

*/

/**
* @XmlRootElement 指定根元素，作用：客户端与服务端传递对象数据时候，序列化为
xml或json的根元素的名称
* 客户端与服务端传递XML:
* <Car1></Car> 这里的根元素Car是由name="Car"指定的
*
* 客户端与服务端传递JSON:
* {"Car": {"id":100,"name":"","price":100}}
*
*/
@XmlRootElement(name = "Car")
public class Car {
private Integer id;
private String carName;
private Double price; 省略get、set
}
@XmlRootElement(name = "User")
public class User {
private Integer id;
private String username;
private String city;
private List<Car> cars = new ArrayList<Car>(); 省略get、set
}

7.1.4 使用的注解分析

使用的注解：
@XmlRootElement
指定根元素，
作用：客户端与服务端传递对象数据时候，序列化为xml或json的根元素的名称
@Path("/userService")
路径；访问当前服务接口时候的路径、接口方法的路径。
@POST insert操作
// 用户集合
users.add(user1);
users.add(user2);
return users;
}
public User finUserById(Integer id) {
if (id == 1) {
return new User(1,“小明”,“广州”,null);
}
return null;
}
public void deleteUser(Integer id) {
System.out.println(“delete user id :” + id);
}
}
北京市昌平区建材城西路金燕龙办公楼一层 电话：400-618-9090@PUT update操作
@GET select 查询操作
@DELETE delete删除操作
@Consumes 服务端支持的请求的数据格式(xml、json)
@Produces 服务端支持的响应的数据格式

7.1.5 发布服务

package com.tjk;

import com.tjk.service.impl.UserServiceImpl;
import org.apache.cxf.interceptor.LoggingInInterceptor;
import org.apache.cxf.interceptor.LoggingOutInterceptor;
import org.apache.cxf.jaxrs.JAXRSServerFactoryBean;

public class sever {

    public static void main(String[] args) {
        //创建发布服务工厂
        JAXRSServerFactoryBean factoryBean = new JAXRSServerFactoryBean();

        //设置服务地址
        factoryBean.setAddress("http://localhost:8001/rs/");

        //设置服务类
        factoryBean.setServiceBean(new UserServiceImpl());

        //添加日志输入输出拦截器
        factoryBean.getInInterceptors().add(new LoggingInInterceptor());
        factoryBean.getOutInterceptors().add(new LoggingOutInterceptor());

        //发布服务
        factoryBean.create();
        System.out.println("发布成功");
    }
}

7.2 客户端

7.2.1 创建项目

在这里插入图片描述

7.2.2 添加依赖


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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>jaxrs_sever</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>jaxrs_sever</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxrs</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-transports-http-jetty</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-client</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-extension-providers</artifactId>
      <version>3.0.1</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jettison</groupId>
      <artifactId>jettison</artifactId>
      <version>1.3.7</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- clean lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#clean_Lifecycle -->
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- default lifecycle, jar packaging: see https://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-jar-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!-- site lifecycle, see https://maven.apache.org/ref/current/maven-core/lifecycles.html#site_Lifecycle -->
        <plugin>
          <artifactId>maven-site-plugin</artifactId>
          <version>3.7.1</version>
        </plugin>

      </plugins>
    </pluginManagement>
  </build>
</project>

7.2.3 写junit，远程访问服务端

package com.tjk;


import com.tjk.entity.User;
import org.apache.cxf.jaxrs.client.WebClient;
import org.junit.Test;

import javax.ws.rs.core.MediaType;

public class client {

    @Test
    public  void testSave(){
        User user = new User();
        user.setCity("韩城");
        user.setId(1);
        user.setUsername("tjk");
        WebClient
                .create("http://localhost:8001/rs/userService/user")
                .type(MediaType.APPLICATION_JSON_TYPE)
                .post(user);
    }


    @Test
    public void testGet(){
        User user=WebClient.create("http://localhost:8001/rs/userService/user/1")
                 .accept(MediaType.APPLICATION_JSON_TYPE)
                .get(User.class);
        System.out.println(user);
    }
}

结果：
在这里插入图片描述

在这里插入图片描述

8. Sping整合CXF实现基于Restful风格的webservice(jax-rs)

8.1 服务端

8.1.1 创建工程

在这里插入图片描述

8.1.2 添加依赖

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.tjk</groupId>
  <artifactId>jaxrs_spring_sever</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>jaxrs_spring_sever Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- cxf 进行rs开发 必须导入  -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-frontend-jaxrs</artifactId>
      <version>3.0.1</version>
    </dependency>
    <!-- 日志引入  -->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.12</version>
    </dependency>

    <!-- 客户端 -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-client</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 扩展json提供者 -->
    <dependency>
      <groupId>org.apache.cxf</groupId>
      <artifactId>cxf-rt-rs-extension-providers</artifactId>
      <version>3.0.1</version>
    </dependency>

    <!-- 转换json工具包，被extension providers 依赖 -->
    <dependency>
      <groupId>org.codehaus.jettison</groupId>
      <artifactId>jettison</artifactId>
      <version>1.3.7</version>
    </dependency>

    <!-- spring 核心 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <!-- spring web集成 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <!-- spring 整合junit  -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <!-- junit 开发包 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
          <showWarnings>true</showWarnings>
        </configuration>
      </plugin>
      <!-- 运行tomcat7方法：tomcat7:run -->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!-- 指定端口 -->
          <port>8080</port>
          <!-- 请求路径 -->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

8.1.3 web.xml

<!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>
  <display-name>Archetype Created Web Application</display-name>

  <servlet>
    <servlet-name>cxfservlet</servlet-name>
    <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>cxfservlet</servlet-name>
    <url-pattern>/ws/*</url-pattern>
  </servlet-mapping>
  <!--2.spring容器配置-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

</web-app>

8.1.4 编写实体 接口和实现类

  • 实体
    在这里插入图片描述
package com.tjk.entity;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "Car")
public class Car {
	private Integer id;
	private String carName;
	private Double price;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getCarName() {
		return carName;
	}

	public void setCarName(String carName) {
		this.carName = carName;
	}

	public Double getPrice() {
		return price;
	}

	public void setPrice(Double price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Car [id=" + id + ", carName=" + carName + ", price=" + price + "]";
	}

}


------------------------------------------------------------------------------------------------------
package com.tjk.entity;

import javax.xml.bind.annotation.XmlRootElement;
import java.util.ArrayList;
import java.util.List;

@XmlRootElement(name = "User")
public class User {
	private Integer id;
	private String username;
	private String city;

	private List<Car> cars = new ArrayList<Car>();

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	public List<Car> getCars() {
		return cars;
	}

	public void setCars(List<Car> cars) {
		this.cars = cars;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", city=" + city + ", cars=" + cars + "]";
	}

}
  • 接口
package com.tjk.service;

import com.tjk.entity.User;

import javax.ws.rs.*;
import java.util.List;

//  访问当前服务接口对应的路径
@Path("/userService")
//@Produces("*/*")  // 服务器支持的返回的数据格式类型
public interface IUserService {

	// 表示处理的请求的类型，post 对应的是insert新增操作
	@POST
	// 访问当前服务接口方法对应的路径。 【.../userService/user】
	@Path("/user")
	//  服务器支持的请求的数据格式类型
	@Consumes({ "application/xml", "application/json" })
	public void saveUser(User user);

	// 表示处理的请求的类型，put 对应的是update修改操作
	@PUT
	@Path("/user")
	@Consumes({ "application/xml", "application/json" })
	public void updateUser(User user);

	// 表示处理的请求的类型，get 对应的是查询修改操作
	@GET
	@Path("/user")
	// 服务器支持的返回的数据格式类型
	@Produces({ "application/xml", "application/json" })
	public List<User> findAllUsers();

	@GET
	@Path("/user/{id}")
	@Consumes("application/xml")
	@Produces({ "application/xml", "application/json" })
	public User finUserById(@PathParam("id") Integer id);

	// 表示处理的请求的类型，delete 对应的是删除操作
	@DELETE
	@Path("/user/{id}")
	@Consumes({"application/xml", "application/json"})
	public void deleteUser(@PathParam("id") Integer id);
}
  • 实现类
package com.tjk.service;

import com.tjk.entity.Car;
import com.tjk.entity.User;

import java.util.ArrayList;
import java.util.List;

public class UserServiceImpl implements IUserService {

	public void saveUser(User user) {
		System.out.println("save user:" + user);
	}

	public void updateUser(User user) {
		System.out.println("update user:" + user);
	}

	public List<User> findAllUsers() {
		List<User> users = new ArrayList<User>();
		User user1 = new User();
		user1.setId(1);
		user1.setUsername("小明");
		user1.setCity("北京");

		List<Car> carList1 = new ArrayList<Car>();
		Car car1 = new Car();
		car1.setId(101);
		car1.setCarName("保时捷");
		car1.setPrice(1000000d);
		carList1.add(car1);
		Car car2 = new Car();
		car2.setId(102);
		car2.setCarName("宝马");
		car2.setPrice(400000d);
		carList1.add(car2);
		user1.setCars(carList1);

		users.add(user1);

		User user2 = new User();
		user2.setId(2);
		user2.setUsername("小丽");
		user2.setCity("上海");
		users.add(user2);

		return users;
	}

	public User finUserById(Integer id) {
		if (id == 1) {
			User user1 = new User();
			user1.setId(1);
			user1.setUsername("小明");
			user1.setCity("北京");
			return user1;
		}
		return null;
	}

	public void deleteUser(Integer id) {
		System.out.println("delete user id :" + id);
	}

}

8.1.5 CXF整合Spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://cxf.apache.org/jaxrs
        http://cxf.apache.org/schemas/jaxrs.xsd">

    <!--
        Spring整合cxf发布基于restful风格的服务，关键点：
        1. 服务地址
        2. 服务类
        服务完整访问地址：
            http://localhost:8080/ws/hello
    -->
    <jaxrs:server address="/userService">

        <jaxrs:serviceBeans>
            <bean class="com.tjk.service.UserServiceImpl"></bean>
        </jaxrs:serviceBeans>

    </jaxrs:server>

</beans>

8.1.6 发布服务

在这里插入图片描述

8.2 客户端

8.2.1 创建工程

在这里插入图片描述

8.2.2 添加依赖

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.tjk</groupId>
    <artifactId>jaxrs_spring_client</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>jaxrs_spring_client</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- cxf 进行rs开发 必须导入  -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-frontend-jaxrs</artifactId>
            <version>3.0.1</version>
        </dependency>
        <!-- 日志引入  -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>

        <!-- 客户端 -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-client</artifactId>
            <version>3.0.1</version>
        </dependency>

        <!-- 扩展json提供者 -->
        <dependency>
            <groupId>org.apache.cxf</groupId>
            <artifactId>cxf-rt-rs-extension-providers</artifactId>
            <version>3.0.1</version>
        </dependency>

        <!-- 转换json工具包，被extension providers 依赖 -->
        <dependency>
            <groupId>org.codehaus.jettison</groupId>
            <artifactId>jettison</artifactId>
            <version>1.3.7</version>
        </dependency>

        <!-- spring 核心 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- spring web集成 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- spring 整合junit  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.2.4.RELEASE</version>
        </dependency>
        <!-- junit 开发包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>
            <!-- 运行tomcat7方法：tomcat7:run -->
        </plugins>
    </build>
</project>

8.2.3 添加实体类

与8.2.4 的实体类一样

8.2.3 测试服务

package com.tjk;


import com.tjk.entity.User;
import org.apache.cxf.jaxrs.client.WebClient;
import org.junit.Test;
import javax.ws.rs.core.MediaType;
public class client {

    @Test
    public  void testSave(){
        User user = new User();
        user.setCity("韩城");
        user.setId(1);
        user.setUsername("tjk");
        WebClient
                .create("http://localhost:8080/ws/userService/userService/user")
                .type(MediaType.APPLICATION_JSON_TYPE)
                .post(user);
    }


    @Test
    public void testGet(){
        User user=WebClient.create("http://localhost:8080/ws/userService/userService/user/1")
                 .accept(MediaType.APPLICATION_JSON_TYPE)
                .get(User.class);
        System.out.println(user);
    }
}
  • 结果
    在这里插入图片描述
小玩偶啊
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
web service 结构(摘)
冷峰的空间
12-06 80
今天，看java web service，发现书中例子很形象，拿出来大家分享。 我们来举一个简单的例子，大家都知道中国人懂日文的比较少，而日本人懂中文的也比较少，假设现在日本人开了个日本面馆，提供各种面例如炸酱面，石锅面等等，而且他想提供服务给全球各地的客户，让他们都能看懂提供的服务，并自己点面。那么是否这个日本人就需要学习全球各地的语言，然后挂上50 种语言的面单，之后接待50 种不同...
web service概念、架构及相关知识
liu_shi_jun的专栏
04-11 1万+
一、WebService的定义WebService有好几种定义： W3C组织对其定义:WebService是一个软件系统，为了支持跨网络的机器间互操作交互而设计。 WebService通常被定义为一组模块化的API,我们可以通过网络进行调用，来执行远程系统的请求服务。 WebService就是暴露给外部使用的，可通过web调用的一组API。 WebService是一种跨编程语言和跨操作系统平台的远程
几种流行Webservice框架
anyao4367的博客
05-10 377
一、 几个比较流行的Webservice框架： ApacheAxis1、ApacheAxis2、CodehausXFire、ApacheCXF、ApacheWink、JbossRESTEasy、sunJAX-WS（最简单、方便）、阿里巴巴Dubbo（除外）等，采用Java作为测试用例，通过本机和远程两种进行测试方式，对这几种框架进行了性能测试，并对测试结果分析和性能...
webservice简介及架构
07-26
详细的介绍webservice，用图文详细的说明webservice架构
webservice框架
weixin_44942769的博客
04-30 949
webservice框架
面向服务架构SOA软件产业新火种
02-27
SOA与构件技术、软件工程、...面向服务架构（SOA，Service-orientedarchitecture）就是在此背景下出现的，SOA被誉为下一代Web服务的基础框架，目前已经成为计算机信息领域的一个新的发展方向。1996年，Gartner最早提
WebService-CXF学习.doc
最新发布
08-12
这个框架的主要目标是提供高效、可扩展且用户友好的服务创建和路由工具，尤其适用于构建面向服务的架构（SOA）。CXF支持多种标准，如JAX-WS、JSR-181、SAAJ、JAX-RS等，以及SOAP 1.1和1.2、WSDL 1.1等协议，并具备WS...
webservice-cxf-spring-jar.zip
05-15
【标题】"webservice-cxf-spring-jar.zip" 是一个包含了使用Apache CXF与Spring框架集成开发Web服务的Java库集合。这个压缩包提供了一整套必要的JAR文件，以便于开发者在他们的项目中快速搭建和运行基于CXF的Web服务...
05-ApacheCamel-CXF-WebService
02-02
Apache Camel 是一个强大的开源企业集成库，它...无论是对于理解SOA（面向服务架构）还是微服务架构，这种集成技术都具有很高的实用价值。通过深入研究和实践，开发者可以提升其在企业级服务集成和API管理方面的技能。
完整的webservice架构源代码
07-28
一个完成的webservice程序，下载直接可运行。
软件架构设计-面向服务的架构设计
小毕超博客
06-12 6392
一、面向服务的架构SOA SOA 是一种在计算环境中设计、开发、部署和管理离散逻辑单元（服务）模型的方法。 SOA 并不是一个新鲜事物，而只是面向对象模型的一种替代。虽然基于 SOA 的系统并不排除使用 OOD 来构建单个服务，但是其整体设计却是面向服务的。由于 SOA 考虑到了系统内的对象，所以虽然 SOA 是基于对象的，但是作为一个整体，它却不是面向对象的。 SOA 系统原型的一个典型例子是 CORBA，它已经出现很长时间，其定义的概念与 SOA 相似。SOA 建立在 XML 等新技术的基础上，通过使用
WebService 四种发布方式总结
热门推荐
zl的博客
06-08 9万+
WebService 四种发布方式总结 1. CXF方式 CXF与spring搭建webservice是目前最流行的方式，但是传闻cxf与jdk1.5有些不兼容，我没有遇到过，我遇到的问题是cxf与was6.1.1不兼容，表现在cxf必须的jar包“wsdl4j-1.6.2.jar”报错，报的错为： java.lang.IncompatibleClassChangeError，明显
webservice-WSDL结构与各元素解析
xiongqi215的专栏
08-04 3258
承接上一遍webservice初识，这篇文章将着重于WSDL。    wsdl协议说明http://www.w3.org/TR/wsdl。 结构     现在开始说说wsdl的结构以及各个元素的意义。 从下面这张图可以看出wsdl中各元素是存在嵌套的关系的 (reference:http://www.ibm.com/developerworks/cn/webservices/ws
手把手教你如何玩转WebService（包含项目实践）
郝啊的博客
12-15 1464
声明：本文为转载Cs_hnu_scw博主分享的文章，仅用于个人学习。 原文链接：https://blog.csdn.net/cs_hnu_scw/article/details/80181762
创建WebService项目
wisdom_bo的博客
12-19 2828
在此之前，还是有必要了解下webSerbice的为何值得学习？究竟有哪些优点及所承担的作用？ 1、webService可跨平台调用（不局限与操作系统，可在任意不同的系统之间调用服务）。 2、webService可跨语言调用（不局限于编程语言，可在任意编程语言之间调用服务），如可以在Java语言中调用C#语言提供的服务，反之亦然。 3、webService可远程调用（通过使用web
WebService的简介, 原理, 使用，流程图
weixin_41167961的博客
04-04 2716
第一部分: 直观概述 WebService的几种概念: 以HTTP协议为基础，通过XML进行客户端和服务器端通信的框架/组件 两个关键点: 1. 服务端提供的功能, 通过xml描述 2. 第一步中的描述的功能, 嵌入到HTTP协议中, 使得能通过HTTP协议进行通信【所谓的SOAP】. 用图可以如下表示: 图一: WebServi...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值