Spring入門介紹
Spring誕生：

創建Spring的目的就是用來替代更加重量級的的企業級Java技術
簡化Java的開發

基于POJO輕量級和最小侵入式開發
通過依賴注入和面向接口實現松耦合
基于切面和慣例進行聲明式編程
通過切面和模板減少樣板式代碼
侵入式概念
Spring是一種非侵入式的框架...

侵入式

對于EJB、Struts2等一些傳統的框架，通常是要實現特定的接口，繼承特定的類才能增強功能

改變了java類的結構
非侵入式

對于Hibernate、Spring等框架，對現有的類結構沒有影響，就能夠增強JavaBean的功能
松耦合
前面我們在寫程序的時候，都是面向接口編程，通過DaoFactroy等方法來實現松耦合

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);

private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);

private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

這里寫圖片描述

DAO層和Service層通過DaoFactory來實現松耦合

如果Serivce層直接new DaoBook()，那么DAO和Service就緊耦合了【Service層依賴緊緊依賴于Dao】。
而Spring給我們更加合適的方法來實現松耦合，并且更加靈活、功能更加強大！---->IOC控制反轉

切面編程
切面編程也就是AOP編程，其實我們在之前也接觸過...動態代理就是一種切面編程了...

當時我們使用動態代理+注解的方式給Service層的方法添加權限.

@Override
@permission("添加分類")
/*添加分類*/
public void addCategory(Category category) {
categoryDao.addCategory(category);
}

/*查找分類*/
@Override
public void findCategory(String id) {
categoryDao.findCategory(id);
}

@Override
@permission("查找分類")
/*查看分類*/
public List<Category> getAllCategory() {
return categoryDao.getAllCategory();
}

/*添加圖書*/
@Override
public void addBook(Book book) {
bookDao.addBook(book);

}
Controller調用Service的時候，Service返回的是一個代理對象
代理對象得到Controller想要調用的方法，通過反射來看看該方法上有沒有注解
如果有注解的話，那么就判斷該用戶是否有權限來調用 此方法，如果沒有權限，就拋出異常給Controller，Controller接收到異常，就可以提示用戶沒有權限了。
AOP編程可以簡單理解成：在執行某些代碼前，執行另外的代碼

Struts2的攔截器也是面向切面編程【在執行Action業務方法之前執行攔截器】
Spring也為我們提供更好地方式來實現面向切面編程！

引出Spring
我們試著回顧一下沒學Spring的時候，是怎么開發Web項目的

1. 實體類--->class User{ }
2. daoclass--> UserDao{ .. 訪問db}
3. service--->class UserService{ UserDao userDao = new UserDao();}
4. actionclass UserAction{UserService userService = new UserService();}
用戶訪問：

Tomcat->action->service->dao
我們來思考幾個問題：

①：對象創建創建能否寫死？
②：對象創建細節

對象數量

action 多個 【維護成員變量】
service 一個 【不需要維護公共變量】
dao 一個 【不需要維護公共變量】
創建時間

action 訪問時候創建
service 啟動時候創建
dao 啟動時候創建
③：對象的依賴關系

action 依賴 service
service依賴 dao
對于第一個問題和第三個問題，我們可以通過DaoFactory解決掉(雖然不是比較好的解決方法)

對于第二個問題，我們要控制對象的數量和創建時間就有點麻煩了....

而Spring框架通過IOC就很好地可以解決上面的問題....

IOC控制反轉
Spring的核心思想之一：Inversion of Control , 控制反轉 IOC

那么控制反轉是什么意思呢？？？對象的創建交給外部容器完成，這個就做控制反轉。

Spring使用控制反轉來實現對象不用在程序中寫死
控制反轉解決對象處理問題【把對象交給別人創建】
那么對象的對象之間的依賴關系Spring是怎么做的呢？？依賴注入，dependency injection.

Spring使用依賴注入來實現對象之間的依賴關系
在創建完對象之后，對象的關系處理就是依賴注入
上面已經說了，控制反轉是通過外部容器完成的，而Spring又為我們提供了這么一個容器，我們一般將這個容器叫做：IOC容器.

