Programmering

Simpel fjeder HTTP-fjerneksempel

Jeg bruger dette blogindlæg til at demonstrere ved et enkelt eksempel brugen af ​​Spring Framework's HTTP Remoting. Der er adskillige online ressourcer om dette emne, så min hensigt her er at give en ekstremt enkel, men komplet demonstration af brug af Spring's HTTP Remoting med ikke-browser klienter.

Spring tilgang til HTTP Remoting giver klienter mulighed for at kommunikere med den Spring-hostede serverkode via HTTP uden at klientkoden kræver noget kendskab til HTTP. I stedet "ser" klientens Java-kode kun normale forretningsrelaterede Java-objekter (normalt grænseflader) snarere end HTTP-specifikke objekter.

Spring HTTP Remoting kræver generelt Spring og Java på både serversiden og klientsiden. Men hvis disse to krav kan opfyldes, anvendes Spring HTTP Remoting let.

Følgende trin tillader HTTP-kommunikation mellem Spring-hostede klienter og servere. Efter først kort at have skitseret trinnene, vil jeg derefter gå ned i dem mere detaljeret (inklusive kodeeksempler).

  1. Opret eller brug en eksisterende Spring Bean, der typisk implementerer en Java-grænseflade.

    Dette er ikke noget særligt for HTTP-fjernstyring og er det samme trin, som du skal tage for at gøre de fleste ting om foråret (en bemærkelsesværdig undtagelse er

    Forår JDBC

    der ikke kræver brug af springbønner).

  2. Opret Spring XML-konfigurationsfilen til at knytte bønnen oprettet i trin # 1 til en Spring-applikationskontekst.

    Som med trin nr. 1 er denne XML-fil ikke noget særligt for Spring HTTP Remoting, men er i stedet fælles for næsten alle Spring Framework-ledninger og konfigurationer.

  3. Opret eller tilføj til web.xml fil.

    Dette tredje trin er det første trin, der er mere specifikt for Spring HTTP Remoting, men som stadig er generelt anvendeligt med

    Spring MVC ramme

    . Dette trin inkluderer tilføjelse af servletklassen og URL-tilknytninger, som man normalt bruger med

    Java EE

    servlets

    og

    JavaServer-sider

    . Den vigtigste del af dette trin er at specificere foråret

    DispatcherServlet

    . Et valgfrit "link" findes også i dette

    web.xml

    fil til en kontekstkonfigurationsplacering, hvor en eller flere Spring XML-applikationskontekstfiler findes og bruges.

  4. Opret den forårsspecifikke servlet-kontekstfil.

    Denne XML-fil ligner meget en "normal" XML-konfigurationsfil for Spring-applikationskontekst, men dens navn er ordineret af konventionen om servletnavn efterfulgt af en hypen og ordet servlet. Med andre ord, hvis servlet blev kaldt "et eller andet" i

    web.xml

    fil, kaldes denne Spring-servletkonfigurationsfil

    et sted-servlet.xml

    . Denne fil indeholder konfigurationen til

    HttpInvokerServiceExporter

    (det stykke af dette, der er specifikt for HTTP Remoting, der er dækket af dette blogindlæg) og URL-kortoplysninger.

  5. Prøve!

    Selvom den enkle klient skriver uden HTTP i tankerne og tilsyneladende kun bruger Java-objekter, vil den faktisk påkalde tjenesten via HTTP. Dette vil blive "bevist" ved at køre klienten uden den service, der er implementeret, og se efter den resulterende HTTP-fejlkode.

Jeg går nu videre med at demonstrere ovenstående trin mere detaljeret og forsøger at illustrere dem konkret med kodeeksempler.

Trin # 1: Bønnen og dens interface

Dette trin er ikke anderledes end at definere Java-klasser og grænseflader, de implementerer til brug med Spring. Følgende kodelister viser grænsefladen (StateCapitalServiceIF) og implementeringsklassen (StateCapitalService) brugt til dette eksempel.

--- StateCapitalServiceIF.java ---

pakkeeksempler.springhttp; import java.io.Serializable; / ** * State Capital Service-grænsefladen, som klienten bruger til at få adgang til * serversides funktionalitet via HTTP. * / offentlig grænseflade StateCapitalServiceIF udvider Serialiserbar {/ ** * Giv hovedstad, hvis navn er angivet. * * @param stateName Navn på den stat, hvis kapital ønskes. * @ retur kapital i den angivne stat; null hvis ikke fundet. * / public String getCapital (final String stateName); } 

--- StateCapitalService.java ---

