Spring WS - Guida rapida

Spring Web Services (Spring-WS) è uno dei progetti sviluppati dalla Spring Community. Il suo obiettivo principale è creare servizi Web basati su documenti. Il progetto Spring Web Services facilita il primo contrattoSOAP Service Development, fornisce diversi modi per creare servizi Web flessibili, che possono manipolare i payload XML in diversi modi.

I servizi Web Spring utilizzano concetti di Spring come l'inserimento di dipendenze e le configurazioni senza problemi. Spring-WS richiede la versione Spring 3.0. Con lo sviluppo del contratto, iniziamo conWSDL Contract e quindi utilizzerà JAVA per implementare il contratto richiesto.

Contrariamente all'approccio dell'ultimo contratto in cui le interfacce JAVA generano il contratto WSDL / XSD. Il contratto basato su WSDL rimane indipendente dall'implementazione di JAVA nell'approccio contratto prima. Nel caso in cui sia necessario modificare le interfacce JAVA, non è necessario comunicare le modifiche apportate al contratto WSDL esistente agli utenti dei servizi web. Spring-WS mira a fornire un accoppiamento libero tra il contratto WSDL e la sua implementazione basata su JAVA.

Caratteristiche

Di seguito sono riportate le funzionalità di Spring Web Services:

  • XML Mapping to Objects - Le richieste basate su XML possono essere mappate a qualsiasi oggetto utilizzando le informazioni memorizzate nel Message Payload, SOAP Action Header o utilizzando un'espressione XPath.

  • Multiple API Support to parse XML - Oltre alle API JAXP standard (DOM, SAX, StAX) per analizzare le richieste XML in arrivo, sono supportate anche altre librerie come JDOM, dom4j, XOM.

  • Multiple API Support to marshal XML- Spring Web Services supporta le librerie JAXB 1 e 2, Castor, XMLBeans, JiBX e XStream utilizzando il suo modulo Object / XML Mapping. Il modulo Object / XML Mapping può essere utilizzato anche nel codice di servizi non Web.

  • Spring based configurations - Spring Web Services utilizza Spring Application Contexts per le sue configurazioni aventi un'architettura simile a quella di Spring Web MVC.

  • Integrated WS-Security module - Utilizzando il modulo WS-Security, è possibile firmare, crittografare, decrittografare i messaggi SOAP o autenticarli.

  • Support for Acegi Security - Utilizzando l'implementazione WS-Security di Spring Web Services, la configurazione Acegi può essere utilizzata per i tuoi servizi SOAP.

Architettura

Il progetto Spring-WS è costituito da cinque moduli principali, che vengono spiegati di seguito.

  • Spring-WS Core - È il modulo principale e fornisce le interfacce centrali come WebServiceMessage e SoapMessage, il framework lato server, potenti capacità di invio di messaggi e classi di supporto per implementare gli endpoint del servizio Web. Fornisce inoltre client consumer di Web Service comeWebServiceTemplate.

  • Spring-WS Support - Questo modulo fornisce supporti per JMS, e-mail, ecc.

  • Spring-WS Security- Questo modulo è responsabile di fornire l'implementazione di WS-Security integrata con il modulo di servizio Web principale. Utilizzando questo modulo, possiamo aggiungere token principali, firmare, crittografare e decrittografare i messaggi SOAP. Questo modulo consente di utilizzare l'implementazione Spring Security esistente per l'autenticazione e l'autorizzazione.

  • Spring XML- Questo modulo fornisce classi di supporto XML per Spring Web Services. Questo modulo è utilizzato internamente dal framework Spring-WS.

  • Spring OXM - Questo modulo fornisce classi di supporto per XML vs Object Mapping.

In questo capitolo, comprenderemo il processo di configurazione di Spring-WS su sistemi basati su Windows e Linux. Lo Spring-WS può essere facilmente installato e integrato con la tua correnteJava environment e MAVENseguendo alcuni semplici passaggi senza complesse procedure di configurazione. Durante l'installazione è richiesta l'amministrazione degli utenti.

Requisiti di sistema

La tabella seguente elenca i requisiti di sistema, mentre i passaggi successivi ci guideranno attraverso la procedura di configurazione dell'ambiente.

JDK Java SE 2 JDK 1.5 o successivo
Memoria 1 GB di RAM (consigliato)
Spazio sul disco Nessun requisito minimo
Versione del sistema operativo Windows XP o successivo, Linux

Procediamo ora con i passaggi per installare Spring-WS.

Passaggio 1: verifica l'installazione di Java

