Spring的AOP

<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置Service -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 通知方法 -->
    <!-- 配置事務管理器-->
    <bean id="txManager" class="com.itheima.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <!-- 切面 -->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.itheima.service.impl.*.*(..))"/>

        <aop:aspect ref="txManager">
            <aop:before method="beginTransaction" pointcut-ref="pc"/>
            <aop:after-returning method="commit" pointcut-ref="pc"/>
            <aop:after-throwing method="rollback" pointcut-ref="pc"/>
            <aop:after method="release" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>

 

AOP（Aspect Oriented Programming）：面向切面編程

橫向重複，縱向抽取。

  簡單的說它就是把咱們程序重複的代碼抽取出來，在須要執行的時候，使用動態代理的技術，在不修改源碼的基礎上，對咱們的已有方法進行加強。

 

實現原理：動態代理；

       在咱們原始的控制事務中，ConnectionUtils類：控制單線程內只使用一個數據庫鏈接（connection）--->

TransactionManager類 :書寫方法：

　　1)打開手動提交事務conn.setAutoCommit(false)；

　　2)提交事務conn.commit()；

　　3)回滾事務conn.rollback()；

　　4)釋放當前數據庫鏈接（手寫）。--->

在業務層中，

try{

1)       

業務方法

2)

 }

catch(Throws t){  

 3) 

} finally{

 4)

}

       在每一個須要事務控制的方法都像這樣加上事務控制。

這樣書寫的業務層的代碼，過於臃腫，重複代碼過多。

 

使用動態代理：

      事先寫一個生成建立Service的代理對象的工廠類

/**
 * 用於建立Service的代理對象的工廠
 */
public class BeanFactory {

    private IAccountService accountService;

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    /**
     * 獲取Service代理對象
     * @return
     */
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事務的支持
                     *
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        Object rtValue = null;
                        try {
                            //1.開啓事務
                            txManager.beginTransaction();
                            //2.執行操做
                            rtValue = method.invoke(accountService, args);
                            //3.提交事務
                            txManager.commit();
                            //4.返回結果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滾操做
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.釋放鏈接
                            txManager.release();
                        }
                    }
                });

    }

BeanFactory 使用動態代理返回一個 IAccountService 對象並調用相應方法。

把這個建立的對象存入Spring容器中，並注入原來的 accountService 和 txManager（事務管理工具類）；

<!--配置beanfactory-->
<bean id="beanFactory" class="com.itheima.factory.BeanFactory">
    <!-- 注入service -->
    <property name="accountService" ref="accountService"></property>
    <!-- 注入事務管理器 -->
    <property name="txManager" ref="txManager"></property>
</bean>

把動態代理建立的 IAccountService ，也存入到 Spring 容器中。

<!--配置代理的service-->
<bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

測試方法：

/**
     * 使用Junit單元測試：測試咱們的配置
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:bean.xml")
    public class AccountServiceTest {

        @Autowired
        @Qualifier("proxyAccountService")
        private  IAccountService as;

        @Test
        public  void testTransfer(){
            as.transfer("aaa","bbb",100f);
        }
}

       在作業務層的事務控制時，可直接調用工廠類建立出的代理對象，實現事務控制，從而也使程序員在寫業務層時只管寫業務，而不用管事務代碼。

 

 

       固然咱們能想到這樣的辦法，spring也早就封裝好了，在書寫xml配置文件時更加簡潔，可觀。

 

AOP的使用

　　經過配置的方式實現上述功能，不用再本身書寫工廠類。

      

AOP的相關術語：

Joinpoint(鏈接點):

所謂鏈接點是指那些被攔截到的點。在spring中,這些點指的是方法,由於spring只支持方法類型的鏈接點。

Pointcut(切入點):

所謂切入點是指咱們要對哪些Joinpoint進行攔截的定義

Advice(通知/加強

所謂通知是指攔截到Joinpoint以後所要作的事情就是通知。

通知的類型：前置通知,後置通知,異常通知,最終通知,環繞通知。

Introduction(引介):

引介是一種特殊的通知在不修改類代碼的前提下, Introduction能夠在運行期爲類動態地添加一些方法或Field。

Target(目標對象):

代理的目標對象。

Weaving(織入):

是指把加強應用到目標對象來建立新的代理對象的過程。

spring採用動態代理織入，而AspectJ採用編譯期織入和類裝載期織入。

Proxy（代理）:

一個類被AOP織入加強後，就產生一個結果代理類。

Aspect(切面):

是切入點和通知（引介）的結合。

 

學習Spring中的AOP要明確的事

a、開發階段（咱們作的）

編寫核心業務代碼（開發主線）：大部分程序員來作，要求熟悉業務需求。

把公用代碼抽取出來，製做成通知。（開發階段最後再作）：AOP編程人員來作。

在配置文件中，聲明切入點與通知間的關係，即切面。：AOP編程人員來作。

b、運行階段（Spring框架完成的）

Spring框架監控切入點方法的執行。一旦監控到切入點方法被運行，使用代理機制，動態建立目標對象的代理對象，根據通知類別，在代理對象的對應位置，將通知對應的功能織入，完成完整的代碼邏輯運行。

 :

1.導包

 

 

 2.書寫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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置Service -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 通知方法 -->
    <!-- 配置事務管理器-->
    <bean id="txManager" class="com.itheima.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <!-- 切面 -->
    <aop:config>
        <aop:pointcut id="pc" expression="execution(* com.itheima.service.impl.*.*(..))"/>

        <aop:aspect ref="txManager">
            <aop:before method="beginTransaction" pointcut-ref="pc"/>
            <aop:after-returning method="commit" pointcut-ref="pc"/>
            <aop:after-throwing method="rollback" pointcut-ref="pc"/>
            <aop:after method="release" pointcut-ref="pc"/>
        </aop:aspect>
    </aop:config>

3.業務層代碼

public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根據名稱查詢轉出帳戶
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根據名稱查詢轉入帳戶
            Account target = accountDao.findAccountByName(targetName);
            //2.3轉出帳戶減錢
            source.setMoney(source.getMoney()-money);
            //2.4轉入帳戶加錢
            target.setMoney(target.getMoney()+money);
            //2.5更新轉出帳戶
            accountDao.updateAccount(source);

//            int i=1/0;

            //2.6更新轉入帳戶
            accountDao.updateAccount(target);
    }

4.測試

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {

    @Autowired
    @Qualifier("accountService")
    private  IAccountService as;

    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }
}

使用spring的AOP基於動態代理開發，簡潔的實現了該對象方法的加強，也就是實現了對轉帳的事務控制。

/**
      * 使用Junit單元測試：測試咱們的配置
      */
     @RunWith(SpringJUnit4ClassRunner.class)

    @ContextConfiguration(locations = "classpath:bean.xml")

    public class AccountServiceTest {



        @Autowired

        @Qualifier("proxyAccountService")

        private  IAccountService as;



        @Test

        public  void testTransfer(){

            as.transfer("aaa","bbb",100f);

        }
}