Spring WS - Kurzanleitung

Spring Web Services (Spring-WS) ist eines der von der Spring Community entwickelten Projekte. Der Hauptfokus liegt auf der Erstellung dokumentengesteuerter Webdienste. Das Spring Web Services-Projekt erleichtert die VertragsabwicklungSOAP Service Developmentbietet mehrere Möglichkeiten zum Erstellen flexibler Webdienste, mit denen XML-Nutzdaten auf verschiedene Arten bearbeitet werden können.

Die Spring-Webdienste verwenden Spring-Konzepte wie Abhängigkeitsinjektion und Konfigurationen nahtlos. Das Spring-WS erfordert die Version Spring 3.0. Mit der Vertragsentwicklung beginnen wir mitWSDL Contract und wird dann JAVA verwenden, um den erforderlichen Vertrag umzusetzen.

Im Gegensatz zum Vertrag-Last-Ansatz, bei dem JAVA-Schnittstellen einen WSDL / XSD-Vertrag generieren. Der WSDL-basierte Vertrag bleibt unabhängig von der JAVA-Implementierung im Contract-First-Ansatz. Wenn wir die JAVA-Schnittstellen ändern müssen, müssen die im bestehenden WSDL-Vertrag vorgenommenen Änderungen den Benutzern der Webdienste nicht mitgeteilt werden. Spring-WS zielt darauf ab, eine lose Kopplung zwischen dem WSDL-Vertrag und seiner JAVA-basierten Implementierung herzustellen.

Eigenschaften

Im Folgenden sind die Funktionen von Spring Web Services aufgeführt:

  • XML Mapping to Objects - XML-basierte Anforderungen können mithilfe der in der Nachrichtennutzlast, im SOAP-Aktionsheader oder mithilfe eines XPath-Ausdrucks gespeicherten Informationen jedem Objekt zugeordnet werden.

  • Multiple API Support to parse XML - Neben den Standard-JAXP-APIs (DOM, SAX, StAX) zum Parsen der eingehenden XML-Anforderungen werden auch andere Bibliotheken wie JDOM, dom4j, XOM unterstützt.

  • Multiple API Support to marshal XML- Spring Web Services unterstützt die Bibliotheken JAXB 1 und 2, Castor, XMLBeans, JiBX und XStream mithilfe des Object / XML Mapping-Moduls. Das Objekt- / XML-Zuordnungsmodul kann auch in Nicht-Webdienstcode verwendet werden.

  • Spring based configurations - Spring Web Services verwendet die Spring-Anwendungskontexte für seine Konfigurationen mit einer ähnlichen Architektur wie die Spring Web MVC.

  • Integrated WS-Security module - Mit dem WS-Sicherheitsmodul können Sie SOAP-Nachrichten signieren, verschlüsseln, entschlüsseln oder authentifizieren.

  • Support for Acegi Security - Mit der WS-Security-Implementierung von Spring Web Services kann die Acegi-Konfiguration für Ihre SOAP-Services verwendet werden.

Die Architektur

Das Spring-WS-Projekt besteht aus fünf Hauptmodulen, die im Folgenden erläutert werden.

  • Spring-WS Core - Es ist das primäre Modul und bietet die zentralen Schnittstellen wie WebServiceMessage und SoapMessage, das serverseitige Framework, leistungsstarke Funktionen zum Versenden von Nachrichten und Supportklassen zur Implementierung von Webdienstendpunkten. Es bietet auch Web Service Consumer Client alsWebServiceTemplate.

  • Spring-WS Support - Dieses Modul bietet Unterstützung für JMS, E-Mails usw.

  • Spring-WS Security- Dieses Modul ist für die Bereitstellung der WS-Security-Implementierung verantwortlich, die in das Kern-Webdienstmodul integriert ist. Mit diesem Modul können wir Haupttoken hinzufügen, SOAP-Nachrichten signieren, verschlüsseln und entschlüsseln. Dieses Modul ermöglicht die Verwendung der vorhandenen Spring Security-Implementierung zur Authentifizierung und Autorisierung.

  • Spring XML- Dieses Modul bietet XML-Unterstützungsklassen für Spring Web Services. Dieses Modul wird intern vom Spring-WS-Framework verwendet.

  • Spring OXM - Dieses Modul bietet Unterstützungsklassen für XML vs Object Mapping.

In diesem Kapitel erfahren Sie, wie Sie Spring-WS auf Windows- und Linux-basierten Systemen einrichten. Der Spring-WS kann einfach installiert und in Ihren Strom integriert werdenJava environment und MAVENBefolgen Sie einige einfache Schritte ohne komplexe Einrichtungsverfahren. Während der Installation ist eine Benutzerverwaltung erforderlich.

System Anforderungen

In der folgenden Tabelle sind die Systemanforderungen aufgeführt. Die folgenden Schritte führen uns durch die Einrichtung der Umgebung.

JDK Java SE 2 JDK 1.5 oder höher
Erinnerung 1 GB RAM (empfohlen)
Festplattenplatz Keine Mindestanforderung
Betriebssystemversion Windows XP oder höher, Linux

Fahren wir nun mit den Schritten zur Installation von Spring-WS fort.

Schritt 1: Überprüfen Sie die Java-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.

Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.

Plattform Befehl Beispielausgabe
Windows

Öffnen Sie die Befehlskonsole und geben Sie - ein

\> Java-Version

Java-Version "1.7.0_60"

Java (TM) SE-Laufzeitumgebung (Build 1.7.0_60-b19)

Java Hotspot (TM) 64-Bit-Server-VM (Build 24.60-b09, gemischter Modus)

Linux

Befehlsterminal öffnen und - eingeben

$ java -version

Java-Version "1.7.0_25"

Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.3.10.4.el6_4-x86_64).

Öffnen Sie die JDK 64-Bit-Server-VM (Build 23.7-b01, gemischter Modus).

  • Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.7.0_60 auf ihrem System installiert haben.

  • Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunter https://www.oracle.com/technetwork/java/javase/downloads/index.html und habe es installiert.

Schritt 2: Legen Sie Ihre Java-Umgebung fest

Legen Sie die Umgebungsvariable fest JAVA_HOME um auf das Basisverzeichnis zu verweisen, in dem Java auf Ihrem Computer installiert ist.

S.No. Plattform & Beschreibung
1

Windows

Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60

2

Linux

Exportieren Sie JAVA_HOME = / usr / local / java-current

Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.

S.No. Plattform & Beschreibung
1

Windows

Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen PATH an.

2

Linux

Export PATH = $ PATH: $ JAVA_HOME / bin /

Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.

Schritt 3: Laden Sie das Maven-Archiv herunter

Laden Sie Maven 3.3.3 von herunter https://maven.apache.org/download.cgi

Betriebssystem Archivname
Windows apache-maven-3.3.3-bin.zip
Linux apache-maven-3.3.3-bin.tar.gz
Mac apache-maven-3.3.3-bin.tar.gz

