Spring Web Services

Spring framework
Motto: Musíte rozbít vejce když chcete udělat omeletu

Spring framework training materials by Roman Pichlík is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

Sunday 13 May 2012 1

Spring WS, REST, HTTP
Vzdáleny přístup k datům


Vzdálený přístup k datům

• Motivace
• Integrace heterogeních sytému
• Mashups
• Strojové zpracování dat


Remote service bridge

Remote
service
bridge


Remote service bridge je jenom jednou z dalších možností, kromě UI, jak vystavit aplikační
logiku

Jak na webové služby

• Spring
• Spring WS (SOAP)
• Spring MVC (REST)
• Spring Remoting
• HTTP, Hessian, Burlap, RMI


- každá z těchto technologií má sve výhody a nevýhody

WS (SOAP)

• Průmyslový standard
• WSDL descriptor a XSD
• Interoperabilní technologie
• .NET, Java, Ruby...
• Protokolově nezávislé
• HTTP, JMS, XMPP, SMTP

WS (REST)
• Navržené s ohledem na HTTP
• Metody, Statusy, Cont. type nego.
• Jednoduchý interface
• POST, PUT, GET, DELETE
• Různé reprezentace
• JSON, XML


Spring Remoting

• Hessian, Spring HTTP, Burlap
• Proprietární technologie
• Interoperabilita omezená
• Více se jedná o RCP
• Rychlé prototypování


RPC vs. Zprávy
Service interface

Client Server

Client Stub
Service Service
RPC facade
logic stub implementace


- distribujeme chování (služba se jeví lokální, ale není)
- máme touhu věřit, že síť je spolehlivá

RPC vs. Zprávy
Client

ClientStub Message Protokol
logic adapter adapter

Message

Server

Protokol Message Service
adapter adapter implementace


vyměňují se zprávy (dokumenty/resources) namísto zakrývání vzdáleného volání

Web Services


Z čeho se skládjí WS
• Deﬁnice zpráv
• Deﬁnice kontraktu služby
• Binding do aplikačního protokolu
• Binding do transportního
protokolu
• Runtime
• Vlastní služba

Z čeho se skládjí WS
• Aplikační vývojář
• Deﬁnice zpráv a kontraktu služby
• Vlastní služba
• SpringWS
• binding SOAP a transport
• Aplikační server

Sunday 13 May 2012
• runtime 13

Techniky návrhu

• Contract first
• Začínáme definicí XSD a WSDL
• Contract last
• Začínáme kódem


Spring WS podporuje pouze contract first

Contract ﬁrst
• Výhody
• Robustnost
• Výkonnost
• Interoperabilita
• Nevýhody
• Složitější (znalost XSD, WSDL)


robustnost = nepodléhá refactoru (změna názvu metod apod.)
interoperabilita = problém s různymi generátory WSDL/XSD, typy atd.

Contract ﬁrst
• Návrh zpráv (dokumentů) pro
komunikaci server/client
• Popis kontraktu
• Struktura zpráv/dokumentů
• Volitlně popis služby
• WSDL


Spring WS - XSD, Relax NG, Schematron

Příklad zprávy (rezervace knih)

<rs:Reservation xmlns:rs="http://dagblog.cz/BookReservation">
<rs:bookId>1</rs:bookId>
</rs:Reservation>


Namespace předchází konﬂiktum pokud mixujeme různé XML fragmenty

XSD

<schema xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://dagblog.cz/BookReservation"
xmlns:rs="http://dagblog.cz/BookReservation">

<element name="Reservation">
<complexType>
<all>
<element name="bookId" type="long"/>
<element name="reservationId"
type="long" minOccurs="0" nillable="true"/>
</all>
</complexType>
</element>
</schema> <Reservation>
<bookId>1</bookId>
</Reservation>

Deﬁnice kontraktu služeb


WSDL

• Definice zpráv
• Definice operací (ports)
• Definice bindingu
• Aplikační protokol
• Transportní protokol


- Není povinné pro Spring WS
- SpringWS umí vygenerovat a automaticky vystavit
- Vhodné mít pro klienty

<wsdl:definitions xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://
schemas.xmlsoap.org/wsdl/soap/"
xmlns:schema="http://dagblog.cz/BookReservation/schema" xmlns:rs="http://dagblog.cz/BookReservation"
targetNamespace="http://dagblog.cz/BookReservation">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:import namespace="http://dagblog.cz/BookReservation/schema"
schemaLocation="BookReservation.xsd"/>
</xsd:schema>
</wsdl:types>

<wsdl:message name="ClaimReservationRequest">
<wsdl:part element="schema:ClaimReservationRequest" name="ClaimReservationRequest"/>
</wsdl:message>
<wsdl:message name="ClaimReservationResponse">
<wsdl:part element="schema:ClaimReservationResponse" name="ClaimReservationResponse"/>
</wsdl:message>

