Spring知識點總結大全

openkk 12年前發布 | 260K 次閱讀 Spring JEE框架

chapter01 Spring簡介

一、Spring是什么？

在了解Spring之前，我們來了解在Java EE框架下企業級開發采用EJB框架的一些不足：

(1) EJB太笨重，而且Entity EJB不能脫離容器

(2) 企業級服務使用困難

(3) 開發的復雜度太高

(4) 侵入式方案，EJB要使用特定的接口

因此，Spring應運而生。

Spring是一個開源的用于簡化采用Java語言開發企業級程序的一個分層的框架。

關于程序的分層結構：

1、Presentation layer（表示層）

(1) 表示邏輯（生成界面代碼）

(2) 接收請求

(3) 處理業務層拋出的異常

(4) 負責規則驗證（數據格式，數據非空等）

(5) 流程控制

2、Service layer（服務層/業務層）

(1) 封裝業務邏輯處理，并且對外暴露接口

(2) 負責事務，安全等服務

3、Persistence layer（持久層）

(1) 封裝數據訪問的邏輯，暴露接口

(2) 提供方便的數據訪問的方案（查詢語言，API，映射機制等）

Domain layer（域層）

(1) 業務對象以及業務關系的表示

(2) 處理簡單的業務邏輯

(3) 域層的對象可以穿越表示層，業務層，持久層

二、Spring的作用

為什么要使用Spring？

(1) 簡化企業級開發

① 封裝了大部分的企業級服務，提供了更好的訪問這些服務的方式

② 提供了IOC，AOP功能的容器，方便編程

(2) 遵循Spring框架的應用程序，一定是設計良好的，針對接口編程，這樣就簡化了企業級程序的設計。

(3) Spring的組成

① Spring Core：核心容器，BeanFactory提供了組件生命周期的管理，組件的創建，裝配，銷毀等功能

SpringContext：ApplicationContext，擴展核心容器，提供事件處理、國際化等功能。它提供了一些企業級服務的功能，提供了JNDI，EJB，RMI的支持。

② Spring AOP：提供切面支持

③ Spring DAO：提供事務支持，JDBC，DAO支持

④ Spring ORM：對流行的O/R Mapping封裝或支持

⑤ Spring Web：提供Web應用上下文，對Web開發提供功能上的支持，如請求，表單，異常等。

⑥ Spring Web MVC：全功能MVC框架，作用等同于Struts。

chapter02 Spring的IoC

一、IoC的概念

IoC，Inversion of Control，控制反轉。

對象的協作關系由對象自己負責。

依賴注入：對象的協作關系有容器來建立。

二、IoC的類型

(1) 基于特定接口（侵入式方案）

(2) 基于set方法

(3) 基于構造器

三、Spring容器

Spring容器負責生成、組裝、銷毀組件，并負責事件處理、國際化等功能。

(1) BeanFactory<interface>

① 核心容器，負責組件生成和裝配

② 實現主要包括Xml BeanFactory

(2) ApplicationContext

(3) WebApplicationContext

(4) ……

四、IoC的使用

Resource：interface，用來包裝資源

xmlBeanFactory：BeanFactory的一個實現，使用Resource對象來查找配置文件

BeanFactory.gerBean（“BeanId”）：取得以參數命名，或者Id等于參數值的一個Bean實例。

BeanFactory（容器）在默認情況下，會采用單例方式返回對象。容器只到調用getBean方法時，才會實例化某個對象。

(1) Spring可以采用XML或者.properties文件作配置

(2) 配置文件（XML）

根元素<beans>可以有多個<bean>子元素，每個<bean>代表一個需要裝配的對象。

1、setter注入

(1) 注入簡單屬性（String和8中基本類型）

<beans>

<value>parameterValue</value>

</property>

</bean>

</beans>

對于基本類型，Spring容器會自動作類型轉換，以便賦值。

(2) 注入對象

<bean>

</bean>

A、讓Spring容器在當前配置文件中找到相應的Bean，并調用set方法，注入該Bean。