pakkeeksempler.springhttp; importere java.util.Map; / ** * Implementering af funktionalitet, der skal køres efter opkald fra klient via * HTTP. * / public class StateCapitalService implementerer StateCapitalServiceIF {Map statesAndCapitals = null; public StateCapitalService () {} / ** * Indstil mine stater til kortlægning af hovedstæder. * * @param statesAndCapitals Stater til statlige hovedstads kortlægning. * / public void setStatesAndCapitals (final Map statesAndCapitals) {this.statesAndCapitals = statesAndCapitals; } / ** * Angiv hovedstad, hvis navn er angivet. * * @param stateName Navn på den stat, hvis kapital ønskes. * @ retur kapital i den angivne stat; null hvis ikke fundet. * / public String getCapital (final String stateName) {returner this.statesAndCapitals.get (stateName); }} 

Trin # 2: Forårsapplikationskontekstkonfigurationsfil

Jeg kan godt lide at holde Spring's HTTP-specifikke konfiguration adskilt fra bønnens XML-konfiguration. Derfor er bønnens konfiguration nøjagtigt som man normalt ville se med Spring. For at konfigurere StateCapitalService klasse ovenfor anvendes følgende konfiguration:

--- spring-http-config.xml ---

Indtil videre er der ikke gjort noget specifikt for HTTP Remoting. Faktisk kunne bønnen, dens grænseflade og dens XML-applikationskontekstkonfiguration alle køres af en normal Java SE-klasse som vist nedenfor:

--- MainServiceAppContext.java ---

pakkeeksempler.springhttp; import org.springframework.context.ApplicationContext; importer org.springframework.context.support.ClassPathXmlApplicationContext; / ** * Demonstrerer, hvordan Spring Bean kan bruges uden HTTP-involvering. * / public class MainServiceAppContext {public static void printStateInfo (final StateCapitalServiceIF stateCapitalMapper, final String state) {System.out.println ("Hovedstaden i" + state + "er" + stateCapitalMapper.getCapital (state)); } / ** * @param argumenterer for kommandolinjeargumenterne * / public static void main (String [] args) {final ApplicationContext context = new ClassPathXmlApplicationContext ("examples / springhttp / spring-http-config.xml"); StateCapitalServiceIF stateCapitalMapper = (StateCapitalServiceIF) context.getBean ("stateCapitalService"); printStateInfo (stateCapitalMapper, "Alabama"); printStateInfo (stateCapitalMapper, "Colorado"); }} 

Trin # 3: web.xml Fil

Det her web.xml filen er kendt for alle, der har udviklet en Java EE-webapplikation. Det web.xml brugt i dette eksempel vises næste.

  Simple Spring HTTP Remoting Eksempel Dette er ment som et ekstremt simpelt eksempel på brug af Spring's HTTP Remoting-kapacitet. statesCapitals org.springframework.web.servlet.DispatcherServlet 1 statesCapitals / statesCapitals org.springframework.web.context.ContextLoaderListener contextConfigLocation /WEB-INF/examples/springhttp/spring-http-config.xml 

Trin # 4: Konfigurationsfilen til Servlet-kontekst

Fordi servlet i dette eksempel hedder "statesCapitals", en Spring-servletkonfigurationsfil med navnet statesCapitals-servlet.xml skal leveres. Det vises derefter:

--- staterCapitals-servlet.xml ---

   eksempler.springhttp.StateCapitalServiceIF httpStateCapitalService 

Trin # 5: Test det

Vi er nødt til at konfigurere klienten til at kommunikere via HTTP med vores server-side-applikation. Konfigurationen til dette er indeholdt i spring-http-client-config.xml til dette eksempel og vises derefter:

--- spring-http-client-config.xml ---

   // localhost: 8080 / SpringHTTPExample / statesCapitals examples.springhttp.StateCapitalServiceIF 

Klientkoden, der bruger ovenstående XML til at bootstrap en Spring-container og kalde serversiden via HTTP, er i klassen HttpClient og den kode vises derefter:

--- HttpClient.java ---

pakkeeksempler.springhttp.client; importer eksempler.springhttp.StateCapitalServiceIF; import org.springframework.context.ApplicationContext; importer org.springframework.context.support.ClassPathXmlApplicationContext; / ** * Denne klasse demonstrerer en klient af en Spring HTTP-eksponeret tjeneste og viser * hvordan klienten interagerer med serveren som om han bruger normale Java-objekter * i stedet for at bruge noget HTTP-specifikt. * / public class HttpClient {public static void printStateInfo (final StateCapitalServiceIF stateCapitalMapper, final String state) {System.out.println ("Hovedstaden i" + state + "er" + stateCapitalMapper.getCapital (state)); } offentlig statisk ugyldig hoved (endelig String [] argumenter) {final ApplicationContext context = new ClassPathXmlApplicationContext ("eksempler / springhttp / client / spring-http-client-config.xml"); endelig StateCapitalServiceIF stateCapitalService = (StateCapitalServiceIF) context.getBean ("stateCapitalProxyService"); printStateInfo (stateCapitalService, "Colorado"); printStateInfo (stateCapitalService, "Alabama"); }}