Programmering

Enkelt fjerns HTTP-fjerneksempel

Jeg bruker denne bloggoppføringen for å demonstrere bruken av Spring Framework's HTTP Remoting med et enkelt eksempel. Det er mange online ressurser om dette emnet, så min intensjon her er å gi en ekstremt enkel, men fullstendig demonstrasjon av å bruke Spring's HTTP Remoting med ikke-nettleserklienter.

Vårtilnærmingen til HTTP Remoting gjør at klienter kan kommunisere med den vårhostede serverkoden via HTTP uten at klientkoden krever kunnskap om HTTP. I stedet "ser" klientens Java-kode bare normale forretningsrelaterte Java-objekter (vanligvis grensesnitt) i stedet for HTTP-spesifikke objekter.

Fjær HTTP-fjernkontroll krever generelt Spring og Java både på serversiden og klientsiden. Imidlertid, hvis disse to kravene kan oppfylles, kan Spring HTTP Remoting enkelt brukes.

Følgende trinn tillater HTTP-kommunikasjon mellom Spring-klienter og servere. Etter å ha kort beskrevet først trinnene, vil jeg deretter gå nærmere inn på dem (inkludert kodeeksempler).

  1. Opprett eller bruk en eksisterende vårbønne som vanligvis implementerer et Java-grensesnitt.

    Dette er ikke noe spesielt for HTTP-fjernkontroll og er det samme trinnet du må ta for å gjøre det meste om våren (et bemerkelsesverdig unntak er

    Våren JDBC

    som ikke krever bruk av vårbønner).

  2. Opprett vår XML-konfigurasjonsfil for å knytte bønnen som ble opprettet i trinn 1 med en Spring-applikasjonskontekst.

    Som med trinn 1, er denne XML-filen ikke noe spesielt for Spring HTTP Remoting, men er i stedet vanlig for nesten alle Spring Framework-ledninger og konfigurasjoner.

  3. Opprett eller legg til web.xml fil.

    Dette tredje trinnet er det første trinnet som er mer spesifikt for Spring HTTP Remoting, men som fremdeles er generelt aktuelt med

    Vår MVC rammeverk

    . Dette trinnet inkluderer å legge til servlettklassen og URL-kartlegginger som man vanligvis bruker med

    Java EE

    servlets

    og

    JavaServer-sider

    . Den viktigste delen av dette trinnet er å spesifisere våren

    DispatcherServlet

    . En valgfri "lenke" er også gitt i dette

    web.xml

    fil til et kontekstkonfigurasjonssted der en eller flere kontekstfiler for Spring XML-applikasjoner ligger og brukes.

  4. Opprett vårspesifikk servlet-kontekstfil.

    Denne XML-filen ser ut som en "normal" XML-konfigurasjonsfil for vårapplikasjon, men navnet er foreskrevet av konvensjonen om servletnavn etterfulgt av en hypen og ordet servlet. Med andre ord, hvis servetten ble kalt "noe" i

    web.xml

    fil, vil denne vårservlet-konfigurasjonsfilen kalles

    en eller annen ting-servlet.xml

    . Denne filen inneholder konfigurasjonen for

    HttpInvokerServiceExporter

    (delen av dette som er spesielt for HTTP Remoting dekket i denne blogginnlegget) og URL-kartinformasjon.

  5. Test!

    Selv om den enkle klienten skriver uten HTTP i tankene og ser ut til å bare bruke Java-objekter, vil den faktisk påkalle tjenesten via HTTP. Dette blir "bevist" ved å kjøre klienten uten at tjenesten er distribuert og ser etter den resulterende HTTP-feilkoden.

Jeg fortsetter nå med å demonstrere trinnene ovenfor i større detalj og prøver å illustrere dem konkret med kodeeksempler.

Trinn 1: The Bean and Its Interface

Dette trinnet er ikke annerledes enn å definere Java-klasser og grensesnitt de implementerer for bruk med Spring. Følgende kodeoppføringer viser grensesnittet (StateCapitalServiceIF) og gjennomføringsklassen (StateCapitalService) brukt i dette eksemplet.

--- StateCapitalServiceIF.java ---

