Categorías
spring

Cómo conectar el servidor LDAP usando Spring LDAP framework (código completamente probado)

Aunque Java JNDI proporciona API para operaciones LDAP, pero el uso de JNDI normalmente requiere mucho trabajo de programación de bajo nivel. Spring LDAP framework es una buena forma de hacer LDAP en Java. En esta guía paso a paso, verá cómo conectarse al servidor LDAP y luego buscar el nombre de un usuario usando la identificación del usuario.

Antes de que empieces, aquí es un navegador LDAP de código abierto. Al configurar la información de inicio de sesión correcta, debería poder navegar por el directorio ldap. De esta manera, tiene la idea de lo que puede obtener del servidor Ldap.

1. Necesitamos tanto los binarios de Spring Framework como los binarios de Spring LDAP para ejecutar el siguiente ejemplo. Spring LDAP requiere J2SE 1.4 y es compatible con las versiones 1.2.8 y 2.0 de Spring Framework. El código de muestra de este artículo se basa en la versión 1.1.2 de Spring LDAP y se ha probado con Spring Framework 2.0.1.

2. Cree las siguientes clases. Todas las clases se pueden colocar en un directorio de paquetes, usted lo agrega al paquete a su manera.

1. La interfaz ContactDAO
Defina dos funciones. Uno es para obtener todos los nombres de contacto, otro es para obtener detalles de contacto.

import java.util.List;
 
public interface ContactDAO {
 
	public List getAllContactNames();
 
	public List getContactDetails(String commonName);
 
}

2. LDAPContactDAO
Implementar la interfaz definida.

import java.util.List;
 
import javax.naming.NamingException;
import javax.naming.directory.Attributes;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.BasicAttributes;
 
import org.springframework.ldap.AttributesMapper;
import org.springframework.ldap.LdapTemplate;
import org.springframework.ldap.support.DistinguishedName;
import org.springframework.ldap.support.filter.AndFilter;
import org.springframework.ldap.support.filter.EqualsFilter;
 
public class LDAPContactDAO implements ContactDAO{
	private LdapTemplate ldapTemplate;
 
	public void setLdapTemplate(LdapTemplate ldapTemplate) {
		this.ldapTemplate = ldapTemplate;
	}
 
	public List getAllContactNames() {
		return ldapTemplate.search("", "(objectClass=person)",
				new AttributesMapper() {
					public Object mapFromAttributes(Attributes attrs)
							throws NamingException {
						return attrs.get("mail").get();
					}
				});
	}
 
	public List getContactDetails(String objectclass){
		AndFilter andFilter = new AndFilter();
		andFilter.and(new EqualsFilter("objectClass",objectclass));
		System.out.println("LDAP Query " + andFilter.encode());
		return ldapTemplate.search("", andFilter.encode(),new ContactAttributeMapper());
 
	}
}

3. springldap.xml

Aquí tenga cuidado con el nombre base, puede usar un cliente para conectar el servidor LDAP primero y ver qué hay dentro. Yo uso OU = ***, porque todos nuestros usuarios están almacenados en este directorio.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
    <bean id="contextSource"
        class="org.springframework.ldap.support.LdapContextSource">
        <property name="url" value="ldap://your.ldap.url:389" />
        <property name="base" value="base, be careful to put it right" />
        <property name="userName" value="your username" />
        <property name="password" value="password" />
    </bean>
    <bean id="ldapTemplate" class="org.springframework.ldap.LdapTemplate">
        <constructor-arg ref="contextSource" />
    </bean>
    <bean id="ldapContact"
        class="com.javaworld.sample.LDAPContactDAO">
        <property name="ldapTemplate" ref="ldapTemplate" />
    </bean>
</beans>

4. ContactAttributeMapper

import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
 
import org.springframework.ldap.AttributesMapper;
 
public class ContactAttributeMapper implements AttributesMapper{
 
