Spring第二天-動態代理與AOP

 

共性問題：

         1.服務器啓動報錯，什麼原因？

                   *jar包缺少、jar包衝突

                            1)先檢查項目中是否缺少jar包引用

                            2) 服務器:檢查jar包有沒有發佈到服務器下；

                                     用戶庫jar包，需要手動發佈到tomcat.(每次新建項目)

                            3)重新發布項目

 

                   *配置文件錯誤

                            (web.xml/ struts.xml /bean.xml /hibernate.xml / *.hbm.xml)

                            明確的提示

 

                   *端口占用

 

                   *webapps項目過多

                            當前項目沒有問題，有可能是其他項目出錯，這樣啓動也會報錯！但這個錯誤不是當前錯誤報的，所以不影響當前項目運行.

 

                   注意：

                            一般開發中，一個tomcat下只有一個項目。

                  

         2.一般啓動報錯： ClassNotFoundException異常

                   少jar包。

 

         3.訪問404，什麼原因？

                   1）客戶端路徑寫錯，或跳轉錯誤。

                   2）啓動報錯

                            Web項目中，啓動後一定要看下，是否報錯。

 

 

         4.點擊某個功能報錯。

                   後臺代碼錯誤：

                            à 找到頁面，點擊哪個操作，提交到哪個地址

                            --》後臺在提交地址的第一行打斷點

 

 

Spring提供了一站式解決方案：

         1） Spring Core  spring的核心功能： IOC容器, 解決對象創建及依賴關係

         2） Spring Web Spring對web模塊的支持。

                                                        -à 可以與struts整合,讓struts的action創建交給spring

                                                   -à spring mvc模式

         3） Spring DAO  Spring對jdbc操作的支持 【JdbcTemplate模板工具類】

         4） SpringORM  spring對orm的支持：

                                                        à 既可以與hibernate整合，【session】

                                                        à 也可以使用spring的對hibernate操作的封裝

         5）Spring AOP 切面編程

         6）SpringEE   spring 對javaEE其他模塊的支持

 

 

目標：

         1） 代理模式

                   靜態代理

                  動態代理

                   Cglib代理

         2）手動實現AOP編程 【代理模式】

         3）AOP編程

                    * 註解方式實現

                    * XMl配置方式實現

         4） Spring DAO 

                   Spring對jdbc操作的支持

 

 

1. 代理模式

1.1 概述

 代理（Proxy）是一種設計模式， 提供了對目標對象另外的訪問方式；即通過代理訪問目標對象。 這樣好處： 可以在目標對象實現的基礎上，增強額外的功能操作。(擴展目標對象的功能)。

舉例：明星（鄧紫棋）ß---經紀人<-------用戶 

             目標           （代理）

 

 

代理模式的關鍵點：代理對象與目標對象。

 

 

1.2 靜態代理

靜態代理，

         1） 代理對象，要實現與目標對象一樣的接口；

         2） 舉例:

                            保存用戶(模擬)

                                     Dao  ,  直接保存

                                     DaoProxy,給保存方法添加事務處理

 

 

 

 

 

 

總結靜態代理：

         1）可以做到在不修改目標對象的功能前提下，對目標對象功能擴展。

         2）缺點：

                   --》  因爲代理對象，需要與目標對象實現一樣的接口。所以會有很多代理類，類太多。

                   --》  一旦接口增加方法，目標對象與代理對象都要維護。

 

解決：

         代理工廠？  可以使用動態代理。

 

 

1.3 動態代理

動態代理，

         1）代理對象，不需要實現接口；

         2）代理對象的生成，是利用JDKAPI， 動態的在內存中構建代理對象(需要我們指定創建 代理對象/目標對象 實現的接口的類型；);

         3)  動態代理， JDK代理， 接口代理；

 

JDK中生成代理對象的API：

|-- Proxy

         staticObject newProxyInstance(

ClassLoader loader,       指定當前目標對象使用類加載器

 Class<?>[] interfaces,     目標對象實現的接口的類型

InvocationHandler h       事件處理器

) 

 

 

動態代理總結：

         代理對象不需要實現接口，但是目標對象一定要實現接口；否則不能用動態代理！
         (class  $Proxy0 implements IuserDao)

 

 

 

思考：

         有一個目標對象，想要功能擴展，但目標對象沒有實現接口，怎樣功能擴展？

         Class  UserDao{}

         //子類的方式

         Classsubclass  extends  UserDao{}

                                               

         以子類的方式實現(cglib代理)

 

 

1.4 Cglib代理

Cglib代理，也叫做子類代理。在內存中構建一個子類對象從而實現對目標對象功能的擴展。

 

l  JDK的動態代理有一個限制，就是使用動態代理的對象必須實現一個或多個接口。如果想代理沒有實現接口的類，就可以使用CGLIB實現。

l    CGLIB是一個強大的高性能的代碼生成包，它可以在運行期擴展Java類與實現Java接口。它廣泛的被許多AOP的框架使用，例如Spring AOP和dynaop，爲他們提供方法的interception（攔截）。

