2. 程式人生 > >java動態代理和spring動態代理對比

java動態代理和spring動態代理對比

阿新 • • 發佈：2019-01-03

Java編譯器編譯好Java檔案之後，產生.class 檔案在磁碟中。這種class檔案是二進位制檔案，內容是隻有JVM虛擬機器能夠識別的機器碼。JVM虛擬機器讀取位元組碼檔案，取出二進位制資料，載入到記憶體中，解析.class 檔案內的資訊，生成對應的 Class物件:

.java檔案到jjvm的過程圖:


 class位元組碼檔案是根據JVM虛擬機器規範中規定的位元組碼組織規則生成的、具體class檔案是怎樣組織類資訊的，可以參考 此博文：或者是。

在執行期的程式碼中生成二進位制位元組碼

   由於JVM通過位元組碼的二進位制資訊載入類的，那麼，如果我們在執行期系統中，遵循Java編譯系統組織.class檔案的格式和結構，生成相應的二進位制資料，然後再把這個二進位制資料載入轉換成對應的類，這樣，就完成了在程式碼中，動態建立一個類的能力了。


由於本人知識有限就不胡給大家介紹如何利用位元組碼增強,實現動態生成.clas檔案了,大家可以參考http://www.blogjava.net/hello-yun/archive/2014/09/28/418365.html

今天就介紹如何利用jdk和cglib生成動態代理,:

首先我們編寫目標類,即要被增強的類:

package com.leige.proxy;

public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		// TODO Auto-generated method stub
		System.out.println("adddUser------");
	}

}

介面: 
package com.leige.proxy;

public interface UserService {
	public void addUser();
	
}
切面類即增強程式碼類利用動態代理可以動態的將增強程式碼加入目標類中: 
package com.leige.proxy;

public class MyAspect {
	public void before(){
		System.out.println("前置通知");
	}
	public void after(){
		System.out.println("後置通知");
	}
}

工廠類: 
package com.leige.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.util.MethodInvoker;

public class MyFactoryBean {

	/**
	 * @return
	 * 利用jdk實現動態代理,
	 * jdk實現動態代理,必須要保證目標類有介面,否則無法實現動態代理
	 */
	public Object getBean(){
		//目標類,即被增強類
		UserService service=new UserServiceImpl();
		//切面類,即增強程式碼類
		MyAspect aspect=new MyAspect();
		//jdk動態代理實現
		return Proxy.newProxyInstance(this.getClass().getClassLoader(), service.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				// TODO Auto-generated method stub
				//前置通知
				aspect.before();
				//執行目標類的方法:
				Object obj=method.invoke(service, args);
				//後置通知
				aspect.after();
				return obj;
			}
		});
		
	}
	
	/**
	 * @return
	 * 通過cglib實現動態代理,不需要目標類有介面,代理之後返回的是目標類的子類,所以目標類不是final的,
	 * 
	 */
	public Object getBeanByCglib(){
		//目標類,即被增強類
		UserService service=new UserServiceImpl();
		//切面類,即增強程式碼類
		MyAspect aspect=new MyAspect();
		Enhancer enhancer=new Enhancer();
		//設定父類,即被代理類,cglib的代理物件通過子類實現的
		//因為我們的切入點是方法,所以使用MethodInterceptor
		enhancer.setSuperclass(service.getClass());
		enhancer.setCallback(new MethodInterceptor() {
			
			@Override
			public Object intercept(Object proxy, Method method, Object[] args,
					MethodProxy methodProxy) throws Throwable {
				// TODO Auto-generated method stub
				//前置通知
				aspect.before();
				//執行目標類的方法有兩種方式
				//Object obj=method.invoke(service, args);
				/*執行的是代理物件的父類,在此代理物件是proxy,proxy的父類就是目標類即UserService
				 * 這是cglib的工作機制,即生成目標的的子類,作為代理物件
				 */
				Object obj=methodProxy.invokeSuper(proxy, args);
				//後置通知
				aspect.after();
				return obj;
			}
		});
		//建立代理類:
		Object obj=enhancer.create();
		return obj;
		
		
	}
}

測試類:
package com.leige.proxy;

