Spring基礎知識（二）

Spring_day02總結

今日內容

l AOP的概述

l AOP 的底層實現

l Spring 的AOP

l 使用AspectJ 實現AOP

l Spring JdbcTemplate 使用

1.1 上次課的內容回顧:

第一天:Spring的IOC.Spring就是一個大的工廠,通過工廠對Bean進行管理.

* Spring的概述:

* Spring的環境搭建:

* Spring中的IOC:

* IOC:控制反轉.將對象的創建權交給Spring管理.

* DI:依賴注入.在由Spring創建的對象的時候,將對象依賴的對象注入進來.

* IOC的Bean裝配(XML):

* 定義類:

* <bean id=”標識” class=”類的全路徑”>

* 其他的屬性:

* id和name:

* id:滿足XMLid約束語法,裏面不能出現特殊的字符.

* name:可以出現特殊的字符.

***** 如果配置<bean>標籤的時候,如果只配置了name,就可以將這個name的值作爲id.

* scope:類的作用範圍.

* Bean的生命週期:

* init-method:

* destroy-method:

* Bean的完整生命週期:

* 後處理Bean.增強

* 注入屬性:

* <property name=”” value=””>

* <property name=”” ref=””>

* IOC的Bean裝配(註解):

* 定義類:

* 注入屬性:

* Spring框架與web整合.

* Spring整合JUnit單元測試.

第二天Spring的AOP.JdbcTemplate.

1.2 AOP的概述:

1.2.1 什麼是AOP:

AOP Aspect Oriented Programing 面向切面編程

AOP採取橫向抽取機制，取代了傳統縱向繼承體系重複性代碼（性能監視、事務管理、安全檢查、緩存）

Spring AOP使用純Java實現，不需要專門的編譯過程和類加載器，在運行期通過代理方式向目標類織入增強代碼

AspecJ是一個基於Java語言的AOP框架，Spring2.0開始，Spring AOP引入對Aspect的支持，AspectJ擴展了Java語言，提供了一個專門的編譯器，在編譯時提供橫向代碼的織入

1.2.2 AOP底層原理;

就是代理機制:

* 動態代理:(JDK中使用)

* JDK的動態代理,對實現了接口的類生成代理.

1.2.3 Spring的AOP代理:

JDK動態代理:對實現了接口的類生成代理

CGLib代理機制:對類生成代理

1.2.4 AOP的術語:

Joinpoint(連接點):所謂連接點是指那些被攔截到的點。在spring中,這些點指的是方法,因爲spring只支持方法類型的連接點.

Pointcut(切入點):所謂切入點是指我們要對哪些Joinpoint進行攔截的定義.

Advice(通知/增強):所謂通知是指攔截到Joinpoint之後所要做的事情就是通知.通知分爲前置通知,後置通知,異常通知,最終通知,環繞通知(切面要完成的功能)

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

Target(目標對象):代理的目標對象

Weaving(織入):是指把增強應用到目標對象來創建新的代理對象的過程.

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

Proxy（代理）:一個類被AOP織入增強後，就產生一個結果代理類

Aspect(切面): 是切入點和通知（引介）的結合

1.3 AOP的底層實現

1.3.1 JDK動態代理:

public class JDKProxy implements InvocationHandler{

private UserDao userDao;

public JDKProxy(UserDao userDao) {

super();

this.userDao = userDao;

}

public UserDao createProxy() {

UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass()

.getClassLoader(), userDao.getClass().getInterfaces(), this);

return proxy;

}

// 調用目標對象的任何一個方法都相當於調用invoke();

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

if("add".equals(method.getName())){

// 記錄日誌:

System.out.println("日誌記錄=================");

Object result = method.invoke(userDao, args);

return result;

}

return method.invoke(userDao, args);

}

1.3.2 CGLIB動態代理:

CGLIB(Code Generation Library)是一個開源項目！是一個強大的，高性能，高質量的Code生成類庫，它可以在運行期擴展Java類與實現Java接口。 Hibernate支持它來實現PO(Persistent Object 持久化對象)字節碼的動態生成

Hibernate生成持久化類的javassist.