無論是創建對象、處理對象之間的依賴關系、對象創建的時間還是對象的數量，我們都是在Spring為我們提供的IOC容器上配置對象的信息就好了。

那么使用IOC控制反轉這一思想有什么作用呢？？？我們來看看一些優秀的回答...

來自知乎：https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分：

ioc的思想最核心的地方在于，資源不由使用資源的雙方管理，而由不使用資源的第三方管理，這可以帶來很多好處。第一，資源集中管理，實現資源的可配置和易管理。第二，降低了使用資源雙方的依賴程度，也就是我們說的耦合度。
也就是說，甲方要達成某種目的不需要直接依賴乙方，它只需要達到的目的告訴第三方機構就可以了，比如甲方需要一雙襪子，而乙方它賣一雙襪子，它要把襪子賣出去，并不需要自己去直接找到一個賣家來完成襪子的賣出。它也只需要找第三方，告訴別人我要賣一雙襪子。這下好了，甲乙雙方進行交易活動，都不需要自己直接去找賣家，相當于程序內部開放接口，賣家由第三方作為參數傳入。甲乙互相不依賴，而且只有在進行交易活動的時候，甲才和乙產生聯系。反之亦然。這樣做什么好處么呢，甲乙可以在對方不真實存在的情況下獨立存在，而且保證不交易時候無聯系，想交易的時候可以很容易的產生聯系。甲乙交易活動不需要雙方見面，避免了雙方的互不信任造成交易失敗的問題。因為交易由第三方來負責聯系，而且甲乙都認為第三方可靠。那么交易就能很可靠很靈活的產生和進行了。這就是ioc的核心思想。生活中這種例子比比皆是，支付寶在整個淘寶體系里就是龐大的ioc容器，交易雙方之外的第三方，提供可靠性可依賴可靈活變更交易方的資源管理中心。另外人事代理也是，雇傭機構和個人之外的第三方。
==========================update===========================

在以上的描述中，誕生了兩個專業詞匯，依賴注入和控制反轉所謂的依賴注入，則是，甲方開放接口，在它需要的時候，能夠講乙方傳遞進來(注入)所謂的控制反轉，甲乙雙方不相互依賴，交易活動的進行不依賴于甲乙任何一方，整個活動的進行由第三方負責管理。

參考優秀的博文①：https://www.tianmaying.com/tutorial/spring-ioc

參考優秀的博文②：這里寫鏈接內容

知乎@Intopass的回答：

不用自己組裝，拿來就用。
享受單例的好處，效率高，不浪費空間。
便于單元測試，方便切換mock組件。
便于進行AOP操作，對于使用者是透明的。
統一配置，便于修改。
Spring模塊
Spring可以分為6大模塊：

Spring Core spring的核心功能： IOC容器, 解決對象創建及依賴關系
Spring Web Spring對web模塊的支持。

可以與struts整合,讓struts的action創建交給spring
spring mvc模式
Spring DAO Spring 對jdbc操作的支持 【JdbcTemplate模板工具類】
Spring ORM spring對orm的支持：

既可以與hibernate整合，【session】
也可以使用spring的對hibernate操作的封裝
Spring AOP 切面編程
SpringEE spring 對javaEE其他模塊的支持
這里寫圖片描述

上面文主要引出了為啥我們需要使用Spring框架，以及大致了解了Spring是分為六大模塊的....下面主要講解Spring的core模塊！

Core模塊快速入門
搭建配置環境
引入jar包:

本博文主要是core模塊的內容，涉及到Spring core的開發jar包有五個：

commons-logging-1.1.3.jar 日志
spring-beans-3.2.5.RELEASE.jar bean節點
spring-context-3.2.5.RELEASE.jar spring上下文節點
spring-core-3.2.5.RELEASE.jar spring核心功能
spring-expression-3.2.5.RELEASE.jar spring表達式相關表
我主要使用的是Spring3.2版本...

編寫配置文件:

Spring核心的配置文件applicationContext.xml或者叫bean.xml

那這個配置文件怎么寫呢？？一般地，我們都知道框架的配置文件都是有約束的...我們可以在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html找到XML配置文件的約束

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

</beans>
我是使用Intellij Idea集成開發工具的，可以選擇自帶的Spring配置文件,它長的是這樣：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>
前面在介紹Spring模塊的時候已經說了，Core模塊是：IOC容器，解決對象創建和之間的依賴關系。

因此Core模塊主要是學習如何得到IOC容器，通過IOC容器來創建對象、解決對象之間的依賴關系、IOC細節。

得到Spring容器對象【IOC容器】
Spring容器不單單只有一個，可以歸為兩種類型

Bean工廠，BeanFactory【功能簡單】
應用上下文，ApplicationContext【功能強大，一般我們使用這個】
通過Resource獲取BeanFactory
加載Spring配置文件
通過XmlBeanFactory+配置文件來創建IOC容器

//加載Spring的資源文件
Resource resource = new ClassPathResource("applicationContext.xml");

//創建IOC容器對象【IOC容器=工廠類+applicationContext.xml】
BeanFactory beanFactory = new XmlBeanFactory(resource);

類路徑下XML獲取ApplicationContext
直接通過ClassPathXmlApplicationContext對象來獲取

// 得到IOC容器對象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

System.out.println(ac);

在Spring中總體來看可以通過三種方式來配置對象:

使用XML文件配置
使用注解來配置
使用JavaConfig來配置
XML配置方式
在上面我們已經可以得到IOC容器對象了。接下來就是在applicationContext.xml文件中配置信息【讓IOC容器根據applicationContext.xml文件來創建對象】

首先我們先有個JavaBean的類

/**
* Created by ozc on 2017/5/10.
*/
public class User {

private String id;
private String username;

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}
}
以前我們是通過new User的方法創建對象的....

User user = new User();
現在我們有了IOC容器，可以讓IOC容器幫我們創建對象了。在applicationContext.xml文件中配置對應的信息就行了

<!--
使用bean節點來創建對象
id屬性標識著對象
name屬性代表著要創建對象的類全名
-->
<bean id="user" class="User"/>
通過IOC容器對象獲取對象:

在外界通過IOC容器對象得到User對象

// 得到IOC容器對象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

User user = (User) ac.getBean("user");

System.out.println(user);
這里寫圖片描述

上面我們使用的是IOC通過無參構造函數來創建對象，我們來回顧一下一般有幾種創建對象的方式：

無參構造函數創建對象
帶參數的構造函數創建對象
工廠創建對象

靜態方法創建對象
非靜態方法創建對象
使用無參的構造函數創建對象我們已經會了，接下來我們看看使用剩下的IOC容器是怎么創建對象的。

帶參數的構造函數創建對象
首先，JavaBean就要提供帶參數的構造函數：

public User(String id, String username) {
this.id = id;
this.username = username;
}
接下來，關鍵是怎么配置applicationContext.xml文件了。

<bean id="user" class="User">

<!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個-->
<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
<constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg>
</bean>
這里寫圖片描述

在constructor上如果構造函數的值是一個對象，而不是一個普通類型的值，我們就需要用到ref屬性了，而不是value屬性

比如說：我在User對象上維護了Person對象的值，想要在構造函數中初始化它。因此，就需要用到ref屬性了

<bean id="person" class="Person"></bean>

<bean id="user" class="User" >

<!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個-->
<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg>
<constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg>
</bean>
工廠靜態方法創建對象
首先，使用一個工廠的靜態方法返回一個對象

public class Factory {

public static User getBean() {

return new User();
}

}
配置文件中使用工廠的靜態方法返回對象

<!--工廠靜態方法創建對象，直接使用class指向靜態類，指定靜態方法就行了-->
<bean id="user" class="Factory" factory-method="getBean" >

</bean>
這里寫圖片描述

工廠非靜態方法創建對象
首先，也是通過工廠的非非靜態方法來得到一個對象

public class Factory {

public User getBean() {

return new User();
}

}
配置文件中使用工廠的非靜態方法返回對象

<!--首先創建工廠對象-->
<bean id="factory" class="Factory"/>

<!--指定工廠對象和工廠方法-->
<bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>
這里寫圖片描述

c名稱空間
我們在使用XML配置創建Bean的時候，如果該Bean有構造器，那么我們使用<constructor-arg>這個節點來對構造器的參數進行賦值...

<constructor-arg>未免有點太長了，為了簡化配置，Spring來提供了c名稱空間...

要想c名稱空間是需要導入xmlns:c="http://www.springframework.org/schema/c"的

<bean id="userService" class="bb.UserService" c:userDao-ref="">

</bean>
c名稱空間有個缺點：不能裝配集合，當我們要裝配集合的時候還是需要<constructor-arg>這個節點

裝載集合
如果對象上的屬性或者構造函數擁有集合的時候，而我們又需要為集合賦值，那么怎么辦？

在構造函數上，普通類型

<bean id="userService" class="bb.UserService" >
<constructor-arg >
<list>
//普通類型
<value></value>
</list>
</constructor-arg>
</bean>
在屬性上,引用類型

<property name="userDao">

<list>
<ref></ref>
</list>
</property>
注解方式
自從jdk5有了注解這個新特性，我們可以看到Struts2框架、Hibernate框架都支持使用注解來配置信息...

通過注解來配置信息就是為了簡化IOC容器的配置，注解可以把對象添加到IOC容器中、處理對象依賴關系，我們來看看怎么用吧：

使用注解步驟：

1）先引入context名稱空間

xmlns:context="http://www.springframework.org/schema/context"
2）開啟注解掃描器

<context:component-scan base-package=""></context:component-scan>
第二種方法:也可以通過自定義掃描類以@CompoentScan修飾來掃描IOC容器的bean對象。。如下代碼:

//表明該類是配置類
@Configuration

//啟動掃描器，掃描bb包下的
//也可以指定多個基礎包
//也可以指定類型
@ComponentScan("bb")
public class AnnotationScan {

}
在使用@ComponentScan()這個注解的時候，在測試類上需要@ContextConfiguration這個注解來加載配置類...

@ContextConfiguration這個注解又在Spring的test包下..
創建對象以及處理對象依賴關系，相關的注解：

@ComponentScan掃描器
@Configuration表明該類是配置類
@Component 指定把一個對象加入IOC容器--->@Name也可以實現相同的效果【一般少用】
@Repository 作用同@Component； 在持久層使用
@Service 作用同@Component； 在業務邏輯層使用
@Controller 作用同@Component； 在控制層使用
@Resource 依賴關系

如果@Resource不指定值，那么就根據類型來找，相同的類型在IOC容器中不能有兩個
如果@Resource指定了值，那么就根據名字來找
測試代碼:

UserDao
package aa;

import org.springframework.stereotype.Repository;

/**
* Created by ozc on 2017/5/10.
*/

//把對象添加到容器中,首字母會小寫
@Repository
public class UserDao {

public void save() {
System.out.println("DB:保存用戶");
}

}
userService

package aa;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

//把UserService對象添加到IOC容器中,首字母會小寫
@Service
public class UserService {

//如果@Resource不指定值，那么就根據類型來找--->UserDao....當然了，IOC容器不能有兩個UserDao類型的對象
//@Resource

//如果指定了值，那么Spring就在IOC容器找有沒有id為userDao的對象。
@Resource(name = "userDao")
private UserDao userDao;

public void save() {
userDao.save();
}
}
userAction

package aa;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
* Created by ozc on 2017/5/10.
*/

//把對象添加到IOC容器中,首字母會小寫
@Controller
public class UserAction {

@Resource(name = "userService")
private UserService userService;

public String execute() {
userService.save();
return null;
}
}
測試

package aa;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by ozc on 2017/5/10.
*/
public class App {

public static void main(String[] args) {

// 創建容器對象
ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();
}
}
這里寫圖片描述

通過Java方式
由于Spring的自動裝配并不能將第三方庫組件裝配到應用中，于是需要顯式裝配配置。顯示裝配有兩種方式

通過java代碼裝配bean
通過XML裝配bean
Spring In Action作者首推使用自動裝配的功能，而后是通過java代碼配置bean，最后才用XML文件配置的方式..

那么怎么通過java代碼來配置Bean呢？？

編寫一個java類，使用@Configuration修飾該類
被@Configuration修飾的類就是配置類
編寫配置類:

@org.springframework.context.annotation.Configuration
public class Configuration {

}
使用配置類創建bean:

使用@Bean來修飾方法，該方法返回一個對象。
不管方法體內的對象是怎么創建的，Spring可以獲取得到對象就行了。
Spring內部會將該對象加入到Spring容器中
容器中bean的ID默認為方法名

?

@org.springframework.context.annotation.Configuration
public class Configuration {

@Bean
public UserDao userDao() {

UserDao userDao = new UserDao();
System.out.println("我是在configuration中的"+userDao);
return userDao;
}

}
測試代碼：要使用@ContextConfiguration加載配置類的信息【引入test包】

package bb;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;

/**
* Created by ozc on 2017/5/11.
*/
//加載配置類的信息
@ContextConfiguration(classes = Configuration.class)
public class Test2 {

@Test
public void test33() {

ApplicationContext ac =
new ClassPathXmlApplicationContext("bb/bean.xml");

UserDao userDao = (UserDao) ac.getBean("userDao");

System.out.println(userDao);
}
}
這里寫圖片描述

三種方式混合使用
注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的...

如果JavaConfig的配置類是分散的，我們一般再創建一個更高級的配置類（root），然后使用@Import來將配置類進行組合
如果XML的配置文件是分散的，我們也是創建一個更高級的配置文件（root），然后使用<import>來將配置文件組合

在JavaConfig引用XML

使用@ImportResource()
在XML引用JavaConfig

使用<bean>節點就行了
bean對象創建細節
在Spring第一篇中，我們為什么要引入Spring提出了這么一些問題：

這里寫圖片描述

既然我們現在已經初步了解IOC容器了，那么這些問題我們都是可以解決的。并且是十分簡單【對象寫死問題已經解決了，IOC容器就是控制反轉創建對象】

scope屬性
指定scope屬性，IOC容器就知道創建對象的時候是單例還是多例的了。

屬性的值就只有兩個：單例/多例

這里寫圖片描述

當我們使用singleton【單例】的時候，從IOC容器獲取的對象都是同一個：
這里寫圖片描述

當我們使用prototype【多例】的時候，從IOC容器獲取的對象都是不同的：
這里寫圖片描述

scope屬性除了控制對象是單例還是多例的，還控制著對象創建的時間！

我們在User的構造函數中打印出一句話，就知道User對象是什么時候創建了。
public User() {

System.out.println("我是User，我被創建了");
}
當使用singleton的時候，對象在IOC容器之前就已經創建了

這里寫圖片描述
當使用prototype的時候，對象在使用的時候才創建

這里寫圖片描述
lazy-init屬性
lazy-init屬性只對singleton【單例】的對象有效.....lazy-init默認為false....

有的時候，可能我們想要對象在使用的時候才創建，那么將lazy-init設置為ture就行了

這里寫圖片描述

init-method和destroy-method
如果我們想要對象在創建后，執行某個方法，我們指定為init-method屬性就行了。。

如果我們想要IOC容器銷毀后，執行某個方法，我們指定destroy-method屬性就行了。

<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>
Bean創建細節總結

/**
* 1) 對象創建： 單例/多例
* scope="singleton", 默認值， 即 默認是單例 【service/dao/工具類】
* scope="prototype", 多例； 【Action對象】
*
* 2) 什么時候創建?
* scope="prototype" 在用到對象的時候，才創建對象。
* scope="singleton" 在啟動(容器初始化之前)， 就已經創建了bean，且整個應用只有一個。
* 3)是否延遲創建
* lazy-init="false" 默認為false, 不延遲創建，即在啟動時候就創建對象
* lazy-init="true" 延遲初始化， 在用到對象的時候才創建對象
* （只對單例有效）
* 4) 創建對象之后，初始化/銷毀
* init-method="init_user" 【對應對象的init_user方法，在對象創建之后執行 】
* destroy-method="destroy_user" 【在調用容器對象的destroy方法時候執行，(容器用實現類)】
*/
此文轉載于知乎博主，原文鏈接如下：https://segmentfault.com/a/1190000013700859

轉載于:https://www.cnblogs.com/Silencewj/p/11133378.html

總結

以上是生活随笔為你收集整理的Spring入门介绍：的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。