import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:com/leige/proxy/beans.xml")
public class TestApp {
	@Autowired
	UserService userService;
	@Test
	public void test() {
		userService.addUser();
	}

}
beans.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
       					   <context:annotation-config/>
       		<bean id="myfactory" class="com.leige.proxy.MyFactoryBean"/>
       		<bean  id="userService" factory-bean="myfactory" factory-method="getBeanByCglib"/>


</beans>

以上是未使用springaop的動態代理,下面將介紹spring實現動態代理的方法:

第一種通知再切面類中配置，注意都是有介面的，這裡不再寫介面程式碼：

實現類：

package com.leige.aspect;

public class StudentServiceImpl implements StudentService {

	public void add() {
		System.out.println("addd student");
		
	}

}

切面類，這種方法通知都是解除安裝程式碼中，xml中只需配置切面和切入點即可：
package com.leige.aspect;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class Myaspect implements MethodInterceptor {

	public Object invoke(MethodInvocation mi) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("前置通知");
		Object obj=mi.proceed();
		System.out.println("後置通知");
		return obj;
	}

}

xml配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					   http://www.springframework.org/schema/beans/spring-beans.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context
       					   http://www.springframework.org/schema/context/spring-context.xsd
       					   ">
       					 
       					  
	<bean id="studentServiceId" class="com.leige.aspect.StudentServiceImpl"></bean>
	<!-- 配置切面bean -->
	<bean id="myAspect" class="com.leige.aspect.Myaspect"></bean>
	<aop:config>
<!-- 	切入點 
 expression定義切入點
 advisor 定義通知
-->
	<aop:pointcut expression="execution(* com.leige.aspect.*ServiceImpl.*(..))" id="myPointCut"/>
	<aop:advisor advice-ref="myAspect" pointcut-ref="myPointCut"/>
	</aop:config>
</beans>
第二種方法，通知型別在xml中指定，但是程式碼實現也是在切面類中：

實現類：

package com.leige.aspect2;



public class PersonServiceImpl implements  PersonService {

	public void addPerson() {
	System.out.println("person --------addperson");

	}

	
}
切面類：
package com.leige.aspect2;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * @author 
 * 
 * 
 * 
 * 
					<!--  宣告通知型別 
				#1 前置通知 , 目標方法之前執行。
					* 第一個引數為JoinPoint，可以獲得目標方法名等。
				<aop:before method="myBefore" pointcut-ref="myPonitCut"/>
				#2 後置通知，目標方法之後執行，可以獲得返回值。 通過“returning”屬性配置第二個引數的名稱，獲得返回值的，型別必須Object
					* 第一個引數為：JoinPoint
					* 第二個引數為：Object xxx
				<aop:after-returning method="myAfterReturning" pointcut-ref="myPonitCut" returning="xxx"/>
				#3 環繞通知， 目標方法前後
					方法要求：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
					執行目標方法：joinPoint.proceed();
				<aop:around method="myAround" pointcut-ref="myPonitCut"/>
				#4 丟擲異常通知，目標方法出現異常時才執行。通過“throwing”屬性配置第二個引數的名稱,獲得具體的異常資訊，型別必須是Throwable
					* 第一個引數為：JoinPoint
					* 第二個引數為：Throwable e
				<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPonitCut" throwing="e"/>
 *
 */
public class MyAspect {
	
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知, 方法名稱：" + joinPoint.getSignature().getName());
	}
	
	public void myAfterReturning(JoinPoint joinPoint,Object xxx){
		System.out.println("後置通知, 返回值：" + xxx);
	}
	
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		
		System.out.println("前");
		//必須執行目標方法
		Object obj = joinPoint.proceed();
		
		System.out.println("後");
		return obj;
	}
	
	public void myAfterThrowing(JoinPoint joinPoint, Throwable e){
		System.out.println("丟擲異常通知, " + e.getMessage());
	}
	
	public void myAfter(){
		System.out.println("最終");
	}
}