pakkeeksempler.springhttp; importere java.io.Serializable; / ** * Grensesnittet State Capital Service som klienten vil bruke til å få tilgang til * server-funksjonalitet via HTTP. * / offentlig grensesnitt StateCapitalServiceIF utvider Serializable {/ ** * Gi hovedstad hvis navn er oppgitt. * * @param stateName Navnet på staten hvis hovedstad er ønsket. * @ retur kapital i den spesifiserte staten; null hvis ikke funnet. * / public String getCapital (final String stateName); } 

--- StateCapitalService.java ---

pakkeeksempler.springhttp; importere java.util.Map; / ** * Implementering av funksjonalitet som skal kjøres etter å ha blitt ringt opp av klienten via * HTTP. * / public class StateCapitalService implementerer StateCapitalServiceIF {Map statesAndCapitals = null; public StateCapitalService () {} / ** * Sett statene mine til kartlegging av statlige hovedsteder. * * @param statesAndCapitals States to state capitals mapping. * / public void setStatesAndCapitals (final Map statesAndCapitals) {this.statesAndCapitals = statesAndCapitals; } / ** * Gi hovedstad hvis navn er oppgitt. * * @param stateName Navnet på staten hvis hovedstad er ønsket. * @ retur kapital i den spesifiserte staten; null hvis ikke funnet. * / public String getCapital (final String stateName) {returner this.statesAndCapitals.get (stateName); }} 

Trinn 2: Konfigurasjonsfil for vårapplikasjon

Jeg liker å holde vårens HTTP-spesifikke konfigurasjon atskilt fra bønnens XML-konfigurasjon. Derfor er bønnens konfigurasjon akkurat som man normalt ville sett med våren. For å konfigurere StateCapitalService klasse over, brukes følgende konfigurasjon:

--- vår-http-config.xml ---

Så langt er det ikke gjort noe spesifikt for HTTP Remoting. Faktisk kan bønnen, grensesnittet og XML-applikasjonskontekstkonfigurasjonen kjøres av en vanlig Java SE-klasse som vist nedenfor:

--- MainServiceAppContext.java ---

pakkeeksempler.springhttp; importer org.springframework.context.ApplicationContext; importer org.springframework.context.support.ClassPathXmlApplicationContext; / ** * Demonstrerer hvordan Spring Bean kan brukes uten HTTP-involvering. * / public class MainServiceAppContext {public static void printStateInfo (final StateCapitalServiceIF stateCapitalMapper, final String state) {System.out.println ("Capital of" + state + "is" + stateCapitalMapper.getCapital (state)); } / ** * @param argumenterer for kommandolinjeargumentene * / 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"); }} 

Trinn 3: The web.xml Fil

Dette web.xml filen er kjent for alle som har utviklet et Java EE-nettprogram. De web.xml brukt i dette eksemplet vises neste.

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

Trinn 4: Servlet-kontekstkonfigurasjonsfilen

Fordi servletten i dette eksemplet heter "statesCapitals", en Spring-servletkonfigurasjonsfil med navnet statesCapitals-servlet.xml må skaffes. Det vises neste:

--- statesCapitals-servlet.xml ---

   eksempler.springhttp.StateCapitalServiceIF httpStateCapitalService 

Trinn 5: Test det

Vi må konfigurere klienten til å kommunisere via HTTP med server-siden vår applikasjon. Konfigurasjonen for dette er inneholdt i vår-http-klient-config.xml for dette eksemplet og vises neste:

--- vår-http-klient-config.xml ---

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

Klientkoden som bruker ovennevnte XML for å starte en Spring-container og ringe serversiden via HTTP, er i klassen HttpClient og den koden vises neste:

--- HttpClient.java ---

pakkeeksempler.springhttp.client; importere eksempler.springhttp.StateCapitalServiceIF; importer org.springframework.context.ApplicationContext; importer org.springframework.context.support.ClassPathXmlApplicationContext; / ** * Denne klassen viser en klient til en Spring HTTP-eksponert tjeneste og viser * hvordan klienten samhandler med serveren som om han bruker vanlige Java-objekter * i stedet for å bruke noe HTTP-spesifikt. * / public class HttpClient {public static void printStateInfo (final StateCapitalServiceIF stateCapitalMapper, final String state) {System.out.println ("Hovedstaden i" + state + "er" + stateCapitalMapper.getCapital (state)); } public static void main (final 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"); }} 
$config[zx-auto] not found$config[zx-overlay] not found