spring Tutorial
Empezando con la primavera

Observaciones

Versiones

Configuración (Configuración XML)

Pasos para crear Hello Spring:

0. Investigue Spring Boot para ver si eso se adapta mejor a sus necesidades.
1. Tener un proyecto configurado con las dependencias correctas. Se recomienda que esté utilizando Maven o Gradle .
2. crear una clase POJO, por ejemplo, Employee.java
3. cree un archivo XML donde pueda definir su clase y variables. ej. beans.xml
4. crea tu clase principal, por ejemplo, Customer.java
5. Incluya las judías de primavera (y sus dependencias transitivas) como una dependencia.

Employee.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);
    }
}

beans.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>

Customer.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();
   }
}

Presentando las características principales de Spring Spring por 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 el constructor y por la propiedad, y enlaces Pre / Post .

Dependencias

Estas dependencias son necesarias en el classpath:

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

Clase principal

Comenzando desde el final, esta es nuestra clase principal que sirve como un marcador de posición para el método main() que inicializa el contexto de la aplicación al señalar la clase de configuración y carga todos los diversos 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 analizará en busca de Beans y dependencias registradas usando 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 de componentes.

@Component
public class BeanDeclaredByAnnotation {

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

Declaración de frijol 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 está ocurriendo 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 Constructor

Observe que la anotación @Autowired se establece en el nivel de 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 de 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

Observe que la anotación @Autowired delimita el método de establecimiento 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 !");
    }
}

PostConstruct / PreDestroy hooks

Podemos interceptar la inicialización y la destrucción de un Bean mediante 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 ir por él?

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

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

1. Cargando la clase de conductor
2. Creando la conexion
3. Creación de objeto de declaración
4. Manejando las excepciones.
5. Creando consulta
6. Ejecutando consulta
7. Cerrando la conexion

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

Entonces, ¿por qué elegir la primavera como puntales está ahí

Strut es un marco que proporciona soluciones solo para aspectos web y struts es de naturaleza invasiva. La primavera tiene muchas características sobre los puntales, así que tenemos que elegir la primavera.

1. Spring no es de naturaleza invasiva : eso significa que no necesita extender ninguna clase ni implementar ninguna interfaz a 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. La primavera es liviana : eso significa que si desea trabajar en un módulo en particular, no necesita aprender la primavera completa, solo aprenda ese módulo en particular (por ejemplo, Spring Jdbc, Spring DAO)
5. La primavera soporta inyección de dependencia .
6. Spring admite el desarrollo de múltiples proyectos, por ejemplo: aplicación Core java, aplicación web, aplicación distribuida, aplicación empresarial.
7. Spring es compatible con la Programación orientada a Aspectos para asuntos transversales.

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

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