Iniciativa de formación GRATUITA y de LIBRE ACCESO que realiza/organiza WUL4.

2. Iniciativa de formación GRATUITA y de LIBRE ACCESO que realiza/organiza WUL4. Se admiten sugerencias así como que otras empresas/organismos participen u organicen eventos de formación siempre que se mantenga el carácter gratuito y de libre acceso de los eventos. Temática variada… aunque nos intentaremos centrar en aquello que conocemos ;) De entre los temas a abordar en futuras sesiones tenemos: a)Uso y abuso de Git b)Desarrollo en Android: Mitos y leyendas c)Hacking de aplicaciones Web: #melopillodegratis d)Desarrollo en iOS: Be Apple, myfriend e)Mavenizando, Rooneando y JenkinizandoJ2EE Se admiten nuevas sugerencias en: tt@wul4.com Qué son los Training Thursday(TT)?

4. Para quien pueda…. Usamos el STS: Spring Tool Suite Version: 3.4 Como Servidor (para las pruebas) usamos el que trae por defecto el STS Los ejemplos están en un repositorio público Conforme vayamos presentando como funciona, accederemos al repositorio y usaremos los ejemplos https://bitbucket.org/jjrider/formacionj2ee

5. Spring Framework Framework de código abierto para el desarrollo de aplicaciones (empresariales) Java Origen: Rod Johnson, Expert One-to-One J2EE Design and Development (Octubre, 2002) Alternativa popular a J2EE (EJBs) La motivación principal de Spring es eliminar la necesidad de usar sistemas complejos como los EJBs que además tienen una gran dependencia del contenedor lo que los hace ineficientes y difíciles de depurar, mediante el desarrollo de POJOs. Al mismo tiempo, te ‘obliga’ a desarrollar componentes reutilizables, basados en interfaces, lo que permite la modularización y separación de funcionalidades/componentes lo que facilita un desarrollo TDD.

6. Spring Framework: Módulos Principales Spring Core (Inversión del control (IoC) / Inyección de dependencias (DI)) Spring AOP (Programación orientada a aspectos) Spring DAO (Acceso a datos), vía JDBC o ORM Spring Transaction Abstraction (Gestión de transacciones) Spring MVC (desarrollo Web según el patrón MVC) Otros Proyectos de Spring: Spring Integration, Spring Security, Spring Web Flow, Spring Social, Spring mobile, Spring Web Services, Spring.NET, Spring BATCH, Spring DATA, Spring Roo, … IDE: Spring Tool Suite(IDE), …

7. Spring Core

8. Spring Core Inversion of Control (IoC): Hollywood principle "Don't call us, we'll call you" Los componentes NO se crean (con new) o buscan (p.ej. con JNDI) Las referencias a otros componentes que necesitan para realizar su trabajo, sino que simplemente se declaran qué dependencias tienen (fichero de configuración, anotaciones) y el contenedor de Spring les proporciona (inyecta) estas dependencias DependencyInjection (DI) El contenedor se encarga de instanciar o localizar los componentes necesarios e inicializarlos antes de inyectar su referencia a quién la necesite REPITO: Los componentes NO se crean, NO se hace new…

9. Spring Core Se suele combinar con programación basada en interfaces, para conseguir bajo acoplamiento entre componentes, sólo dependencia con las interfaces, no con las implementaciones concretas Ventajas: Se reduce el código de pegamento Llamadas a JNDI para localizar componentes Código de conexión con componentes remotos El contenedor proporciona proxy Fichero de configuración de dependencias: tocar sólo ahí para cambiarlas sin tocar el código fuente y sin recompilar Facilidad para llevar a cabo pruebas  (TDD: PERO ESTO HAY QUE HACERLO!!) Reemplazar componentes por Mockupobjects

10. ID: HolaMundo (I) Interfaz del servicio: Implementación del servicio: package es.wul4.formacion.spring.service; publicinterfaceMensajeService { publicabstract String sayMessage(String name); } @Service(value="MensajeService") publicclassMensajeServiceImplimplementsMensajeService { @Autowired private Mensaje msg = null; publicvoidsetMsg(Mensaje msg) { this.msg = msg; } /* (non-Javadoc) * @see es.wul4.formacion.spring.service.MensajeService#sayMessage(java.lang.String) */ @Override publicStringsayMessage(Stringname) { returnmsg.getMsg()+ " " + name; } }

11. ID: HolaMundo (II) Mensaje: @Repository(value="MensajeBienvenida") publicclass Mensaje { @Value("${mensaje.mes}") privateStringmsg=null; publicStringgetMsg() { returnmsg; } publicvoidsetMsg(Stringmsg) { this.msg = msg; } }

12. ID: HolaMundo (III) Fichero de configuración XML de Spring (spring-test.xml): El archivo contiene únicamente el elemento raíz "<beans>" dentro del cual declararemos cada uno de nuestros beans usando un elemento "<bean>" para cada uno o bien que mediante anotaciones busque lo que necesita. <?xmlversion="1.0" encoding="UTF-8"?> <beansxmlns="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 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:annotation-config/> <context:property-placeholderlocation="classpath*:es/wul4/formacion/spring/test/*.properties"/> <context:component-scanbase-package="es.wul4.formacion.spring" /> </beans>

13. ID: HolaMundo (IV) Main de la aplicación: publicclassMain { /** * @paramargs */ publicstaticvoid main(String[] args) { // TODO Auto-generatedmethodstub ApplicationContextcontext = newClassPathXmlApplicationContext( "es/wul4/formacion/spring/test/spring-test.xml"); MensajeServicehello = (MensajeService) context.getBean("MensajeService"); System.out.println(hello.sayMessage(args[0])); } }

15. Spring MVC: Funcionamiento (I)

16. Spring MVC: Funcionamiento (II) (1) Las peticiones pasan a través de un servlet que actúa de Front Controller (DispatcherServlet) (2) El DispatcherServlet consulta a un HandlerMapping para decidir a qué controlador le pasa la petición o Usa la URL de la solicitud para decidir (3 y 4) El controlador procesa la petición, accede a la lógica de negocio y potencialmente obtiene resultados (modelo, un Map) además selecciona la vista para presentar el modelo Para que el controlador no esté acoplado a la vista, se devuelve un identificador lógico (nombre) de vista Devuelve al DispatcherServlet un objeto que encapsula ambos: ModelAndView (5) El DispatcherServlet utiliza un ViewResolver para resolver el nombre en una vista concreta Normalmente un JSP, pero se soportan otros Velocity, XSLT, Tiles, SiteMesh, ... (6) El DispatcherServletutiliza la vista para mostrar el modelo al usuario

17. Spring MVC: Configuración I Para que la aplicación web entienda que se va a usar Spring MVC, es necesario añadir la siguiente línea al descriptor de despliegue (web.xml): Ahora tenemos que definir la configuración de Spring MVC y esto se hace en el fichero que llamaremos mvc-dispatcher-servlet.xml. <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>*.html</url-pattern> </servlet-mapping>

18. Spring MVC: Configuración II <beansxmlns="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/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <mvc:annotation-driven/> <context:component-scanbase-package="es.wul4" use-default-filters="false"> <context:include-filterexpression="org.springframework.stereotype.Controller" type="annotation"/> </context:component-scan> <beanid="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver"> <propertyname="viewClass" value="org.springframework.web.servlet.view.JstlView" /> <property name="prefix" value="/WEB-INF/jsp/" /> <property name="suffix" value=".jsp" /> </bean> </beans>

19. Spring MVC: Configuración III En el archivo de configuración XML anterior, hemos definido un tag<context:component-scan>. Esto permitirá a Spring cargar todos los componentes del paquete indicado y todos sus paquetes secundarios. Así se carga nuestra clase HelloWorldController. También hemos definido un beanviewResolver. Este bean va a resolver las vista y agregar la cadena de prefijo /WEB-INF/jsp/ y el sufijo .jsp a la vista en los ModelAndView. Tenga en cuenta que, en nuestra clase HelloWorldController, hemos devuelto un objeto con el nombre de la vista ModelAndView “hello". Esto se resolverá a la ruta /WEB-INF/jsp/hello.jsp

20. Spring MVC: Controllers IV El archivo hello.jsp, quedaría así. Y el index.jsp: <html> <head>     <title>Spring 3.0 MVC Series: Hello World</title> </head> <body>     ${message} </body> </html> <html> <head>     <title>Spring 3.0 MVC Series: Index</title> </head> <body>     <a href="hello.html">Say Hello</a> </body> </html>

21. Spring MVC: Formularios I Ahora nos disponemos a aprender cómo Spring MVC captura datos de un formulario a través de los controllers y los valida. Vamos a exponer este tema usando otro ejemplo: supongamos que queremos meter los datos de unos contactos y para ello vamos a usar una web, o sea, el objetivo es tener algo así:

22. Spring MVC: Formularios II Vamos a ir viendo los archivos usados: Tendríamos el jsp del formulario, contactos.jsp <%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%> <html> <head>     <title>Spring 3 MVC Series - Contact Manager</title> </head> <body> <h2>Contact Manager</h2> <form:form method="post" action="addContact.html">     <table>     <tr>         <td><form:label path="firstname">First Name</form:label></td>         <td><form:input path="firstname" /></td>     </tr>

23. Spring MVC: Formularios III     <tr>         <td><form:label path="lastname">Last Name</form:label></td>         <td><form:input path="lastname" /></td>     </tr>     <tr>         <td><form:label path="lastname">Email</form:label></td>         <td><form:input path="email" /></td>     </tr>     <tr>         <td><form:label path="lastname">Telephone</form:label></td>         <td><form:input path="telephone" /></td>     </tr>     <tr>         <td colspan="2">             <input type="submit" value="Add Contact"/>         </td>     </tr> </table>  </form:form> </body> </html>

24. Spring MVC: Formularios IV Usaremos también una clase tipo modelo con los datos del usuario: public class Contact {     private String firstname;     private String lastname;     private String email;     private String telephone;     //.. getters y setters. }

25. Spring MVC: Formularios IV El controller: @Controller @SessionAttributes public class ContactController {     @RequestMapping(value = "/addContact", method = RequestMethod.POST)     public String addContact(@ModelAttribute("contact")                             Contact contact, BindingResult result) {         System.out.println("First Name:" + contact.getFirstname() +                     "Last Name:" + contact.getLastname());         return "redirect:contacts.html";     }     @RequestMapping("/contacts")     public ModelAndView showContacts() {         return new ModelAndView("contact", "command", new Contact());     } }

26. Spring MVC: Formularios V La aplicación recibe datos de un formulario y, cuando introducimos un contacto, deja una traza en la consola. Pero, ¿y si queremos validar esos datos?. Podemos hacerlo de dos maneras: Usando notaciones de validación sobre los miembros de la clase de mapeo del formulario. Usando validators.

27. THANK YOU FOR YOUR ATTENTION!