Per cominciare, devi avere Java Software Development Kit (SDK) installato sul tuo sistema. Per verificarlo, esegui uno dei seguenti due comandi a seconda della piattaforma su cui stai lavorando.

Se l'installazione di Java è stata eseguita correttamente, verranno visualizzate la versione corrente e le specifiche dell'installazione di Java. Un output di esempio è fornito nella tabella seguente.

piattaforma Comando Output di esempio
finestre

Apri la console dei comandi e digita -

\> java -version

Versione Java "1.7.0_60"

Java (TM) SE Run Time Environment (build 1.7.0_60-b19)

VM server Java Hotspot (TM) a 64 bit (build 24.60-b09, modalità mista)
Linux

Apri il terminale di comando e digita -

$ java -version

versione java "1.7.0_25"

Aprire JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64)

Apri la VM server JDK a 64 bit (build 23.7-b01, modalità mista)

  • Si presume che i lettori di questo tutorial abbiano Java SDK versione 1.7.0_60 installato sul proprio sistema.

  • Se non disponi di Java SDK, scarica la versione corrente da https://www.oracle.com/technetwork/java/javase/downloads/index.html e averlo installato.

Passaggio 2: imposta l'ambiente Java

Imposta la variabile d'ambiente JAVA_HOME per puntare alla posizione della directory di base in cui Java è installato sulla macchina.

S.No. Piattaforma e descrizione
1

Windows

Imposta JAVA_HOME su C: \ ProgramFiles \ java \ jdk1.7.0_60
2

Linux

Esporta JAVA_HOME = / usr / local / java-current

Aggiungi il percorso completo della posizione del compilatore Java al percorso di sistema.

S.No. Piattaforma e descrizione
1

Windows

Aggiungi la stringa "C: \ Programmi \ Java \ jdk1.7.0_60 \ bin" alla fine della variabile di sistema PATH.
2

Linux

Esporta PATH = $ PATH: $ JAVA_HOME / bin /

Esegui il comando java -version dal prompt dei comandi come spiegato sopra.

Passaggio 3: scarica l'archivio Maven

Scarica Maven 3.3.3 da https://maven.apache.org/download.cgi

OS Nome dell'archivio
finestre 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

Passaggio 4: estrai l'archivio Maven

Estrai l'archivio, nella directory in cui desideri installare Maven 3.3.3. La sottodirectory apache-maven-3.3.3 verrà creata dall'archivio.

OS Posizione (può essere diversa in base all'installazione)
finestre C: \ Programmi \ Apache Software Foundation \ apache-maven-3.3.3
Linux / usr / local / apache-maven
Mac / usr / local / apache-maven

Passaggio 5: imposta le variabili di ambiente Maven

Aggiungi M2_HOME, M2 e MAVEN_OPTS alle variabili d'ambiente.

OS Produzione
finestre

Imposta le variabili di ambiente utilizzando le proprietà di sistema.

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

M2 =% M2_HOME% \ bin

MAVEN_OPTS = -Xms256m -Xmx512m
Linux

Apri il terminale dei comandi e imposta le variabili d'ambiente.

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

esporta M2 = $ M2_HOME / bin

esporta MAVEN_OPTS = -Xms256m -Xmx512m
Mac

Apri il terminale dei comandi e imposta le variabili d'ambiente.

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

esporta M2 = $ M2_HOME / bin

esporta MAVEN_OPTS = -Xms256m -Xmx512m

Passaggio 6: aggiungere la posizione della directory bin Maven al percorso di sistema

Ora aggiungi la variabile M2 al percorso di sistema.

OS Produzione
finestre Aggiungi la stringa;% M2% alla fine della variabile di sistema, Path.
Linux export PATH = $ M2: $ PATH
Mac export PATH = $ M2: $ PATH

Passaggio 7: verifica l'installazione di Maven

Ora apri la console, esegui quanto segue mvn comando.

OS Compito Comando
finestre Apri la Console di comando c: \> mvn --version
Linux Apri Terminale di comando $ mvn --version
Mac Apri Terminale macchina: <joseph $ mvn --version

Infine, verifica l'output dei comandi precedenti, che dovrebbe essere qualcosa come mostrato di seguito -

OS Produzione
finestre

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

Home page di Maven: C: \ Programmi \ Apache Software Foundation \ apache-maven-3.3.3

Versione Java: 1.7.0_75, fornitore: Oracle Corporation

Home page di Java: C: \ Programmi \ Java \ jdk1.7.0_75 \ jre

Impostazioni internazionali predefinite: en_US, codifica piattaforma: Cp1252
Linux

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

Home page di Maven: /usr/local/apache-maven/apache-maven-3.3.3

Versione Java: 1.7.0_75, fornitore: Oracle Corporation

Home page di Java: /usr/local/java-current/jdk1.7.0_75/jre
Mac

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

Home page di Maven: /usr/local/apache-maven/apache-maven-3.3.3

Versione Java: 1.7.0_75, fornitore: Oracle Corporation

Home page di Java: /Library/Java/Home/jdk1.7.0_75/jre

Passaggio 8: configurazione dell'IDE di Eclipse

Tutti gli esempi in questo tutorial sono stati scritti utilizzando l'IDE Eclipse. Si consiglia ai lettori di avere l'ultima versione di Eclipse installata sulla propria macchina. Per installare l'IDE di Eclipse, scaricare gli ultimi binari di Eclipse dal seguente collegamentohttps://www.eclipse.org/downloads/. Una volta scaricata l'installazione, decomprimere la distribuzione binaria in una posizione comoda.

Ad esempio in C:\eclipse su Windows o /usr/local/eclipsesu Linux / Unix e infine impostare la variabile PATH in modo appropriato. Eclipse può essere avviato eseguendo i seguenti comandi sulla macchina Windows, oppure puoi semplicemente fare doppio clic su eclipse.exe.

%C:\eclipse\eclipse.exe

Eclipse può essere avviato eseguendo i seguenti comandi sulla macchina UNIX (Solaris, Linux, ecc.) -

$/usr/local/eclipse/eclipse

Dopo un avvio riuscito, se tutto va bene, dovrebbe visualizzare la seguente schermata:

Passaggio 9: configurazione di Apache Tomcat

Possiamo scaricare l'ultima versione di Tomcat da https://tomcat.apache.org/. Una volta scaricata l'installazione, decomprimere la distribuzione binaria in una posizione comoda. Ad esempio inC:\apache-tomcat-7.0.59 su una macchina Windows o in /usr/local/apache-tomcat-7.0.59 su una macchina Linux / Unix e quindi impostare il file CATALINA_HOME variabile di ambiente che punta alle posizioni di installazione.

Tomcat può essere avviato eseguendo i seguenti comandi su una macchina Windows, oppure puoi semplicemente fare doppio clic su startup.bat

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

Tomcat può essere avviato eseguendo i seguenti comandi su una macchina UNIX (Solaris, Linux, ecc.) -

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

Dopo un avvio riuscito, le applicazioni Web predefinite incluse con Tomcat saranno disponibili visitando: http://localhost:8080/. Se tutto va bene, dovrebbe visualizzare la seguente schermata:

Ulteriori informazioni sulla configurazione e l'esecuzione di Tomcat sono disponibili nella documentazione inclusa qui, nonché sul sito Web Tomcat - https://tomcat.apache.org

Tomcat può essere arrestato eseguendo i seguenti comandi su una macchina Windows:

%CATALINA_HOME%\bin\shutdown

or

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

Tomcat può essere arrestato eseguendo i seguenti comandi sulla macchina UNIX (Solaris, Linux, ecc.):

$CATALINA_HOME/bin/shutdown.sh

or

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

Una volta terminato questo ultimo passaggio, siamo pronti per procedere con il primo esempio di servizi Web, di cui parleremo nel prossimo capitolo.

Cominciamo a scrivere un vero servizio web basato su SOAP con Spring-WS Framework. Prima di iniziare a scrivere il nostro primo esempio utilizzando il framework Spring-WS, dobbiamo assicurarci che l'ambiente Spring-WS sia configurato correttamente come spiegato nel capitolo Servizi Web Spring - Configurazione dell'ambiente . Presumiamo che i lettori abbiano una conoscenza di base di lavoro con l'IDE Eclipse.

Pertanto, procediamo a scrivere una semplice applicazione Spring WS che esporrà un metodo di servizio web per prenotare un congedo in un portale delle risorse umane.

Approccio al primo contratto

Spring-WS utilizza l'approccio Contract-first, il che significa che dovremmo avere il nostro XML Structurespronto prima di scrivere qualsiasi codice di implementazione basato su JAVA. Stiamo definendo un oggetto LeaveRequest, che ha oggetti secondari: Leave e Employee.

Di seguito sono riportati i costrutti XML richiesti:

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>

Crea il progetto

Apriamo ora una console di comando, andiamo nella directory C: \ MVN ed eseguiamo quanto segue mvn comando.

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

Maven inizierà l'elaborazione e creerà la struttura completa del progetto dell'applicazione Java.

[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] ------------------------------------------------------------------------

Adesso vai a C:/MVNdirectory. Vedremo un progetto di applicazione java creato denominatoleaveService(come specificato in artifactId). Aggiorna il pom.xml e aggiungi HumanResourceService.java e HumanResourceServiceImpl.java nella seguente cartella: C: \ MVN \ leaveService \ src \ main \ java \ com \ tutorialspoint \ hr \ service folder. Una volta fatto, aggiungi LeaveEndpoint.java nella seguente cartella: 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>

Costruisci il progetto

Apriamo ora la console dei comandi, andiamo nella directory C: \ MVN \ leaveService ed eseguiamo quanto segue mvn comando.

C:\MVN\leaveService>mvn clean package

Maven inizierà a costruire il progetto.

[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] ------------------------------------------------------------------------

Importa progetto in Eclipse

Seguire i passaggi indicati di seguito per importare il progetto in Eclipse.

  • Apri Eclipse.

  • Selezionare File → Import → opzione.

  • Seleziona l'opzione Maven Projects. Fare clic sul pulsante Avanti.

  • Seleziona Posizione progetto, dove leaveService project è stato creato utilizzando Maven.

  • Fare clic sul pulsante Fine.

Esegui il progetto

Una volta terminata la creazione dei file sorgente e di configurazione, esportare l'applicazione. Fare clic con il pulsante destro del mouse sull'applicazione, utilizzare l'opzione Esporta → File WAR e salvare il file leaveService.war nella cartella webapps di Tomcat.

Avvia il server Tomcat e assicurati di essere in grado di accedere ad altre pagine web dalla cartella webapps utilizzando un browser standard. Prova ad accedere all'URL - http: // localhost: 8080 / leaveService / leave.wsdl, se tutto va bene con l'applicazione Web Spring, dovremmo vedere la seguente schermata.

Nel capitolo precedente Spring -WS - First Application , abbiamo generato WSDL automaticamente utilizzando la configurazione Spring WS. In questo caso, verrà visualizzato come esporre il WSDL esistente utilizzando Spring WS.

Passo Descrizione
1 Creare un progetto con un nome leaveService in un pacchetto com.tutorialspoint come spiegato nel capitolo Spring WS - Prima applicazione.
2 Creare un leave.wsdl WSDL nella sottocartella / WEB-INF / wsdl.
3 Aggiorna spring-ws-servlet.xml nella sottocartella / WEB-INF. Stiamo usando il tag static-wsdl qui invece di dynamic-wsdl.
4 Il passaggio finale è creare il contenuto di tutti i file di origine e di configurazione ed esportare l'applicazione come spiegato di seguito.

/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>

Esegui il progetto

Una volta che abbiamo finito con la creazione dei file sorgente e di configurazione, dovremmo esportare l'applicazione. Fare clic con il pulsante destro del mouse sull'applicazione, utilizzare l'opzione Esporta → File WAR e salvare il file leaveService.war nella cartella webapps di Tomcat.

Ora, avvia il server Tomcat e assicurati di poter accedere ad altre pagine web dalla cartella webapps utilizzando un browser standard. Prova ad accedere all'URL - http: // localhost: 8080 / leaveService / leave.wsdl, se tutto va bene con l'applicazione Web Spring, vedremo la seguente schermata.

In questo capitolo capiremo come creare un server di applicazioni Web utilizzando Spring WS.

Passo Descrizione
1 Creare un progetto con un nome countryService in un pacchetto com.tutorialspoint come spiegato nel capitolo Spring WS - Prima applicazione.
2 Crea countries.xsd, classi di dominio, CountryRepository e CountryEndPoint come spiegato nei passaggi seguenti.
3 Aggiorna spring-ws-servlet.xml nella sottocartella / WEB-INF.
4 Il passaggio finale consiste nel creare il contenuto per tutti i file di origine e di configurazione ed esportare l'applicazione come spiegato di seguito.

paesi.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>

Crea il progetto

Apriamo la console dei comandi, andiamo nella directory C: \ MVN ed eseguiamo quanto segue mvn comando.

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

Maven inizierà l'elaborazione e creerà la struttura completa del progetto dell'applicazione Java.

[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] ------------------------------------------------------------------------

Ora vai alla directory C: / MVN. Vedremo un progetto di applicazione java creato denominato countryService (come specificato in artifactId). Aggiorna il file 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>

Crea classi di dominio

Copia il file countries.xsd nella cartella C: \ mvn \ countryService \ src \ main \ resources. Apriamo la console dei comandi, andiamo nella directory C: \ mvn \ countryService \ src \ main \ resources ed eseguiamo quanto seguexjc comando per generare classi di dominio utilizzando countries.xsd.

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

Maven inizierà l'elaborazione e creerà le classi di dominio nel pacchetto 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

Crea la cartella java nella cartella C: \ mvn \ countryService \ src \ main. Copia tutte le classi nella cartella C: \ mvn \ countryService \ src \ main \ java. Creare CountryRepository e CountryEndPoint per rappresentare rispettivamente il database del paese e il server del paese.

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>

Costruisci il progetto

Apriamo la console dei comandi. Vai alla directory C: \ MVN \ countryService ed esegui quanto seguemvn comando.

C:\MVN\countryService>mvn clean package

Maven inizierà a costruire il progetto.

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] ------------------------------------------------------------------------

