一、代理模式
代理模式的英文叫做Proxy或Surrogate，中文都可譯為”代理“，所謂代理，就是一個人或者一個機構代表另一個人或者另一個機構采取行動。在一些情況下，一個客戶不想或者不能夠直接引用一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
以簡單模擬事務的執行過程說明各種代理區別
1.1 靜態代理
由程序員創建或由特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。
|
1
2
3
4
|
public
interface
PersonDao {
void
savePerson();
}
|
|
1
2
3
4
5
6
7
|
public
class
PersonDaoImpl
implements
PersonDao {
@Override
public
void
savePerson() {
System.out.println(
"save person"
);
}
}
|
|
1
2
3
4
5
6
7
8
9
10
|
public
class
Transaction {
void
beginTransaction(){
System.out.println(
"begin Transaction"
);
}
void
commit(){
System.out.println(
"commit"
);
}
}
|
接下來編寫靜態代理類---實現PersonDao接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/**
* 靜態代理類
* @author qjc
*/
public
class
PersonDaoProxy
implements
PersonDao{
PersonDao personDao;
Transaction transaction;
public
PersonDaoProxy(PersonDao personDao, Transaction transaction) {
this
.personDao = personDao;
this
.transaction = transaction;
}
@Override
public
void
savePerson() {
this
.transaction.beginTransaction();
this
.personDao.savePerson();
this
.transaction.commit();
}
}
|
測試
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/**
* 測試靜態代理
* @author qjc
*/
public
class
TestPersonProxy {
@Test
public
void
testSave(){
PersonDao personDao =
new
PersonDaoImpl();
Transaction transaction =
new
Transaction();
PersonDaoProxy proxy =
new
PersonDaoProxy(personDao, transaction);
proxy.savePerson();
}
}
|
總結：
1、靜態代理模式並沒有做到事務的重用
2、假設dao有100個類，100個proxy，接口中有多少方法，在proxy層就得實現多少方法，有多少方法就要開啟和提交多少事務
3、如果一個proxy實現了多個接口，如果其中的一個接口發生變化（添加了一個方法），那么proxy也要做相應改變
1.2 JDK動態代理
動態代理類：在程序運行時，運用反射機制動態創建而成。
JDK的動態代理必須具備四個條件：1、目標接口 2、目標類 3、攔截器 4、代理類
使用上個例子的PersonDao接口、PersonDaoImpl類及Transaction類
編寫攔截器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
import
java.lang.reflect.InvocationHandler;
import
java.lang.reflect.Method;
/**
* 攔截器
* 1、目標類導入進來
* 2、事物導入進來
* 3、invoke完成：開啟事務、調用目標對象的方法、事務提交
*
* @author qjc
*/
public
class
Interceptor
implements
InvocationHandler {
private
Object target;
// 目標類
private
Transaction transaction;
public
Interceptor(Object target, Transaction transaction) {
this
.target = target;
this
.transaction = transaction;
}
/**
* @param proxy 目標對象的代理類實例
* @param method 對應於在代理實例上調用接口方法的Method實例
* @param args 傳入到代理實例上方法參數值的對象數組
* @return 方法的返回值，沒有返回值是null
* @throws Throwable
*/
public
Object invoke(Object proxy, Method method, Object[] args)
throws
Throwable {
String methodName = method.getName();
if
(
"savePerson"
.equals(methodName)
||
"deletePerson"
.equals(methodName)
||
"updatePerson"
.equals(methodName)) {
this
.transaction.beginTransaction();
// 開啟事務
method.invoke(target);
// 調用目標方法
this
.transaction.commit();
// 提交事務
}
else
{
method.invoke(target);
}
return
null
;
}
}
|
測試
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
/**
* 測試jdk動態代理
* @author qjc
*/
public
class
TestJDKProxy {
@Test
public
void
testSave(){
/**
* 1、創建一個目標對象
* 2、創建一個事務
* 3、創建一個攔截器
* 4、動態產生一個代理對象
*/
Object target =
new
PersonDaoImpl();
Transaction transaction =
new
Transaction();
Interceptor interceptor =
new
Interceptor(target, transaction);
/**
* 參數一：設置代碼使用的類加載器，一般采用跟目標類相同的類加載器
* 參數二：設置代理類實現的接口，跟目標類使用相同的接口
* 參數三：設置回調對象，當代理對象的方法被調用時，會調用該參數指定對象的invoke方法
*/
PersonDao personDao = (PersonDao) Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
interceptor);
personDao.savePerson();
}
}
|
總結：
1、因為利用JDKProxy生成的代理類實現了接口，所以目標類中所有的方法在代理類中都有。
2、生成的代理類的所有的方法都攔截了目標類的所有的方法。而攔截器中invoke方法的內容正好就是代理類的各個方法的組成體。
3、利用JDKProxy方式必須有接口的存在。
4、invoke方法中的三個參數可以訪問目標類的被調用方法的API、被調用方法的參數、被調用方法的返回類型。
缺點：
1、在攔截器中除了能調用目標對象的目標方法以外，功能是比較單一的，在這個例子中只能處理事務
2、攔截器中的invoke方法的if判斷語句在真實的開發環境下是不靠譜的，因為一旦方法很多if語句需要寫很多。
1.3 CGLIB動態代理
使用上個例子的PersonDaoImpl類和Transaction類（不用接口）
編寫攔截器類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
|
import
net.sf.cglib.proxy.Enhancer;
import
net.sf.cglib.proxy.MethodInterceptor;
import
net.sf.cglib.proxy.MethodProxy;
/**
* CGLIB代理 攔截器
* @author qjc
*/
public
class
Interceptor
implements
MethodInterceptor {
private
Object target;
// 代理的目標類
private
Transaction transaction;
public
Interceptor(Object target, Transaction transaction) {
this
.target = target;
this
.transaction = transaction;
}
/**
* 創建目標對象的代理對象
*
* @return
*/
public
Object createProxy() {
// 代碼增強
Enhancer enhancer =
new
Enhancer();
// 該類用於生成代理對象
enhancer.setCallback(
this
);
// 參數為攔截器
enhancer.setSuperclass(target.getClass());
// 設置父類
return
enhancer.create();
// 創建代理對象
}
/**
* @param obj 目標對象代理類的實例
* @param method 代理實例上 調用父類方法的Method實例
* @param args 傳入到代理實例上方法參數值的對象數組
* @param methodProxy 使用它調用父類的方法
* @return
* @throws Throwable
*/
public
Object intercept(Object obj, Method method, Object[] args,
MethodProxy methodProxy)
throws
Throwable {
this
.transaction.beginTransaction();
method.invoke(target);
this
.transaction.commit();
return
null
;
}
}
|
測試
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/**
* 測試cglib動態代理
* 通過cglib產生的代理對象，代理類是目標類的子類
* @author qjc
*/
public
class
TestCglibProxy {
@Test
public
void
testSave(){
Object target =
new
PersonDaoImpl();
Transaction transaction =
new
Transaction();
Interceptor interceptor =
new
Interceptor(target, transaction);
PersonDaoImpl personDaoImpl = (PersonDaoImpl) interceptor.createProxy();
personDaoImpl.savePerson();
}
}
|
總結：
1、CGlib是一個強大的,高性能,高質量的Code生成類庫。它可以在運行期擴展Java類與實現Java接口。
2、用CGlib生成代理類是目標類的子類。
3、用CGlib生成 代理類不需要接口
4、用CGLib生成的代理類重寫了父類的各個方法。
5、攔截器中的intercept方法內容正好就是代理類中的方法體 CGLIB和JDK動態代理區別:
JDK:
目標類和代理類實現了共同的接口
攔截器必須實現InvocationHandler接口,而這個接口中invoke方法體的內容就是代理對象方法體的內容
CGLIB:
目標類 是代理類的父類
攔截器必須實現MethodInterceptor接口,而接口中的intercept方法就是代理類的方法體,使用字節碼增強機制創建代理對象的.
二、面向切面編程
OOP(面向對象編程)：封裝、繼承、多態、抽象
封裝，對代碼進行基本的管理、模塊化的管理。每個類可能都有自己的職能，出了問題就是論事找人就行了。從修改角度講，直接修改代碼可能有風險，這不是個長遠之計，最自然的是從類型封裝變化。但是新的類型和舊的體系之間怎么去融合，所以說需要在類與類之間建立一種血緣關系。那么這就是繼承的需求，通過繼承就可以發現這些類之間是有關聯的，它們之間是有父子關系的。然后在繼承基礎之上多態起決定性的特征。所以說一般認為面向對象最核心的特征，其實是多態。前面幾個都是在做鋪墊的。多態才是它最核心的特征。子類中通過重寫方法，代表了擴展這個層面的東西，而它能融入老的體系中能夠正常工作，這是重用這個層面的東西，新的方法、舊的體系、擴展和重用。
AOP(面向切面編程):
面向切面編程,是一種通過預編譯方式運行期動態代理實現在不修改源代碼的情況下給程序動態統一添加功能的一種技術.
OOP與AOP區別:
OOP:針對業務處理過程的實體及其屬性和行為進行抽象封裝,以獲得更加清楚的邏輯單元划分。
AOP:針對業務處理過程中的橫切邏輯 進行提取，它所面對的是處理過程中的某個步驟或者階段,以獲得邏輯過程中各部分之間低耦合的隔離效果。這兩種設計思想在目標上有着本質的差異。AOP做到了代碼塊的重用。
spring AOP代理機制：
1、若目標對象實現了若干接口，spring使用JDK的java.lang.reflect.Proxy類代理。
優點：因為有接口，所以使系統更加松耦合
缺點：為每一個目標類創建接口
2、若目標對象沒有實現任何接口，spring使用CGLIB庫生成目標對象的子類。
優點：因為代理類與目標類是繼承關系，所以不需要有接口的存在。
缺點：因為沒有使用接口，所以系統的耦合性沒有使用JDK的動態代理好。
使用第一個例子的 PersonDao接口、PersonDaoImpl類和Transaction類
編寫spring配置
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
<bean id=
"personDao"
class
=
"cn.qjc.aop.xml.PersonDaoImpl"
></bean>
<bean id=
"transaction"
class
=
"cn.qjc.aop.xml.Transaction"
></bean>
<aop:config>
<!-- 切入點表達式 確定目標類 -->
<aop:pointcut expression=
"execution(* cn.qjc.aop.xml.PersonDaoImpl.*(..))"
id=
"perform"
/>
<!-- ref指向對象就是切面 -->
<aop:aspect ref=
"transaction"
>
<aop:before method=
"beginTransaction"
pointcut-ref=
"perform"
/>
<aop:after-returning method=
"commit"
pointcut-ref=
"perform"
/>
</aop:aspect>
</aop:config>
</beans>
|
測試
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
/**
* 測試spring動態代理
* @author qjc
*/
public
class
TransactionTest {
@Test
public
void
testSave(){
ApplicationContext context =
new
ClassPathXmlApplicationContext(
"cn/qjc/aop/xml/applicationContext.xml"
);
PersonDao personDao = (PersonDao) context.getBean(
"personDao"
);
personDao.savePerson();
}
}
|
spring AOP原理
1、當spring容器啟動的時候，加載兩個bean，對像個bean進行實例化
2、當spring容器對配置文件解析到<aop:config>的時候，把切入點表達式解析出來，按照切入點表達式匹配spring容器內容的bean
3、如果匹配成功，則為該bean創建代理對象
4、當客戶端利用context.getBean獲取一個對象時，如果該對象有代理對象，則返回代理對象，如果沒有代理對象，則返回對象本身