B、將一個Bean的定義嵌套在另一個Bean中（可讀性差），被嵌套的Bean不能采用getBean（）返回

C、采用<ref bean=” ”>搜索多個配置文件來注入

(3) 注入集合類型

① Set

Set中存放字符串，對象，集合，不允許重復

② List

List中可以放入字符串，對象，List

③ Map

Map 有<entry>子元素來存取key，value，key只能為String

④ Properties

Properties有<props>子元素

2、consctructor注入

<bean>

<constructor-arg>

</constructor-arg>

<constructor-arg>

</constructor-arg>

</bean>

如果Bean屬性不多，并且屬性值必須要注入才能使用，則應該采用constructor注入，其他情況就要set方法注入。

裝配關系檢查（Dependency checking）

simple：檢查簡單類型

ojects：檢查對象類型

all：檢查所有

自動裝配（Autowring Properties）

裝配方式：byName，byType，autodetect，constructor

autowire=“byName”：按照名稱匹配

按照Bean的Id與屬性的名稱進行匹配

自動裝配與手動裝配可以結合使用，手動裝配會覆蓋自動裝配。

autowire=“byType”：按照類型匹配

要注入的屬性類型與配置文件中的Bean類型匹配的個數超過一個，會出錯。

autowire=“antodetect”：

先按照construct，后按照byType。

autowire=“constructor”：

先去匹配構造器中參數類型，后與配置文件中的Bean類型匹配。

3、比較兩種注入方式

關于自動匹配：

優點：快速開發

缺點：依賴關系不清楚，易出錯，不易維護。

自動匹配的應用場合：

(1) 構建系統原型

(2) 與依賴關系檢查（Dependency-check）結合使用

(3) 自動裝配與手動裝配結合

4、特殊的IoC

① 后處理Bean

接口：org.springframework.beans.factory.config.BeanPostProcessor

Spring已經實現該接口的BeanPostProcessor(不用再注冊)

ApplicationContextAwareProcessor：

把應用上下文傳遞給所用實現了 ApplicationContextAware接口的Bean

ApplicationContextAware接口使用舉例，可參照事件監聽機制

DefaultAdvisorAutoProxyCreator自動對Bean應用切面

② Bean工廠后處理(只能在應用上下文中使用)

接口：org.springframework.beans.factory.config.BeanFactoryPostProcessor

Spring內部接口實現：

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer

屬性編輯

org.springframework.beans.factory.config.CustomEditorConfigurer

CustomerInfo("fname-lname-address")

實例工廠配置

代碼：

--------------------------------------------------------------------------------

<beans>

</property>

</property>

</bean>

</beans>

--------------------------------------------------------------------------------

靜態工廠配置

--------------------------------------------------------------------------------

<beans>

</property>

</property>

</bean>

</beans>

--------------------------------------------------------------------------------

5、事件處理

事件監聽

1）自定義事件，通過繼承org.springframework.context.ApplicationEvent

2）自定義監聽器，實現 org.springframework.context.ApplicationListener，并注冊

3）發布事件，為得到應用上下文，

必須實現org.springframework.context.ApplicationContextAware接口

chapter03 Spring的AOP

一、AOP(Aspect-oriented programming,面向切面編程)：

什么是AOP？

定義：將程序中的交叉業務邏輯提取出來，稱之為切面。將這些切面動態織入到目標對象，然后生成一個代理對象的過程。

二、AOP核心概念

1、Aspect（切面）

切面，是對交叉業務邏輯的統稱。

2、Joinpoint（連接點）

連接點，指切面可以織入到目標對象的位置（方法，屬性等）。

3、Advice（通知）

通知，指切面的具體實現。

4、Pointcut（切入點）

切入點，指通知應用到哪些類的哪些方法或屬性之上的規則。

5、Introduction（引入）

引入，指動態地給一個對象增加方法或屬性的一種特殊的通知。

6、Weaving（織入）

織入，指將通知插入到目標對象。