Esegui il progetto

Dopo aver creato i file di origine e di configurazione, esportare il file countryService.war nella cartella webapps di Tomcat.

Ora, avvia il server Tomcat e assicurati di poter accedere ad altre pagine web dalla cartella webapps utilizzando un browser standard. Effettuare una richiesta POST all'URL - http: // localhost: 8080 / countryService / e utilizzando qualsiasi client SOAP effettuare la seguente richiesta.

<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>

Vedrai il seguente risultato.

<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 questo capitolo si capirà come eseguire un test unitario di un servizio di applicazioni Web creato utilizzando Spring WS.

Passo Descrizione
1 Aggiorna il paese del progetto Servizio creato nel capitolo Spring WS - Write Server. Aggiungi la cartella src / test / java.
2 Creare CustomerEndPointTest.java nella cartella - src / test / java / com / tutorialspoint / ws e quindi aggiornare POM.xml come descritto di seguito.
3 Aggiungi spring-context.xml nella sottocartella src / main / resources.
4 Il passaggio finale consiste nel creare contenuto per tutti i file di origine e di configurazione e testare l'applicazione come spiegato di seguito.

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));
   }	
}

Costruisci il progetto

Apriamo la console dei comandi, andiamo nella directory C: \ MVN \ countryService ed eseguiamo il seguente comando mvn.

