文档章节

Spring Boot实践--集成WebServices基础开发

spinachgit
 spinachgit
发布于 2018/02/01 19:52
字数 2187
阅读 195
收藏 1

Spring Boot实践--集成Web Services基础开发

Spring Web Services(下简称ws)本质上是基于SpringBoot的项目,因此如果有对SpringBoot不太了解的同学,回头再来看比较合适。

ws分为server端与client端两个部分,本文旨在介绍框架搭建的流程与重点。

一、ws.server端搭建

建立Server的关键是首先建立xsd文件。xsd文件是xml文件的定义与基础,你希望别人如何访问与获取你的数据都需要在xsd文件中说明。

countries.xsd

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:tns="http://learnhow.org/ws/schema" targetNamespace="http://learnhow.org/ws/schema"
    elementFormDefault="qualified">
    <xs:element name="getCountryRequest">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="name" type="xs:string" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:element name="getCountryResponse">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="country" type="tns:country" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:complexType name="country">
        <xs:sequence>
            <xs:element name="name" type="xs:string" />
            <xs:element name="population" type="xs:int" />
            <xs:element name="capital" type="xs:string" />
            <xs:element name="currency" type="tns:currency" />
            <xs:element name="language" type="tns:language" />
        </xs:sequence>
    </xs:complexType>

    <xs:simpleType name="currency">
        <xs:restriction base="xs:string">
            <xs:enumeration value="GBP" />
            <xs:enumeration value="EUR" />
            <xs:enumeration value="PLN" />
        </xs:restriction>
    </xs:simpleType>

    <xs:complexType name="language">
        <xs:sequence>
            <xs:element name="name" type="xs:string" />
        </xs:sequence>
    </xs:complexType>
</xs:schema>

users.xsd

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://learnhow.org/ws/schema" targetNamespace="http://learnhow.org/ws/schema" elementFormDefault="qualified">
    <xs:element name="getUserRequest">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="name" type="xs:string" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>

    <xs:element name="getUserResponse">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="user" type="tns:user" />
            </xs:sequence>
        </xs:complexType>
    </xs:element>
    
    <xs:complexType name="user">
        <xs:sequence>
            <xs:element name="name" type="xs:string" />
            <xs:element name="gender" type="tns:gender" />
            <xs:element name="age" type="xs:int" />
            <xs:element name="address" type="xs:string" />
        </xs:sequence>
    </xs:complexType>
    
    <xs:simpleType name="gender">
        <xs:restriction base="xs:string">
            <xs:enumeration value="MALE" />
            <xs:enumeration value="FEMALE" />
        </xs:restriction>
    </xs:simpleType>
</xs:schema>

这两个文件默认请存放于 src/main/resources 目录下,如下图所示:

建立完成以后我们可以着手编写pom.xml文件,即建立工程依赖。

<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>org.learnhow</groupId>
    <artifactId>ws.server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>ws.server</name>
    <url>http://maven.apache.org</url>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
    </parent>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web-services</artifactId>
        </dependency>
        <dependency>
            <groupId>wsdl4j</groupId>
            <artifactId>wsdl4j</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>jaxb2-maven-plugin</artifactId>
                <version>1.6</version>
                <executions>
                    <execution>
                        <id>xjc</id>
                        <goals>
                            <goal>xjc</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <schemaDirectory>${project.basedir}/src/main/resources/</schemaDirectory>
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <clearOutputDir>false</clearOutputDir>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

重点是最后的一项maven plugin,它会读取resources目录下的xsd文件并在 src/main/java 目录下建立.java文件。需要注意的是代码的package路径是通过xsd的targetNamespace事先指定的。

代码文件被maven创建完成以后代表第一段工作顺利完成。下面我们需要人工编写Endpoint类,即建立对外访问的服务接口。通常你提供了几分xsd文件就应该创建几个Endpoint类。Endpoint本质上是接收一个request,然后经过你的业务逻辑再返回一个response。与传统意义上的浏览器不同,后者通常传输json字符串,而前者则是xml。

CountryEndpoint

package org.learnhow.ws.server;

import org.learnhow.ws.schema.GetCountryRequest;
import org.learnhow.ws.schema.GetCountryResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;

@Endpoint
public class CountryEndpoint {
    private static final String NAMESPACE_URI = "http://learnhow.org/ws/schema";
    @Autowired
    private CountryRepository countryRepository;

