本文主要介紹Java中兩種常見的動態代理方式：JDK原生動態代理和CGLIB動態代理，
什么是代理模式
就是為其他物件提供一種代理以控制對這個物件的訪問，代理可以在不改動目標物件的基礎上，增加其他額外的功能（擴展功能），
代理模式角色分為 3 種：
Subject（抽象主題角色）：定義代理類和真實主題的公共對外方法，也是代理類代理真實主題的方法；RealSubject（真實主題角色）：真正實作業務邏輯的類；Proxy（代理主題角色）：用來代理和封裝真實主題；
如果根據位元組碼的創建時機來分類，可以分為靜態代理和動態代理：
- 所謂靜態也就是在程式運行前就已經存在代理類的位元組碼檔案，代理類和真實主題角色的關系在運行前就確定了，
- 而動態代理的原始碼是在程式運行期間由JVM根據反射等機制動態的生成，所以在運行前并不存在代理類的位元組碼檔案
靜態代理
學習動態代理前，有必要來學習一下靜態代理，
靜態代理在使用時,需要定義介面或者父類,被代理物件（目標物件）與代理物件（Proxy）一起實作相同的介面或者是繼承相同父類，
來看一個例子，模擬小貓走路的時間，
// 介面
public interface Walkable {
void walk();
}
// 實作類
public class Cat implements Walkable {
@Override
public void walk() {
System.out.println("cat is walking...");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
如果我想知道走路的時間怎么辦？可以將實作類Cat修改為：
public class Cat implements Walkable {
@Override
public void walk() {
long start = System.currentTimeMillis();
System.out.println("cat is walking...");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("walk time = " + (end - start));
}
}
這里已經侵入了源代碼，如果源代碼是不能改動的，這樣寫顯然是不行的，這里可以引入時間代理類CatTimeProxy，
public class CatTimeProxy implements Walkable {
private Walkable walkable;
public CatTimeProxy(Walkable walkable) {
this.walkable = walkable;
}
@Override
public void walk() {
long start = System.currentTimeMillis();
walkable.walk();
long end = System.currentTimeMillis();
System.out.println("Walk time = " + (end - start));
}
}
如果這時候還要加上常見的日志功能，我們還需要創建一個日志代理類CatLogProxy，
public class CatLogProxy implements Walkable {
private Walkable walkable;
public CatLogProxy(Walkable walkable) {
this.walkable = walkable;
}
@Override
public void walk() {
System.out.println("Cat walk start...");
walkable.walk();
System.out.println("Cat walk end...");
}
}
如果我們需要先記錄日志，再獲取行走時間，可以在呼叫的地方這么做：
public static void main(String[] args) {
Cat cat = new Cat();
CatLogProxy p1 = new CatLogProxy(cat);
CatTimeProxy p2 = new CatTimeProxy(p1);
p2.walk();
}
這樣的話，計時是包括打日志的時間的，
靜態代理的問題
如果我們需要計算SDK中100個方法的運行時間，同樣的代碼至少需要重復100次，并且創建至少100個代理類，往小了說，如果Cat類有多個方法，我們需要知道其他方法的運行時間，同樣的代碼也至少需要重復多次，因此，靜態代理至少有以下兩個局限性問題：
- 如果同時代理多個類，依然會導致類無限制擴展
- 如果類中有多個方法，同樣的邏輯需要反復實作
所以，我們需要一個通用的代理類來代理所有的類的所有方法，這就需要用到動態代理技術，
動態代理
學習任何一門技術，一定要問一問自己，這到底有什么用，其實，在這篇文章的講解程序中，我們已經說出了它的主要用途，你發現沒，使用動態代理我們居然可以在不改變原始碼的情況下，直接在方法中插入自定義邏輯，這有點不太符合我們的一條線走到底的編程邏輯，這種編程模型有一個專業名稱叫AOP，所謂的AOP，就像刀一樣，抓住時機，趁機插入，
Jdk動態代理
JDK實作代理只需要使用newProxyInstance方法,但是該方法需要接收三個引數:
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
/*
* Look up or generate the designated proxy class.
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}
方法是在Proxy類中是靜態方法,且接收的三個引數依次為:
ClassLoader loader//指定當前目標物件使用類加載器Class<?>[] interfaces//目標物件實作的介面的型別,使用泛型方式確認型別InvocationHandler h//事件處理器
主要是完成InvocationHandler h的撰寫作業，
介面類UserService：
public interface UserService {
public void select();
public void update();
}
介面實作類，即要代理的類UserServiceImpl：
public class UserServiceImpl implements UserService {
@Override
public void select() {
System.out.println("查詢 selectById");
}
@Override
public void update() {
System.out.println("更新 update");
}
}
代理類UserServiceProxy：
public class UserServiceProxy implements UserService {
private UserService target;
public UserServiceProxy(UserService target){
this.target = target;
}
@Override
public void select() {
before();
target.select();
after();
}
@Override
public void update() {
before();
target.update();
after();
}
private void before() { // 在執行方法之前執行
System.out.println(String.format("log start time [%s] ", new Date()));
}
private void after() { // 在執行方法之后執行
System.out.println(String.format("log end time [%s] ", new Date()));
}
}
主程式類：
public class UserServiceProxyJDKMain {
public static void main(String[] args) {
// 1. 創建被代理的物件，即UserService的實作類
UserServiceImpl userServiceImpl = new UserServiceImpl();
// 2. 獲取對應的classLoader
ClassLoader classLoader = userServiceImpl.getClass().getClassLoader();
// 3. 獲取所有介面的Class, 這里的userServiceImpl只實作了一個介面UserService，
Class[] interfaces = userServiceImpl.getClass().getInterfaces();
// 4. 創建一個將傳給代理類的呼叫請求處理器，處理所有的代理物件上的方法呼叫
// 這里創建的是一個自定義的日志處理器，須傳入實際的執行物件 userServiceImpl
InvocationHandler logHandler = new LogHandler(userServiceImpl);
/*
5.根據上面提供的資訊，創建代理物件 在這個程序中，
a.JDK會通過根據傳入的引數資訊動態地在記憶體中創建和.class 檔案等同的位元組碼
b.然后根據相應的位元組碼轉換成對應的class，
c.然后呼叫newInstance()創建代理實體
*/
// 會動態生成UserServiceProxy代理類，并且用代理物件實體化LogHandler，呼叫代理物件的.invoke()方法即可
UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
// 呼叫代理的方法
proxy.select();
proxy.update();
// 生成class檔案的名稱
ProxyUtils.generateClassFile(userServiceImpl.getClass(), "UserServiceJDKProxy");
}
}
這里可以保存下來代理生成的實作了介面的代理物件：
public class ProxyUtils {
/*
* 將根據類資訊 動態生成的二進制位元組碼保存到硬碟中，
* 默認的是clazz目錄下
* params :clazz 需要生成動態代理類的類
* proxyName : 為動態生成的代理類的名稱
*/
public static void generateClassFile(Class clazz, String proxyName) {
//根據類資訊和提供的代理類名稱，生成位元組碼
byte[] classFile = ProxyGenerator.generateProxyClass(proxyName, clazz.getInterfaces());
String paths = clazz.getResource(".").getPath();
System.out.println(paths);
FileOutputStream out = null;
try {
//保留到硬碟中
out = new FileOutputStream(paths + proxyName + ".class");
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
動態代理實作程序
- 通過
getProxyClass0()生成代理類，JDK生成的最終真正的代理類，它繼承自Proxy并實作了我們定義的介面. - 通過
Proxy.newProxyInstance()生成代理類的實體物件，創建物件時傳入InvocationHandler型別的實體， - 呼叫新實體的方法，即原
InvocationHandler類中的invoke()方法，
代理物件不需要實作介面，但是目標物件一定要實作介面，否則不能用動態代理
Cglib動態代理
JDK的動態代理機制只能代理實作了介面的類，而不能實作介面的類就不能實作JDK的動態代理，cglib是針對類來實作代理的，他的原理是對指定的目標類生成一個子類，并覆寫其中方法實作增強，但因為采用的是繼承，所以不能對final修飾的類進行代理，
Cglib代理，也叫作子類代理，它是在記憶體中構建一個子類物件從而實作對目標物件功能的擴展，
Cglib子類代理實作方法:
- 需要引入
cglib的jar檔案,但是Spring的核心包中已經包括了Cglib功能,所以直接引入Spring-core.jar即可. - 引入功能包后,就可以在記憶體中動態構建子類
- 代理的類不能為
final,否則報錯 - 目標物件的方法如果為
final/static,那么就不會被攔截,即不會執行目標物件額外的業務方法.
基本使用
<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
方法攔截器
public class LogInterceptor implements MethodInterceptor{
/*
* @param o 要進行增強的物件
* @param method 要攔截的方法
* @param objects 引數串列，基本資料型別需要傳入其包裝類
* @param methodProxy 對方法的代理，
* @return 執行結果
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
before();
Object result = methodProxy.invokeSuper(o, objects);
after();
return result;
}
private void before() {
System.out.println(String.format("log start time [%s] ", new Date()));
}
private void after() {
System.out.println(String.format("log end time [%s] ", new Date()));
}
}
測驗用例
這里保存了代理類的.class檔案
public class CglibMain {
public static void main(String[] args) {
// 創建Enhancer物件，類似于JDK動態代理的Proxy類
Enhancer enhancer = new Enhancer();
// 設定目標類的位元組碼檔案
enhancer.setSuperclass(UserDao.class);
// 設定回呼函式
enhancer.setCallback(new LogInterceptor());
// create會創建代理類
UserDao userDao = (UserDao)enhancer.create();
userDao.update();
userDao.select();
}
}
結果
log start time [Mon Nov 30 17:26:39 CST 2020]
UserDao 更新 update
log end time [Mon Nov 30 17:26:39 CST 2020]
log start time [Mon Nov 30 17:26:39 CST 2020]
UserDao 查詢 selectById
log end time [Mon Nov 30 17:26:39 CST 2020]
JDK動態代理與CGLIB動態代理對比
JDK 動態代理
- 為了解決靜態代理中，生成大量的代理類造成的冗余；
JDK動態代理只需要實作InvocationHandler介面，重寫invoke方法便可以完成代理的實作，- jdk的代理是利用反射生成代理類
Proxyxx.class代理類位元組碼，并生成物件 - jdk動態代理之所以只能代理介面是因為代理類本身已經
extends了Proxy，而java是不允許多重繼承的，但是允許實作多個介面
優點：解決了靜態代理中冗余的代理實作類問題，
缺點：JDK 動態代理是基于介面設計實作的，如果沒有介面，會拋例外，
CGLIB 代理
- 由于
JDK動態代理限制了只能基于介面設計，而對于沒有介面的情況，JDK方式解決不了； CGLib采用了非常底層的位元組碼技術，其原理是通過位元組碼技術為一個類創建子類，并在子類中采用方法攔截的技術攔截所有父類方法的呼叫，順勢織入橫切邏輯，來完成動態代理的實作，- 實作方式實作
MethodInterceptor介面，重寫intercept方法，通過Enhancer類的回呼方法來實作， - 但是
CGLib在創建代理物件時所花費的時間卻比JDK多得多，所以對于單例的物件，因為無需頻繁創建物件，用CGLib合適，反之，使用JDK方式要更為合適一些， - 同時，由于
CGLib由于是采用動態創建子類的方法，對于final方法，無法進行代理，
優點：沒有介面也能實作動態代理，而且采用位元組碼增強技術，性能也不錯，
缺點：技術實作相對難理解些，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/229674.html
標籤：Java
上一篇：硬核！從零實作一個作業系統內核！畢設/專案經驗不愁了
下一篇：java題型解答