Spring框架IOC容器和AOP解析

阿新 • • 發佈：2019-01-10

主要分析點：

一、Spring開源框架的簡介

二、Spring下IOC容器和DI(依賴注入Dependency injection)

三、Spring下面向切面程式設計(AOP)和事務管理配置

一、Spring開源框架的簡介

Spring是一個開源框架，Spring是於2003 年興起的一個輕量級的Java 開發框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中闡述的部分理念和原型衍生而來。它是為了解決企業應用開發的複雜性而建立的。Spring使用基本的JavaBean來完成以前只可能由EJB完成的事情。然而，Spring的用途不僅限於伺服器端的開發。從簡單性、可測試性和鬆耦合的角度而言，任何Java應用都可以從Spring中受益。簡單來說，Spring是一個輕量級的控制反轉（IoC）和麵向切面（AOP）的容器框架。

spring的基本框架主要包含六大模組：DAO、ORM、AOP、JEE、WEB、CORE

Spring DAO：Spring提供了對JDBC的操作支援：JdbcTemplate模板工具類。

Spring ORM：Spring可以與ORM框架整合。例如Spring整合Hibernate框架，其中Spring還提供HibernateDaoSupport工具類，簡化了Hibernate的操作。

Spring WEB：Spring提供了對Struts、Springmvc的支援，支援WEB開發。與此同時Spring自身也提供了基於MVC的解決方案。

Spring AOP：Spring提供面向切面的程式設計，可以給某一層提供事務管理，例如在Service層新增事物控制。

Spring JEE：J2EE開發規範的支援，例如EJB 。

Spring Core：提供IOC容器物件的建立和處理依賴物件關係。

二、Spring下IOC容器和DI(依賴注入Dependency injection)

　　IOC容器：就是具有依賴注入功能的容器，是可以建立物件的容器，IOC容器負責例項化、定位、配置應用程式中的物件及建立這些物件間的依賴。通常new一個例項，控制權由程式設計師控制，而"控制反轉"是指new例項工作不由程式設計師來做而是交給Spring容器來做。。在Spring中BeanFactory是IOC容器的實際代表者。

　　DI(依賴注入Dependency injection)

：在容器建立物件後，處理物件的依賴關係。

　　依賴注入spring的注入方式：

- - set注入方式
  - 靜態工廠注入方式
  - 構造方法注入方式
  - 基於註解的方式

1、set注入方式：

控制層程式碼：

private OrderServiceImp orderService;
    
public void setOrderService(OrderServiceImp orderService) {
       this.orderService = orderService;
}

Spring配置XML檔案：其中配置宣告OrderAction類存在屬性orderService。程式執行時候，會將已經例項化的orderService物件呼叫setOrderService方式注入。

<bean name="orderAction" class="com.pec.action.OrderAction">
        <property name="orderService" ref="orderService"></property>
</bean>
<bean name="orderService" class="com.pec.service.imp.OrderServiceImp"></bean>

2、構造器注入方式：

控制層程式碼：

private OrderServiceImp orderService;
    
public OrderAction(OrderServiceImp orderService) {
        this.orderService = orderService;
    }

Spring配置XML檔案：

<bean name="orderAction" class="com.pec.action.OrderAction">
      <constructor-arg ref="orderService"></constructor-arg>
</bean>
<bean name="orderService" class="com.pec.service.imp.OrderServiceImp"></bean>

3、基於註解的方式（推薦使用，比較便捷少配置）

控制層程式碼：

@Autowired   //@Resource
private OrderServiceImp orderService;

服務層程式碼：

@Service("orderService")
public class OrderServiceImp implements IOrderService {

    @Autowired
    private JavaOrderMDaoImp javaOrderMDao;

    @Autowired
    private JavaOrderDDaoImp javaOrderDDao;

    @Override
    public List<JavaOrderMList> findOrderM(OrderSearch search) {
        return javaOrderMDao.findJavaOrderM(search);
    }

    @Override
    public List<JavaOrderDList> findOrderD(OrderSearch search) {
        return javaOrderDDao.findJavaOrderD(search);
    }

}

DAO層程式碼：

@Repository("javaOrderMDao")
public class JavaOrderMDaoImp extends BaseHibernateDAO<JavaOrderM, Serializable> implements IJavaOrderMDao {...}

@Repository("javaOrderDDao")
public class JavaOrderDDaoImp extendsBaseHibernateDAO<JavaOrderD, Serializable> implements IJavaOrderDDao {...}

注意點：

　　⑴ 持久層DAO層註解Repository中規定了名稱，在Service層中宣告名稱必須一致。

　　⑵ 服務層Service層註解Service中規定了名稱，在控制層中宣告的名稱必須一致。

　　⑶ 註解方式注入依賴註解：

@Component         把物件加入ioc容器，物件引用名稱是類名，第一個字母小寫
@Component(“name”) 把指定名稱的物件，加入ioc容器
@Repository        主要用於標識加入容器的物件是一個持久層的元件(類)
@Service           主要用於標識加入容器的物件是一個業務邏輯層的元件
@Controller        主要用於標識加入容器的物件是一個控制層的元件
@Resource          注入屬性(DI), 會從容器中找物件注入到@Resource修飾的物件上
@Autowired         注入屬性(DI), 會從容器中找物件注入到@Autowired修飾的物件上

　　 ⑷ 註解可以簡化配置，提升開發效率，但是也不利於後期維護。

三、Spring下面向切面程式設計(AOP)和事務管理配置

　　AOP就是縱向的程式設計，如業務1和業務2都需要一個共同的操作，與其往每個業務中都新增同樣的程式碼，不如寫一遍程式碼，讓兩個業務共同使用這段程式碼。在日常有訂單管理、商品管理、資金管理、庫存管理等業務，都會需要到類似日誌記錄、事務控制、許可權控制、效能統計、異常處理及事務處理等。AOP把所有共有程式碼全部抽取出來，放置到某個地方集中管理，然後在具體執行時，再由容器動態織入這些共有程式碼。

AOP涉及名稱：

切面（Aspect）：其實就是共有功能的實現。如日誌切面、許可權切面、事務切面等。在實際應用中通常是一個存放共有功能實現的普通Java類，之所以能被AOP容器識別成切面，是在配置中指定的。

通知（Advice）：是切面的具體實現。以目標方法為參照點，根據放置的地方不同，可分為前置通知（Before）、後置通知（AfterReturning）、異常通知（AfterThrowing）、最終通知（After）與環繞通知（Around）5種。在實際應用中通常是切面類中的一個方法，具體屬於哪類通知，同樣是在配置中指定的。

連線點（Joinpoint）：就是程式在執行過程中能夠插入切面的地點。例如，方法呼叫、異常丟擲或欄位修改等，但Spring只支援方法級的連線點。

切入點（Pointcut）：用於定義通知應該切入到哪些連線點上。不同的通知通常需要切入到不同的連線點上，這種精準的匹配是由切入點的正則表示式來定義的。

目標物件（Target）：就是那些即將切入切面的物件，也就是那些被通知的物件。這些物件中已經只剩下乾乾淨淨的核心業務邏輯程式碼了，所有的共有功能程式碼等待AOP容器的切入。

代理物件（Proxy）：將通知應用到目標物件之後被動態建立的物件。可以簡單地理解為，代理物件的功能等於目標物件的核心業務邏輯功能加上共有功能。代理物件對於使用者而言是透明的，是程式執行過程中的產物。

織入（Weaving）：將切面應用到目標物件從而建立一個新的代理物件的過程。這個過程可以發生在編譯期、類裝載期及執行期，當然不同的發生點有著不同的前提條件。譬如發生在編譯期的話，就要求有一個支援這種AOP實現的特殊編譯器；發生在類裝載期，就要求有一個支援AOP實現的特殊類裝載器；只有發生在執行期，則可直接通過Java語言的反射機制與動態代理機制來動態實現。

　　Spring使用AOP配置事務管理由三個部分組成，分別是DataSource、TransactionManager和代理機制這三部分，無論哪種配置方式，一般變化的只是代理機制這部分。DataSource、TransactionManager這兩部分只是會根據資料訪問方式有所變化，比如使用hibernate進行資料訪問時，DataSource實際為SessionFactory，TransactionManager的實現為HibernateTransactionManager。

spring事務配置的五種方式：每個Bean都有一個代理、所有Bean共享一個代理基類、使用攔截器、使用tx標籤配置的攔截器、全註解

1、使用tx標籤配置的攔截器

<!--4、配置hibernate屬性 -->
    <!--引入db.properties屬性檔案 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="classpath:db.properties"></property>
    </bean>
    <!-- 配置資料來源，連線池使用c3p0,詳細資訊參見hibernate官方文件"基礎配置章節" -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
        destroy-method="close" dependency-check="none">
        <property name="driverClass">
            <value>${datasource.driverClassName}</value>
        </property>
        <property name="jdbcUrl">
            <value>${datasource.url}</value>
        </property>
        <property name="user">
            <value>${datasource.username}</value>
        </property>
        <property name="password">
            <value>${datasource.password}</value>
        </property>
        <property name="acquireIncrement">
            <!--當連線池中的連線耗盡的時候c3p0一次同時獲取的連線數。Default: 3 -->
            <value>${c3p0.acquireIncrement}</value>
        </property>
        <property name="initialPoolSize">
            <!--初始化時獲取的連線數，取值應在minPoolSize與maxPoolSize之間。Default: 3 -->
            <value>${c3p0.initialPoolSize}</value>
        </property>
        <property name="minPoolSize">
            <!--連線池中保留的最小連線數。 -->
            <value>${c3p0.minPoolSize}</value>
        </property>
        <property name="maxPoolSize">
            <!--連線池中保留的最大連線數。Default: 15 -->
            <value>${c3p0.maxPoolSize}</value>
        </property>
        <property name="maxIdleTime">
            <!--最大空閒時間,60秒內未使用則連線被丟棄。若為0則永不丟棄。Default: 0 -->
            <value>${c3p0.maxIdleTime}</value>
        </property>
        <property name="idleConnectionTestPeriod">
            <!--每60秒檢查所有連線池中的空閒連線。Default: 0 -->
            <value>${c3p0.idleConnectionTestPeriod}</value>
        </property>
        <property name="maxStatements">
            <!-- JDBC的標準引數，用以控制資料來源內載入的PreparedStatements數量。但由於預快取的statements 屬於單個connection而不是整個連線池。所以設定這個引數需要考慮到多方面的因素。 
                如果maxStatements與maxStatementsPerConnection均為0，則快取被關閉。Default: 0 -->
            <value>${c3p0.maxStatements}</value>
        </property>
        <property name="numHelperThreads">
            <!-- C3P0是非同步操作的，緩慢的JDBC操作通過幫助程序完成。擴充套件這些操作可以有效的提升效能， 通過多執行緒實現多個操作同時被執行。Default: 
                3 -->
            <value>${c3p0.numHelperThreads}</value>
        </property>
    </bean>

    <!--配置 sessionFactory -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <property name="dataSource" ref="dataSource">
        </property>
        <!-- hibernate的設定 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql"> ${hibernate.show_sql} </prop>
                <prop key="hibernate.jdbc.fetch_size">${hibernate.jdbc.fetch_size}</prop>
                <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
                <prop key="hibernate.connection.release_mode">${hibernate.connection.release_mode}</prop>
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <prop key="hibernate.connection.SetBigStringTryClob">true</prop>
            </props>
        </property>
        <!-- anotation註解掃描實體類 -->
        <property name="packagesToScan">
            <list>
                <value>com.pec.model</value>
            </list>
        </property>
    </bean>

    <!--5、Spring 配置宣告式事物 -->
    
    <!-- 配置事務 -->
    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    
    <!-- 配置事務範圍 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="get*" read-only="false" propagation="NOT_SUPPORTED" />
            <tx:method name="find*" read-only="false" propagation="NOT_SUPPORTED" />
            <tx:method name="save*" propagation="REQUIRED" />
            <tx:method name="update*" propagation="REQUIRED" />
            <tx:method name="delete*" propagation="REQUIRED" />
            <tx:method name="create*" propagation="REQUIRED" />
            <tx:method name="anscy*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>
    
    <!-- 定義切面 -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="pointcut" expression="execution(* com.pec.service..*.*(..))"  />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

有幾點需要說明：

⑴ pointcut中的三個"*"中，第一個*代表返回值，第二*代表service下子包，第三個*代表方法名，“（..）”代表方法引數。

⑵ 此時配置的切點在Service層，方法命名需要按照以上advice通知點開頭命名。

⑶ 按照規定命名方法，會受到Spring事務的管控，保持操作的一致性。例如向資料庫插入100條資料，前面99條記錄都正常執行直至第100條出現錯誤，則事務管控會回滾到執行前的初始狀態。