C:\MVN\countryService>mvn test

Maven inizierà a costruire e testare il progetto.

[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 questo capitolo impareremo come creare un client per il server di applicazioni Web creato in Spring WS - Server di scrittura utilizzando Spring WS.

Passo Descrizione
1 Aggiornare il progetto countryService nel pacchetto com.tutorialspoint come spiegato nel capitolo Spring WS - Server di scrittura.
2 Creare CountryServiceClient.java nel pacchetto com.tutorialspoint.client e MainApp.java nel pacchetto com.tutorialspoint come spiegato nei passaggi seguenti.

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());
   }
}

Avvia il servizio Web

Avvia il server Tomcat e assicurati di poter accedere ad altre pagine web dalla cartella webapps utilizzando un browser standard.

Test del client del servizio Web

Fare clic con il pulsante destro del mouse su MainApp.java nella propria applicazione in Eclipse e utilizzare run as Java Applicationcomando. Se tutto va bene con l'applicazione, stamperà il seguente messaggio.

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

Qui abbiamo creato un cliente - CountryServiceClient.javaper il servizio web basato su SOAP. MainApp utilizza CountryServiceClient per fare un hit al servizio web, effettua una richiesta di post e ottiene i dati.

In questo capitolo impareremo come eseguire un test unitario di un client creato in Spring WS - Client di scrittura per il server di applicazioni Web creato nel capitolo Spring WS - Server di scrittura utilizzando Spring WS.

Passo Descrizione
1 Aggiornare il progetto countryService nel pacchetto com.tutorialspoint come spiegato nel capitolo Spring WS - Server di scrittura.
2 Creare CountryServiceClientTest.java nel pacchetto com.tutorialspoint nella cartella SRC → Test → Java come spiegato nei passaggi indicati di seguito.

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());
   }
}

Avvia il servizio Web

Avvia il server Tomcat e assicurati di essere in grado di accedere ad altre pagine web dalla cartella webapps utilizzando un browser standard.

Client del servizio Web di unit test

Apriamo la console dei comandi, andiamo nella directory C: \ MVN \ countryService ed eseguiamo il seguente comando mvn.

C:\MVN\countryService>mvn test

Maven inizierà a costruire e testare il progetto.

[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] ------------------------------------------------------------------------
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved