El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Spring Framework

Següent ►
►

El Spring Framework és un dels frameworks més populars per al desenvolupament d'aplicacions Java. Proporciona una infraestructura completa per desenvolupar aplicacions robustes, escalables i mantenibles. En aquest tema, explorarem els conceptes bàsics del Spring Framework, incloent-hi la seva configuració, els components principals i alguns exemples pràctics.

Continguts

  1. Introducció al Spring Framework
  2. Configuració del Projecte Spring
  3. Inversió de Control (IoC) i Injecció de Dependències (DI)
  4. Spring Beans
  5. Configuració de Spring amb Anotacions
  6. Spring MVC
  7. Exemples Pràctics
  8. Exercicis

  1. Introducció al Spring Framework

El Spring Framework és un framework de codi obert per a la plataforma Java. Ofereix una infraestructura completa per al desenvolupament d'aplicacions Java, incloent-hi:

  • Inversió de Control (IoC): Permet gestionar les dependències entre els components de l'aplicació.
  • Programació Orientada a Aspectes (AOP): Facilita la separació de preocupacions transversals com la seguretat, la transaccionalitat, etc.
  • Spring MVC: Un framework per al desenvolupament d'aplicacions web basades en el patró Model-View-Controller.
  • Accés a Dades: Suport per a JDBC, ORM, transaccions, etc.
  • Integració: Suport per a la integració amb altres tecnologies i frameworks.

  1. Configuració del Projecte Spring

2.1. Configuració amb Maven

Per començar amb Spring, necessitem configurar el nostre projecte amb les dependències necessàries. Utilitzarem Maven per gestionar les dependències.

<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.example</groupId>
    <artifactId>spring-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.10</version>
        </dependency>
        <!-- Altres dependències necessàries -->
    </dependencies>
</project>

2.2. Configuració amb Gradle

Si utilitzes Gradle, la configuració seria similar:

plugins {
    id 'java'
}

group 'com.example'
version '1.0-SNAPSHOT'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework:spring-context:5.3.10'
    implementation 'org.springframework:spring-webmvc:5.3.10'
    // Altres dependències necessàries
}

  1. Inversió de Control (IoC) i Injecció de Dependències (DI)

3.1. Inversió de Control (IoC)

La Inversió de Control és un principi de disseny que permet que el control del flux del programa sigui invertit. En lloc de que l'aplicació controli el flux, el framework Spring ho fa.

3.2. Injecció de Dependències (DI)

La Injecció de Dependències és un patró de disseny que permet que les dependències siguin injectades en un objecte en lloc de ser creades per l'objecte mateix. Spring proporciona diverses maneres d'injectar dependències:

  • Injecció per Constructor
  • Injecció per Setter
  • Injecció per Camp

Exemple d'Injecció de Dependències

public class HelloWorld {
    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message : " + message);
    }
}

Configuració XML per a la injecció de dependències:

<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.xsd">

    <bean id="helloWorld" class="com.example.HelloWorld">
        <property name="message" value="Hello Spring!"/>
    </bean>

</beans>

  1. Spring Beans

Un Bean de Spring és un objecte que és gestionat pel contenidor de Spring. Els Beans són definits en un fitxer de configuració XML o mitjançant anotacions.

Exemple de Definició de Bean

<bean id="helloWorld" class="com.example.HelloWorld">
    <property name="message" value="Hello Spring!"/>
</bean>

  1. Configuració de Spring amb Anotacions

Spring permet configurar els Beans utilitzant anotacions en lloc de fitxers XML.

Exemple d'Anotacions

@Component
public class HelloWorld {
    private String message;

    @Value("Hello Spring!")
    public void setMessage(String message) {
        this.message = message;
    }

    public void getMessage() {
        System.out.println("Your Message : " + message);
    }
}

Configuració de l'escaneig de components:

<context:component-scan base-package="com.example"/>

  1. Spring MVC

Spring MVC és un framework per al desenvolupament d'aplicacions web basades en el patró Model-View-Controller.

Exemple de Controlador

@Controller
public class HelloWorldController {

    @RequestMapping("/hello")
    public ModelAndView helloWorld() {
        String message = "Hello, Spring MVC!";
        return new ModelAndView("hello", "message", message);
    }
}

Configuració de Spring MVC:

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

<context:component-scan base-package="com.example"/>
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>

  1. Exemples Pràctics

Exemple 1: Configuració Bàsica de Spring

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

Exemple 2: Aplicació Web amb Spring MVC

@Controller
public class HomeController {

    @RequestMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC!");
        return "home";
    }
}

  1. Exercicis

Exercici 1: Crear un Bean i injectar una dependència

  1. Crea una classe GreetingService amb un mètode getGreeting().
  2. Defineix un Bean per a GreetingService en un fitxer XML.
  3. Crea una classe MainApp que carregui el context de Spring i cridi al mètode getGreeting().

Exercici 2: Desenvolupar una Aplicació Web amb Spring MVC

  1. Crea un projecte web amb Spring MVC.
  2. Defineix un controlador que gestioni una petició GET a /greeting.
  3. Configura una vista JSP que mostri un missatge de benvinguda.

Conclusió

En aquest tema, hem explorat els conceptes bàsics del Spring Framework, incloent-hi la configuració del projecte, la inversió de control, la injecció de dependències, els Spring Beans, la configuració amb anotacions i el desenvolupament d'aplicacions web amb Spring MVC. Els exemples pràctics i els exercicis proporcionats t'ajudaran a consolidar els coneixements adquirits.

◄ Anterior
◄
Següent ►
►

Curs de Programació en Java

Mòdul 1: Introducció a Java

Mòdul 2: Flux de Control

Mòdul 3: Programació Orientada a Objectes

Mòdul 4: Programació Orientada a Objectes Avançada

Mòdul 5: Estructures de Dades i Col·leccions

Mòdul 6: Gestió d'Excepcions

Mòdul 7: Entrada/Sortida de Fitxers

Mòdul 8: Multithreading i Concurrència

Mòdul 9: Xarxes

Mòdul 10: Temes Avançats

Mòdul 11: Frameworks i Llibreries de Java

Mòdul 12: Construcció d'Aplicacions del Món Real

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats