Spring的第一個程序
一、Spring概述
1. Spring是什麼？
Spring 的主要作用就是為代碼「解耦」，降低代碼間的耦合度。就是讓對象和對象（模塊和模塊）之間關係不是使用代碼關聯，而是通過配置來說明。即在 Spring 中說明對象（模塊）的關係
Spring 根據代碼的功能特點，使用 Ioc 降低業務對象之間耦合度。IoC 使得主業務在相互調用過程中，不用再自己維護關係了，即不用再自己創建要使用的對象了。而是由 Spring容器統一管理，自動「注入」,注入即賦值。 而 AOP 使得系統級服務得到了最大復用，且不用再由程序員手工將系統級服務「混雜」到主業務邏輯中了，而是由 Spring 容器統一完成「織入」
spring全家桶：
spring ， springmvc ，spring boot , spring cloud
spring: 出現是在2002左右，解決企業開發的難度。減輕對項目模塊之間的管理，類和類之間的管理， 幫助開發人員創建對象，管理對象之間的關係。
spring核心技術 ioc(控制反轉) ， aop(面向切面編程) 。能實現模塊之間，類之間的解耦合。
2. IOC控制反轉
控制反轉（IoC，Inversion of Control），是一個概念，是一種思想。指將傳統上由程序代碼直接操控的對象調用權交給容器，通過容器來實現對象的裝配和管理,控制反轉就是對對象控制權的轉移，從程序代碼本身反轉到了外部容器。
通過容器實現對象的創建，屬性賦值，依賴的管理。
IoC 是一個概念，是一種思想，其實現方式多種多樣。當前比較流行的實現方式是依賴注入
依賴：classA 類中含有 classB 的實例，在 classA 中調用 classB 的方法完成功能，即 classA對 classB 有依賴
IOC的實現：
依賴注入：DI(Dependency Injection)，程序代碼不做定位查詢，這些工作由容器自行完成
依賴注入 DI 是指程序運行過程中，若需要調用另一個對象協助時，無須在代碼中創建被調用者，而是依賴於外部容器，由外部容器創建後傳遞給程序
Spring 框架使用依賴注入（DI ）實現 IoC
Spring 容器是一個超級大工廠，負責創建、管理所有的 Java 對象，這些 Java 對象被稱為 Bean。Spring 容器管理着容器中 Bean 之間的依賴關係，Spring 使用「依賴注入」的方式來管理 Bean 之間的依賴關係。使用 IoC 實現對象之間的解耦和
二、Spring的第一個程序
1. 創建Maven項目
下面的直接下一步就可以了，具體的看之前寫的關於Maven的操作
創建成功的如下：
2. 加入maven依賴pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="//maven.apache.org/POM/4.0.0" xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="//maven.apache.org/POM/4.0.0 //maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.md</groupId>
<artifactId>01-hello-spring</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<!--單元測試-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--spring依賴-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
</dependencies>
<build>
</build>
</project>
3. 定義接口和實體類
package com.md.service;
/**
* @author MD
* @create 2020-08-07 17:32
*/
public interface SomeService {
void doSome();
}
//-----------------------------------------
package com.md.service.impl;
import com.md.service.SomeService;
/**
* @author MD
* @create 2020-08-07 17:33
*/
public class SomeServiceImpl implements SomeService {
public SomeServiceImpl() {
System.out.println("我是SomeServiceImpl的無參構造方法");
}
@Override
public void doSome() {
System.out.println("執行了SomeServiceImpl的doSome()方法");
}
}
4. 創建Spring的配置文件
在src/main/resources目錄下創建xml文件，具體如下：文件名可以隨意，但 Spring 建議的名稱為applicationContext.xml
具體的解釋看代碼中的注釋
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="//www.springframework.org/schema/beans"
xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="//www.springframework.org/schema/beans
//www.springframework.org/schema/beans/spring-beans.xsd">
<!--
spring的配置文件
1. beans：根標籤，spring把java對象成為bean
2. spring-beans.xsd是約束文件，和mybatis的dtd類
-->
<!--
spring在創建對象的時候，聲明bean，就是告訴spring要創建某個類的對象
id: 這個對象自定義名稱，唯一，spring通過這個id能找到對象
class：類的全限定名稱（不能是接口的，因為spring是反射機制創造對象的）
spring就完成這樣的工作 SomeService someService = new SomeServiceImpl();
spring是把創建好的對象放入到map中，spring框架中有一個map存放對象
spring.put(id值，對象)
例：springMap.put("someService",new SomeServiceImpl());
一個 bean 標籤聲明一個對象
-->
<bean id="someService" class="com.md.service.impl.SomeServiceImpl" />
</beans>
- spring在創建對象的時候，聲明bean，就是告訴spring要創建某個類的對象
- id: 這個對象自定義名稱，唯一，spring通過這個id能找到對象
- class：類的全限定名稱（不能是接口的，因為spring是反射機制創造對象的）
5. 定義測試類
spring默認創建對象的時間：在創建spring的容器時，就創建配置文件中的<所有對象>
spring創建對象，默認調用的是無參的構造方法
@Test
public void test02(){
// 使用spring容器創建對象,spring配置文件在類路徑下
// 1. 指定spring配置文件名稱
String config = "beans.xml";
//2. 表示創建spring容器的對象， ApplicationContext
// ApplicationContext就是表示Spring容器，通過容器獲取對象了
// ClassPathXmlApplicationContext:表示從類路徑中加載spring的配置文件,
// 如圖所示，得把beans.xml放到編譯好的target下面的classes中
// 若自動放的話這裡就不用放了，如果出現找不到這個文件的時候手動放就行了
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
System.out.println("------------------");
//3. 從容器中獲取某個對象， 你要調用對象的方法
//getBean("配置文件中的bean的id值")
SomeService someService = (SomeService) ac.getBean("someService");
// 4. 使用spring創建好的對象來調用方法
someService.doSome();
// 我是SomeServiceImpl的無參構造方法
// ------------------
// 執行了SomeServiceImpl的doSome()方法
}
當運行報錯找不到beans.xml文件的時候，手動複製一個就可以了
6. 使用spring創建非自定義類對象
在Spring的配置文件beans.xml中添加
<!--
spring能創建一個非自定義類的對象嗎？創建一個已經存在的類的對象
-->
<bean id="mydate" class="java.util.Date" />
在測試類
/**
* 獲取一個非自定義的類的對象
*/
@Test
public void test04(){
String config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
// 獲取對象
Date d = (Date) ac.getBean("mydate");
System.out.println(d);
}
7. 獲取spring容器中java對象的信息
@Test
public void test03(){
String config = "beans.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
// 使用spring提供的方法，獲取容器中定義的對象的數量
int count = ac.getBeanDefinitionCount();
System.out.println(count);
// 容器中定義的每個對象的名稱
String[] names = ac.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
}
三、使用Spring框架的步驟
- 加入依賴
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
- 創建類：接口、實現類、或者沒有接口的類
- 創建spring的配置文件，使用<bean>標籤聲明對象
<bean id="someService" class="com.md.service.impl.SomeServiceImpl" />
- 我們使用容器中的對象，通過ApplicationContext接口和它的實現類ClassPathXmlApplicationContext的方法getBean(“要使用的id”)
四、總結
1. 什麼是spring
- 是一個框架，核心技術是ioc、aop，實現解耦合
- spring是一個容器，容器中存放的是java對象，需要做的是把對象放入到容器中
2. 怎麼使用spring
- spring是一個容器，把項目中用的對象放入到容器中
- 讓容器完成對象的創建、對象之間的關係的管理也就是屬性的賦值
- 我們在程序中從容器中獲取到想使用的對象
3. 什麼樣的對象放入容器中
- dao類、service類、controller類、工具類
spring中對象默認都是單例，在容器中這個對象只有一個
4. 不放入spring容器中的對象
- 實體類對象，實體類的數據是來自數據庫的
- servlet、listener、filter等(這幾個是來自Tomcat的)