    @PayloadRoot(namespace = NAMESPACE_URI, localPart = "getCountryRequest")
    @ResponsePayload
    public GetCountryResponse getCountry(@RequestPayload GetCountryRequest request) {
        GetCountryResponse response = new GetCountryResponse();
        response.setCountry(countryRepository.findCountry(request.getName()));

        return response;
    }
}

UserEndpoint

package org.learnhow.ws.server;

import org.learnhow.ws.schema.GetUserRequest;
import org.learnhow.ws.schema.GetUserResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;

@Endpoint
public class UserEndpoint {
    private static final String NAMESPACE_URI = "http://learnhow.org/ws/schema";
    @Autowired
    private UserRepository userRepository;

    @PayloadRoot(namespace = NAMESPACE_URI, localPart = "getUserRequest")
    @ResponsePayload
    public GetUserResponse getUser(@RequestPayload GetUserRequest request) {
        GetUserResponse response = new GetUserResponse();
        response.setUser(userRepository.findUser(request.getName()));
        return response;
    }
}

很显然你的业务逻辑应该封装在CountryRepository和UserRepository对象里。接下来创建CountryRepository对象。

CountryRepository

package org.learnhow.ws.server;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.PostConstruct;

import org.learnhow.ws.schema.Country;
import org.learnhow.ws.schema.Currency;
import org.learnhow.ws.schema.Language;
import org.springframework.stereotype.Component;

@Component
public class CountryRepository {
    private static final Map<String, Country> countries = new HashMap<>();

    @PostConstruct
    public void initData() {
        Country spain = new Country();
        spain.setName("Spain");
        spain.setCapital("Madrid");
        spain.setCurrency(Currency.EUR);
        spain.setPopulation(46704314);
        Language spanish = new Language();
        spanish.setName("spanish");
        spain.setLanguage(spanish);

        Country poland = new Country();
        poland.setName("Poland");
        poland.setCapital("Warsaw");
        poland.setCurrency(Currency.PLN);
        poland.setPopulation(38186860);
        Language polish = new Language();
        polish.setName("polish");
        poland.setLanguage(polish);

        Country uk = new Country();
        uk.setName("United Kingdom");
        uk.setCapital("London");
        uk.setCurrency(Currency.GBP);
        uk.setPopulation(63705000);
        Language english = new Language();
        english.setName("english");
        uk.setLanguage(english);

        countries.put(spain.getName(), spain);
        countries.put(poland.getName(), poland);
        countries.put(uk.getName(), uk);
    }
    
    public Country findCountry(String name) {
        return countries.get(name);
    }
}

UserRepository(略)

最后是编写configuration,它是整个框架调用的核心。

package org.learnhow.ws.server;

import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.ws.config.annotation.EnableWs;
import org.springframework.ws.config.annotation.WsConfigurerAdapter;
import org.springframework.ws.transport.http.MessageDispatcherServlet;
import org.springframework.ws.wsdl.wsdl11.DefaultWsdl11Definition;
import org.springframework.xml.xsd.SimpleXsdSchema;
import org.springframework.xml.xsd.XsdSchema;

@EnableWs
@Configuration
public class WebServiceConfig extends WsConfigurerAdapter {
    @Bean
    public ServletRegistrationBean messageDispatcherServlet(ApplicationContext applicationContext) {
        MessageDispatcherServlet servlet = new MessageDispatcherServlet();
        servlet.setApplicationContext(applicationContext);
        servlet.setTransformWsdlLocations(true);
        return new ServletRegistrationBean(servlet, "/ws/*");
    }

    @Bean(name = "countries")
    public DefaultWsdl11Definition defaultWsdl11DefinitionCountry() {
        DefaultWsdl11Definition wsdl11Definition = new DefaultWsdl11Definition();
        wsdl11Definition.setPortTypeName("CountriesPort");
        wsdl11Definition.setLocationUri("/ws");
        wsdl11Definition.setTargetNamespace("http://learnhow.org/ws/schema");
        wsdl11Definition.setSchema(countriesSchema());
        return wsdl11Definition;
    }

    @Bean(name = "users")
    public DefaultWsdl11Definition defaultWsdl11DefinitionUser() {
        DefaultWsdl11Definition wsdl11Definition = new DefaultWsdl11Definition();
        wsdl11Definition.setPortTypeName("CountriesPort");
        wsdl11Definition.setLocationUri("/ws");
        wsdl11Definition.setTargetNamespace("http://learnhow.org/ws/schema");
        wsdl11Definition.setSchema(usersSchema());
        return wsdl11Definition;
    }

    @Bean
    public XsdSchema countriesSchema() {
        return new SimpleXsdSchema(new ClassPathResource("countries.xsd"));
    }