7、Target（目標對象）

目標對象，指需要織入切面的對象。

8、Proxy（代理對象）

代理對象，指切面織入目標對象之后形成的對象。

三、Spring AOP原理

采用動態代理模式。

Spring AOP采用動態代理的過程：

(1) 將切面使用動態代理的方式動態織入到目標對象（被代理類），形成一個代理對象；

(2) 目標對象如果沒有實現代理接口，那么Spring會采用CGLib來生成代理對象，該代理對象是目標對象的子類；

(3) 目標對象如果是final類，并且也沒實現代理接口，就不能運用AOP。

四、Spring的通知

1、Spring的通知類型

(1) MethodBeforeAdvice

類全名：org.springframework.aop.MethodBeforeAdvice

在方法調用之前，做處理。

不能夠改變返回值

不能夠改變目標方法的流程，也不能中斷流程的處理過程（除非拋出異常）

(2) AfterReturningAdvice

類全名：org.springframework.aop.AfterReturningAdvice

在方法調用之后，做處理。

不能夠改變返回值

不能夠改變目標方法的流程，也不能中斷流程的處理過程（除非拋出異常）

(3) MethodInterceptor

類全名：org.aopalliance.intercept.MethodInterceptor

在方法調用之前以及之后，做處理。

可以改變返回值，也可以改變流程。

(4) ThrowsAdvice

類全名：org.springframework.aop.ThrowsAdvice

在方法拋出異常后，做處理。

當該通知處理完異常后，會簡單地將異常再次拋出給目標調用方法。

2、配置過程：

（1）配置目標對象

（2）配置通知

（3）利用ProxyFactoryBean將通知織入到目標對象，形成一個動態代理對象

（4）客戶端使用動態代理來訪問目標對象的方法。

在默認情況下，通知會應用到所有的方法之上。

Pointcut：

根據方法和類決定在什么地方織入通知

Advisor：

將Pointcut與Advice結合到一起。

自定義切入點：

步驟：

1）實現org.springframework.aop.ClassFilter

2）實現org.springframework.aop.MethodMatcher

3）實現org.springframework.aop.Pointcut

4）實現org.springframework.aop.PointcutAdvisor

注意：

在此可定義

private Advice advice;

private Pointcut pointcut;

在配置文件中，將自定義的切入點與通知綁訂到一起

5）利用ProxyFactoryBean將advisor織入到目標對象

ProxyFactoryBean的作用：

依照配置信息，將切面應用到目標對象，生成動態代理對象。

(1) Spring只支持方法連接點，不支持屬性連接點。

（原因是Spring AOP采用的是動態代理模式，而動態代理本身就是在方法調用前加入代碼。）

(2) Spring只在運行時，將切面織入到目標對象。

（有些AOP實現，可以在編譯是織入切面到目標對象。）

Injecting Advice（con’t d）

<property name=”proxyInterfaces”> ←目標對象實現的接口

（如果沒有定義接口，則所有方法使用CGLib

<value>aop.RegisterService</value>

</proxy>

<property name=”target”> ←目標對象

</property>

<property name=”interceptorNames”> ←需要織入到目標對象的切面

<list>

<value>logAdvice</value>

<value>throwsAdvice</value>

</list>

</property>

</bean>

五、切入點（Pointcut）

1、Pointcut<interface>

切入點是指通知/切面可以應用到哪些類，哪些方法之上。

Pointcut API

Pointcut：org.springframework.aop.Pointcut

對某些類某些方法應用切面。

Classfilter：org.springframework.aop.ClassFilter

用來過濾類（哪些類可以應用切面）

MethodMather：org.springframework.aop.MethodMatcher

用來過濾方法（類中哪些方法應用切面）

Advisor：org.springframework.aop.PointcutAdvisor

將Pointcut與Advice結合到一起

配置文件樣例：

<beans>

</property>

</property>

</bean>

</property>

<list>

<value>myPointcutAdvisor</value>

</list>

</property>

</bean>

</beans>

2、預定義切入點

① 靜態切入點：

a、NameMatchMethodPointAdviosr

org.springframework.aop.support.NameMatchMethodPointcutAdvisor

根據方法名稱的特點進行匹配

核心XML：mappedName→advice(ref)

配置文件樣例：

<beans>

<value>methodOne</value>

</property>

</property>

</bean>

<bean id="registerService"

class="org.springframework.aop.framework.ProxyFactoryBean">

</property>

<list>

<value>namedPointcutAdvisor</value>

</list>

</property>

</bean>

</beans>

b、RegexpMethodPointcutAdvisor

根據正則表達式匹配方法名

org.springframework.aop.support.RegexpMethodPointcutAdvisor

核心XML：pattern→advice(ref)

配置文件樣例：

<value>.*method.*</value>

</property>

</property>

</bean>

<bean id="registerService"

class="org.springframework.aop.framework.ProxyFactoryBean">

</property>

<list>

<value>regexpAdvisor</value>

</list>

</property>

</bean>

</beans>

② 動態切入點：

org.springframework.aop.support.ControlFlowPointcut

③ 切入點的交叉與合并：

Pointcuts.union

配置文件樣例：

<list>

</list>

</property>

</bean>

</property>

</property>

</bean>

④ Introduction

一種特殊類型的Advice，為類動態增加方法和屬性。

編程步驟：

1)實現org.springframework.aop.IntroductionInterceptor或

繼承org.springframework.aop.support.DelegatingIntroductionInterceptor

2)使用org.springframework.aop.support.DefaultIntroductionAdvisor

配置文件樣例：

<constructor-arg>

</constructor-arg>

<constructor-arg>

<value>aop8.OtherBean</value>

</constructor-arg>

</bean>

六、自動代理

Spring在生成代理對象的時候，默認情況下，會使用被代理對象的接口來生成代理對象。

如果被代理對象沒有實現接口，此時，Spring會使用CGLIB生成代理對象，此時該代理對象是被代理對象的子類。

a、BeanNameAutoProxyCreator

org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator

根據類的名稱來為符合相應名稱的類生成相應代理對象。

beanNames(list),interceptorNames

配置文件樣例：

<list>

<value>someService</value>

<value>otherService</value>

</list>

</property>

<list>

<value>logAdvice</value>

</list>

</property>

</bean>

b、DefaultAdvisorAutoProxyCreator

org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator

自動將Advisor與匹配的Bean進行綁定

只能與Advisor配合使用

配置文件樣例：

chapter04 Spring對持久層的支持

Spring對持久層的支持：① JDBC，② O/R Mapping（Hibernate，TopLink等）

一、Spring對持久層支持采用的策略：

1、Spring對持久層“不發明重復的輪子”，即沒有重新實現新的持久層方案，對現有持久層方案做封裝，更利于使用。

2、采用DAO模式

3、提供了大量的模板類來簡化編程（HibernateDaoSupport，JdbcTemplate等）

4、重新設計了一套完善的異常體系結構

① 類型豐富，細化異常類型

② 全都是運行時異常（RuntimeException）

二、Spring對JDBC的支持

1、配置數據源

方式一：采用Spring內置的數據源，Spring內置實現 DriverManagerDataSource

<value>com.mysql.jdbc.Driver</value>

</property>

<value>jdbc:mysql://localhost:3306/hibdb</value>

</property>

</property>

<value>windows</value>

</property>

</bean>

方式二：采用開源數據庫產品如DBCP

DBCP提供的BasicDataSource

<value>com.mysql.jdbc.Driver</value>

</property>

<value>jdbc:mysql://localhost:3306/hibdb</value>

</property>

</property>

<value>windows</value>

</property>

</bean>

方式三：直接使用容器提供的數據源（如Tomcat，Weblogic，Sun Application Server）

JNDI數據源：(mysql5,tomcat5.5)

step1:

在server.xml中：