	public Object mapFromAttributes(Attributes attributes) throws NamingException {
		ContactDTO contactDTO = new ContactDTO();
 
		Attribute mail = attributes.get("mail");
		Attribute sap = attributes.get("employeeNumber");
		if(mail != null)
			contactDTO.setMail((String)mail.get());
		if(sap != null)
			contactDTO.setSap((String)sap.get());
 
		return contactDTO;
	}
 
}

5. Póngase en contacto con DTO

public class ContactDTO {
 
	String mail;
	String sap;
	public String getSap() {
		return sap;
	}
	public void setSap(String sap) {
		this.sap = sap;
	}
	public String getMail() {
		return mail;
	}
	public void setMail(String mail) {
		this.mail = mail;
	}
 
	public String toString() {
		StringBuffer contactDTOStr = new StringBuffer("Person=[");
 
		contactDTOStr.append(" mail = " + mail);
		contactDTOStr.append(" ]");
		return contactDTOStr.toString();
	}
}

6. La clase de prueba: SpringFrameworkLDAPClient

import java.util.List;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.dao.DataAccessException;
 
public class SpringFrameworkLDAPClient {
 
	public static void main(String[] args) {
		//Resource resource = new ClassPathResource("/SpringLDAPClient/src/com/javaworld/sample/springldap.xml");
		//System.out.println(resource.toString());
		try {
			Resource resource = new ClassPathResource("springldap.xml");
			BeanFactory factory = new XmlBeanFactory(resource);
			System.out.println(factory.toString() + "n");
 
			ContactDAO ldapContact = (LDAPContactDAO)factory.getBean("ldapContact");	
 
			List contactList = ldapContact.getContactDetails("30662");
			//List contactList =ldapContact.getAllContactNames();
			//System.out.println(contactList.size());
			int count = 0;
			for( int i = 0 ; i < contactList.size(); i++){
				System.out.print("Email: " + ((ContactDTO) contactList.get(i)).getMail() + "  ");
				System.out.println("SAP: " + ((ContactDTO) contactList.get(i)).getSap());
				count++;
			}
			System.out.println("n" + count);
 
		} catch (DataAccessException e) {
			System.out.println("Error occured " + e.getCause());
		}
	}
}

Este tutorial es de Javaword, pero dediqué algo de tiempo a que realmente funcionara.

Categorías
spring

¿Por qué necesitamos Spring Web Flow (SWF)?

¿Por qué todavía necesitamos Spring Web Flow si ya tenemos buenos marcos web?

Spring Web Flow (SWF) se enfoca completamente en la definición y ejecución de una conversación compleja en una aplicación web, es decir, el flujo de la página de la aplicación web.

Para entender por qué es una buena solución, es una buena idea comenzar con el problema que intenta resolver y las complejidades involucradas en la solución. Un caso de ejemplo es la transacción de compra que implica agregar / actualizar el carrito de compras, proporcionar información del comprador, confirmar el pago del pedido, etc. Tiene un flujo de página web claro, si no hay ningún problema de seguridad. Sin embargo, puede haber problemas como saltos de pago, actualización de páginas, etc. SWF es una buena solución para esas situaciones.

SWF se puede integrar fácilmente con marcos existentes como Spring MVC, Struts y JSF, tanto en entornos de servlet como de portlet.

La relación entre Spring Web Flow y Spring MVC es clara en esta imagen.

Categorías
spring

El mejor tutorial gratuito de Fast Spring MVC

Aquí hay un buen sitio sobre Spring MVC.

http://maestric.com/doc/java/spring/hello_world

Supongo que esta es la forma correcta de hacer un tutorial. Si bien hay tantas publicaciones que hablan sobre ejemplos de Spring MVC, aplicaciones de muestra o tutoriales, todavía hay una razón para hacer una nueva. Este es un buen ejemplo que puede marcar la diferencia.

No creo que pueda mejorarlo, porque se muestra muy claro con ejemplos de código y diagramas. Sin embargo, creo que una forma aún mejor es hacer tutoriales en flash o en video.

Categorías
spring

Tutorial de Spring Framework – Hola mundo