CGLIB生成代理機制:其實生成了一個真實對象的子類.

下載cglib的jar包.

* 現在做cglib的開發,可以不用直接引入cglib的包.已經在spring的核心中集成cglib.

public class CGLibProxy implements MethodInterceptor{

private ProductDao productDao;

public CGLibProxy(ProductDao productDao) {

super();

this.productDao = productDao;

}

public ProductDao createProxy(){

// 使用CGLIB生成代理:

// 1.創建核心類:

Enhancer enhancer = new Enhancer();

// 2.爲其設置父類:

enhancer.setSuperclass(productDao.getClass());

// 3.設置回調:

enhancer.setCallback(this);

// 4.創建代理:

return (ProductDao) enhancer.create();

}

public Object intercept(Object proxy, Method method, Object[] args,

MethodProxy methodProxy) throws Throwable {

if("add".equals(method.getName())){

System.out.println("日誌記錄==============");

Object obj = methodProxy.invokeSuper(proxy, args);

return obj;

}

return methodProxy.invokeSuper(proxy, args);

}

結論:Spring框架,如果類實現了接口,就使用JDK的動態代理生成代理對象,如果這個類沒有實現任何接口,使用CGLIB生成代理對象.

1.4 Spring中的AOP

1.4.1 Spring的傳統AOP :

AOP:不是由Spring定義.AOP聯盟的組織定義.

Spring中的通知:(增強代碼)

前置通知 org.springframework.aop.MethodBeforeAdvice

* 在目標方法執行前實施增強

後置通知 org.springframework.aop.AfterReturningAdvice

* 在目標方法執行後實施增強

環繞通知 org.aopalliance.intercept.MethodInterceptor

* 在目標方法執行前後實施增強

異常拋出通知 org.springframework.aop.ThrowsAdvice

* 在方法拋出異常後實施增強

引介通知 org.springframework.aop.IntroductionInterceptor(課程不講.)

* 在目標類中添加一些新的方法和屬性

1.4.2 Spring中的切面類型:

Advisor : Spring中傳統切面.

* Advisor:都是有一個切點和一個通知組合.

* Aspect:多個切點和多個通知組合.

Advisor : 代表一般切面，Advice本身就是一個切面，對目標類所有方法進行攔截(* 不帶有切點的切面.針對所有方法進行攔截)

PointcutAdvisor : 代表具有切點的切面，可以指定攔截目標類哪些方法(帶有切點的切面,針對某個方法進行攔截)

IntroductionAdvisor : 代表引介切面，針對引介通知而使用切面（不要求掌握）

1.4.3 Spring的AOP的開發:

針對所有方法的增強:(不帶有切點的切面)

第一步:導入相應jar包.

* spring-aop-3.2.0.RELEASE.jar

* com.springsource.org.aopalliance-1.0.0.jar

第二步:編寫被代理對象:

* CustomerDao接口

* CustoemrDaoImpl實現類

第三步:編寫增強的代碼:

public class MyBeforeAdvice implements MethodBeforeAdvice{

/**

* method:執行的方法

* args:參數

* target:目標對象

public void before(Method method, Object[] args, Object target)

throws Throwable {

System.out.println("前置增強...");

}

第四步:生成代理:(配置生成代理:)

* 生成代理Spring基於ProxyFactoryBean類.底層自動選擇使用JDK的動態代理還是CGLIB的代理.

* 屬性:

target : 代理的目標對象

proxyInterfaces : 代理要實現的接口

如果多個接口可以使用以下格式賦值

<list>

....

</list>

proxyTargetClass : 是否對類代理而不是接口，設置爲true時，使用CGLib代理

interceptorNames : 需要織入目標的Advice

singleton : 返回代理是否爲單實例，默認爲單例

optimize : 當設置爲true時，強制使用CGLib

</bean>

***** 注入的時候要注入代理對象:

@Autowired

// @Qualifier("customerDao")// 注入是真實的對象,必須注入代理對象.

@Qualifier("customerDaoProxy")

private CustomerDao customerDao;

帶有切點的切面:(針對目標對象的某些方法進行增強)

PointcutAdvisor 接口:

DefaultPointcutAdvisor 最常用的切面類型，它可以通過任意Pointcut和Advice 組合定義切面

RegexpMethodPointcutAdvisor 構造正則表達式切點切面

第一步:創建被代理對象.

* OrderDao

第二步:編寫增強的類:

public class MyAroundAdvice implements MethodInterceptor{

public Object invoke(MethodInvocation methodInvocation) throws Throwable {

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

Object result = methodInvocation.proceed();// 執行目標對象的方法

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

return result;

}

第三步:生成代理:

</bean>

</bean>

1.4.4 自動代理:

前面的案例中，每個代理都是通過ProxyFactoryBean織入切面代理，在實際開發中，非常多的Bean每個都配置ProxyFactoryBean開發維護量巨大

自動創建代理(*****基於後處理Bean.在Bean創建的過程中完成的增強.生成Bean就是代理.)

BeanNameAutoProxyCreator 根據Bean名稱創建代理

DefaultAdvisorAutoProxyCreator 根據Advisor本身包含信息創建代理

* AnnotationAwareAspectJAutoProxyCreator 基於Bean中的AspectJ 註解進行自動代理

BeanNameAutoProxyCreator :按名稱生成代理

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

<property name="beanNames" value="*Dao"/>

<property name="interceptorNames" value="beforeAdvice"/>

</bean>

DefaultAdvisorAutoProxyCreator :根據切面中定義的信息生成代理

<bean id="myPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">

<property name="pattern" value=".*add.*"/>

<property name="advice" ref="aroundAdvice"/>

</bean>

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"></bean>

區分基於ProxyFattoryBean的代理與自動代理區別?

***** ProxyFactoryBean:先有被代理對象,將被代理對象傳入到代理類中生成代理.

自動代理基於後處理Bean.在Bean的生成過程中,就產生了代理對象,把代理對象返回.生成Bean已經是代理對象.

1.5 Spring的AspectJ的AOP(*)

AspectJ是一個面向切面的框架，它擴展了Java語言。AspectJ定義了AOP語法所以它有一個專門的編譯器用來生成遵守Java字節編碼規範的Class文件。

AspectJ是一個基於Java語言的AOP框架

Spring2.0以後新增了對AspectJ切點表達式支持

@AspectJ 是AspectJ1.5新增功能，通過JDK5註解技術，允許直接在Bean類中定義切面

新版本Spring框架，建議使用AspectJ方式來開發AOP

AspectJ表達式:

* 語法:execution(表達式)

execution(<訪問修飾符>?<返回類型><方法名>(<參數>)<異常>)

* execution(“* cn.itcast.spring3.demo1.dao.*(..)”)---只檢索當前包

* execution(“* cn.itcast.spring3.demo1.dao..*(..)”)---檢索包及當前包的子包.

* execution(* cn.itcast.dao.GenericDAO+.*(..))---檢索GenericDAO及子類

AspectJ增強:

@Before 前置通知，相當於BeforeAdvice

@AfterReturning 後置通知，相當於AfterReturningAdvice

@Around 環繞通知，相當於MethodInterceptor

@AfterThrowing拋出通知，相當於ThrowAdvice

@After 最終final通知，不管是否異常，該通知都會執行

@DeclareParents 引介通知，相當於IntroductionInterceptor (不要求掌握)

1.5.1 基於註解:

第一步:引入相應jar包.

* aspectj依賴aop環境.

* spring-aspects-3.2.0.RELEASE.jar

* com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

第二步:編寫被增強的類:

* UserDao

第三步:使用AspectJ註解形式:

@Aspect

public class MyAspect {

@Before("execution(* cn.itcast.spring3.demo1.UserDao.add(..))")

public void before(){

System.out.println("前置增強....");

}

第四步:創建applicationContext.xml

* 引入aop的約束:

* <aop:aspectj-autoproxy /> --- 自動生成代理:

* 底層就是AnnotationAwareAspectJAutoProxyCreator

<aop:aspectj-autoproxy />

AspectJ的通知類型:

@Before 前置通知，相當於BeforeAdvice

* 就在方法之前執行.沒有辦法阻止目標方法執行的.

@AfterReturning 後置通知，相當於AfterReturningAdvice

* 後置通知,獲得方法返回值.

@Around 環繞通知，相當於MethodInterceptor

* 在可以方法之前和之後來執行的,而且可以阻止目標方法的執行.

@AfterThrowing拋出通知，相當於ThrowAdvice

@After 最終final通知，不管是否異常，該通知都會執行

@DeclareParents 引介通知，相當於IntroductionInterceptor (不要求掌握)

切點的定義:

@Pointcut("execution(* cn.itcast.spring3.demo1.UserDao.find(..))")

private void myPointcut(){}

面試:

* Advisor和Aspect的區別?

* Advisor:Spring傳統意義上的切面:支持一個切點和一個通知的組合.

* Aspect:可以支持多個切點和多個通知的組合.

1.5.2 基於XML:

第一步:編寫被增強的類:

* ProductDao

第二步:定義切面

第三步:配置applicationContext.xmll

前置通知:

* 代碼:

public void before(){

System.out.println("前置通知...");

}

* 配置:

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">

<aop:before method="before" pointcut-ref="mypointcut"/>

</aop:aspect>

</aop:config>

後置通知:

* 代碼:

public void afterReturing(Object returnVal){

System.out.println("後置通知...返回值:"+returnVal);

}

* 配置:

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">

<aop:after-returning method="afterReturing" pointcut-ref="mypointcut" returning="returnVal"/>

</aop:aspect>

</aop:config>

環繞通知:

* 代碼:

public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

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

Object result = proceedingJoinPoint.proceed();

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

return result;

}

* 配置:

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">

<aop:around method="around" pointcut-ref="mypointcut"/>

</aop:aspect>

</aop:config>

異常通知:

* 代碼;

public void afterThrowing(Throwable e){

System.out.println("異常通知..."+e.getMessage());

}

* 配置;

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">

<aop:after-throwing method="afterThrowing" pointcut-ref="mypointcut" throwing="e"/>

</aop:aspect>

</aop:config>

最終通知:

* 代碼:

public void after(){

System.out.println("最終通知....");

}

* 配置:

<aop:config>

<aop:pointcut expression="execution(* cn.itcast.spring3.demo2.ProductDao.add(..))" id="mypointcut"/>

<aop:aspect ref="myAspectXML">

<aop:after method="after" pointcut-ref="mypointcut"/>

</aop:aspect>

</aop:config>

1.6 Spring的JdbcTemplate

JdbcTemplate模板與DbUtils工具類比較類似.

1.6.1 Spring對持久層技術支持:

JDBC:org.springframework.jdbc.core.JdbcTemplate

Hibernate3.0:org.springframework.orm.hibernate3.HibernateTemplate

IBatis(MyBatis):org.springframework.orm.ibatis.SqlMapClientTemplate

JPA:org.springframework.orm.jpa.JpaTemplate

1.6.2 開發JDBCTemplate入門:

第一步:引入相應jar包:

* spring-tx-3.2.0.RELEASE.jar

* spring-jdbc-3.2.0.RELEASE.jar

* mysql驅動.

第二步:創建applicationContext.xml

第三步:編寫一個測試類:

1.6.3 配置連接池:

Spring默認的連接池:

</bean>

DBCP連接池:

導入jar包:

* com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar

* com.springsource.org.apache.commons.pool-1.5.3.jar

</bean>

C3P0連接池:

導入jar包:

* com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar

</bean>

1.6.4 參數設置到屬性文件中:

在src下創建jdbc.properties

jdbc.driver = com.mysql.jdbc.Driver

jdbc.url = jdbc:mysql:///spring3_day02

jdbc.user = root

jdbc.password = 123

需要在applicationContext.xml 中使用屬性文件配置的內容.

* 第一種寫法:

</bean>

* 第二種寫法:

<context:property-placeholder location="classpath:jdbc.properties"/>

1.6.5 JdbcTemplate的CRUD的操作:

Spring框架中提供了對持久層技術支持的類:

JDBC:org.springframework.jdbc.core.support.JdbcDaoSupport

Hibernate 3.0:org.springframework.orm.hibernate3.support.HibernateDaoSupport

iBatis:org.springframework.orm.ibatis.support.SqlMapClientDaoSupport

編寫DAO的時候:

Public class UserDao extends JdbcDaoSupport{

}

進行CRUD的操作;

* 保存:update(String sql,Object... args)

* 修改:update(String sql,Object... args)

* 刪除:update(String sql,Object... args)

查詢:

* 簡單查詢:

* select count(*) from user;--- queryForInt(String sql);

* select name from user where id = ?;--- queryForObject(String sql,Class clazz,Object... args);

* 複雜查詢:(返回對象,和對象集合)

* select * from user where id = ?--- queryForObjectString sql,RowMapper<T> rowMapper,Object... args);

* select * from user;--- query(String sql,RowMapper<T> rowMapper,Object... args);

今天的內容總結:

Spring AOP

* AOP:面向切面編程.不是替代面向對象,對面向對象擴展,延伸.

* AOP的思想:

* 代理機制.(橫向抽取).

* Spring使用AOP的時候,根據類的情況,自動選擇代理機制:

* JDK:針對實現了接口的類生成代理.

* CGLIB:針對沒有實現接口的類生成代理.生成某個類的子類.

* Spring的AOP的開發中:

* 術語 :

* JoinPoint:連接點.可以被增強的方法.

* PointCut:切入點.真正被增強的方法.

* Advice:通知.增強的代碼.

* Target:目標對象.被增強的類.

* Weaving:

* Aspect:切面.在切入點應用增強.

* 傳統的Spring AOP.

* 不帶切點的切面:

* 帶有切點的切面:

* 生成代理:基於ProxyFactoryBean.

* 缺點;每個類都需要配置ProxyFactroyBean.

* 自動代理:(基於後處理Bean)

* Bean名稱自動代理:

* 切面信息自動代理:

* Spring中AspectJ的支持.

* 爲了簡便開發引入AspectJ的支持.

* 註解:

* @Aspect:

* @Before

* @Around

* @AfterReturing

* @AfterThrowing

* @After

* PointCut

* XML:

* 引入aop約束:

<aop-config>

<aop:pointcut id=”” expression=””/>

<aop:aspect ref=””>

<aop:before />

</aop:aspect>

</aop-config>

Spring JDBCTemplate:

* 配置連接池:

* 默認的:

* DBCP:

* C3P0:(*****)

* 提取了properties

* JdbcTemplate的CRUD的操作.

須佐能乎--靈玉

發佈了66 篇原創文章 · 獲贊 22 · 訪問量 5萬+

私信關注

Spring基礎知識（二）

1.1 上次課的內容回顧:

1.2 AOP的概述:

1.2.1 什麼是AOP:

1.2.2 AOP底層原理;

1.2.3 Spring的AOP代理:

1.2.4 AOP的術語:

1.3 AOP的底層實現

1.3.1 JDK動態代理:

1.3.2 CGLIB動態代理:

1.4 Spring中的AOP

1.4.1 Spring的傳統AOP :

1.4.2 Spring中的切面類型:

1.4.3 Spring的AOP的開發:

針對所有方法的增強:(不帶有切點的切面)

帶有切點的切面:(針對目標對象的某些方法進行增強)

1.4.4 自動代理:

BeanNameAutoProxyCreator :按名稱生成代理

DefaultAdvisorAutoProxyCreator :根據切面中定義的信息生成代理

1.5 Spring的AspectJ的AOP(*****)

1.5.1 基於註解:

AspectJ的通知類型:

切點的定義:

1.5.2 基於XML:

1.6 Spring的JdbcTemplate

1.6.1 Spring對持久層技術支持:

1.6.2 開發JDBCTemplate入門:

1.6.3 配置連接池:

Spring默認的連接池:

DBCP連接池:

C3P0連接池:

1.6.4 參數設置到屬性文件中:

1.6.5 JdbcTemplate的CRUD的操作:

1.5 Spring的AspectJ的AOP(*)