2、使用Bean代理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/tx 
      http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
      http://www.springframework.org/schema/aop 
      http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
      default-autowire="default">
    
    <!-- <bean name="userManager" class="com.tgb.manager.UserManagerImpl"></bean>
    <bean name="userController" class="com.tgb.web.UserController">
        <property name="userManager" ref="userManager"></property>
    </bean> -->
    <context:component-scan base-package="com.tgb.dao" />
    <context:component-scan base-package="com.tgb.entity" />
    <context:component-scan base-package="com.tgb.manager" />
    <context:component-scan base-package="com.tgb.web" />
    
    <!-- 引入init.properties中屬性 -->
    <bean id="placeholderConfig" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
        <list>
            <value>classpath:config/spring/jdbc.properties</value>
        </list>
        </property>
    </bean>
    
    <!-- 配置資料來源，連線池使用c3p0,詳細資訊參見hibernate官方文件"基礎配置章節" -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
        <property name="driverClass" value="${datasource.driverClassName}"></property>
        <property name="jdbcUrl" value="${datasource.url}"></property>
        <property name="user" value="${datasource.username}"></property>
        <property name="password" value="${datasource.password}"></property>
    </bean>
    
    <!-- 配置SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">
                    ${hibernate.dialect}
                </prop>
                <prop key="hibernate.show_sql"> 
                    ${hibernate.show_sql} 
                </prop>
                <prop key="hibernate.jdbc.fetch_size">
                    ${hibernate.jdbc.fetch_size}
                </prop>
                <prop key="hibernate.jdbc.batch_size">
                    ${hibernate.jdbc.batch_size}
                </prop>
                <prop key="hibernate.connection.release_mode">
                    ${hibernate.connection.release_mode}
                </prop>
                <prop key="hibernate.format_sql">
                    ${hibernate.format_sql}
                </prop>
                <prop key="hibernate.connection.SetBigStringTryClob">true</prop>
            </props>
        </property>
        <!-- anotation註解掃描實體類  -->
        <property name="annotatedClasses">
            <list>
                <value>com.tgb.entity.User</value>
            </list>
        </property>
    </bean>

    <!-- 配置一個事務管理器 將事務與Hibernate關聯-->
    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    
    <!-- 配置事務範圍，使用代理的方式 -->
    <bean id="transactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">  
        <!--   為事務代理bean注入事務管理器--> 
        <property name="transactionManager" >
            <ref bean="transactionManager"/>
        </property>  
         <!--設定事務屬性範圍-->  
        <property name="transactionAttributes">  
            <props>  
                <prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>  
                <prop key="get">PROPAGATION_REQUIRED,-Exception</prop> 
                <prop key="update*">PROPAGATION_REQUIRED,-myException</prop>  
                <prop key="del*">PROPAGATION_REQUIRED</prop>  
                <prop key="*">PROPAGATION_REQUIRED</prop>      
            </props>  
        </property>  
    </bean> 
    
    <bean id="userDao" class="com.tgb.dao.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>

    <bean id="userManagerBase" class="com.tgb.manager.UserManagerImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
    
    <!-- 此處為代理 -->
    <bean name="userManager" parent="transactionProxy">
        <property name="target" ref="userManagerBase"></property>
    </bean>    
     
</beans>

Spring框架IOC容器和AOP解析

Spring框架IOC容器和AOP解析

spring框架IOC容器和AOC解析

Spring框架—— IOC容器和Bean的配置

Spring框架之IOC容器和AOP詳解

SpringMVC系列（十五）Spring MVC與Spring整合時實例被創建兩次的解決方案以及Spring 的 IOC 容器和 SpringMVC 的 IOC 容器的關系

Spring的IOC,DI和AOP（不看後悔，一看必懂）

Spring框架IOC容器

spring框架---IOC容器

spring框架 IOC容器的理解

Spring 的 IOC 容器和 SpringMVC 的 IOC 容器關係

Spring框架——關於IOC容器和註解的36個小實驗

Spring的IOC容器原始碼學習----Bean的定位，載入，解析，註冊，注入

深入解讀Spring Framework IoC容器（第四彈：p名稱空間和c名稱空間）

Spring核心技術（一）——IoC容器和Bean簡介

Spring IoC 容器和 bean 物件

【spring源碼學習】spring的IOC容器之BeanFactoryPostProcessor接口學習

Spring框架IOC，DI概念理解

Spring框架（四）AOP面向切面編程

【Java框架型項目從入門到裝逼】第一節 - Spring框架 IOC的喪心病狂解說

Spring中IOC容器對數組，集合的相關bean的裝配

Spring框架IOC容器和AOP解析

相關推薦