Schritt 4: Extrahieren Sie das Maven-Archiv

Extrahieren Sie das Archiv in das Verzeichnis, in dem Sie Maven 3.3.3 installieren möchten. Das Unterverzeichnis apache-maven-3.3.3 wird aus dem Archiv erstellt.

Betriebssystem Standort (kann je nach Installation unterschiedlich sein)
Windows C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3
Linux / usr / local / apache-maven
Mac / usr / local / apache-maven

Schritt 5: Legen Sie die Maven-Umgebungsvariablen fest

Fügen Sie den Umgebungsvariablen M2_HOME, M2 und MAVEN_OPTS hinzu.

Betriebssystem Ausgabe
Windows

Legen Sie die Umgebungsvariablen mithilfe der Systemeigenschaften fest.

M2_HOME = C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3

M2 =% M2_HOME% \ bin

MAVEN_OPTS = -Xms256m -Xmx512m

Linux

Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest.

export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.3

export M2 = $ M2_HOME / bin

export MAVEN_OPTS = -Xms256m -Xmx512m

Mac

Öffnen Sie das Befehlsterminal und legen Sie die Umgebungsvariablen fest.

export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.3

export M2 = $ M2_HOME / bin

export MAVEN_OPTS = -Xms256m -Xmx512m

Schritt 6: Fügen Sie dem Systempfad den Speicherort des Maven bin-Verzeichnisses hinzu

Fügen Sie nun die Variable M2 an den Systempfad an.

Betriebssystem Ausgabe
Windows Hängen Sie die Zeichenfolge% M2% an das Ende der Systemvariablen Path an.
Linux export PATH = $ M2: $ PATH
Mac export PATH = $ M2: $ PATH

Schritt 7: Überprüfen Sie die Installation von Maven

Öffnen Sie nun die Konsole und führen Sie Folgendes aus mvn Befehl.

Betriebssystem Aufgabe Befehl
Windows Öffnen Sie die Befehlskonsole c: \> mvn --version
Linux Öffnen Sie das Befehlsterminal $ mvn --version
Mac Terminal öffnen Maschine: <joseph $ mvn --version

Überprüfen Sie abschließend die Ausgabe der oben genannten Befehle. Dies sollte wie folgt aussehen:

Betriebssystem Ausgabe
Windows

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven-Startseite: C: \ Programme \ Apache Software Foundation \ apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: C: \ Programme \ Java \ jdk1.7.0_75 \ jre

Standardgebietsschema: en_US, Plattformcodierung: Cp1252

Linux

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: /usr/local/java-current/jdk1.7.0_75/jre

Mac

Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30)

Maven nach Hause: /usr/local/apache-maven/apache-maven-3.3.3

Java-Version: 1.7.0_75, Hersteller: Oracle Corporation

Java-Startseite: /Library/Java/Home/jdk1.7.0_75/jre

Schritt 8: Eclipse IDE einrichten

Alle Beispiele in diesem Tutorial wurden mit der Eclipse-IDE geschrieben. Es wird empfohlen, dass die Leser die neueste Version von Eclipse auf ihrem Computer installiert haben. Laden Sie zum Installieren der Eclipse-IDE die neuesten Eclipse-Binärdateien über den folgenden Link herunterhttps://www.eclipse.org/downloads/. Entpacken Sie nach dem Herunterladen der Installation die Binärdistribution an einem geeigneten Ort.

Zum Beispiel in C:\eclipse auf Windows oder /usr/local/eclipseunter Linux / Unix und setzen Sie schließlich die PATH-Variable entsprechend. Eclipse kann durch Ausführen der folgenden Befehle auf dem Windows-Computer gestartet werden, oder Sie können einfach auf eclipse.exe doppelklicken.

%C:\eclipse\eclipse.exe

Eclipse kann durch Ausführen der folgenden Befehle auf dem UNIX-Computer (Solaris, Linux usw.) gestartet werden:

$/usr/local/eclipse/eclipse

Wenn nach einem erfolgreichen Start alles in Ordnung ist, sollte der folgende Bildschirm angezeigt werden:

Schritt 9: Richten Sie Apache Tomcat ein

Wir können die neueste Version von Tomcat von herunterladen https://tomcat.apache.org/. Entpacken Sie nach dem Herunterladen der Installation die Binärdistribution an einem geeigneten Ort. Zum Beispiel in derC:\apache-tomcat-7.0.59 auf einem Windows-Computer oder in der /usr/local/apache-tomcat-7.0.59 auf einem Linux / Unix-Computer und stellen Sie dann die CATALINA_HOME Umgebungsvariable, die auf die Installationsorte verweist.

Tomcat kann durch Ausführen der folgenden Befehle auf einem Windows-Computer gestartet werden, oder Sie können einfach auf startup.bat doppelklicken

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-7.0.59\bin\startup.bat

Tomcat kann durch Ausführen der folgenden Befehle auf einem UNIX-Computer (Solaris, Linux usw.) gestartet werden:

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-7.0.59/bin/startup.sh

Nach einem erfolgreichen Start sind die in Tomcat enthaltenen Standard-Webanwendungen unter folgender Adresse verfügbar: http://localhost:8080/. Wenn alles in Ordnung ist, sollte der folgende Bildschirm angezeigt werden:

Weitere Informationen zum Konfigurieren und Ausführen von Tomcat finden Sie in der hier enthaltenen Dokumentation sowie auf der Tomcat-Website. https://tomcat.apache.org

Tomcat kann gestoppt werden, indem die folgenden Befehle auf einem Windows-Computer ausgeführt werden:

%CATALINA_HOME%\bin\shutdown

or

C:\apache-tomcat-7.0.59\bin\shutdown

Tomcat kann gestoppt werden, indem die folgenden Befehle auf dem UNIX-Computer (Solaris, Linux usw.) ausgeführt werden:

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-7.0.59/bin/shutdown.sh

Sobald wir mit diesem letzten Schritt fertig sind, können Sie mit dem ersten Webdienstbeispiel fortfahren, das wir im nächsten Kapitel behandeln werden.

Beginnen wir mit dem Schreiben eines tatsächlichen SOAP-basierten Webdienstes mit Spring-WS Framework. Bevor wir mit dem Schreiben unseres ersten Beispiels unter Verwendung des Spring-WS-Frameworks beginnen, müssen wir sicherstellen, dass die Spring-WS-Umgebung ordnungsgemäß eingerichtet ist, wie im Kapitel Spring Web Services - Umgebung eingerichtet . Wir gehen davon aus, dass die Leser über grundlegende Kenntnisse der Eclipse-IDE verfügen.

Lassen Sie uns daher eine einfache Spring WS-Anwendung schreiben, die eine Webdienstmethode zur Buchung eines Urlaubs in einem HR-Portal bereitstellt.

Vertrags-erster Ansatz