xml配置方法·： 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       					   http://www.springframework.org/schema/beans/spring-beans.xsd
       					   http://www.springframework.org/schema/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context
       					   http://www.springframework.org/schema/context/spring-context.xsd
       					   ">
       					 
      <!--  		配置增強bean -->			  
	<bean id="personServiceId" class="com.leige.aspect2.PersonServiceImpl"></bean>
	<!-- 配置切面bean ,包含多個通知-->
	<bean id="myAspect" class="com.leige.aspect2.MyAspect"></bean>
			<aop:config>
		<!-- 	切面 通知配置-->
				<aop:aspect ref="myAspect">
				<!-- 定義切入點 ,表示這個bean下的所有方法都是切入點-->
				<aop:pointcut expression="execution(* com.leige.aspect2.PersonServiceImpl.*(..))" id="myPointCut"/>
				
				<!-- 前置通知 
				
					<!--  宣告通知型別 
				#1 前置通知 , 目標方法之前執行。
					* 第一個引數為JoinPoint，可以獲得目標方法名等。
				<aop:before method="myBefore" pointcut-ref="myPonitCut"/>
				#2 後置通知，目標方法之後執行，可以獲得返回值。 通過“returning”屬性配置第二個引數的名稱，獲得返回值的，型別必須Object
					* 第一個引數為：JoinPoint
					* 第二個引數為：Object xxx
				<aop:after-returning method="myAfterReturning" pointcut-ref="myPonitCut" returning="xxx"/>
				#3 環繞通知， 目標方法前後
					方法要求：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
					執行目標方法：joinPoint.proceed();
				<aop:around method="myAround" pointcut-ref="myPonitCut"/>
				#4 丟擲異常通知，目標方法出現異常時才執行。通過“throwing”屬性配置第二個引數的名稱,獲得具體的異常資訊，型別必須是Throwable
					* 第一個引數為：JoinPoint
					* 第二個引數為：Throwable e
				<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPonitCut" throwing="e"/>
			-->
				
				<aop:before method="myBefore" pointcut-ref="myPointCut"/>
				</aop:aspect>
			</aop:config>
</beans>


相比jdk的動態代理，spring遮蔽了底層的實現，使我們可以簡單實現aop程式設計，但是我們也需要對動態代理有一定的基礎瞭解，這是我學習經驗，我自己也是理解不是很透側，並沒有具體應用，所以先寫在這裡，以後在具體研究，歡迎大家矯正，spring中的動態代理採取了兩種實現方式：

當攔截物件實現了介面時，生成方式是用JDK的Proxy類。當沒有實現任何介面時用的是GCLIB開源專案生成的攔截類的子類.


相關推薦

java動態代理和spring動態代理對比

Java編譯器編譯好Java檔案之後，產生.class 檔案在磁碟中。這種class檔案是二進位制檔案，內容是隻有JVM虛擬機器能夠識別的機器碼。JVM虛擬機器讀取位元組碼檔案，取出二進位制資料，載入到記憶體中，解析.class 檔案內的資訊，生成對應的 Class物件:

java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總 Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）

若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。 一、概述1. 什麼是代理我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為

Spring裡的aop實現方式和原始碼分析 java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總

使用"橫切"技術，AOP把軟體系統分為兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的部分是橫切關注點。橫切關注點的一個特點是，他們經常發生在核心關注點的多處，而各處基本相似，比如許可權認證、日誌、事務。AOP的作用在於分離系統中的各種關注點，將核心關注點和橫切關注點分離開來。

Mybatis(四)：MyBatis核心元件介紹原理解析和原始碼解讀 java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總

Mybatis核心成員 Configuration        MyBatis所有的配置資訊都儲存在Configuration物件之中，配置檔案中的大部分配置都會儲存到該類中 SqlSession         &

Spring的兩種代理方式：JDK動態代理和CGLIB動態代理

轉自 ：https://blog.csdn.net/cckevincyh/article/details/54962920   代理模式 代理模式的英文叫做Proxy或Surrogate，中文都可譯為”代理“，所謂代理，就是一個人或者一個機構代表另一個人或者另一個機構採取行動。

Spring JDK動態代理和CGLIB動態代理

的雙方各和進口量認同感和基你妹， 狂歡節空虛，嗎了 離開了是發；是否  進口量嗎， 的雙方各和進口量認同感和基你妹， 狂歡節空虛，嗎了 離開了是發；是否  進口量嗎， 的雙方各和進口量認同感和基你妹， 狂歡節空虛，嗎了 離開了是發；是否  進口量嗎， 

Spring 靜態代理+JDK動態代理和CGLIB動態代理

代理分為兩種：靜態代理　　動態代理 靜態代理：本質上會在硬碟上建立一個真正的物理類 動態代理：本質上是在記憶體中構建出一個類。 如果多個類需要進行方法增強，靜態代理則需要建立多個物理類，佔用磁碟空間。而動態代理則是在記憶體中建立，不會對磁碟進行影響。 靜態代理和JDK動態代理需要有介面。　　CGLIB