l   CGLIB包的底層是通過使用一個小而快的字節碼處理框架ASM，來轉換字節碼並生成新的類。不鼓勵直接使用ASM，因爲它要求你必須對JVM內部結構包括class文件的格式和指令集都很熟悉。

 

 

Cglib子類代理：

         1)需要引入cglib – jar文件，但是spring的核心包中已經包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

         2）引入功能包後，就可以在內存中動態構建子類

         3）代理的類不能爲final， 否則報錯。

         4） 目標對象的方法如果爲final/static,那麼就不會被攔截，即不會執行目標對象額外的業務方法。

 

        

在Spring的AOP編程中，

         如果加入容器的目標對象有實現接口，用JDK代理；

         如果目標對象沒有實現接口，用Cglib代理；

 

 

2. 手動實現AOP編程

AOP 面向切面的編程，

         AOP可以實現“業務代碼”與“關注點代碼”分離

 

// 保存一個用戶

public void add(User user) {

                   Session session = null;

                   Transaction trans = null;

                   try {

                            session = HibernateSessionFactoryUtils.getSession();   // 【關注點代碼】

                            trans = session.beginTransaction();    // 【關注點代碼】

                             

                            session.save(user);     // 核心業務代碼

                             

                            trans.commit();     //…【關注點代碼】

 

                   } catch (Exception e) {     

                            e.printStackTrace();

                            if(trans != null){

                                     trans.rollback();   //..【關注點代碼】

 

                            }

                   } finally{

                            HibernateSessionFactoryUtils.closeSession(session);   ////..【關注點代碼】

 

                   }

   }

 

 

分析總結：

         關注點代碼，就是指重複執行的代碼。

         業務代碼與關注點代碼分離，好處？

            --à 關注點代碼寫一次即可；

                   -à開發者只需要關注核心業務；

                   -à運行時期，執行核心業務代碼時候動態植入關注點代碼； 【代理】

 

 

如何分離？

         過程式/對象式/代理模式分離

 

 

 

3. AOP編程

3.1 概述：

Aop，  aspect objectprogramming  面向切面編程

         功能： 讓關注點代碼與業務代碼分離！

關注點,

         重複代碼就叫做關注點；

切面，

          關注點形成的類，就叫切面(類)！

          面向切面編程，就是指對很多功能都有的重複的代碼抽取，再在運行的時候網業務方法上動態植入“切面類代碼”。

切入點，

         執行目標對象方法，動態植入切面代碼。

         可以通過切入點表達式，指定攔截哪些類的哪些方法； 給指定的類在運行的時候植入切面類代碼。

 

3.2 註解方式實現AOP編程

步驟：

1） 先引入aop相關jar文件           （aspectj  aop優秀組件）                                      

         spring-aop-3.2.5.RELEASE.jar   【spring3.2源碼】

aopalliance.jar                              【spring2.5源碼/lib/aopalliance】

aspectjweaver.jar                         【spring2.5源碼/lib/aspectj】或【aspectj-1.8.2\lib】

aspectjrt.jar                                   【spring2.5源碼/lib/aspectj】或【aspectj-1.8.2\lib】

 

注意：用到spring2.5版本的jar文件，如果用jdk1.7可能會有問題。

                   需要升級aspectj組件，即使用aspectj-1.8.2版本中提供jar文件提供。

 

 

2） bean.xml中引入aop名稱空間

 

 

3） 開啓aop註解

 

4) 使用註解

@Aspect                                                              指定一個類爲切面類             

@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")  指定切入點表達式

 

@Before("pointCut_()")                                   前置通知: 目標方法之前執行

@After("pointCut_()")                                      後置通知：目標方法之後執行（始終執行）

@AfterReturning("pointCut_()")              返回後通知： 執行方法結束前執行(異常不執行)

@AfterThrowing("pointCut_()")                    異常通知:  出現異常時候執行

@Around("pointCut_()")                                  環繞通知： 環繞目標方法執行

 

 

1. IUserDao.java

// 接口

public interface IUserDao {

    void save();

}

 

2. UserDao.java

/**

 * 目標對象

 * @author Jie.Yuan

 *

 */

@Component   // 加入容器

public class UserDao implements IUserDao{

 

    @Override

    public void save() {

        System.out.println("-----核心業務：保存！！！------");

    }

}

 

3. Aop.java  切面類

 

@Component

@Aspect  // 指定當前類爲切面類

public class Aop {

 

    // 指定切入點表單式：攔截哪些方法；即爲哪些類生成代理對象

   

    @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")

    public void pointCut_(){

    }

   

    // 前置通知 :在執行目標方法之前執行

    @Before("pointCut_()")

    public void begin(){

        System.out.println("開始事務/異常");

    }

   

    // 後置/最終通知：在執行目標方法之後執行 【無論是否出現異常最終都會執行】

    @After("pointCut_()")

    public void after(){

        System.out.println("提交事務/關閉");

    }

   

    // 返回後通知：在調用目標方法結束後執行【出現異常不執行】