<wsdl:portType name="BookReservationResource">
<wsdl:operation name="ClaimReservation">
<wsdl:input message="rs:Reservation" name="ClaimReservationRequest"/>
<wsdl:output message="rs:Reservation" name="ClaimReservationResponse"/>
</wsdl:operation>
</wsdl:portType>

<wsdl:binding name="BookReservationBinding" type="rs:BookReservationResource">
<soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
<wsdl:operation name="ClaimReservation">
<soap:operation soapAction="http://dagblog.cz/BookReservation/ClaimReservation"/>
<wsdl:input name="ClaimReservationRequest"><soap:body use="literal"/></wsdl:input>
<wsdl:output name="ClaimReservationResponse"><soap:body use="literal"/></wsdl:output>
</wsdl:operation>
</wsdl:binding>

<wsdl:service name="BookReservationService">
<wsdl:port binding="rs:BookReservationBinding" name="BookReservationResourcePort">
<soap:address location="http://localhost:8080/springws/ws/"/>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>

SOAP
• SOAP
• Simple Object Access Protocol
• Deﬁnuje způsob komunikace
služeb
• Platformově nezávislý
• Nezávislý na transp. protokolu
• Deﬁnuje binding

SOAP


zjednodušeně řečeno SOAP je obálka pro naše zprávy, která zaručí jejich doručení

SOAP zpráva

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<sch:ClaimReservationRequest xmlns:sch="http://dagblog.cz/BookReservation/schema">
<rs:bookId xmlns:rs="http://dagblog.cz/BookReservation">1</rs:bookId>
</rs:Reservation>
</sch:ClaimReservationRequest>
</soapenv:Body>
</soapenv:Envelope>


SpringWS


SpringWS


core - SOAP, zakladni abstrakce, server i klient, message dispatching, HTTP
support - dalsi protokoly (JSM, SMTP, Jabber)
xml - WS Security a napojeni do Spring security

SpringWS


Request processing


Endpoint

• Základní abstrakce
• Velmi podobné Controleru z
Spring MVC
• Bridge mezi aplikační logikou a
světem WS (SOAP)


SpringWS nám umožňuje se zaměřit pouze na payload (vlastní zpráva), zbytek (SOAP) je v jeho
režii
Keep it simple

Zprava a její zpracování
• Jakým způsobem může endpoint
zpracovat payload
• Low level
• DOM, SAX, StAX
• Marshalling
• JAXB, Castor, XML beans


Rozdíl SAX a DOM
DOM = (JDOM, XOM, Dom4j)
Vysvětlení rozdílu Low level a Marshallingu (kdy použít jedno a kdy druhé)

Endpoint


Spring WS endpoint
@Endpoint
public class ReservationServiceWSEndpoint {

private static final String SCHEMA_NS = "http://dagblog.cz/BookReservation/schema";

@Autowired
private ReservationService reservationService;

@PayloadRoot(namespace = SCHEMA_NS, localPart = "ClaimReservationRequest")
@ResponsePayload
public Element bookRequest(@RequestPayload Element bookReservationRequest) throws
Exception {
....
}
}

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
mapping
<soapenv:Body>
<sch:ClaimReservationRequest xmlns:sch="http://dagblog.cz/BookReservation/schema">
<rs:bookId xmlns:rs="http://dagblog.cz/BookReservation">1</rs:bookId>
</rs:Reservation>
</sch:ClaimReservationRequest>
</soapenv:Body>
</soapenv:Envelope>

význam anotací

Co dále SpringWS umožňuje

• Deﬁnice transportního protokolů
• Endpoint zůstává stejný
• Handlování vyjímek a překlad na
SOAP Faults
• Podpora psaní testů Endpointů


Klientský přístup k WS


WebServiceTemplate

• Zjednodušuje přístup k WS
• Zaměření pouze na payload
• žádný SOAP
• Konvenční metody pro volání
služeb


Možné použít
WebServiceGatewaySupport

@Component
public class BookReservationClientWS {

private final Namespace namespace =
Namespace.getNamespace("rs", "http://dagblog.cz/BookReservation");

@Autowired
private WebServiceTemplate webServiceTemplate;

private static final String MESSAGE =
"<sch:ClaimReservationRequest xmlns:sch="http://dagblog.cz/BookReservation/schema">" +
" <rs:Reservation xmlns:rs="http://dagblog.cz/BookReservation">" +
" <rs:bookId>1</rs:bookId>" +
" </rs:Reservation>" +
"</sch:ClaimReservationRequest>";

public Reservation reserveBook(long bookId) {
StreamSource source = new StreamSource(new StringReader(MESSAGE));
JDOMResult jdomResult = new JDOMResult();
webServiceTemplate.sendSourceAndReceiveToResult(source, jdomResult);
Document document = jdomResult.getDocument();
Element reservationElement = document.getRootElement();
Long reservationId = Long.valueOf(reservationElement.getChild("reservationId",namespace).getValue());
Long bookIdRet = Long.valueOf(reservationElement.getChild("bookId",namespace).getValue());
ReservationImpl reservationImpl = new ReservationImpl();
reservationImpl.setBookId(bookIdRet);
reservationImpl.setReservationId(reservationId);
return reservationImpl;
}
}


