spring
Spring Core

Wprowadzenie do Spring Core

Wiosna jest obszernym szkieletem, dlatego szkielet Spring został podzielony na kilka modułów, dzięki czemu sprężyna jest lekka. Niektóre ważne moduły to:

1. Spring Core
2. Wiosna AOP
3. Wiosna JDBC
4. Transakcja wiosenna
5. Wiosna ORM
6. Wiosna MVC

Wszystkie moduły Spring są niezależne od siebie, z wyjątkiem Spring Core. Ponieważ rdzeń sprężynowy jest modułem podstawowym, dlatego we wszystkich modułach musimy używać sprężyn rdzeniowych

Spring Core

Spring Core mówi wszystko o zarządzaniu zależnościami. Oznacza to, że jeśli dowolne klasy dostarczone wiosną, Spring może zarządzać zależnościami.

Co to jest zależność:
Z punktu widzenia projektu w projekcie lub aplikacji istnieje wiele klas o różnych funkcjach. i każda klasa wymagała pewnej funkcjonalności innych klas.

Przykład:

class Engine {

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

class Car {

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

Tutaj klasa silnik jest wymagana przez samochód klasy, więc możemy powiedzieć, że silnik klasy jest zależny od klasy samochodu, więc zamiast zarządzać tą zależnością przez dziedziczenie lub tworzenie obiektu jako odłogi.

Przez dziedziczenie:

class Engine {

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

class Car extends Engine {

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

Tworząc obiekt klasy zależnej:

class Engine {

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

class Car {

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

Więc zamiast zarządzać zależnością między klasami, rdzeń sprężynowy przejmuje zarządzanie zależnością od odpowiedzialności. Ale istnieją pewne reguły. Klasy muszą być zaprojektowane przy użyciu techniki projektowania, która jest wzorcem projektowania strategii.

Zrozumienie, jak wiosna zarządza zależnością?

Pozwólcie, że napiszę fragment kodu, który pokazuje całkowicie luźno powiązane, dzięki czemu można łatwo zrozumieć, jak Spring core wewnętrznie zarządza zależnością. Rozważmy scenariusz: internetowy biznes Flipkart już tam jest, używa czasami usługi kurierskiej DTDC lub Blue Dart, więc pozwól mi zaprojektować aplikację, która pokazuje całkowicie luźno powiązane. Katalog Eclipse jako daniele:

//Interface
package com.sdp.component;

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

}

// klasy implementacji

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

}

// Klasa komponentów

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

}

// Klasy fabryczne do tworzenia i zwracania obiektów

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

// plik właściwości

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

// Klasa testowa

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

}

Jeśli piszemy ten kod, wówczas możemy ręcznie osiągnąć luźne sprzężenie, ma to zastosowanie, jeśli wszystkie klasy chcą albo BlueDart lub Dtdc, ale jeśli jakaś klasa chce BlueDart, a inna klasa chce Dtdc, to znowu będzie ściśle powiązane, więc zamiast nas tworzenie i zarządzanie wstrzykiwaniem zależności Spring core bierze odpowiedzialność za tworzenie i zarządzanie ziarnami, Hope To pomoże, w następnym przykładzie zobaczymy! st. aplikację na Spring core z deitalami