spring
Spring Core

Introductie tot Spring Core

De lente is een uitgebreid raamwerk, dus het veerraamwerk is verdeeld in verschillende modules waardoor de lente licht van gewicht is. Enkele belangrijke modules zijn:

1. Spring Core
2. Lente AOP
3. Lente JDBC
4. Voorjaarstransactie
5. Lente ORM
6. Lente MVC

Alle modules van Spring zijn onafhankelijk van elkaar behalve Spring Core. Omdat Spring Core de basismodule is, moeten we in alle modules Spring Core gebruiken

Spring Core

Spring Core heeft alles te maken met afhankelijkheidsbeheer. Dat betekent dat als willekeurige klassen worden verstrekt om te springen, Spring de afhankelijkheid kan beheren.

Wat is een afhankelijkheid:
Vanuit projectoogpunt zijn er in een project of applicatie meerdere klassen aanwezig met verschillende functionaliteit. en elke klasse vereiste enige functionaliteit van andere klassen.

Voorbeeld:

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 is class Engine vereist door class car, dus we kunnen zeggen dat class engine afhankelijk is van class Car, dus in plaats van dat we die afhankelijkheid beheren door Overerving of een object maken als braakliggend object.

Overerving:

class Engine {

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

class Car extends Engine {

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

Door een object van afhankelijke klasse te maken:

class Engine {

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

class Car {

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

Dus in plaats van dat we afhankelijkheid tussen klassen beheren, neemt spring core het verantwoordelijkheidsafhankelijkheidsbeheer op zich. Maar er zijn enkele regels, de klassen moeten worden ontworpen met een of andere ontwerptechniek die een strategisch ontwerppatroon is.

Inzicht in hoe lente afhankelijkheid beheert?

Laat me een stuk code schrijven dat volledig losjes is gekoppeld, dan kun je gemakkelijk begrijpen hoe Spring Core de afhankelijkheid intern beheert. Overweeg een scenario, online bedrijf Flipkart is er, het gebruikt soms DTDC of Blue Dart koeriersdienst, dus laat me een applicatie ontwerpen die volledig los gekoppeld toont. De Eclipse-map als braakliggend:

//Interface
package com.sdp.component;

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

}

// implementatieklassen

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

}

// Component klasse

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

}

// Fabrieksklassen om Object te maken en terug te sturen

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

// eigenschappenbestand

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

}

Als we deze code schrijven, kunnen we handmatig een losse koppeling tot stand brengen, dit is van toepassing als alle klassen BlueDart of Dtdc willen, maar als een klasse BlueDart en een andere klasse Dtdc wil, wordt het opnieuw strak gekoppeld, dus in plaats van dat we het creëren en beheren van de afhankelijkheidsinjectie Spring core neemt de verantwoordelijkheid voor het maken en beheren van de bonen, Hope Dit zal nuttig zijn, in het volgende voorbeeld zien we de! e applicatie op Spring core met deitals