Spring-WS verwendet den Contract-First-Ansatz, was bedeutet, dass wir unseren haben sollten XML Structuresbereit, bevor Sie einen JAVA-basierten Implementierungscode schreiben. Wir definieren ein LeaveRequest-Objekt mit Unterobjekten - Leave und Employee.

Im Folgenden sind die erforderlichen XML-Konstrukte aufgeführt:

Leave.xml

<Leave xmlns = "http://tutorialspoint.com/hr/schemas">
   <StartDate>2016-07-03</StartDate>
   <EndDate>2016-07-07</EndDate>
</Leave>

Employee.xml

<Employee xmlns = "http://tutorialspoint.com/hr/schemas">
   <Number>404</Number>
   <FirstName>Mahesh</FirstName>
   <LastName>Parashar</LastName>
</Employee>

LeaveRequest.xml

<LeaveRequest xmlns = "http://tutorialspoint.com/hr/schemas">
   <Leave>
      <StartDate>2016-07-03</StartDate>
      <EndDate>2016-07-07</EndDate>
   </Leave>
   
   <Employee>
      <Number>404</Number>
      <FirstName>Mahesh</FirstName>
      <LastName>Parashar</LastName>
   </Employee>
</LeaveRequest>

hr.xsd

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema"
   xmlns:hr = "http://tutorialspoint.com/hr/schemas"
   elementFormDefault = "qualified"
   targetNamespace = "http://tutorialspoint.com/hr/schemas">
   
   <xs:element name = "LeaveRequest">
      <xs:complexType>
         <xs:all>
            <xs:element name = "Leave" type = "hr:LeaveType"/>
            <xs:element name = "Employee" type = "hr:EmployeeType"/>
         </xs:all>
      </xs:complexType>
   </xs:element>
   
   <xs:complexType name = "LeaveType">
      <xs:sequence>
         <xs:element name = "StartDate" type = "xs:date"/>
         <xs:element name = "EndDate" type = "xs:date"/>
      </xs:sequence>
   </xs:complexType>
   
   <xs:complexType name = "EmployeeType">
      <xs:sequence>
         <xs:element name = "Number" type = "xs:integer"/>
         <xs:element name = "FirstName" type = "xs:string"/>
         <xs:element name = "LastName" type = "xs:string"/>
      </xs:sequence>
   </xs:complexType>
</xs:schema>

Erstellen Sie das Projekt

Lassen Sie uns nun eine Befehlskonsole öffnen, das Verzeichnis C: \ MVN aufrufen und Folgendes ausführen mvn Befehl.

C:\MVN>mvn archetype:generate -DarchetypeGroupId = org.springframework.ws
-DarchetypeArtifactId = spring-ws-archetype -DgroupId = com.tutorialspoint.hr
-DartifactId = leaveService

Maven beginnt mit der Verarbeitung und erstellt die vollständige Struktur des Java-Anwendungsprojekts.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] Using property: groupId = com.tutorialspoint.hr
[INFO] Using property: artifactId = leaveService
Define value for property 'version':  1.0-SNAPSHOT: :
[INFO] Using property: package = com.tutorialspoint.hr
Confirm properties configuration:
groupId: com.tutorialspoint.hr
artifactId: leaveService
version: 1.0-SNAPSHOT
package: com.tutorialspoint.hr
 Y: :
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
 spring-ws-archetype:2.0.0-M1
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint.hr
[INFO] Parameter: packageName, Value: com.tutorialspoint.hr
[INFO] Parameter: package, Value: com.tutorialspoint.hr
[INFO] Parameter: artifactId, Value: leaveService
[INFO] Parameter: basedir, Value: C:\mvn
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\mvn\leaveService
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 35.989 s
[INFO] Finished at: 2017-01-21T11:18:31+05:30
[INFO] Final Memory: 17M/178M
[INFO] ------------------------------------------------------------------------

Jetzt geh zu C:/MVNVerzeichnis. Wir werden ein Java-Anwendungsprojekt mit dem Namen sehenleaveService(wie in Artefakt-ID angegeben). Aktualisieren Sie die Datei pom.xml und fügen Sie HumanResourceService.java und HumanResourceServiceImpl.java im folgenden Ordner hinzu: C: \ MVN \ LeaveService \ src \ main \ java \ com \ tutorialspoint \ hr \ service. Fügen Sie anschließend LeaveEndpoint.java im folgenden Ordner hinzu: C: \ MVN \ LeaveService \ src \ main \ java \ com \ tutorialspoint \ hr \ ws.

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/maven-v4_0_0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint.hr</groupId>
   <artifactId>leaveService</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>leaveService Spring-WS Application</name>
   <url>http://www.springframework.org/spring-ws</url>
   
   <build>
      <finalName>leaveService</finalName>
   </build>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.ws</groupId>
         <artifactId>spring-ws-core</artifactId>
         <version>2.4.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>jdom</groupId>
         <artifactId>jdom</artifactId>
         <version>1.0</version>
      </dependency>
      
      <dependency>
         <groupId>jaxen</groupId>
         <artifactId>jaxen</artifactId>
         <version>1.1</version>
      </dependency>
      
      <dependency>
         <groupId>wsdl4j</groupId>
         <artifactId>wsdl4j</artifactId>
         <version>1.6.2</version>
      </dependency>
   </dependencies>
</project>

HumanResourceService.java

package com.tutorialspoint.hr.service;

import java.util.Date;

public interface HumanResourceService {
   void bookLeave(Date startDate, Date endDate, String name);
}

HumanResourceServiceImpl.java

package com.tutorialspoint.hr.service;

import java.util.Date;
import org.springframework.stereotype.Service;

@Service
public class HumanResourceServiceImpl implements HumanResourceService {
   public void bookLeave(Date startDate, Date endDate, String name) {
      System.out.println("Booking holiday for [" + startDate + "-" + endDate + "]
         for [" + name + "] ");
   }
}

LeaveEndpoint.java

package com.tutorialspoint.hr.ws;

import java.text.SimpleDateFormat;
import java.util.Date;

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 com.tutorialspoint.hr.service.HumanResourceService;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.Namespace;
import org.jdom.xpath.XPath;

@Endpoint
public class LeaveEndpoint {
   private static final String NAMESPACE_URI = "http://tutorialspoint.com/hr/schemas";
   private XPath startDateExpression;
   private XPath endDateExpression;
   private XPath nameExpression;
   private HumanResourceService humanResourceService;

   @Autowired
   public LeaveEndpoint(HumanResourceService humanResourceService) throws JDOMException {
      this.humanResourceService = humanResourceService;

      Namespace namespace = Namespace.getNamespace("hr", NAMESPACE_URI);

      startDateExpression = XPath.newInstance("//hr:StartDate");
      startDateExpression.addNamespace(namespace);

      endDateExpression = XPath.newInstance("//hr:EndDate");
      endDateExpression.addNamespace(namespace);

      nameExpression = XPath.newInstance("concat(//hr:FirstName,' ',//hr:LastName)");
      nameExpression.addNamespace(namespace);
   }

   @PayloadRoot(namespace = NAMESPACE_URI, localPart = "LeaveRequest")                  
   public void handleLeaveRequest(@RequestPayload Element leaveRequest) throws Exception {
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
      Date startDate = dateFormat.parse(startDateExpression.valueOf(leaveRequest));
      Date endDate = dateFormat.parse(endDateExpression.valueOf(leaveRequest));
      String name = nameExpression.valueOf(leaveRequest);

      humanResourceService.bookLeave(startDate, endDate, name);
   }
}

/WEB-INF/spring-ws-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:sws = "http://www.springframework.org/schema/web-services"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/web-services
   http://www.springframework.org/schema/web-services/web-services-2.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint.hr"/>
   <bean id = "humanResourceService"
      class = "com.tutorialspoint.hr.service.HumanResourceServiceImpl" />
   <sws:annotation-driven/>

   <sws:dynamic-wsdl id = "leave"
      portTypeName = "HumanResource"
      locationUri = "/leaveService/"
      targetNamespace = "http://tutorialspoint.com/hr/definitions">
      <sws:xsd location = "/WEB-INF/hr.xsd"/>
   </sws:dynamic-wsdl>
</beans>

/WEB-INF/web.xml

<web-app xmlns = "http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
   version = "2.4">

   <display-name>TutorialsPoint HR Leave Service</display-name>
   <servlet>
      <servlet-name>spring-ws</servlet-name>
      <servlet-class>
         org.springframework.ws.transport.http.MessageDispatcherServlet
      </servlet-class>
      <init-param>
         <param-name>transformWsdlLocations</param-name>
         <param-value>true</param-value>
      </init-param>
   </servlet>

   <servlet-mapping>
      <servlet-name>spring-ws</servlet-name>
      <url-pattern>/*</url-pattern>
   </servlet-mapping>
</web-app>

/WEB-INF/hr.xsd

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema"
   xmlns:hr = "http://tutorialspoint.com/hr/schemas"
   elementFormDefault = "qualified"
   targetNamespace = "http://tutorialspoint.com/hr/schemas">

   <xs:element name = "LeaveRequest">
      <xs:complexType>
         <xs:all>
            <xs:element name = "Leave" type = "hr:LeaveType"/>
            <xs:element name = "Employee" type = "hr:EmployeeType"/>
         </xs:all>
      </xs:complexType>
   </xs:element>

   <xs:complexType name = "LeaveType">
      <xs:sequence>
         <xs:element name = "StartDate" type = "xs:date"/>
         <xs:element name = "EndDate" type = "xs:date"/>
      </xs:sequence>
   </xs:complexType>

   <xs:complexType name = "EmployeeType">
      <xs:sequence>
         <xs:element name = "Number" type = "xs:integer"/>
         <xs:element name = "FirstName" type = "xs:string"/>
         <xs:element name = "LastName" type = "xs:string"/>
      </xs:sequence>
   </xs:complexType>
</xs:schema>

Erstellen Sie das Projekt

Lassen Sie uns nun die Befehlskonsole öffnen, das Verzeichnis C: \ MVN \ LeaveService aufrufen und Folgendes ausführen mvn Befehl.

C:\MVN\leaveService>mvn clean package

Maven wird mit dem Bau des Projekts beginnen.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building leaveService Spring-WS Application 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ leaveService ---
[INFO] Deleting C:\mvn\leaveService\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ leaveServi
ce ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ leaveService --
-
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 3 source files to C:\mvn\leaveService\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ le
aveService ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\mvn\leaveService\src\test\resource
s
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ leaveSe
rvice ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ leaveService ---
[INFO] No tests to run.
[INFO]
[INFO] --- maven-war-plugin:2.2:war (default-war) @ leaveService ---
[INFO] Packaging webapp
[INFO] Assembling webapp [leaveService] in [C:\mvn\leaveService\target\leaveServ
ice]
[INFO] Processing war project
[INFO] Copying webapp resources [C:\mvn\leaveService\src\main\webapp]
[INFO] Webapp assembled in [7159 msecs]
[INFO] Building war: C:\mvn\leaveService\target\leaveService.war
[INFO] WEB-INF\web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 19.667 s
[INFO] Finished at: 2017-01-21T11:56:43+05:30
[INFO] Final Memory: 18M/173M
[INFO] ------------------------------------------------------------------------

Projekt in Eclipse importieren

Führen Sie die folgenden Schritte aus, um das Projekt in Eclipse zu importieren.

  • Öffnen Sie Eclipse.

  • Wählen File → Import → Möglichkeit.

  • Wählen Sie die Option Maven-Projekte. Klicken Sie auf Weiter.

  • Wählen Sie den Projektspeicherort aus leaveService project wurde mit Maven erstellt.

  • Klicken Sie auf die Schaltfläche Fertig stellen.

Führen Sie das Projekt aus

Wenn Sie mit dem Erstellen der Quell- und Konfigurationsdateien fertig sind, exportieren Sie die Anwendung. Klicken Sie mit der rechten Maustaste auf die Anwendung, verwenden Sie die Option Exportieren → WAR-Datei und speichern Sie die Datei LeaveService.war im Ordner webapps von Tomcat.

Starten Sie den Tomcat-Server und stellen Sie sicher, dass wir mit einem Standardbrowser über den Ordner webapps auf andere Webseiten zugreifen können. Versuchen Sie, auf die URL zuzugreifen - http: // localhost: 8080 / LeaveService / Leave.wsdl. Wenn mit der Spring-Webanwendung alles in Ordnung ist, sollte der folgende Bildschirm angezeigt werden.

Im vorherigen Kapitel Spring -WS - Erste Anwendung haben wir WSDL automatisch mithilfe der Spring WS-Konfiguration generiert. In diesem Fall zeigen wir, wie die vorhandene WSDL mithilfe des Spring WS verfügbar gemacht wird.

Schritt Beschreibung
1 Erstellen Sie ein Projekt mit dem Namen LeaveService unter einem Paket com.tutorialspoint, wie im Kapitel Spring WS - First Application erläutert.
2 Erstellen Sie eine WSDL Leave.wsdl im Unterordner / WEB-INF / wsdl.
3 Aktualisieren Sie die Datei spring-ws-servlet.xml im Unterordner / WEB-INF. Wir verwenden hier das statische wsdl-Tag anstelle des dynamischen wsdl.
4 Der letzte Schritt besteht darin, den Inhalt aller Quell- und Konfigurationsdateien zu erstellen und die Anwendung wie unten erläutert zu exportieren.

/WEB-INF/spring-ws-servlet.xml

<wsdl:definitions xmlns:wsdl = "http://schemas.xmlsoap.org/wsdl/"
   xmlns:soap = "http://schemas.xmlsoap.org/wsdl/soap/"
   xmlns:schema = "http://tutorialspoint.com/hr/schemas"
   xmlns:tns = "http://tutorialspoint.com/hr/definitions"
   targetNamespace = "http://tutorialspoint.com/hr/definitions">
   
   <wsdl:types>
      <xsd:schema xmlns:xsd = "http://www.w3.org/2001/XMLSchema">
         <xsd:import namespace = "http://tutorialspoint.com/hr/schemas"
            schemaLocation = "hr.xsd"/>
      </xsd:schema>
   </wsdl:types>
   
   <wsdl:message name = "LeaveRequest">
      <wsdl:part element = "schema:LeaveRequest" name = "LeaveRequest"/>
   </wsdl:message>
   
   <wsdl:portType name = "HumanResource">
      <wsdl:operation name = "Leave">
         <wsdl:input message = "tns:LeaveRequest" name = "LeaveRequest"/>
      </wsdl:operation>
   </wsdl:portType>
   
   <wsdl:binding name = "HumanResourceBinding" type = "tns:HumanResource">
      <soap:binding style = "document"
         transport = "http://schemas.xmlsoap.org/soap/http"/>
      <wsdl:operation name = "Leave">
         <soap:operation soapAction = "http://mycompany.com/RequestLeave"/>
         <wsdl:input name = "LeaveRequest">
            <soap:body use = "literal"/>
         </wsdl:input>
      </wsdl:operation>
   </wsdl:binding>
   
   <wsdl:service name = "HumanResourceService">
      <wsdl:port binding = "tns:HumanResourceBinding" name = "HumanResourcePort">
         <soap:address location = "http://localhost:8080/leaveService/"/>
      </wsdl:port>
   </wsdl:service>
</wsdl:definitions>

/WEB-INF/spring-ws-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:sws = "http://www.springframework.org/schema/web-services"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/web-services
   http://www.springframework.org/schema/web-services/web-services-2.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint.hr"/>
   <sws:annotation-driven/>
   <sws:static-wsdl id = "leave" location = "/WEB-INF/wsdl/leave.wsdl"/>
</beans>

Führen Sie das Projekt aus

Sobald wir mit dem Erstellen der Quell- und Konfigurationsdateien fertig sind, sollten wir die Anwendung exportieren. Klicken Sie mit der rechten Maustaste auf die Anwendung, verwenden Sie die Option Exportieren → WAR-Datei und speichern Sie Ihre LeaveService.war-Datei im Webapps-Ordner von Tomcat.

Starten Sie nun den Tomcat-Server und stellen Sie sicher, dass wir mit einem Standardbrowser über den Ordner webapps auf andere Webseiten zugreifen können. Versuchen Sie, auf die URL zuzugreifen - http: // localhost: 8080 / LeaveService / Leave.wsdl. Wenn mit der Spring-Webanwendung alles in Ordnung ist, wird der folgende Bildschirm angezeigt.

In diesem Kapitel erfahren Sie, wie Sie mit Spring WS einen Webanwendungsserver erstellen.

Schritt Beschreibung
1 Erstellen Sie ein Projekt mit dem Namen countryService unter einem Paket com.tutorialspoint, wie im Kapitel Spring WS - First Application erläutert.
2 Erstellen Sie Länder.xsd, Domänenklassen, CountryRepository und CountryEndPoint, wie in den folgenden Schritten erläutert.
3 Aktualisieren Sie die Datei spring-ws-servlet.xml im Unterordner / WEB-INF.
4 Der letzte Schritt besteht darin, Inhalte für alle Quell- und Konfigurationsdateien zu erstellen und die Anwendung wie unten erläutert zu exportieren.

Länder.xsd

<xs:schema xmlns:xs = "http://www.w3.org/2001/XMLSchema" 
   xmlns:tns = "http://tutorialspoint/schemas"
   targetNamespace = "http://tutorialspoint/schemas" 
   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:sequence>
   </xs:complexType>

   <xs:simpleType name = "currency">
      <xs:restriction base = "xs:string">
         <xs:enumeration value = "GBP"/>
         <xs:enumeration value = "USD"/>
         <xs:enumeration value = "INR"/>
      </xs:restriction>
   </xs:simpleType>
</xs:schema>

Erstellen Sie das Projekt

Lassen Sie uns die Befehlskonsole öffnen, das Verzeichnis C: \ MVN aufrufen und Folgendes ausführen mvn Befehl.

C:\MVN>mvn archetype:generate -DarchetypeGroupId = org.springframework.ws 
-DarchetypeArtifactId = spring-ws-archetype -DgroupId = com.tutorialspoint 
-DartifactId = countryService

Maven beginnt mit der Verarbeitung und erstellt die vollständige Struktur des Java-Anwendungsprojekts.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] Using property: groupId = com.tutorialspoint
[INFO] Using property: artifactId = countryService
Define value for property 'version':  1.0-SNAPSHOT: :
[INFO] Using property: package = com.tutorialspoint
Confirm properties configuration:
groupId: com.tutorialspoint
artifactId: countryService
version: 1.0-SNAPSHOT
package: com.tutorialspoint
 Y: :
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
 spring-ws-archetype:2.0.0-M1
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: countryService
[INFO] Parameter: basedir, Value: C:\mvn
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\mvn\countryService
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 35.989 s
[INFO] Finished at: 2017-01-21T11:18:31+05:30
[INFO] Final Memory: 17M/178M
[INFO] ------------------------------------------------------------------------

Wechseln Sie nun in das Verzeichnis C: / MVN. Wir werden ein Java-Anwendungsprojekt mit dem Namen countryService sehen (wie in Artefakt-ID angegeben). Aktualisieren Sie die Datei pom.xml.

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/maven-v4_0_0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint.hr</groupId>
   <artifactId>countryService</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>countryService Spring-WS Application</name>
   <url>http://www.springframework.org/spring-ws</url>
   
   <build>
      <finalName>countryService</finalName>
   </build>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.ws</groupId>
         <artifactId>spring-ws-core</artifactId>
         <version>2.4.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>jdom</groupId>
         <artifactId>jdom</artifactId>
         <version>1.0</version>
      </dependency>
      
      <dependency>
         <groupId>jaxen</groupId>
         <artifactId>jaxen</artifactId>
         <version>1.1</version>
      </dependency>
      
      <dependency>
         <groupId>wsdl4j</groupId>
         <artifactId>wsdl4j</artifactId>
         <version>1.6.2</version>
      </dependency>
   </dependencies>
</project>

Erstellen Sie Domänenklassen

Kopieren Sie die Datei country.xsd in den Ordner C: \ mvn \ countryService \ src \ main \ resources. Öffnen Sie die Befehlskonsole, wechseln Sie in das Verzeichnis C: \ mvn \ countryService \ src \ main \ resources und führen Sie Folgendes ausxjc Befehl zum Generieren von Domänenklassen mit der Datei country.xsd.

C:\MVN\countryService\src\main\resources>xjc -p com.tutorialspoint countries.xsd

Maven beginnt mit der Verarbeitung und erstellt die Domänenklassen im Paket com.tutorialspoint.

parsing a schema...
compiling a schema...
com\tutorialspoint\Country.java
com\tutorialspoint\Currency.java
com\tutorialspoint\GetCountryRequest.java
com\tutorialspoint\GetCountryResponse.java
com\tutorialspoint\ObjectFactory.java
com\tutorialspoint\package-info.java

Erstellen Sie den Ordner Java im Ordner C: \ mvn \ countryService \ src \ main. Kopieren Sie alle Klassen in den Ordner C: \ mvn \ countryService \ src \ main \ java. Erstellen Sie CountryRepository und CountryEndPoint, um die Länderdatenbank bzw. den Länderserver darzustellen.

CountryRepository.java

package com.tutorialspoint;

import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.propertyeditors.CurrencyEditor;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

@Component
public class CountryRepository {
   private static final List<Country> countries = new ArrayList<Country>();

   public CountryRepository(){
      initData();
   }
   public void initData() {
      Country us = new Country();
      us.setName("United States");
      us.setCapital("Washington");
      us.setCurrency(Currency.USD);
      us.setPopulation(46704314);
   
      countries.add(us);
   
      Country india = new Country();
      india.setName("India");
      india.setCapital("New Delhi");
      india.setCurrency(Currency.INR);
      india.setPopulation(138186860);

      countries.add(india);
    
      Country uk = new Country();
      uk.setName("United Kingdom");
      uk.setCapital("London");
      uk.setCurrency(Currency.GBP);
      uk.setPopulation(63705000);
   
      countries.add(uk);
   }
   public Country findCountry(String name) {
      Assert.notNull(name);
      Country result = null;

      for (Country country : countries) {
         if (name.trim().equals(country.getName())) {
            result = country;
         }
      }
      return result;
   }
}

CountryEndPoint.java

package com.tutorialspoint.ws;

import org.jdom.JDOMException;
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;

import com.tutorialspoint.Country;
import com.tutorialspoint.CountryRepository;
import com.tutorialspoint.GetCountryRequest;
import com.tutorialspoint.GetCountryResponse;

@Endpoint
public class CountryEndPoint {
   private static final String NAMESPACE_URI = "http://tutorialspoint/schemas";
   private CountryRepository countryRepository;

   @Autowired
   public CountryEndPoint(CountryRepository countryRepository) throws JDOMException {
      this.countryRepository = countryRepository;
   }
   @PayloadRoot(namespace = NAMESPACE_URI, localPart = "getCountryRequest")
   @ResponsePayload
   public GetCountryResponse getCountry(@RequestPayload GetCountryRequest request) 
      throws JDOMException {
      
      Country country = countryRepository.findCountry(request.getName());
      GetCountryResponse response = new GetCountryResponse();
      response.setCountry(country);
      return response;
   }
}

/WEB-INF/spring-ws-servlet.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:sws = "http://www.springframework.org/schema/web-services"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/web-services
   http://www.springframework.org/schema/web-services/web-services-2.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint"/>
   <sws:annotation-driven/>

   <sws:dynamic-wsdl id="countries"
      portTypeName = "CountriesPort"
      locationUri = "/countryService/"
      targetNamespace = "http://tutorialspoint.com/definitions">
      <sws:xsd location = "/WEB-INF/countries.xsd"/>
   </sws:dynamic-wsdl>
</beans>

/WEB-INF/web.xml

<web-app xmlns = "http://java.sun.com/xml/ns/j2ee"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
   version = "2.4">

   <display-name>TutorialsPoint Country Service</display-name>

   <servlet>
      <servlet-name>spring-ws</servlet-name>
      <servlet-class>org.springframework.ws.transport.http.MessageDispatcherServlet
      </servlet-class>
      <init-param>
         <param-name>transformWsdlLocations</param-name>
         <param-value>true</param-value>
      </init-param>
   </servlet>
   
   <servlet-mapping>
      <servlet-name>spring-ws</servlet-name>
      <url-pattern>/*</url-pattern>
   </servlet-mapping>
</web-app>

Erstellen Sie das Projekt

Öffnen wir die Befehlskonsole. Wechseln Sie in das Verzeichnis C: \ MVN \ countryService und führen Sie Folgendes ausmvn Befehl.

C:\MVN\countryService>mvn clean package

Maven wird mit dem Bau des Projekts beginnen.

INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building countryService Spring-WS Application 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ countryService ---
[INFO] Deleting C:\mvn\countryService\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ countrySer
vice ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ countryService
---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. 
build is platform dependent!
[INFO] Compiling 4 source files to C:\mvn\countryService\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ co
untryService ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\mvn\countryService\src\test\resour
ces
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ country
Service ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ countryService ---

[INFO] No tests to run.
[INFO]
[INFO] --- maven-war-plugin:2.2:war (default-war) @ countryService ---
[INFO] Packaging webapp
[INFO] Assembling webapp [countryService] in [C:\mvn\countryService\target\count
ryService]
[INFO] Processing war project
[INFO] Copying webapp resources [C:\mvn\countryService\src\main\webapp]
[INFO] Webapp assembled in [5137 msecs]
[INFO] Building war: C:\mvn\countryService\target\countryService.war
[INFO] WEB-INF\web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 16.484 s
[INFO] Finished at: 2017-01-28T09:07:59+05:30
[INFO] Final Memory: 19M/170M
[INFO] ------------------------------------------------------------------------

Führen Sie das Projekt aus

Nachdem Sie die Quell- und Konfigurationsdateien erstellt haben, exportieren Sie die Datei countryService.war in den Webapps-Ordner von Tomcat.

Starten Sie nun den Tomcat-Server und stellen Sie sicher, dass wir mit einem Standardbrowser über den Ordner webapps auf andere Webseiten zugreifen können. Stellen Sie eine POST-Anfrage an die URL - http: // localhost: 8080 / countryService / und stellen Sie mithilfe eines beliebigen SOAP-Clients die folgende Anfrage.

<x:Envelope xmlns:x = "http://schemas.xmlsoap.org/soap/envelope/" 
   xmlns:tns = "http://tutorialspoint/schemas">
   <x:Header/>
   <x:Body>
      <tns:getCountryRequest>
         <tns:name>United States</tns:name>
      </tns:getCountryRequest>
   </x:Body>
</x:Envelope>

Sie sehen das folgende Ergebnis.

<SOAP-ENV:Envelope xmlns:SOAP-ENV = "http://schemas.xmlsoap.org/soap/envelope/">
   <SOAP-ENV:Header/>
   <SOAP-ENV:Body>
      <ns2:getCountryResponse xmlns:ns2 = "http://tutorialspoint/schemas">
         <ns2:country>
            <ns2:name>United States</ns2:name>
            <ns2:population>46704314</ns2:population>
            <ns2:capital>Washington</ns2:capital>
            <ns2:currency>USD</ns2:currency>
         </ns2:country>
      </ns2:getCountryResponse>
   </SOAP-ENV:Body>
</SOAP-ENV:Envelope>

In diesem Kapitel erfahren Sie, wie Sie einen Webanwendungsdienst testen, der mit Spring WS erstellt wurde.

Schritt Beschreibung
1 Aktualisieren Sie das im Kapitel Spring WS - Write Server erstellte Projekt countryService. Fügen Sie den Ordner src / test / java hinzu.
2 Erstellen Sie CustomerEndPointTest.java im Ordner - src / test / java / com / tutorialspoint / ws und aktualisieren Sie die Datei POM.xml wie unten beschrieben.
3 Fügen Sie spring-context.xml im Unterordner src / main / resources hinzu.
4 Der letzte Schritt besteht darin, Inhalte für alle Quell- und Konfigurationsdateien zu erstellen und die Anwendung wie unten erläutert zu testen.

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/maven-v4_0_0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>countryService</artifactId>
   <packaging>war</packaging>
   <version>1.0-SNAPSHOT</version>
   <name>countryService Spring-WS Application</name>
   <url>http://www.springframework.org/spring-ws</url>
   <build>
      <finalName>countryService</finalName>
   </build>
   
   <dependencies>
      <dependency>
         <groupId>org.springframework.ws</groupId>
         <artifactId>spring-ws-core</artifactId>
         <version>2.4.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-test</artifactId>
         <version>2.5</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.ws</groupId>
         <artifactId>spring-ws-test</artifactId>
         <version>2.4.0.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-tx</artifactId>
         <version>3.1.2.RELEASE</version>
      </dependency>
      
      <dependency>
         <groupId>jdom</groupId>
         <artifactId>jdom</artifactId>
         <version>1.0</version>
      </dependency>
      
      <dependency>
         <groupId>jaxen</groupId>
         <artifactId>jaxen</artifactId>
         <version>1.1</version>
      </dependency>
      
      <dependency>
         <groupId>wsdl4j</groupId>
         <artifactId>wsdl4j</artifactId>
         <version>1.6.2</version>
      </dependency>
      
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.5</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
</project>

spring-context.xml

<beans xmlns = "http://www.springframework.org/schema/beans"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context = "http://www.springframework.org/schema/context"
   xmlns:sws = "http://www.springframework.org/schema/web-services"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/web-services
   http://www.springframework.org/schema/web-services/web-services-2.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package = "com.tutorialspoint"/>
   <sws:annotation-driven/>

   <bean id = "schema" class = "org.springframework.core.io.ClassPathResource">
      <constructor-arg index = "0" value = "countries.xsd" />
   </bean>
</beans>

CustomerEndPointTest.java

package com.tutorialspoint.ws;

import javax.xml.transform.Source;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.ws.test.server.MockWebServiceClient;
import org.springframework.xml.transform.StringSource;

import static org.springframework.ws.test.server.RequestCreators.withPayload;
import static org.springframework.ws.test.server.ResponseMatchers.payload;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration( locations = "/spring-context.xml" )
public class CustomerEndPointTest {
   @Autowired
   private ApplicationContext applicationContext;
   private MockWebServiceClient mockClient;

   @Before
   public void createClient() {
      mockClient = MockWebServiceClient.createClient(applicationContext);
      GenericApplicationContext ctx = (GenericApplicationContext) applicationContext;
      final XmlBeanDefinitionReader definitionReader = new XmlBeanDefinitionReader(ctx);
      definitionReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_NONE);
      definitionReader.setNamespaceAware(true);
   }
   @Test
   public void testCountryEndpoint() throws Exception {
      Source requestPayload = new StringSource(
         "<getCountryRequest xmlns = 'http://tutorialspoint/schemas'>"+
         "<name>United States</name>"+
         "</getCountryRequest>");				
      Source responsePayload = new StringSource(
         "<getCountryResponse xmlns='http://tutorialspoint/schemas'>" +
         "<country>" +
         "<name>United States</name>"+
         "<population>46704314</population>"+
         "<capital>Washington</capital>"+
         "<currency>USD</currency>"+
         "</country>"+
         "</getCountryResponse>");
      mockClient.sendRequest(withPayload(requestPayload)).andExpect(payload(responsePayload));
   }	
}

Erstellen Sie das Projekt

Öffnen Sie die Befehlskonsole, wechseln Sie in das Verzeichnis C: \ MVN \ countryService und führen Sie den folgenden Befehl mvn aus.

C:\MVN\countryService>mvn test

Maven wird mit dem Bau beginnen und das Projekt testen.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building countryService Spring-WS Application 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ countrySer
vice ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ countryService
---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ co
untryService ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\countryService\src\test\resour
ces
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ country
Service ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ countryService ---

[INFO] Surefire report directory: C:\MVN\countryService\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.tutorialspoint.ws.CustomerEndPointTest
Feb 27, 2017 11:49:30 AM org.springframework.test.context.TestContextManager ret
rieveTestExecutionListeners
INFO: @TestExecutionListeners is not present for class [class com.tutorialspoint
.ws.CustomerEndPointTest]: using defaults.
Feb 27, 2017 11:49:30 AM org.springframework.beans.factory.xml.XmlBeanDefinition
Reader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-context.xml]

Feb 27, 2017 11:49:30 AM org.springframework.context.support.GenericApplicationC
ontext prepareRefresh
INFO: Refreshing org.springframework.context.support.GenericApplicationContext@b
2eddc0: startup date [Mon Feb 27 11:49:30 IST 2017]; root of context hierarchy
Feb 27, 2017 11:49:31 AM org.springframework.ws.soap.addressing.server.Annotatio
nActionEndpointMapping afterPropertiesSet
INFO: Supporting [WS-Addressing August 2004, WS-Addressing 1.0]
Feb 27, 2017 11:49:31 AM org.springframework.ws.soap.saaj.SaajSoapMessageFactory
 afterPropertiesSet
INFO: Creating SAAJ 1.3 MessageFactory with SOAP 1.1 Protocol
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.386 sec
Feb 27, 2017 11:49:31 AM org.springframework.context.support.GenericApplicationC
ontext doClose
INFO: Closing org.springframework.context.support.GenericApplicationContext@b2ed
dc0: startup date [Mon Feb 27 11:49:30 IST 2017]; root of context hierarchy

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.517 s
[INFO] Finished at: 2017-02-27T11:49:31+05:30
[INFO] Final Memory: 11M/109M
[INFO] ------------------------------------------------------------------------

In diesem Kapitel erfahren Sie, wie Sie einen Client für den Webanwendungsserver erstellen, der im Spring WS - Writing Server mit Spring WS erstellt wurde.

Schritt Beschreibung
1 Aktualisieren Sie das Projekt countryService unter dem Paket com.tutorialspoint, wie im Kapitel Spring WS - Writing Server erläutert.
2 Erstellen Sie CountryServiceClient.java unter dem Paket com.tutorialspoint.client und MainApp.java unter dem Paket com.tutorialspoint, wie in den folgenden Schritten erläutert.

CountryServiceClient.java

package com.tutorialspoint.client;

import org.springframework.ws.client.core.support.WebServiceGatewaySupport;
import com.tutorialspoint.GetCountryRequest;
import com.tutorialspoint.GetCountryResponse;

public class CountryServiceClient extends WebServiceGatewaySupport {
   public GetCountryResponse getCountryDetails(String country){
      String uri = "http://localhost:8080/countryService/";
      GetCountryRequest request = new GetCountryRequest();
      request.setName(country);

      GetCountryResponse response =(GetCountryResponse) getWebServiceTemplate()
         .marshalSendAndReceive(uri, request);
      return response;
   }
}

MainApp.java

package com.tutorialspoint;

import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import com.tutorialspoint.client.CountryServiceClient;

public class MainApp {
   public static void main(String[] args) {
      CountryServiceClient client = new CountryServiceClient();
      Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
      marshaller.setContextPath("com.tutorialspoint");
      client.setMarshaller(marshaller);
      client.setUnmarshaller(marshaller);
      GetCountryResponse response = client.getCountryDetails("United States");

      System.out.println("Country : " + response.getCountry().getName());
      System.out.println("Capital : " + response.getCountry().getCapital());
      System.out.println("Population : " + response.getCountry().getPopulation());
      System.out.println("Currency : " + response.getCountry().getCurrency());
   }
}

Starten Sie den Webdienst

Starten Sie den Tomcat-Server und stellen Sie sicher, dass wir mit einem Standardbrowser über den Ordner webapps auf andere Webseiten zugreifen können.

Testen Sie den Webdienst-Client

Klicken Sie mit der rechten Maustaste auf die MainApp.java in Ihrer Anwendung unter Eclipse und verwenden Sie run as Java ApplicationBefehl. Wenn mit der Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

Country : United States
Capital : Washington
Population : 46704314
Currency : USD

Hier haben wir einen Client erstellt - CountryServiceClient.javafür den SOAP-basierten Webdienst. MainApp verwendet CountryServiceClient, um einen Treffer für den Webdienst zu erzielen, eine Post-Anfrage zu stellen und die Daten abzurufen.

In diesem Kapitel erfahren Sie, wie Sie einen im Spring WS - Writing Client erstellten Client für den in Kapitel Spring WS - Writing Server mit Spring WS erstellten Webanwendungsserver einem Komponententest unterziehen .

Schritt Beschreibung
1 Aktualisieren Sie das Projekt countryService unter dem Paket com.tutorialspoint, wie im Kapitel Spring WS - Writing Server erläutert.
2 Erstellen Sie CountryServiceClientTest.java unter dem Paket com.tutorialspoint unter Ordner SRC → Test → Java, wie in den folgenden Schritten erläutert.

CountryServiceClientTest.java

package com.tutorialspoint;

import static org.junit.Assert.*;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;

import com.tutorialspoint.client.CountryServiceClient;

public class CountryServiceClientTest {
   CountryServiceClient client;
   
   @Before
   public void setUp() throws Exception {
      client = new CountryServiceClient();
      Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
      marshaller.setContextPath("com.tutorialspoint");
      client.setMarshaller(marshaller);
      client.setUnmarshaller(marshaller);
   }
   @Test
   public void test() {
      GetCountryResponse response = client.getCountryDetails("United States");
      Country expectedCountry = new Country();
      expectedCountry.setCapital("Washington");
      Country actualCountry = response.getCountry();
      Assert.assertEquals(expectedCountry.getCapital(), actualCountry.getCapital());
   }
}

Starten Sie den Webdienst

Starten Sie den Tomcat-Server und stellen Sie sicher, dass wir mit einem Standardbrowser über den Ordner webapps auf andere Webseiten zugreifen können.

Unit Test Web Service Client

Öffnen Sie die Befehlskonsole, wechseln Sie in das Verzeichnis C: \ MVN \ countryService und führen Sie den folgenden Befehl mvn aus.

C:\MVN\countryService>mvn test

Maven wird mit dem Aufbau und Testen des Projekts beginnen.

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building countryService Spring-WS Application 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ countrySer
vice ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] Copying 2 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ countryService
---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 10 source files to C:\MVN\countryService\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ co
untryService ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\countryService\src\test\resour
ces
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ country
Service ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. b
uild is platform dependent!
[INFO] Compiling 2 source files to C:\MVN\countryService\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ countryService ---

[INFO] Surefire report directory: C:\MVN\countryService\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.tutorialspoint.CountryServiceClientTest
Feb 27, 2017 8:45:26 PM org.springframework.ws.soap.saaj.SaajSoapMessageFactory
afterPropertiesSet
INFO: Creating SAAJ 1.3 MessageFactory with SOAP 1.1 Protocol
Feb 27, 2017 8:45:26 PM org.springframework.oxm.jaxb.Jaxb2Marshaller createJaxbC
ontextFromContextPath
INFO: Creating JAXBContext with context path [com.tutorialspoint]
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.457 sec
Running com.tutorialspoint.ws.CustomerEndPointTest
Feb 27, 2017 8:45:27 PM org.springframework.test.context.TestContextManager retr
ieveTestExecutionListeners
INFO: @TestExecutionListeners is not present for class [class com.tutorialspoint
.ws.CustomerEndPointTest]: using defaults.
Feb 27, 2017 8:45:27 PM org.springframework.beans.factory.xml.XmlBeanDefinitionR
eader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring-context.xml]

Feb 27, 2017 8:45:27 PM org.springframework.context.support.GenericApplicationCo
ntext prepareRefresh
INFO: Refreshing org.springframework.context.support.GenericApplicationContext@5
17c642: startup date [Mon Feb 27 20:45:27 IST 2017]; root of context hierarchy
Feb 27, 2017 8:45:28 PM org.springframework.ws.soap.addressing.server.Annotation
ActionEndpointMapping afterPropertiesSet
INFO: Supporting [WS-Addressing August 2004, WS-Addressing 1.0]
Feb 27, 2017 8:45:28 PM org.springframework.ws.soap.saaj.SaajSoapMessageFactory
afterPropertiesSet
INFO: Creating SAAJ 1.3 MessageFactory with SOAP 1.1 Protocol
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.243 sec
Feb 27, 2017 8:45:28 PM org.springframework.context.support.GenericApplicationCo
ntext doClose
INFO: Closing org.springframework.context.support.GenericApplicationContext@517c
642: startup date [Mon Feb 27 20:45:27 IST 2017]; root of context hierarchy

Results :

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.686 s
[INFO] Finished at: 2017-02-27T20:45:28+05:30
[INFO] Final Memory: 17M/173M
[INFO] ------------------------------------------------------------------------