Última actualización: 21/05/2014

Esta publicación muestra cómo construir una aplicación Spring Hello World.

Los siguientes son todos los pasos necesarios para crear un programa Spring Hello World.

1. Configurar el entorno de desarrollo

IDE: Eclipse IDE para desarrolladores de Java EE. La última versión es Eclipse Kepler (4.3.2).

Aquí está el que debe descargar:

2. Cree un «Proyecto web dinámico»

Cree un proyecto web dinámico utilizando la configuración predeterminada.

proyecto_web_dinámico

Después de la creación, la vista del explorador del proyecto debería mostrar:

explorador de proyectos

3. Cree un archivo index.jsp

Cree un archivo .jsp con el nombre «index.jsp» en el directorio «WebContent». Haga clic derecho en «webContent» -> Nuevo -> Archivo JSP. Cambie el código generado para que sea el siguiente:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Hello World </title>
</head>
<body>
 
<h1>
Hello World
</h1>
</body>
</html>

Hola mundo

4. Crea un nuevo servidor

Como un proyecto web se ejecuta en un servidor HTTP, se debe configurar un nuevo servidor para albergar el proyecto web.

Descarga Tomcat 7.0 aquí. Descargue la versión central de Zip y descomprímalo en un directorio (recuerde este directorio). En su eclipse, cree un nuevo servidor.

crear-servidor

Seleccione el directorio donde descomprimió el tomcat.

crear-apache2

Ejecute el proyecto en el servidor y debería tener una página de bienvenida de la siguiente manera:

hola-mundo-resultado

5. Agregar compatibilidad con Spring Framework

Descargar: Spring Framework 3.1.0.RELEASE es la versión de producción actual (requiere Java 1.5+)
De: http://www.springsource.org/download
Agregue los siguientes archivos jar al directorio «WebContent / WEB-INF / lib».

commons-logging-1.1.1.jar
commons-logging-api-1.1.1.jar
spring-asm-3.2.0.M1.jar
spring-beans-x.jar
spring-content-x.jar
spring-core-x.jar
spring-expression-x.jar
spring-instrument-x.jar
spring-web-x.jar
spring-webmvc-x.jar

6. Cree Spring MVC

Cambie el archivo web.xml para que sea el siguiente:

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>HelloSpring</display-name>
 
   <servlet>
    <servlet-name>springapp</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
 
  <servlet-mapping>
    <servlet-name>springapp</servlet-name>
    <url-pattern>*.htm</url-pattern>
  </servlet-mapping>
 
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

Cree el archivo springapp-servlet.xml bajo la dirección WEB-INF y copie lo siguiente en él:

<?xml version="1.0" encoding="UTF-8"?>
 
<beans xmlns="http://www.springframework.org/schema/beans"
       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-2.5.xsd">
 
  <!-- the application context definition for the springapp DispatcherServlet -->
 
  <bean name="/hello.htm" class="springapp.web.HelloController"/>
 
</beans>

Cree una clase dentro de «Recursos de Java» de la siguiente manera:

package springapp.web;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
 
public class HelloController implements Controller {
 
	@Override
	public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {
		// TODO Auto-generated method stub
		return new ModelAndView("hello.jsp");
	}
 
}

Categorías
spring

Proyectos de código abierto que utilizan Spring Framework

Spring Framework es difícil de aprender, especialmente cuando desea desarrollar un proyecto real con estándares de la industria. Los tutoriales de lectura son una buena forma de aprender al principio. Pero finalmente, aún necesita leer código de proyectos reales. Afortunadamente, hay algunos proyectos de código abierto muy buenos que utilizan el marco Spring.

Aquí hay 17 proyectos de código abierto que utilizan el marco Spring. Son de diferentes áreas, como el sistema de gestión de contenido, las compras en línea, la gestión de archivos, etc. Al leer su código fuente, puede comprender mejor cómo utilizar el marco de Spring.

Si conoces otros buenos proyectos, puedes dejar tus comentarios a continuación.

Categorías
spring

