Java 動態代理你真的懂瞭嗎(動態和代理)
好幾天不寫文章，今天來寫一篇，從之前的計劃表上看到還有關於java的動態代理沒寫，這個技術平常用的少，也不是特別好理解，今天補上這篇，希望能講明白，不至於像我一樣迷茫好久，開始吧
動態代理分兩部分，動態和代理，我們先說下代理模式
1、代理模式
代理模式是常用的設計模式之一，也是開發中常見的設計模式。
簡單的描述一下，代理模式就是將實現類隔離開，比如你想給你女朋友過個生日，找個明星唱生日歌，你女朋友的偶像是周傑倫，想找周傑倫給她過生日，唱歌，但是你不太能聯系上周傑倫，即使在社交網站上聯系，可能也不太理你，所以你可以聯系周傑倫的經紀人進行溝通，經紀人就是周傑倫的代理。
實現過程：
定義一個唱歌的接口，代表業務
public interface ISing {
void sing();
}
周傑倫有唱歌的業務，並且業務突出，實現接口
/**
* 周傑倫
*/
public class JayImp implements ISing {
@Override
public void sing() {
System.out.println("say happy birthday to you girl friend");
}
}
經紀人接受業務, 經紀人的構造函數需要和明星綁定
經紀人接收唱歌的業務，今天可能是周傑倫唱，明天可能經紀人換瞭明星，比如蔡依林也是可以的
/**
* 經紀人
*/
public class JayProxy implements ISing{
ISing target;
/**
* 初始化的時候，和明星進行簽約
* @param target
*/
public JayProxy(ISing target) {
this.target = target;
}
@Override
public void sing() {
target.sing();
}
}
聯系經紀人進行唱歌，周傑倫唱完歌之後，經紀人收錢，very happy
public class MoneyOwner {
public static void main(String[] args) {
JayImp jay = new JayImp();
// 周傑倫和經紀人進行簽約，這一步可以放在內部實現
JayProxy jayProxy = new JayProxy(jay);
jayProxy.sing();
}
}
看下執行結果，皆大歡喜，你女朋友很開心。
上面這一套就是代理模式的實現，
但是代理類隻能代理一種類，如果為每一個服務都創建一個代理類，有點傻
而且接口如果改變的情況下代理類也需要改變，非常不方便，周傑倫又是拍電影，做綜藝，寫歌，業務很多
好瞭，靜態代理該說的也說瞭，相信看到這裡你應該沒有什麼不理解的，下面我們正式開始今天的正餐，動態代理
2、動態代理
動態代理是Java提供的一種代理方式，這個技術的核心點就是在運行期的時候對接口進行增強，生成class 對象，然後加載進虛擬機，說簡單點就是虛擬機幫你創建瞭一個實現你接口的class
廢話少說，先來實現一個動態代理
第一步定義接口，上面代碼已經有瞭 ISing 就不重復定義瞭
第二步 實現接口，上面代碼也已經實現瞭 JayImp ,也不重復定義瞭，這次經紀人多簽約瞭一個歌手，林俊傑，看下實現
package org.pdool.dynamic;
/**
* 林俊傑
*/
public class JJImp implements ISing {
@Override
public void sing() {
System.out.println("I am JJ! happy birthday to you");
}
}
第三步，經紀人可以動態派出簽約歌手，註意經紀人要實現InvocationHandler，這樣才能統一處理所有的方法調用
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JayAgentFactory implements InvocationHandler {
Object target;
public JayAgentFactory(Object target) {
this.target = target;
}
// 生成代理類
public ISing CreatProxyedObj() {
return (ISing) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object invoke = method.invoke(target, args);
logAfter(invoke);
return invoke;
}
public void logAfter(Object invoke) {
System.out.println("結果 " + invoke);
System.out.println("收入 ++ ");
}
}
第四步，接收業務
package org.pdool.dynamic;
import java.lang.reflect.Proxy;
public class Aain {
public static void main(String[] args) {
JayImp jayImp = new JayImp();
ISing subjectProxy=(ISing) Proxy.newProxyInstance(jayImp.getClass().getClassLoader(), jayImp.getClass().getInterfaces(), new JayAgentFactory(jayImp));
subjectProxy.sing();
}
}
總結：動態代理是Java提供的實現方式，需要InvocationHandler 的實現類
1、為什麼編輯器可以提示接口的方法？因為強轉編輯器才會能有提示
2、生成的內存class是的默認構造函數是需要InvocationHandler參數
3、創建代理class的核心參數是 類加載器，接口，還有InvocationHandler 子類。
類加載器保證和目標類在同一個加載器內，可以調用，防止不同加載器加載的類之間不能調用
接口就是你要代理的接口
InvocationHandler 子類是轉發器，將所有的消息進行攔截處理轉發
3、原理研究
實現看到瞭，探究下原理，動態代理的最根本的在於根據接口創建內存class，這一步是怎麼實現的，我們跟著源碼瞧一瞧
1、克隆接口裡函數的信息
2、查找或生成指定的代理類，如果緩存中有，則用緩存的，沒有則創建
3、通過反射，拿到代理類的構造函數
4、通過構造函數創建一個代理對象，並關聯InvocationHandler 的對象
/** parameter types of a proxy class constructor */
private static final Class<?>[] constructorParams =
{ InvocationHandler.class };
看到瞭流程，我們看下代理class 到底是什麼樣子的，
import sun.misc.ProxyGenerator;
public class Test {
public static void main(String[] args) {
//開啟保存代碼class屬性
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
ProxyGenerator.generateProxyClass("Xiangcai", JayImp.class.getInterfaces());
}
}
執行上面的函數，可以看到在項目的路徑下生成Xiangcai.class
接著看看xiangcai.class 到底有哪些東西，直接拖到編輯器就可以瞭
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.pdool.dynamic.ISing;
public final class xiangcai extends Proxy implements ISing {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
public xiangcai(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
//註意看這裡！！！其他的都不重要
public final void sing() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("org.pdool.dynamic.ISing").getMethod("sing");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
可以看到實現瞭sing的接口，並且調用瞭invokehandler的方法invoke.好瞭，真相大白瞭，你明白瞭嗎？
有人會說，道理我都懂，可是不會用啊，但是沒看到好的應用場景，所以有段時間是沒掌握這些的，下面我們就具體一下應用場景
4、應用
在切面編程（AOP）中，需要攔截特定的方法，通常，會選擇動態代理方式。看個具體的例子 spring-data-jpa 的實現
具體的使用：
spring中訪問數據庫的使用
import com.tao.springboot.hibernate.entity.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
public interface CustomerRepository extends JpaRepository<Customer, Long> {
}
隻要實現上面的接口就可以直接操作數據庫，是不是很簡單？
有幾個問題，你稍微思考下：
1、兩個泛型什麼意思？
2、數據庫連接在哪？是怎麼註入的？
3、隻實現接口是怎麼操作數據庫的？
第一個問題答案：
Customer 為表對象對應的entity實體。
Long 是表的主鍵類型，
第二個答案：
數據庫連接是在spring啟動的時候自動註入到spring 容器中的，在JpaRepository 的實現類自動註入的
第三個答案：
所有的的接口在spring啟動的時候會生成代理類，目標類target就是實現類SimpleJpaRepository
看下類圖
看下JpaRepository的定義，都是一些常用方法
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {
List<T> findAll();
List<T> findAll(Sort var1);
List<T> findAllById(Iterable<ID> var1);
<S extends T> List<S> saveAll(Iterable<S> var1);
void flush();
<S extends T> S saveAndFlush(S var1);
void deleteInBatch(Iterable<T> var1);
void deleteAllInBatch();
T getOne(ID var1);
<S extends T> List<S> findAll(Example<S> var1);
<S extends T> List<S> findAll(Example<S> var1, Sort var2);
}
看下SimpleJpaRepository 的定義：
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
private static final String ID_MUST_NOT_BE_NULL = "The given id must not be null!";
private final JpaEntityInformation<T, ?> entityInformation;
private final EntityManager em;//看這裡！！！
private final PersistenceProvider provider;
@Nullable
private CrudMethodMetadata metadata;
//具體的實現方法
@Transactional
public void delete(T entity) {
Assert.notNull(entity, "The entity must not be null!");
this.em.remove(this.em.contains(entity) ? entity : this.em.merge(entity));
}
類似下面的代碼調用：
Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), JpaRepository.class.getInterfaces(), new SimpleJpaRepository(());
註：隻是表達一下意思，具體的實現應該不是這樣的
5、總結
所有的事情都解開瞭，下面進行總結下：
1、靜態代理是代理模式的實現，是針對某一個具體的接口的實現
2、動態代理的是jdk提供的一種方式，必須要接口，還有其他的實現方式cglib,javassit 等等
3、動態代理是在運行的時候生成class 文件然後自動加載的class
4、動態代理是基於反射調用的技術
5、動態代理會生成class 到 metaspace
6、多應用在框架中
7、解密瞭spring data jpa的實現
到此這篇關於Java 動態代理都不懂怎麼裝逼？的文章就介紹到這瞭,更多相關Java 動態代理內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！