spring
Núcleo de primavera

Introducción a Spring Core

Spring es un marco amplio, por lo que Spring Framework se ha dividido en varios módulos que hacen que el resorte sea liviano. Algunos módulos importantes son:

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

Todos los módulos de Spring son independientes entre sí, excepto Spring Core. Como Spring Core es el módulo base, en todos los módulos tenemos que usar Spring Core

Núcleo de primavera

Spring Core habla sobre la administración de dependencias. Eso significa que si alguna clase arbitraria proporcionada a Spring entonces Spring puede administrar la dependencia.

¿Qué es una dependencia?
Desde el punto de vista del proyecto, en un proyecto o aplicación hay varias clases con diferentes funcionalidades. y cada clase requiere alguna funcionalidad de otras clases.

Ejemplo:

class Engine {

  public void start() {
    System.out.println("Engine started");
  }    
}

class Car {

  public void move() {
    // For moving start() method of engine class is required
  }
}

Aquí el motor de clase requiere el motor de clase, por lo que podemos decir que el motor de clase depende del automóvil de clase, por lo tanto, en lugar de que nosotros gestionemos esas dependencias por herencia o creando un objeto como punto muerto.

Por herencia:

class Engine {

  public void start() {
    System.out.println("Engine started");
  }
}

class Car extends Engine {

  public void move() {
    start(); //Calling super class start method,
  }
}

Al crear objeto de clase dependiente:

class Engine {

  public void start() {
    System.out.println("Engine started");
  }    
}

class Car {

  Engine eng = new Engine();
 
  public void move() {
   eng.start();
  }
}

Entonces, en lugar de administrar la dependencia entre clases, Spring Core toma la responsabilidad de la administración de la dependencia. Pero hay algunas reglas, las clases deben diseñarse con alguna técnica de diseño que sea un patrón de diseño de estrategia.

¿Entendiendo cómo Spring gestiona la dependencia?

Permítanme escribir un fragmento de código que se muestre completamente acoplado, para que pueda comprender fácilmente cómo Spring Core administra la dependencia internamente. Considere un escenario, el negocio en línea de Flipkart está ahí, usa algunas veces el servicio de mensajería DTDC o Blue Dart, así que permítame diseñar una aplicación que muestre una completa sin conexión. El Directorio de Eclipse como barbechos:

//Interface
package com.sdp.component;

public interface Courier {
    public String deliver(String iteams,String address);

}

// clases de implementación

  package com.sdp.component;

public class BlueDart implements Courier {

    
    public String deliver(String iteams, String address) {
        
        return iteams+ "Shiped to Address "+address +"Through BlueDart";
    }

}

package com.sdp.component;

public class Dtdc implements Courier {

    
    public String deliver(String iteams, String address) {
        return iteams+ "Shiped to Address "+address +"Through Dtdc";    }

}

// clasificación de componentes

package com.sdp.service;

import com.sdp.component.Courier;

public class FlipKart {
    private Courier courier;

    public void setCourier(Courier courier) {
        this.courier = courier;
    }
    public void shopping(String iteams,String address)
    {
        String status=courier.deliver(iteams, address);
        System.out.println(status);
    }

}

// Clases de fabrica para crear y devolver objetos.

package com.sdp.util;

import java.io.IOException;
import java.util.Properties;

import com.sdp.component.Courier;

public class ObjectFactory {
private static Properties props;
static{
    
    props=new Properties();
    try {
        props.load(ObjectFactory.class.getClassLoader().getResourceAsStream("com//sdp//common//app.properties"));
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    
}
public static Object getInstance(String logicalclassName)
{
    Object obj = null;
    String originalclassName=props.getProperty(logicalclassName);
    try {
         obj=Class.forName(originalclassName).newInstance();
    } catch (InstantiationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return obj;
}
    
    }

// archivo de propiedades

BlueDart.class=com.sdp.component.BlueDart
Dtdc.class=com.sdp.component.Dtdc
FlipKart.class=com.sdp.service.FlipKart

// clase de prueba

package com.sdp.test;

import com.sdp.component.Courier;
import com.sdp.service.FlipKart;
import com.sdp.util.ObjectFactory;

public class FlipKartTest {
    public static void main(String[] args) {
        Courier courier=(Courier)ObjectFactory.getInstance("Dtdc.class");
        FlipKart flipkart=(FlipKart)ObjectFactory.getInstance("FlipKart.class");
        flipkart.setCourier(courier);
        flipkart.shopping("Hp Laptop", "SR Nagar,Hyderabad");
        
    }

}

Si escribimos este código, entonces podemos lograr un acoplamiento suelto, esto es aplicable si todas las clases quieren BlueDart o Dtdc, pero si alguna clase quiere BlueDart y alguna otra clase quiere Dtdc, entonces nuevamente estará estrechamente acoplada, así que en lugar de nosotros creando y administrando la inyección de dependencia. Spring Core toma la responsabilidad de crear y administrar los beans. Esperamos. Esto será de utilidad. En el siguiente ejemplo veremos la aplicación! st en Spring Core con datos