Instalar el complemento Maven para Eclipse

Es posible que haya intentado instalar el complemento Maven para eclipse y haya fallado. El problema puede deberse a la versión. Entonces, para resolver el problema, puede descargar la última versión de eclipse. A continuación, se muestra cómo instalo el complemento maven para eclipse en Ubuntu. Para la plataforma Windows, debería ser igual.

Descarga Eclipse Kepler

Descargue la última versión de eclipse desde: https://www.eclipse.org/downloads/.

Seleccione «Eclipse IDE para desarrolladores de Java EE».

Instalar el complemento Maven Eclipse

Vaya a http://www.eclipse.org/m2e/download/ y seleccione la última versión de m2e. La URL es http://download.eclipse.org/technology/m2e/releases.

Vaya a «Ayuda» de Eclipse -> «Instalar nuevo software …» y escriba la URL correcta. Debería tener el siguiente aspecto:

Haga clic en «Siguiente» para completar.

Categorías
spring

Ejemplo de Spring HelloWorld usando Eclipse y Maven

Este artículo ilustra cómo hacer un Spring Hello World utilizando Eclipse y Maven. Primero debe instalar el complemento eclipse y maven.

1. Configure un proyecto Maven

Cree un proyecto de Maven utilizando el asistente.

proyecto-nuevo-maven

maven-groupid-artefacto

GroupId identifica el proyecto de forma única en todos los proyectos, por lo que debemos aplicar un esquema de nomenclatura. ArtifactId es el nombre del jar sin versión. Para obtener más información sobre cada campo, consulte la página oficial sobre la convención de nomenclatura de maven: http://maven.apache.org/guides/mini/guide-naming-conventions.html.

Al proyecto creado en la vista Explorador de proyectos le gusta lo siguiente:
explorador de proyectos maven

2. Agregar dependencia de Spring

Edite el archivo pom.xml y agregue las dependencias de los paquetes Spring. El pom.xml debe cambiarse a:

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.programcreek.entrylevel</groupId>
  <artifactId>helloworld</artifactId>
  <version>0.0.1-SNAPSHOT</version>
 
	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
	</dependencies>
 
	<properties>
		<spring.version>3.2.3.RELEASE</spring.version>
	</properties>
</project>

3. Cree el archivo de configuración de Spring Bean

Cree un archivo de configuración de bean llamado «applicationContext.xml» en el directorio src / main / resources. Este archivo xml especifica el bean que definirá en el proyecto. Tenga en cuenta que la clase es el nombre de clase completamente calificado con el paquete.

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd">
 
	<context:component-scan base-package="com.programcreek.examples" />
 
	<bean id="helloWorldService"
		class="com.programcreek.entrylevel.services.HelloWorldService">
		<property name="name" value="Program Creek Readers" />
	</bean>
</beans>

4. Crea un frijol de primavera

Cree HelloWorldService Bean en el directorio / src / main / java. El paquete debe ser el mismo que declaró en el archivo de configuración del bean.

package com.programcreek.helloworld.services;
import org.springframework.stereotype.Service;
 
@Service("helloWorldService")
public class HelloWorldService {
 
	private String name;
 
	public void setName(String name) {
		this.name = name;
	}
 
	public String sayHello() {
		return "Hello! " + name;
	}
}

5. Ejecute el proyecto Maven

Cree una clase Hello en el directorio / src / main / java para probar el proyecto.

package com.programcreek.helloworld;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.programcreek.helloworld.services.HelloWorldService; 
 
public class Hello {
 
	@SuppressWarnings("resource")
	public static void main(String[] args) {
 
		// loading the definitions from the given XML file
		ApplicationContext context = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
 
		HelloWorldService service = (HelloWorldService) context
				.getBean("helloWorldService");
		String message = service.sayHello();
		System.out.println(message);
 
		//set a new name
		service.setName("Spring");
		message = service.sayHello();
		System.out.println(message);
	}
}

Finalmente, el proyecto Spring debería verse así:

proyecto-final-primavera-maven