<Resource name="jdbc/mydatasource" auth="Container" description="DB Connection"

type="javax.sql.DataSource" username="root" password="windows"

driverClassName="com.mysql.jdbc.Driver"

url="jdbc:mysql://localhost:3306/tarena" maxActive="5" />

step2:

在context.xml中（conf\context.xml）：

step3:

在beans-config.xml:

<value>java:comp/env/jdbc/mydatasource</value>

</property>

</bean>

2、配置JdbcTemplate模板類（封裝了絕大多數數據庫操作）

3、配置DAO

4、配置Service

編程步驟：

step1: 配置數據源

step2: 配置JdbcTemplate

<bean id="jdbcTemplate"

class="org.springframework.jdbc.core.JdbcTemplate">

</property>

</bean>

step3:配置DAO

</bean>

注意：查詢時，使用RowMapper

三、Spring對Hibernate的支持

Step1：配置數據源

Step2：配置sessionfactory

<bean id="mySessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

</property>

<list>

<value>lab6/Order.hbm.xml</value>

</list>

</property>

<props>

org.hibernate.dialect.MySQLDialect

</prop>

</props>

</property>

</bean>

Step3：配置DAO

</property>

</bean>

注意：以上配置是要求dao 繼承HibernateDaoSupport

chapter05 Spring對事務的支持

一、AOP事務的含義：

事務當作一個切面，動態地織入到目標對象，形成一個代理對象。

二、Spring的事務機制

Spring支持聲明式事務。

Spring使用事務服務代理和事務管理器（如HibernateTransactionManager）來支持事務服務。

Spring對事務的邊界多了一種嵌套事務（PROPAGATION_NESTED）。

PROPAGATION_NESTED：

如果客戶端啟動了事務T1，那么Bean啟動一個嵌套在T1中的子事務T2；

如果客戶端沒有啟動事務，那么Bean會啟動一個新的事務，類似于REQUIRED_NEW

三、Spring中事務的使用

1、Spring中使用Hibernate事務

Step1：配置數據源

Step2：配置sessionfactory (同上)

Step3：配置事務管理器

<bean id="myTransactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</property>

</bean>

Step4：創建事務服務代理

<bean id="saleService"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

<value>lab7.SaleService</value>

</property>

</property>

</property>

<props>

<prop key="*">PROPAGATION_REQUIRED</prop>

</props>

</property>

</bean>

事務屬性描述格式：

傳播行為，隔離級別，只讀事務(read-only)，回滾規則

在默認情況下，Spring的容器對于非受查異常（服務模塊中拋出的非受查異常），會回滾事務。對于受查異常，會提交事務。

如果即使發生了某種受查異常，也要回滾事務，可以用 “- 異常類型“來聲明。同樣，對于非受查異常，如果不要求回滾事務，可以用"+異常類型"來聲明。

如何簡化事務配置？

使用繼承（抽象的Service類）、自動代理。

四、Spring事務與EJB事務

1、EJB事務：

EJB的CMT管理事務方式，只能設置事務邊界（傳播行為），對于隔離性是不能設置的，并且EJB不支持嵌套事務。

2、Spring事務：

對于Spring來說， Spring的聲明式事務可以設置事務邊界（傳播行為），設置隔離級別，設置只讀事務，回滾規則（+：對于任何異常都提交，-：對于任何異常都回滾）

<props>

</property>

PS：Spring對嵌套事務的支持依賴與數據庫底層對嵌套式事務的支持。

chapter06 SSH整合

一、SSH：

Struts（表示層）+Spring（業務層）+Hibernate（持久層）

Struts：

Struts是一個表示層框架，主要作用是界面展示，接收請求，分發請求。

在MVC框架中，Struts屬于VC層次，負責界面表現，負責MVC關系的分發。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）

Hibernate：

Hibernate是一個持久層框架，它只負責與關系數據庫的操作。

Spring：

Spring是一個業務層框架，是一個整合的框架，能夠很好地黏合表示層與持久層。

