Java >> Java tutorial >  >> Tag >> Spring

Forår 4 HVILE Hello World Eksempel

I dette eksempel skal vi vise dig, hvordan du opretter et simpelt program til at foretage Rest-opkald ved hjælp af Spring Web MVC-rammeværket. Spring Web model-view-controller (MVC) er en Spring-understøttelsesramme for webbaserede præsentationsniveauer. Det giver en model-view-controller-arkitektur og færdige komponenter, der kan bruges til at udvikle fleksible og løst koblede webapplikationer.

På et tidligere Spring MVC HelloWorld-eksempel forklarede vi, hvordan man bygger alle nødvendige komponenter til en applikation med Spring MVC. Her vil vi følge de samme trin, denne gang inklusive et hvileopkald. Vi opretter en Controller for at implementere resten kalder en view (jsp), og vi tilføjer de nødvendige konfigurationsfiler, og så bruger vi en applikationsserver til at køre eksemplet.

Vores foretrukne udviklingsmiljø er Eclipse. Vi bruger Eclipse Juno (4.2) version sammen med Maven Integration plugin version 3.1.0. Du kan downloade Eclipse herfra og Maven Plugin til Eclipse herfra. Installationen af ​​Maven plugin til Eclipse er uden for denne tutorials omfang og vil ikke blive diskuteret. Vi bruger også JDK 7_u_21. Tomcat 7 er den anvendte applikationsserver.

Lad os begynde.

1. Opret et nyt Maven-projekt

Gå til Filer -> Projekt ->Maven -> Maven Project.

På siden "Vælg projektnavn og placering" i guiden skal du sørge for, at "Opret et simpelt projekt (spring over arketypevalg)" er ikke markeret , tryk på "Næste" for at fortsætte med standardværdier.

Her skal maven-arketypen til at oprette en webapplikation tilføjes. Klik på "Tilføj arketype" og tilføje arketypen. Indstil "Arketype Group Id"-variablen til "org.apache.maven.archetypes" , variablen "Arketype artefakt Id" til "maven-archetype-webapp" og "Arketypeversionen" til "1.0" . Klik på “OK” at fortsætte.

På siden "Indtast et artefakt-id" i guiden kan du definere navnet og hovedpakken for dit projekt. Indstil "Group Id"-variablen til "com.javacodegeeks.snippets.enterprise" og variablen "Artifact Id" til "springexample" . De førnævnte valg komponerer hovedprojektpakken som "com.javacodegeeks.snippets.enterprise.springexample" og projektnavnet som "springexample" . Indstil "Pakke"-variablen til "war" , så der oprettes en krigsfil til at blive implementeret på tomcat-serveren. Tryk på "Udfør" for at afslutte guiden og oprette dit projekt.

Maven-projektets struktur er vist nedenfor:

    Den består af følgende mapper:
  • /src/main/java mappe, der indeholder kildefiler til programmets dynamiske indhold,
  • /src/test/java-mappen indeholder alle kildefiler til enhedstest,
  • /src/main/resources-mappen indeholder konfigurationsfiler,
  • /target folder indeholder de kompilerede og pakkede leverancer,
  • /src/main/resources/webapp/WEB-INF mappen indeholder implementeringsbeskrivelserne for webapplikationen,
  • pom.xml er POM-filen (Project Object Model). Den enkelte fil, der indeholder alle projektrelaterede konfigurationer.

2. Tilføj Spring-MVC-afhængigheder

Tilføj afhængighederne i Mavens pom.xml fil, ved at redigere den på "Pom.xml"-siden i POM-editoren. Den nødvendige afhængighed til MVC er spring-webmvc pakke, som vist nedenfor:

pom.xml

<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.javacodegeeks.snippets.enterprise</groupId>
  <artifactId>springexample</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>springexample Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    <dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
  </dependencies>
  <build>
    <finalName>springexample</finalName>
  </build>
  
	<properties>
		<spring.version>4.0.2.RELEASE</spring.version>
	</properties>
</project>

3. Opret controlleren

Controller er hvor DispatcherServlet vil uddelegere anmodninger. @Controller annotation angiver, at klassen tjener rollen som en Controller . @RequestMapping annotation bruges til at knytte en URL til enten en hel klasse eller en bestemt behandlermetode. Her bruges det til begge tilfælde.

HelloWorldController.java klasse består af to metoder, der begge håndterer GET anmodninger fra Dispatcher . Den første er hello(ModelMap model) . org.springframework.ui.ModelMap bruges som en generisk modelholder. Her sætter vi en attribut kaldet name , og en standardværdi JCG Hello World! .

Den anden metode er displayMessage(@PathVariable String msg, ModelMap model) metode. Her er @PathVariable annotation bruges på msg metodens argumentation. Således er msg argument er bundet til værdien af ​​metodens URI-skabelonvariabel.

HelloWorldController.java

package com.javacodegeeks.snippets.enterprise;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping("/helloWorld")
public class HelloWorldController {

		@RequestMapping(value = "/hello", method = RequestMethod.GET)
		public String hello(ModelMap model) {
			model.addAttribute("msg", "JCG Hello World!");
			return "helloWorld";
		}
		
		@RequestMapping(value = "/displayMessage/{msg}", method = RequestMethod.GET)
		public String displayMessage(@PathVariable String msg, ModelMap model) {
			model.addAttribute("msg", msg);
			return "helloWorld";
		}
		
	}

4. Opret visningen

Visningen er en simpel jsp-side, placeret i /WEB-INF/ folder. Den viser værdien af ​​den attribut, der blev sat til Controller .

helloWorld.jsp

<html>
<body>
	<h1>Spring 4.0.2 MVC web service</h1>
	
	<h3>Your Message : ${msg}</h3>	
</body>
</html>

5. Konfigurer applikationen

Filerne, som vi skal konfigurere i applikationen, er web.xml filen og mvc-dispatcher-servlet.xml fil.

web.xml fil er den fil, der definerer alt om applikationen, som en server skal vide. Den er placeret i /WEB-INF/ applikationens bibliotek. <servlet> element erklærer DispatcherServlet . Når DispatcherServlet er initialiseret, vil frameworket forsøge at indlæse applikationskonteksten fra en fil med navnet [servlet-name]-servlet.xml placeret i /WEB-INF/ vejviser. Så vi har oprettet mvc-dispatcher-servlet.xml fil, som vil blive forklaret nedenfor. <servlet-mapping> element af web.xml fil angiver, hvilke URL'er der skal håndteres af DispatcherServlet .

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0"> <display-name>Archetype Created Web Application</display-name>
 
	<servlet>
		<servlet-name>mvc-dispatcher</servlet-name>
		<servlet-class>
			org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<servlet-mapping>
		<servlet-name>mvc-dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping> 
</web-app>


mvc-dispatcher-servlet.xml filen er også placeret i WebContent/WEB-INF vejviser. Den bruger <context:component-scan> så Spring-beholderen vil søge efter alle kommenterede klasser under com.javacodegeeks.snippets.enterprise pakke.
org.springframework.web.servlet.view.InternalResourceViewResolver er defineret som en bønne og bruges som intern ressourcevisningsresolver, hvilket betyder, at den finder jsp- og html-filerne i WebContent/WEB-INF/ folder.

Vi kan også indstille egenskaber såsom prefix eller suffix til visningsnavnet for at generere den endelige visningsside-URL, som vist nedenfor:

mvc-dispatcher-servlet.xml

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

<context:component-scan base-package="com.javacodegeeks.snippets.enterprise" />

	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix">
			<value>/WEB-INF/</value>
		</property>
		<property name="suffix">
			<value>.jsp</value>
		</property>
	</bean>

</beans>

6. Kør programmet

For at køre applikationen bygger vi først projektet med Maven. Alt vi skal gøre er at højreklikke på projektet og vælge -> Kør som:Maven build . Målet skal sættes til package . war fil produceret skal placeres i webapps mappe af tomcat. Nu kan vi starte serveren.

Vi kalder først den første metode og trykker på:

localhost:8080/springexample/helloWorld/hello

på en browser, og resultatet er det, der er vist nedenfor:

Resultatet er standardværdien, der blev sendt til ModelMap .

Lad os derefter prøve at kalde den anden metode og sende også et argument, som vist nedenfor:

localhost:8080/springexample/helloWorld/displayMessage/Have a nice Day!

Som et resultat gik parameteren gennem Controller vises på jsp-siden.


Dette var et Spring MVC Rest Hello World eksempel.

Download Eclipse-projektet i denne tutorial:SpringMVCRestExampleREST spring

Java tag