Haga clic derecho en Hello.java y ejecútelo como aplicación Java. El resultado es:

Hello! Program Creek Readers
Hello! Spring

6. Resumen

Este es un ejemplo simple que muestra cómo crear un proyecto Spring usando Maven en Eclipse. La idea clave del marco Spring es la inversión de control (IoC). IoC se refiere al estilo de programación en el que un marco o tiempo de ejecución controla el flujo del programa. La inversión del control significa que estamos cambiando el control de la forma normal.

Categorías
spring

Instalar Tomcat 7 para Eclipse

Como un proyecto web se ejecuta en un servidor HTTP, se debe configurar un nuevo servidor para albergar el proyecto web.

Descarga Tomcat 7.0 aquí. Descargue la versión central de Zip y descomprímalo en un directorio (recuerde este directorio). En su eclipse, cree un nuevo servidor.

Seleccione el directorio donde descomprimió el tomcat.

crear-apache2

Ejecute el proyecto en el servidor y debería tener una página de bienvenida de la siguiente manera:

hola-mundo-resultado

Categorías
spring

Cómo implementar Spring Project en Live Server

Suponiendo que haya creado un proyecto web dinámico en Eclipse y haya probado su proyecto, ahora desea implementar el proyecto Spring en un servidor en vivo. El proyecto se ejecuta en Tomcat e interactúa con la base de datos MySQL. ¿Cómo implementar correctamente su proyecto?

Para implementar el proyecto, debe crear un archivo .war. Un archivo .war (archivo de aplicación web) es un archivo JAR que se utiliza para distribuir una colección de clases Java, archivos XML, bibliotecas, páginas web estáticas y otros recursos que, en conjunto, constituyen una aplicación web. Puede crear un archivo .war en Eclipse muy rápidamente. Haga clic derecho en el proyecto, haga clic en «Exportar» y elija el archivo de guerra en el cuadro de diálogo.

eclipse-despliegue-guerra

Una vez generado el archivo .war, puede copiar manualmente el archivo .war al directorio del servidor, es decir, el directorio $ TOMCAT_HOME / webapps. También puede utilizar la aplicación Tomcat «Manager».

Si tiene un servidor dedicado, también debe configurar primero el servidor y la base de datos.

Categorías
spring

Spring MVC HelloWorld usando Maven en Eclipse

Los desarrolladores de Java a menudo se basan en ejemplos para aprender el marco de Spring. Los ejemplos simples suelen ser un recurso de aprendizaje clave. Hay muchas aplicaciones Spring MVC HelloWorld. Sin embargo, la mayoría de ellos están desactualizados (no integran Maven, usan la versión anterior de Spring, etc.) o no están completos (faltan pasos clave o vista de jerarquía de archivos). Por lo tanto, no puede conducir a un Hello World que funcione perfectamente. En este artículo, mostraré los pasos para crear una aplicación Spring MVC HelloWorld usando Maven en Eclipse. Se ilustra el contenido y la ubicación de todos los archivos.

Requisito previo

  • Windows 7, Java 7, Eclipse Kepler Java EE
  • Tomcat 7 (Cómo instalar Tomcat 7 en Eclipse)

Paso 1: cree un proyecto Maven

Cree un proyecto de Maven siguiendo los siguientes pasos:

primavera-helloworld-maven-2

Seleccione «aplicación web».

primavera-helloworld-maven-3

primavera-helloworld-maven-4

GroupId identifica el proyecto de forma única en todos los proyectos, por lo que debemos aplicar un esquema de nomenclatura. ArtifactId es el nombre del jar sin versión. Para obtener más información sobre cada campo, consulte el Página Oficial sobre la convención de nomenclatura de maven. (Puede hacer esto más tarde. Tiene más sentido cuando completa el proyecto primero).

Una vez creado el proyecto Maven, el proyecto en la vista del navegador debería tener el siguiente aspecto:

spring-mvc-helloworld-navigator-view1