• Praktické cvičení

• Pojďmě si navrhnout a naimplementovat WS
rozhraní k naší rezervační službě


REST


REST
• Representational State Transfer
• Roy Fielding
• Architektonický styl
• Škálovatelnost
• HTTP je i aplikační protokol
• Web není jenom o prohlížečích


Základní principy
• Vystavujeme Resourcy
• namísto služeb a jejich metod
• Resource může mít 4. základní
operace
• PUT, GET, DELETE, POST
• Klient si řídí reprezentaci resourců
• JSON, XML, HTML, plain text...

- velmi jednoduche oproti službám a jejich kontraktům

Základní principy
• Bezestavová architektura
• Prolinkování
• Resourcy se vzájemně odkazují
• Navigovatelnost (jak jí známe z
webu)
• HTTP hlavičky a Status kódy řídí
komunikaci

Proč REST

• Stačí pouze HTTP klient
• Dostupný na každé platformě
• Žádné XML peklo
• Vše se řídí HTTP protokolem


Né každý zná HTTP protokol ;-)

REST návrh aplikace
• Navrhujeme resourcy z pohledu
požadavků aplikace
• Rezervace, Kniha, Transakce,
Platba
• Navrhujeme URI space a
reprezentace
• Návrh navigovatelnosti/
prolinkování

HTTP status kódy
• Součást HTTP speciﬁkace
• Interpretaci významu odpovědi
• 1xx = Informační statusy
• 2xx = Úspěšně zpracováno
• 3xx = Přesměrování
• 4xx = Klientská chyba
• 5xx = Serverová chyba

Aplikace se nemusí navrhovat a vytvářet vlastní protokol

Příklady HTTP status kódů
• 200 Ok - úspěšně vyřízen
• 201 Created - úspěšně vytvořen
• 301 Moved - přesunut
• 404 Not Found - nenalezen
• 500 Internal Server Error
• Eufemismus pro Blue screen of death


Reprezentace resourců
• XML, JSON, text...
• volba pomocí content negotian
• Media type (iniciuje klient)
• Klientská data
• Content-type
• Odpověď (pouze hint)
• Accept

REST vs. WS
• Volte podle konzumentů
• WS
• vhodné do korporátního
prostředí (standard)
• REST
• vhodné pro internetové appky
• mashups a integrace

REST je velmi vhodný pro mobilní aplikace

Ukázka GoodData REST API


demonstrovat použití HTTP klienta - content/accept, errors atd.

REST v Jave
• JAX-RS Java 6 EE Standard
• Vývoj RESTových služeb
• Není podpora psaní REST
klienta
• Implementace
• Jersey, RESTEasy, Restlet


Spring MVC a REST


Spring MVC
• REST support od 3.0
• Rozšíření Spring MVC
• Vývoj klient i server části aplikace
• Anotace ze standardního Spring
MVC
• @Controller, @RequestMapping
• @PathVariable, @RequestParam

Klíčové anotace
• @RequestBody
• @ResponseBody
• Řídí použití vlastní konverzi mezi
modelem a HTTP request/
response
• Vlastní práce je na message
convertorech


HttpMessageConverter
• Konvertuje mezi HTTP request a
response a argumenty/
návratovými typy metod
• Registrované v HandleAdapter
• Defaultně aktivované
• XML, JSON...
• Řídí se Media typem v HTTP hl.

Klientský přístup


RestTemplate

• Třída pro práci s REST APIs
• Podporuje UriTempate a
HttpMessageConvertory
• Umožňuje zaměřit se pouze na
vlastní aplikační logiku
• Vlastní abstrakce pro HTTP
• Nezávislost na HTTP klientovi

RestTemplate API


@Component
public class BookReservationClientRest {
@Autowired
private RestTemplate restTemplate;

public Reservation reserveBook(long bookId) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
ReservationImpl reservation = new ReservationImpl();
reservation.setBookId(bookId);
URI uri = URI.create("http://localhost:8080/springws/rest/reservation/");
HttpEntity<ReservationImpl> requestEntity =
new HttpEntity<ReservationImpl>(reservation, headers);
ResponseEntity<ReservationImpl> response =
restTemplate.postForEntity(uri), requestEntity,
ReservationImpl.class);
return response.getBody();
}
}
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans">

<bean id="restTemplate" class="org.springframework.web.client.RestTemplate" />

</beans>


• Praktické cvičení

• Pojďmě si navrhnout a naimplementovat REST
rozhraní k naší rezervační službě


Spring Web Services

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (19)

Similar to Spring Web Services

Similar to Spring Web Services (7)

More from Roman Pichlík

More from Roman Pichlík (10)

Spring Web Services