    @Bean
    public XsdSchema usersSchema() {
        return new SimpleXsdSchema(new ClassPathResource("users.xsd"));
    }

}

最后一步:编写启动项Application

package org.learnhow.ws;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
}

完成的目录结构如下:

二、测试

启动application,打开浏览器访问:http://localhost:8080/ws/countries.wsdl

与http://localhost:8080/ws/users.wsdl 如果页面分别展示了两份xml文件代表服务器已经可以正常运行了。也可以用SoapUI Pro进一步测试数据的读取和发送是否正常。

三、ws.client端搭建

如果说server端是通过xsd产生java与WSDL的过程那么client端就恰恰相反。我们还是使用maven工具通过服务器暴露在外的wsdl文件建立java对象。首先编辑pom.xml文件配置依赖和wsdl访问路径。

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.learnhow</groupId>
    <artifactId>ws.client</artifactId>
    <packaging>jar</packaging>
    <version>0.0.1-SNAPSHOT</version>
    
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.ws</groupId>
            <artifactId>spring-ws-core</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.jvnet.jaxb2.maven2</groupId>
                <artifactId>maven-jaxb2-plugin</artifactId>
                <version>0.13.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <schemaLanguage>WSDL</schemaLanguage>
                    <generatePackage>ws.wsdl</generatePackage>
                    <schemas>
                        <schema>
                            <url>http://localhost:8080/ws/countries.wsdl</url>
                        </schema>
                        <schema>
                            <url>http://localhost:8080/ws/users.wsdl</url>
                        </schema>
                    </schemas>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这里要注意,如果此时你已经将server的进程停止,也就是wsdl无法访问,pom.xml文件会报错。看上去大概会像这样:

正常情况下maven会自动帮你在target目录下建立java对象,目录结构如下:

如果你发现无法正常建立java对象,请首先检查以下两点:

maven引入的依赖是否完整:国内的网络环境不是很好,有时候通过maven搭建环境经常会在运行时报出各种莫名其妙的错误。其中绝大多数其实都是由于依赖引入不完整造成的。此时你可能需要对Maven Dependencies目录下的jar包逐一检查。

maven结构错误:maven的版本很多,不同的版本间可能在元素的结构定义上有所差距。如果在<plugins>节点报错可以考虑在外层再包一层<pluginManagement>节点。具体原因我也没有深究,只能说“有时管用”,如果你对maven有深入的了解也希望告诉我。

如果以上环境你进行的都很顺利,那么恭喜你80%的工作已经完成了。

下面是编写client客户端代码:

package org.learnhow.ws.client;

import org.springframework.ws.client.core.support.WebServiceGatewaySupport;
import org.springframework.ws.soap.client.core.SoapActionCallback;

import ws.wsdl.GetCountryRequest;
import ws.wsdl.GetCountryResponse;

public class CountryClient extends WebServiceGatewaySupport {
    public static final String URI = "http://localhost:8080/ws";
    public static final String SOAPACTION = "http://learnhow.org/ws/schema/getUserRequest";

    public GetCountryResponse getCountry(String countryName) {
        GetCountryRequest request = new GetCountryRequest();
        request.setName(countryName);

        GetCountryResponse response = (GetCountryResponse) getWebServiceTemplate().marshalSendAndReceive(URI, request,
                new SoapActionCallback(SOAPACTION));

        return response;
    }
}

然后依然是创建configuration供框架调用

package org.learnhow.ws.client;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;

@Configuration
public class AppConfiguration {
    @Bean
    public Jaxb2Marshaller marshaller() {
        Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
        marshaller.setContextPath("ws.wsdl");
        return marshaller;
    }

    @Bean("country")
    public CountryClient counrtyClient(Jaxb2Marshaller marshaller) {
        CountryClient client = new CountryClient();
        client.setDefaultUri(CountryClient.URI);
        client.setMarshaller(marshaller);
        client.setUnmarshaller(marshaller);
        return client;
    }

    @Bean("user")
    public UserClient userClient(Jaxb2Marshaller marshaller) {
        UserClient client = new UserClient();
        client.setDefaultUri(UserClient.URI);
        client.setMarshaller(marshaller);
        client.setUnmarshaller(marshaller);
        return client;
    }
}

最后是编写Application启动项

package org.learnhow.ws;