JDK動態代理和CGLIB動態代理,實現Spring註解管理事務區別。

註解式事務配置 1.JDK動態代理 <tx:annotation-driven transaction-manager="txManager"/>  預設啟用JDK動態代理，JDK只能代理介面不能代理類。 @Transactional註解可以標註在

Spring底層AOP的原理示例（JDK動態代理和cglib動態代理）

1 JDK動態代理（必須要有介面） 介面 package com.itykd.dao; public interface UserDao { void save(); void update(); void find(); void delete(); } 實現

Spring AOP之---基於JDK動態代理和CGLib動態代理的AOP實現

AOP(面向切面程式設計)是OOP的有益補充，它只適合那些具有橫切邏輯的應用場合，如效能監測，訪問控制，事物管理，日誌記錄等。至於怎麼理解橫切邏輯，敲完例項程式碼也就明白了。 為什麼要使用AOP，舉個栗子：需要監測一些方法的執行所消耗的時間，在每個方法開始

Java框架學習_Spring（三）Spring_AOP底層實現：JDK動態代理和Cglib動態代理

AOP和IOC是Spring的兩大思想，AOP即面向切面程式設計，和OOP相輔相成，具體請看： AOP（面向切面程式設計） 這裡學習一下它的底層實現方法----動態代理，動態代理關鍵的是代理，就像你去公司辦事，你有什麼需求，不可能直接找到 boss（原始碼），而是通過祕書（代理）來實現你

Spring AOP底層實現- JDK動態代理和CGLIB動態代理

Spring AOP是執行時織入的，那麼執行時織入到底是怎麼實現的呢?答案就是代理物件。 代理又可以分為靜態代理和動態代理。 靜態代理：由程式設計師建立或特定工具自動生成原始碼，再對其編譯。在程式執行前，代理類的.class檔案就已經存在了。

Java動態代理（JDK介面代理和Cglib類代理）

代理模式 代理模式是常用的java設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理訊息等。代理類與委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物件本身並不真正實現服

spring aop原理 JDK動態代理和CGLIB動態代理

lan ble -- 自定義 and ets spec gen ase Spring的兩大特性是IOC和AOPIOC負責將對象動態的註入到容器，從而達到一種需要誰就註入誰，什麽時候需要就什麽時候註入的效果。理解spring的ioc也很重要。但是今天主要來和大家講講aop。A

spring AOP 動態代理 jkd動態代理和cglib動態代理 hibernate使用cglib延遲載入

spring 的AOP 實現 可以使用jdk的動態代理，也可以使用cglib的動態代理 先說下兩者區別： 靜態代理：代理之前就已經知道了代理者和被代理者 動態代理：代理之前並不清楚，在執行時使用反射機制動態生成代理類的位元組碼 無需我們手動編寫它的原始碼

Java的三種代理模式(Spring動態代理物件)

Java的三種代理模式 1.代理模式 代理(Proxy)是一種設計模式,提供了對目標物件另外的訪問方式;即通過代理物件訪問目標物件.這樣做的好處是:可以在目標物件實現的基礎上,增強額外的功能操作,即擴充套件目標物件的功能. 這裡使用到程式設計中的一個思想

java的jdk動態代理和cglib動態代理區別

java動態代理是利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。而cglib動態代理是利用asm開源包，對代理物件類的class檔案載入進來，通過修改其位元組碼生成子類來處理。1、如果目標物件實現了介面，預設情況下會採用

AOP之JDK動態代理和CGLib動態代理

測試結果 edit print handle es2017 brush 類庫 構建 sets 一、JDK動態代理 JDK內置的Proxy動態代理可以在運行時動態生成字節碼，而沒必要針對每個類編寫代理類。中間主要使用到了一個接口InvocationHandler與Proxy

SSM(六)JDK動態代理和Cglib動態代理

sys .com images 織入 load obj spa -1 instance 1.Cglib動態代理 目標類： 1 package cn.happy.proxy.cglib; 2 3 public class Service { 4 publ

03、動態代理--JDK動態代理和CGLib動態代理的組合實例

listen -- offer pri eth err imp instance music package com.offer.note.Java基礎.動態代理.CGLib引入增強; public interface Browser { void visitI