① Web分層架構中業務層為什么都選擇Spring？

Service層需要處理業務邏輯和交叉業務邏輯，處理事務，日志，安全等，而這些與Spring的IoC，AOP等不謀而合。

② Web分層架構中，對于各層技術的采用應該遵循一個怎樣的標準？

1、選擇發展成熟的技術：

A、經過了項目實踐證實可行性良好

B、文檔完善

C、技術一直處于可持續發展更新

2、Web應用中對于技術的選擇有賴于開發人員的技術掌握情況

二、Spring與Struts整合

前提：

必須在Web應用啟動時，創建Spring的ApplicationContext實例

方式：

1、采用ContextLoaderListener來創建ApplicationContext：

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/spring-config/applicationContext.xml

</param-value>

</context-param>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

2、采用ContextLoaderPlugIn來創建ApplicationContext

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

<set-property property="contextConfigLocation" value="/WEB-INF/config/sale.xml" />

</plug-in>

或者：

通過listener裝載spring應用上下文

方式一：通過Spring的ActionSupport類

ActionSupport類：

知道ApplicationContext的獲得方式。

步驟：

1、Action直接繼承ActionSupport

2、使用ApplicationContext ctx = getWebApplicationContext();取得Spring上下文

3、取得相應Bean

注意：有可能需要替換commons-attributes-compiler.jar包。

優點：

簡單

缺點：

耦合高

違反IOC

無法使用多方法的Action

方式二：通過Spring的DelegatingActionProxy類

步驟：

1、Action中，使用IOC獲得服務

2、配置struts-config.xml

3、在Spring配置文件中

</bean>

注意，要用bean name命名。

/somepath:Action的path

優點：

不使用Spring api編寫 Action

利用了IOC裝配。

可以利用容器的scope="prototype"來保證每一個請求有一個單獨的Action來處理，

避免struts中Action的線程安全問題。

缺點：

struts配置文件中，所有path都映射到同一個代理類

方式三：通過Spring的DelegatingRequestProcessor類

步驟：

1、Action中，使用IOC獲得服務

2、配置struts-config.xml

3、在Spring配置文件中

</bean>

小結：

Spring與Struts整合方式只有兩種：

（1）由Spring容器來管理Action（方式二，方式三）

（2）Action處于容器之外（方式一）

注意：

中文問題：

設置過濾器，設置頁面編碼，數據庫編碼

三、關于Spring與EJB

1、Spring與EJB3.0的對比

Spring與EJB3.0之間的關系是競爭關系。

① Spring是一個開源的框架，而EJB3.0是一個標準（標準意味著將得到廣泛的支持以及良好的兼容性），并且，采用EJB3.0，項目的后期維護得到了保證。

② Spring是一個輕量級框架，EJB3.0是一個重量級框架（完整的容器，包含所有的服務）。

③ Spring的IoC，AOP集成了大量的開源框架，可擴展性良好。EJB3.0的可擴展性則完全依賴于新的容器。

④ Spring對事務支持不如EJB3.0成熟，Spring對集群的兼容也不夠。

⑤ Spring與EJB3.0都是一個企業級開發框架，都支持聲明式事務。

2、Spring的優勢與劣勢

Spring的優勢：

① 簡化了企業級開發（對企業級服務進行了進一步的封裝）

② 采用Spring框架的程序意味著良好的分層結構設計，并保證是面向接口編程的

③ 用IoC，AOP容器，模塊是可配置的，松耦合的，方便了后期維護

Spring的劣勢：

① 配置復雜，不方便維護

② 容器大量使用反射等機制裝配對象，影響性能，對于高并發的大型應用無能為力。

本文由用戶 openkk 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1329298931749.html

Spring JEE框架

Spring知識點總結大全

chapter01 Spring簡介

chapter02 Spring的IoC

chapter03 Spring的AOP

chapter04 Spring對持久層的支持

chapter05 Spring對事務的支持

chapter06 SSH整合

相關經驗

相關資訊

相關文檔

目錄