spring
Spring Core

Introduzione a Spring Core

La primavera è un quadro vasto, quindi la struttura della primavera è stata divisa in diversi moduli che rendono la primavera leggera. Alcuni moduli importanti sono:

1. Spring Core
2. Spring AOP
3. Spring JDBC
4. Transazione di primavera
5. Primavera ORM
6. Spring MVC

Tutti i moduli di Spring sono indipendenti l'uno dall'altro tranne Spring Core. Poiché il core di Spring è il modulo di base, quindi in tutti i moduli dobbiamo utilizzare Spring Core

Spring Core

Spring Core parla della gestione delle dipendenze. Ciò significa che se tutte le classi arbitrarie vengono fornite a primavera, Spring può gestire la dipendenza.

Cos'è una dipendenza:
Dal punto di vista del progetto, in un progetto o in un'applicazione esistono più classi con diverse funzionalità. e ogni classe richiedeva alcune funzionalità di altre classi.

Esempio:

class Engine {

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

class Car {

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

Qui il motore di classe è richiesto dalla macchina di classe, quindi possiamo dire che il motore di classe dipende dalla classe Car, quindi invece di gestire tali dipendenze per ereditarietà o creare oggetti come fallows.

Per via ereditaria:

class Engine {

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

class Car extends Engine {

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

Creando oggetto di classe dipendente:

class Engine {

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

class Car {

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

Quindi, anziché gestire la dipendenza tra le classi, il nucleo centrale prende la gestione della dipendenza della responsabilità. Ma alcune regole ci sono, le classi devono essere progettate con una tecnica di progettazione che è il modello di progettazione della strategia.

Capire come Spring gestire la dipendenza?

Permettetemi di scrivere un pezzo di codice che si mostra completamente accoppiato, quindi potete facilmente capire come il core Spring gestisca internamente la dipendenza. Considera uno scenario, Flipkart è online, utilizza alcune volte il servizio di corriere DTDC o Blue Dart, quindi permettimi di progettare un'applicazione che mostri un completo accoppiamento libero. La directory di Eclipse come fallows:

//Interface
package com.sdp.component;

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

}

// classi di implementazione

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

}

// Componente classe

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

}

// Classi di fabbrica per creare e restituire Object

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

// file delle proprietà

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

// Test di classe

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

}

Se scriviamo questo codice, possiamo ottenere manualmente un accoppiamento lento, questo è applicabile se tutte le classi vogliono BlueDart o Dtdc, ma se alcune classi vogliono BlueDart e qualche altra classe vogliono Dtdc, di nuovo sarà strettamente accoppiato, quindi invece di noi creare e gestire l'iniezione di dipendenza Il nucleo di Spring si assume la responsabilità di creare e gestire i bean, Spero che ciò sia utile, nel prossimo esempio vedremo l'applicazione! st sul nucleo di Spring con gli effetti