Fork me on GitHub
余鸢

Spring Core简介

发表于 | 分类于

Spring是一个巨大的框架工作，所以人们把Spring框架分成几个模块，使Spring轻量级。 一些重要的模块是：

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

除了Spring Core之外，Spring的所有模块都是彼此独立的。 由于Spring核心是基本模块，因此在所有模块中我们必须使用Spring Core

Spring Core

Spring Core讨论所有关于依赖管理。这意味着如果任何任意类提供到Spring然后Spring可以管理依赖。

什么是依赖： - 从项目的角度来看，在项目或应用程序中，多个类有不同的功能。 并且每个类都需要其他类的一些功能，例如：

1
2
3
4
5
6
7
8
9
10
11
12
class Engine{
  public void start(){
      System.out.println("Engine started");
  }
}
class Car{
 	public void move(){
		// 对于移动start() 方法的引擎类是必需的
	}
}

这里类引擎需要类car，所以我们可以说类引擎依赖于类Car，所以，而不是我们通过继承或创建对象作为fallows管理这些依赖。

继承：

1
2
3
4
5
6
7
8
9
10
11
12
class Engine{
  public void start(){
  	System.out.println("Engine started");
  }
}
class Car extends Engine {
   public void move(){
   	start(); //调用超类start方法
  }
}

通过创建依赖类的对象：

1
2
3
4
5
6
7
8
9
10
11
12
13
class Engine{
  public void start(){
  	System.out.println("Engine started");
  }
}
class Car{
  Engine eng = new Engine();
  public void move(){
   	eng.start();
  }
}

因此，我们不是管理类之间的依赖关系，还是spring core负责依赖管理。 有些规则存在，类必须设计一些设计技术是战略设计模式。

了解Spring如何管理依赖关系？

让我写一段代码，显示完全松散耦合，然后你可以很容易地理解Spring核心如何管理内部依赖。 考虑一个场景，在线商务Flipkart，它使用一些时间DTDC或蓝色Dart快递服务，所以让我设计一个显示完全松散耦合的应用程序。 Eclipse目录作为fallows：

6

1
2
3
4
5
6
7
//Interface
package com.sdp.component;
public interface Courier {
    public String deliver(String iteams,String address);
}

//实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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 classe

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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类创建和返回Object

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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;
}
    
    }

//properties文件

1
2
3
BlueDart.class=com.sdp.component.BlueDart
Dtdc.class=com.sdp.component.Dtdc
FlipKart.class=com.sdp.service.FlipKart

//Test 类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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");
        
    }
}

如果我们写这个代码，我们可以手动实现松耦合，这适用于如果所有的类都想要BlueDart或Dtdc，但如果一些类想要BlueDart和一些其他类想要Dtdc，然后再次将紧密耦合，所以不是我们创建和管理依赖注入Spring核心负责创建和管理bean，Hope这将有所帮助，在下一个示例中，我们将看到在Spring核心上的！st应用在Spring 核心与deitals。