import org.learnhow.ws.client.CountryClient;
import org.learnhow.ws.client.UserClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import ws.wsdl.GetCountryResponse;
import ws.wsdl.GetUserResponse;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    CommandLineRunner lookup(CountryClient client) {
        return args -> {
            String countryName = "Spain";

            if (args.length > 0) {
                countryName = args[0];
            }
            GetCountryResponse response = client.getCountry(countryName);
            System.out.println("response: " + response.getCountry().getName());
        };
    }
}

运行application,如果你能看到控制台有 "response: Spain" 打出代表数据已经能够正常获取。

 

后记:

本文的代码逻辑主要参考了Spring Web Services官网文档。另外WebService除了通过Spring还有多种实现手段,感兴趣的同学可以看看如何使用wsimport工具以及Tomcat发布WebService的例子。这里不再赘述。

本文转载自:http://www.cnblogs.com/learnhow/p/7205524.html

spinachgit
粉丝 10
博文 267
码字总数 272105
作品 0
亳州
架构师
私信 提问
《 Kotlin + Spring Boot : K2EE 服务端开发实战 》

《 Kotlin + Spring Boot : K2EE 服务端开发实战 》 第一篇 Spring Boot 基础 第1章 Spring Boot 与 Kotlin 的极简理念 第2章 Spring Boot + Kotlin 快速开始 Hello World 第3章 Spring Boo...

程序员诗人
2017/11/02
0
0
极速上手进阶大神的 5 门 SpringBoot 课程

SpringBoot 因其大大简化了配置。可快速启动一个应用的开发环境,把时间和精力更多的投入到实现业务需求上去。成为了Java 服务器端近几年特别火爆的框架。 如此火爆的技术,怎能不抢先了解一...

实验楼
08/16
0
0
新书上架:《Spring Boot 开发实战》(基于 Kotlin + Gradle + Spring Boot 2.0 的企业级服务端开发实战)

新书上架:《Spring Boot 开发实战》 — 基于 Kotlin + Gradle + Spring Boot 2.0 的企业级服务端开发实战 京东下单链接 https://item.jd.com/31178320122.html 天猫下单链接 https://detail...

程序员诗人
2018/08/05
0
0
Spring Boot 最流行的 16 条实践解读!

点击上方“java进阶架构师”,选择右上角“置顶公众号” 20大进阶架构专题每日送达 来源:http://t.cn/EJWZNra Spring Boot是最流行的用于开发微服务的Java框架。在本文中,我将与你分享自2...

Java进阶架构师
05/22
0
0
两年摸爬滚打 Spring Boot,总结了这 16 条最佳实践

Spring Boot是最流行的用于开发微服务的Java框架。在本文中,我将与你分享自2016年以来我在专业开发中使用Spring Boot所采用的最佳实践。这些内容是基于我的个人经验和一些熟知的Spring Boot...

Java填坑之路
2018/08/18
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Tensorflow 2.0安装

Tensorflow2.0安装环境: Ubuntu 16.04或更高(64位) Windows 7或者更高(64位,且支持python3) 安装Tensorflow 2.0 GPU版本的需要安装NVIDIA相关软件包: NVIDIA驱动 :版本必须410.x或更...

JosiahMg
32分钟前
4
0
TL138/1808/6748F-EasyEVM开发板硬件、CPU、FLASH、RAM

TL138/1808/6748F-EasyEVM是广州创龙基于SOM-TL138/SOM-TL1808/SOM-TL6748F核心板开发的一款开发板。由于SOM-TL138/SOM-TL1808/SOM-TL6748核心板管脚兼容,所以此三个核心板共用同一个底板。...

Tronlong创龙
39分钟前
4
0
百度嵌入式AI解决方案EdgeBoard之内存驱动设计介绍

1. 背景介绍 由于 FPGA 具备可编程和高性能计算的特点,基于FPGA硬件的AI计算加速,正广泛地应用到计算机视觉处理领域。其中极具代表性的部署方式之一就是使用FPGA和CPU组合构成异构计算系统...

AI君
45分钟前
6
0
开放应用模型(OAM):全球首个云原生应用标准定义与架构模型

Kubernetes 项目作为容器编排领域的事实标准, 成功推动了诸如阿里云 Kubernetes (ACK)等云原生服务的迅速增长。但同时我们也关注到,Kubernetes 的核心 API 资源比如 Service、Deploymen...

Mr_zebra
49分钟前
4
0
《Linux操作系统-Exynos4412》编译和安装Busybox

开发环境:Exynos4412-iTOP-4412开发板 现在 Busybox 的配置已经完成了,接下来开始编译 Busybox,在 Ubuntu 的终端输入 “make”命令开始编译 Busybox,如下图。 下图为编译过程中的截图。 ...

书白
51分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部