溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
前面已經學習了Struts2和Hibernate框架了。接下來學習的是Spring框架…本博文主要是引入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的時候，是怎么開發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就很好地可以解決上面的問題….
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可以分為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模塊！
引入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容器不單單只有一個，可以歸為兩種類型
**Bean工廠，BeanFactory【功能簡單】 **
應用上下文，ApplicationContext【功能強大，一般我們使用這個】
加載Spring配置文件
通過XmlBeanFactory+配置文件來創建IOC容器
//加載Spring的資源文件
Resource resource = new ClassPathResource("applicationContext.xml");
//創建IOC容器對象【IOC容器=工廠類+applicationContext.xml】
BeanFactory beanFactory = new XmlBeanFactory(resource);
直接通過ClassPathXmlApplicationContext對象來獲取
// 得到IOC容器對象
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(ac);
在Spring中總體來看可以通過三種方式來配置對象:
使用XML文件配置
使用注解來配置
使用JavaConfig來配置
在上面我們已經可以得到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"/>
我們在使用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();
}
}
由于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），然后使用
在JavaConfig引用XML
使用@ImportResource()
在XML引用JavaConfig
使用<bean>節點就行了
在Spring第一篇中，我們為什么要引入Spring提出了這么一些問題：
既然我們現在已經初步了解IOC容器了，那么這些問題我們都是可以解決的。并且是十分簡單【對象寫死問題已經解決了，IOC容器就是控制反轉創建對象】
指定scope屬性，IOC容器就知道創建對象的時候是單例還是多例的了。
屬性的值就只有兩個：單例/多例
當我們使用singleton【單例】的時候，從IOC容器獲取的對象都是同一個：
當我們使用prototype【多例】的時候，從IOC容器獲取的對象都是不同的：
scope屬性除了控制對象是單例還是多例的，還控制著對象創建的時間！
我們在User的構造函數中打印出一句話，就知道User對象是什么時候創建了。
public User() {
System.out.println("我是User，我被創建了");
}
當使用singleton的時候，對象在IOC容器之前就已經創建了
當使用prototype的時候，對象在使用的時候才創建
lazy-init屬性只對singleton【單例】的對象有效…..lazy-init默認為false….
有的時候，可能我們想要對象在使用的時候才創建，那么將lazy-init設置為ture就行了
如果我們想要對象在創建后，執行某個方法，我們指定為init-method屬性就行了。。
如果我們想要IOC容器銷毀后，執行某個方法，我們指定destroy-method屬性就行了。
<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>
/**
* 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方法時候執行，(容器用實現類)】
*/
如果文章有錯的地方歡迎指正，大家互相交流。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
