Your SlideShare is downloading. ×
  • Like
Introducccion springframework
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Introducccion springframework

  • 2,306 views
Published

 

Published in Education
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
2,306
On SlideShare
0
From Embeds
0
Number of Embeds
3

Actions

Shares
Downloads
43
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Introducción Spring Framework
    Diego Armando GómezMosquera.
    dgomez@vortexbird.com
    dagmosqu@usbcali.edu.co
    Sun Certified Java Associated.
    Sun Certified Java Programmer.
    Sun Certified Web Component Developer.
    Sun Certified Business Component Developer 5
  • 2. Agenda
    Que es Spring
    Arquitectura de Spring
    Principales módulos de Spring
    Inyección de dependencias
    Programación orientada aspectos.
    Configurando aplicación usando Spring
    Instalar el contenedor de Inversión de Control de Spring (IoC)
    Crear y configurar un Bean en el contenedor de Inversión de Control .
    Usando el Auto-WritingBean con XML
    Usando el Auto-WritingBean con Anotaciones.
  • 3. Que es Spring?
    Un framework contenedor liviano basado en la técnica Inversión de Control (IoC) y una implementación de desarrollo según el paradigma Orientado a Aspectos (AOP)
  • 4. Que es Spring?
    Framework: porque define la forma de desarrollar aplicaciones JavaEE, dando soporte y simplificando complejidad propia del software corporativo.
    Inversión de Control (IoC): promueve el bajo acoplamiento a partir de la inyección de dependencias (DI) entre los objetos (relaciones).
    Orientación a Aspectos (AOP): presenta una estructura simplificada para el desarrollo y utilización de aspectos (módulos multipleobjectcrosscutting).
  • 5. Arquitectura de Spring
  • 6. Arquitectura de Spring
    DAO: Soporta el manejo de transacciones con el soporte de AOP.
    ORM: Integración con diferentes capas de mapeo objeto relacional Hibernate, JPA, JDO, iBates entre otros.
    JavaEE: Acesso a servicios que provee la especificacionJavaEE.
    Web: provee un contexto de trabajo para el desarrollo de aplicaciones web e integración con otros frameworks (Struts, JSF, Tapestry, etc).
  • 7. Inyección de dependencias
    DependencyInjection (DI)
    Patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase quien cree el objeto.
    El término fue acuñado por Martin Fowler.
  • 8. Sin Inyección de dependencias
    publicclassVehiculo {
    private Motor motor = new Motor();
    /** @retorna la velocidad del vehículo*/
    publicDoubleenAceleracionDePedal(intpresionDePedal) {
    motor.setPresionDePedal(presionDePedal);
    int torque = motor.getTorque();
    Double velocidad = ... //realiza el cálculo
    return velocidad;
    }
    }
  • 9. Con Inyección de dependencias
    publicclassVehiculo {
    private Motor motor = null;
    publicsetMotor(Motor motor){
    this.motor = motor;
    }
    /** @retorna la velocidad del vehículo*/
    publicDoubleenAceleracionDePedal(intpresionDePedal) {
    Double velocidad = null;
    if (null != motor){
    motor.setPresionDePedal(presionDePedal);
    int torque = motor.getTorque();
    velocidad = ... //realiza el cálculo
    }
    return velocidad;
    }
    }
  • 10. Con Inyección de dependencias
    //se omite la clase Motor ya que no es relevante para este ejemplo
    publicclassVehiculoFactory {
    publicVehiculoconstruyeVehiculo() {
    Vehiculovehiculo = new Vehiculo();
    Motor motor = new Motor();
    vehiculo.setMotor(motor);
    returnvehiculo;
    }
    }
  • 11. Inversión de control
    Inversion of Control (IoC)
    Es un método de programación en el que el flujo de ejecución de un programa se invierte respecto a los métodos de programación tradicionales, en los que la interacción se expresa de forma imperativa haciendo llamadas a procedimientos (procedurecalls) o funciones. Tradicionalmente el programador especifica la secuencia de decisiones y procedimientos que pueden darse durante el ciclo de vida de un programa mediante llamadas a funciones. En su lugar, en la inversión de control se especifican respuestas deseadas a sucesos o solicitudes de datos concretas, dejando que algún tipo de entidad o arquitectura externa lleve a cabo las acciones de control que se requieran en el orden necesario y para el conjunto de sucesos que tengan que ocurrir.
  • 12. Configurando aplicación usando Spring
    Instalar el contenedor de Inversión de Control de Spring (IoC)
    Crear y configurar un Bean en el contenedor de Inversión de Control .
    Usando el Auto-WritingBean con XML
    Usando el Auto-WritingBean con Anotaciones.
  • 13. applicationContext.xml
    Este archivo permite hacer las configuraciones de las capacidades soportadas por Spring
    <?xmlversion="1.0" encoding="UTF-8"?>
    <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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <beanname="persona" class="com.vortexbird.demo.modelo.Persona" >
    </bean>
    </beans>
  • 14. Configurar un Bean
    <?xmlversion="1.0" encoding="UTF-8"?>
    <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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <beanname="persona" class="com.vortexbird.demo.modelo.Persona" />
    </beans>
  • 15. Configurando el Bean con atributos
    <?xmlversion="1.0" encoding="UTF-8"?>
    <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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <beanname="persona" class="com.vortexbird.demo.modelo.Persona" scope="prototype">
    <propertyname="id" value="142020" />
    <propertyname="nombre" value="Juan Perez" />
    <propertyname="mail" value="jperez@hotmail.com" />
    </bean>
    </beans>
  • 16. Configurando el Bean con constructor
    <?xmlversion="1.0" encoding="UTF-8"?>
    <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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <beanname="persona" class="com.vortexbird.demo.modelo.Persona" scope="prototype">
    <constructor-argname="id" value="90893"/>
    <constructor-argname="nombre" value="Diego Gomez"/>
    <constructor-argname="mail" value="dgomez@vortexbird.com"/>
    </bean>
    </beans>
  • 17. Usando el Auto-WritingBean con XML
    <?xmlversion="1.0" encoding="UTF-8"?>
    <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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    <beanname="vehiculo" class="com.vortexbird.demo.modelo.Vehiculo" autowire="byType"/>
    <beanname="motor" class="com.vortexbird.demo.modelo.Motor"/>
    </beans>
  • 18. Usando el Auto-WritingBean con Anotaciones
    <?xmlversion="1.0" encoding="UTF-8"?>
    <beansxmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    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:component-scan base-package="com.vortexbird.demo" />
    </beans>