    @AfterReturning("pointCut_()")

    public void afterReturning() {

        System.out.println("afterReturning()");

    }

   

    // 異常通知：當目標方法執行異常時候執行此關注點代碼

    @AfterThrowing("pointCut_()")

    public void afterThrowing(){

        System.out.println("afterThrowing()");

    }

   

    // 環繞通知：環繞目標方式執行

    @Around("pointCut_()")

    public void around(ProceedingJoinPoint pjp) throws Throwable{

        System.out.println("環繞前....");

        pjp.proceed();  // 執行目標方法

        System.out.println("環繞後....");

    }

   

}

4. bean.xml

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="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"

    xmlns:aop="http://www.springframework.org/schema/aop"

    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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- 開啓註解掃描 -->

    <context:component-scanbase-package="cn.itcast.e_aop_anno"></context:component-scan>

   

    <!-- 開啓aop註解方式 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>  

 

 

App.java

 

public class App {

   

    ApplicationContext ac =

        new ClassPathXmlApplicationContext("cn/itcast/e_aop_anno/bean.xml");

 

    // 目標對象有實現接口，spring會自動選擇“JDK代理”

    @Test

    public void testApp() {

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

        System.out.println(userDao.getClass());

        userDao.save();

    }

   

    // 目標對象沒有實現接口， spring會用“cglib代理”

    @Test

    public void testCglib() {

        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");

        System.out.println(orderDao.getClass());

        orderDao.save();

    }

}

 

 

 

3.3 XML方式實現AOP編程

 

Xml實現aop編程：

         1） 引入jar文件  【aop 相關jar， 4個】

         2） 引入aop名稱空間

         3）aop 配置

                   *配置切面類 （重複執行代碼形成的類）

                   *aop配置

                            攔截哪些方法 / 攔截到方法後應用通知代碼

 

 

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="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"

    xmlns:aop="http://www.springframework.org/schema/aop"

    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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- dao 實例 -->

    <beanid="userDao"class="cn.itcast.f_aop_xml.UserDao"></bean>

    <beanid="orderDao"class="cn.itcast.f_aop_xml.OrderDao"></bean>

   

    <!-- 切面類 -->

    <beanid="aop"class="cn.itcast.f_aop_xml.Aop"></bean>

   

    <!-- Aop配置 -->

    <aop:config>

        <!-- 定義一個切入點表達式：攔截哪些方法 -->

        <aop:pointcutexpression="execution(* cn.itcast.f_aop_xml.*.*(..))"id="pt"/>

        <!-- 切面 -->

        <aop:aspectref="aop">

            <!-- 環繞通知 -->

            <aop:aroundmethod="around"pointcut-ref="pt"/>

            <!-- 前置通知：在目標方法調用前執行 -->

            <aop:beforemethod="begin"pointcut-ref="pt"/>

            <!-- 後置通知： -->

            <aop:aftermethod="after"pointcut-ref="pt"/>

            <!-- 返回後通知 -->

            <aop:after-returningmethod="afterReturning"pointcut-ref="pt"/>

            <!-- 異常通知 -->

            <aop:after-throwingmethod="afterThrowing"pointcut-ref="pt"/>

           

        </aop:aspect>

    </aop:config>

</beans> 

 

3.4  切入點表達式

切入點表達式,

         可以對指定的“方法”進行攔截；  從而給指定的方法所在的類生層代理對象。

 

 

 

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="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"

    xmlns:aop="http://www.springframework.org/schema/aop"

    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

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- dao 實例 -->

    <beanid="userDao"class="cn.itcast.g_pointcut.UserDao"></bean>

    <beanid="orderDao"class="cn.itcast.g_pointcut.OrderDao"></bean>

   

    <!-- 切面類 -->

    <beanid="aop"class="cn.itcast.g_pointcut.Aop"></bean>

   

    <!-- Aop配置 -->

    <aop:config>

       

        <!-- 定義一個切入點表達式：攔截哪些方法 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->

       

        <!-- 【攔截所有public方法】 -->

        <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->

       

        <!-- 【攔截所有save開頭的方法】 -->

        <!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->

       

        <!-- 【攔截指定類的指定方法,攔截時候一定要定位到方法】 -->

        <!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->

       

        <!-- 【攔截指定類的所有方法】 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->

       

        <!-- 【攔截指定包，以及其自包下所有類的所有方法】 -->

        <!--<aop:pointcut expression="execution(*cn..*.*(..))" id="pt"/>-->

       

        <!-- 【多個表達式】 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!-- 下面2個且關係的，沒有意義 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

       

        <!-- 【取非值】 -->

        <!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <aop:pointcutexpression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())"id="pt"/>

       

        <!-- 切面 -->

        <aop:aspectref="aop">

            <!-- 環繞通知 -->

            <aop:aroundmethod="around"pointcut-ref="pt"/>

        </aop:aspect>

    </aop:config>

</beans>   

 

 

 

4. Spring對jdbc支持

 

使用步驟：

         1）引入jar文件

spring-jdbc-3.2.5.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

         2） 優化