Como se muestra arriba, hay un error marcado con rojo. Si abre el archivo index.jsp, puede ver el mensaje de error:
spring-mvc-helloworld-navigator-view2

The superclass "javax.servlet.http.HttpServlet" was not found on the Java Build Path

Para solucionar el problema, haga clic con el botón derecho en el proyecto -> Propiedades -> Ruta de compilación de Java -> Agregar biblioteca …-> Tiempo de ejecución del servidor -> Apache Tomcat -> Finalizar.

Paso 2: configurar Spring

Para hacer una aplicación web Spring, necesitamos configurar varios archivos xml. En primer lugar, necesitamos agregar dependencias de Spring. Edite el archivo pom.xml generado automáticamente para que sea el siguiente:

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

Edite el archivo web.xml predeterminado.

<?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" 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>dispatcher</servlet-name>
		<servlet-class>
			org.springframework.web.servlet.DispatcherServlet
		</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
 
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
	</context-param>
 
	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener
		</listener-class>
	</listener>
</web-app>

Cree un archivo xml «dispatcher-servlet.xml» en el mismo directorio de web.xml.

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	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">
 
	<context:component-scan base-package="com.programcreek.helloworld.controller" />
 
	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix">
			<value>/WEB-INF/views/</value>
		</property>
		<property name="suffix">
			<value>.jsp</value>
		</property>
	</bean>
</beans>

En el archivo xml anterior, base-package especifica el paquete de los controladores. prefix especifica el directorio de vistas, y está configurado para ser /WEB-INF/views/, lo que significa views El directorio debe crearse bajo WEB-INF. suffix especifica la extensión de archivo de las vistas. Por ejemplo, dada una vista «helloworld», la vista se ubicará como /WEB-INF/views/helloworld.jsp. Puede resolver esto más adelante en el Paso 3.

Paso 3: Cree el controlador Spring y la vista

Crea el HelloWorldController en el directorio src / main / java /.

HelloWorldController.java

package com.programcreek.helloworld.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;
 
@Controller
public class HelloWorldController {
	String message = "Welcome to Spring MVC!";
 
	@RequestMapping("/hello")
	public ModelAndView showMessage(
			@RequestParam(value = "name", required = false, defaultValue = "World") String name) {
		System.out.println("in controller");
 
		ModelAndView mv = new ModelAndView("helloworld");
		mv.addObject("message", message);
		mv.addObject("name", name);
		return mv;
	}
}

En el código de arriba, @RequestMapping la anotación asigna las solicitudes web a clases de controlador específicas y / o métodos de controlador, en este caso, showMessage(). Proporciona un estilo coherente entre los entornos Servlet y Portlet, con la semántica adaptándose al entorno concreto.

RequestParam indica que un parámetro de método debe estar vinculado a un parámetro de solicitud web. En este caso, también lo hacemos no obligatorio y le damos un valor predeterminado.

new ModelAndView("helloworld") determina que helloworld es la vista de destino.

index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
 
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Spring 4 MVC - HelloWorld Index Page</title>
</head>
<body>
 
	<center>
		<h2>Hello World</h2>
		<h3>
			<a href="hello?name=Eric">Click Here</a>
		</h3>
	</center>
</body>
</html>

Hello World

Haga clic aquí

Cree el archivo helloworld.jsp en el directorio / WEB-INF / views /.

helloworld.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Spring 4 MVC -HelloWorld</title>
</head>
<body>
	<center>
		<h2>Hello World</h2>
		<h2>
			${message} ${name}
		</h2>
	</center>
</body>
</html>

Hello World

$ {message} $ {name}

${variable} se convertirá al valor de la variable.

Vista final del navegador del proyecto:
primavera-hola-mundo-vista-final

Paso 4: ejecutar en el servidor

Haga clic con el botón derecho en el proyecto y seleccione Ejecutar como -> Ejecutar en el servidor.

hola-mundo-primavera

hola-mundo-primavera-2

Archivo zip del proyecto para descargar.

Siguiente: Inyección de dependencias y configuración XML