Empezando con la primavera

Configuración (Configuración XML)

Pasos para crear Hello Spring:

  1. Investigue Spring Boot para ver si se adapta mejor a sus necesidades.
  2. Tener un proyecto configurado con las dependencias correctas. Se recomienda usar Maven o Gradle.
  3. crear una clase POJO, p. Empleado.java
  4. cree un archivo XML donde pueda definir su clase y variables. por ejemplo beans.xml
  5. crea tu clase principal, p. Cliente.java
  6. Incluya spring-beans (¡y sus dependencias transitivas!) como una dependencia.

Empleado.java:

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}

frijoles.xml:

<?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-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>

Cliente.java:

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}

Mostrando las funciones principales de Spring con un ejemplo

Descripción

Este es un ejemplo de ejecución autónomo que incluye/muestra: dependencias mínimas necesarias, Configuración de Java, Declaración de bean por anotación y configuración de Java, Inyección de dependencia por constructor y por propiedad, y ganchos Pre/Post .

dependencias

Estas dependencias son necesarias en el classpath:

  1. núcleo de resorte
  2. contexto de primavera
  3. judías primaverales
  4. primavera-aop
  5. expresión-resorte
  6. común-registro

Clase principal

Comenzando desde el final, esta es nuestra clase principal que sirve como marcador de posición para el método main() que inicializa el contexto de la aplicación apuntando a la clase de configuración y carga todos los beans necesarios para mostrar una funcionalidad particular.

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}

Archivo de configuración de la aplicación

La clase de configuración está anotada por @Configuration y se usa como un parámetro en el contexto de aplicación inicializado. La anotación @ComponentScan en el nivel de clase de la clase de configuración apunta a un paquete que se escaneará en busca de Beans y dependencias registradas mediante anotaciones. Finalmente, la anotación @Bean sirve como una definición de bean en la clase de configuración.

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}

Declaración de frijol por anotación

La anotación @Component sirve para demarcar el POJO como un bean Spring disponible para el registro durante el escaneo del componente.

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}

Declaración de beans por configuración de la aplicación

Tenga en cuenta que no necesitamos anotar o marcar nuestro POJO ya que la declaración/definición del bean se realiza en el archivo de clase de configuración de la aplicación.

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}

Inyección de constructor

Tenga en cuenta que la anotación @Autowired se establece en el nivel del constructor. También tenga en cuenta que, a menos que se defina explícitamente por nombre, el cableado automático predeterminado se realiza según el tipo del bean (en este caso, BeanToBeInjected).

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}

Inyección de propiedad

Tenga en cuenta que la anotación @Autowired delimita el método setter cuyo nombre sigue el estándar JavaBeans.

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}

Ganchos PostConstruct / PreDestroy

Podemos interceptar la inicialización y destrucción de un Bean por los ganchos @PostConstruct y @PreDestroy.

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}

¿Qué es Spring Framework, por qué deberíamos hacerlo?

Spring es un marco que proporciona un montón de clases, al usar esto no necesitamos escribir lógica de placa de caldera en nuestro código, por lo que Spring proporciona una capa abstracta en J2ee.


Por ejemplo, en Simple JDBC, el programador de aplicaciones es responsable de

  1. Cargando la clase de controlador
  2. Creando la conexión
  3. Crear objeto de declaración
  4. Manejo de las excepciones
  5. Crear consulta
  6. Ejecutando consulta
  7. Cerrar la conexión

Que se trata como un código repetitivo ya que cada programador escribe el mismo código. Entonces, para simplificar, el marco se encarga de la lógica repetitiva y el programador tiene que escribir solo la lógica comercial. Entonces, al usar Spring Framework, podemos desarrollar proyectos rápidamente con líneas mínimas de código, sin ningún error, el costo y el tiempo de desarrollo también se reducen.

** Entonces, ¿por qué elegir Spring como puntales? **

Strut es un marco que brinda solución solo a aspectos web y struts es de naturaleza invasiva. Spring tiene muchas características sobre los puntales, por lo que tenemos que elegir Spring.

  1. Spring es de naturaleza no invasiva: Eso significa que no necesita extender ninguna clase ni implementar ninguna interfaz para su clase.
  2. Spring es versátil: Eso significa que puede integrarse con cualquier tecnología existente en su proyecto.
  3. Spring proporciona desarrollo de proyectos de extremo a extremo: Eso significa que podemos desarrollar todos los módulos como la capa empresarial, la capa de persistencia.
  4. Spring es ligero: eso significa que si desea trabajar en un módulo en particular, no necesita aprender Spring completo, solo aprender ese módulo en particular (por ejemplo, Spring Jdbc, Spring DAO)
  5. Spring admite inyección de dependencia.
  6. Spring admite desarrollo de proyectos múltiples, por ejemplo: aplicación Core Java, aplicación web, aplicación distribuida, aplicación empresarial.
  7. Spring admite la programación orientada a aspectos para problemas transversales.

Así que finalmente podemos decir que Spring es una alternativa a Struts. Pero Spring no es un reemplazo de la API de J2EE, ya que las clases proporcionadas por Spring utilizan internamente las clases de la API de J2EE. Spring es un gran marco, por lo que se ha dividido en varios módulos. Ningún módulo depende de otro excepto Spring Core. Algunos módulos importantes son

  1. Núcleo de resorte
  2. Primavera JDBC
  3. Primavera AOP
  4. Transacción de primavera
  5. Primavera ORM
  6. Resorte MVC