spring
Base de printemps

Introduction à Spring Core

Le printemps est un vaste cadre, de sorte que le cadre Spring a été divisé en plusieurs modules, ce qui rend le printemps léger. Certains modules importants sont:

1. Base de printemps
2. AOP de printemps
3. JDBC de printemps
4. Transaction de printemps
5. ORM de printemps
6. MVC de printemps

Tous les modules de Spring sont indépendants les uns des autres, à l'exception de Spring Core. Comme le noyau de base est le module de base, nous devons donc utiliser Spring Core dans tous les modules.

Base de printemps

Spring Core parle de la gestion des dépendances. Cela signifie que si des classes arbitraires sont fournies au printemps, Spring peut gérer les dépendances.

Qu'est-ce qu'une dépendance?
Du point de vue du projet, dans un projet ou une application, plusieurs classes ont des fonctionnalités différentes. et chaque classe nécessitait certaines fonctionnalités d'autres classes.

Exemple:

class Engine {

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

class Car {

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

Ici, la classe Engine est requise par la classe car nous pouvons donc dire que le moteur de classe dépend de la classe Car, donc au lieu de gérer ces dépendances par héritage ou de créer un objet comme jachère.

Par héritage:

class Engine {

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

class Car extends Engine {

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

En créant un objet de classe dépendante:

class Engine {

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

class Car {

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

Ainsi, au lieu de gérer la dépendance entre les classes, Spring core prend la responsabilité de la gestion des dépendances. Mais certaines règles existent, les classes doivent être conçues avec une technique de conception qui est le modèle de conception de la stratégie.

Comprendre comment Spring gère les dépendances?

Permettez-moi d'écrire un morceau de code qui montre complètement couplé vaguement, alors vous pouvez facilement comprendre comment Spring core gère la dépendance en interne. Considérons un scénario, les affaires en ligne Flipkart est là, il utilise parfois DTDC ou service de messagerie Blue Dart, alors laissez-moi concevoir une application qui montre complètement couplé vaguement. Le répertoire Eclipse comme jachère:

//Interface
package com.sdp.component;

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

}

// classes d'implémentation

  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";    }

}

// classe de composant

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

}

// Classes d'usine pour créer et renvoyer un objet

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;
}
    
    }

// fichier de propriétés

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

// classe de test

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 nous écrivons ce code, nous pouvons manuellement obtenir un couplage lâche, cela s’applique si toutes les classes veulent BlueDart ou Dtdc, mais si une classe veut BlueDart et une autre classe veut Dtdc, alors elle sera étroitement couplée. créer et gérer l'injection de dépendances Spring core prend la responsabilité de créer et de gérer les beans, Hope Cela vous sera utile, dans l'exemple suivant, nous verrons l'application! st sur Spring core avec des deitals