spring
Spring Core

Einführung in Spring Core

Spring ist ein riesiger Rahmen, daher wurde der Spring-Rahmen in mehrere Module aufgeteilt, wodurch der Frühling leicht wird. Einige wichtige Module sind:

1. Spring Core
2. Frühling AOP
3. Spring JDBC
4. Frühling Transaktion
5. Frühling ORM
6. Spring MVC

Alle Spring-Module sind mit Ausnahme des Spring Core voneinander unabhängig. Da der Federkern das Basismodul ist, müssen wir bei allen Modulen den Federkern verwenden

Spring Core

Spring Core spricht alles über Abhängigkeitsmanagement. Wenn also beliebige Klassen für Spring bereitgestellt werden, kann Spring die Abhängigkeit verwalten.

Was ist eine Abhängigkeit:
Aus Projektsicht gibt es in einem Projekt oder einer Anwendung mehrere Klassen mit unterschiedlicher Funktionalität. und jede Klasse benötigte einige Funktionen anderer Klassen.

Beispiel:

class Engine {

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

class Car {

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

Hier ist Klassen-Engine für Klassenautos erforderlich, sodass wir sagen können, dass Klassen-Engine von Klasse Auto abhängig ist. Also müssen wir diese Abhängigkeiten nicht durch Vererbung verwalten oder Objekte als Brachen erstellen.

Durch Vererbung:

class Engine {

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

class Car extends Engine {

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

Durch Erstellen eines Objekts einer abhängigen Klasse:

class Engine {

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

class Car {

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

Anstatt dass wir die Abhängigkeit zwischen den Klassen verwalten, übernimmt Spring Core das Verantwortungsabhängigkeitsmanagement. Es gibt jedoch einige Regeln, die Klassen müssen mit einer Designtechnik entworfen werden, die Strategieentwurfsmuster ist.

Verstehen, wie Frühling die Abhängigkeit verwaltet?

Lassen Sie mich ein Stück Code schreiben, das vollständig lose gekoppelt ist. Dann können Sie leicht verstehen, wie Spring Core die Abhängigkeit intern verwaltet. Stellen Sie sich ein Szenario vor: Online-Geschäft Flipkart ist vorhanden, es werden einige Male DTDC- oder Blue Dart-Kurierdienst verwendet. Lassen Sie mich eine Anwendung entwerfen, die vollständig lose gekoppelt zeigt. Das Eclipse-Verzeichnis als Brache:

//Interface
package com.sdp.component;

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

}

// Implementierungsklassen

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

}

// Komponentenklasse

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

}

// Factory-Klassen zum Erstellen und Zurückgeben von 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;
}
    
    }

// Eigenschaftendatei

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

// Testklasse

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

}

Wenn wir diesen Code schreiben, können wir manuell eine lose Kopplung erreichen. Dies gilt, wenn alle Klassen entweder BlueDart oder Dtdc möchten. Wenn jedoch eine Klasse BlueDart und eine andere Klasse Dtdc will, dann wird es wieder eng gekoppelt sein, also statt uns Erstellen und Verwalten der Abhängigkeitseinspritzung Spring Core übernimmt die Verantwortung für das Erstellen und Verwalten der Beans. Hoffnung Dies wird hilfreich sein. Im nächsten Beispiel werden wir die! st-Anwendung auf Spring Core mit Deitals sehen