【设计模式】Proxy 代理模式
1.代理模式的定义
代理模式：为另一个对象提供一个替身或占位符以控制对这个对象的访问。
我们给出如下一个接口Moveable 和该接口的实现类：
Moveable.java
解决：我们可以通过在Tank.java的源码中插入自己的代码（红色部分），来统计这个move()方法的运行时间。
问题：如果我们不能对源码进行修改，或者你没有源码，比如这个方法是别人提供的包中提供的class文件。
现实意义是我们对java进行性能测试，我们就需要对各个方法前后记录时间，打印日志等。
方法1：使用继承重写方法，把原来的方法前后添加一些逻辑。
对Tank2调用move()方法，它永远调用的是父类的方法，从这个角度上来说它是父类的一个代理。
Tank2.java
方法2：使用聚合的方式
Tank3在调用move方法的时候永远调用的是实现Moveable接口的实现类的move()方法。
在这种情况下Tank3相当于Moveable实现类的一个代理，将具体的实现替换成特定类。
Tank3.java
以上两种方式聚合要好与继承的方式，
原因：当我们需要添加的事物变得比较多时（比如在方法开始结束时不仅还要记录时间，检查权限，日志等），
继承会比较多，而聚合就可以很好的处理各个功能上的叠加的情况。
假设：我们需要在调用move()方法前先记录日志，在记录时间
TankLogProxy.java
3.代理模式类图
4.动态代理的引入
动态代理的目标：解决类太多的问题，为了可以对任意的对象、任意的接口方法，实现任意的代理。
静态代理：我们的代理类是需要具体写出来的。
动态代理：不关心生成代理类的名称。用户需要的代理对象由Proxy代理类直接产生。
问题：那么这个代理类Proxy如何产生代理对象。
1.假设我们能够将一段源码的字符串进行编译（动态编译），产生一个新的类（我们实现逻辑的代理类）。
对于以上的例子我们可以这样描述：我们在源文件中删除TankTimeProxy.java文件，把TankTimeProxy.java源码作为字符串，
进行动态编译，就相当于产生了TankTimeProxy对象，这段代码我们想完成什么逻辑，就完成我们自己的业务逻辑。
问题来了：我们如何动态编译这段代码
解决：Jdk6 Complier API, CGLib, ASM
2.把这个新的类Load到内存，再由这个新的类产生新的对象（代理类生成的对象）。
例子：
下面我们来模拟下动态代理的过程（实际上字符串源码部分我们也是可以动态生成的，
为了简单起见，我们先把字符串源码写死）
解决：我们把接口也作为参数传进去。
问题2：对于接口的方法是不可以写死的，我们要能够使用户动态指定对接口方法的处理方式
解决：定义处理逻辑的接口InvocationHandler，对方法的处理放在实现中，由具体的子类实现代理逻辑，
封装InvocationHandler中。
2.静态代理
首先我们通过案例来引出为什么我们需要使用代理模式。我们给出如下一个接口Moveable 和该接口的实现类：
Moveable.java
package com.proxy;
public interface Moveable {
void move();
}package com.proxy;
import java.util.Random;
public class Tank implements Moveable{
@Override
public void move() {
//long start = System.currentTimeMillis();
//System.out.println("Tank Moving...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
//long end = System.currentTimeMillis();
//System.out.println("time:"+(end-start));
}
}解决：我们可以通过在Tank.java的源码中插入自己的代码（红色部分），来统计这个move()方法的运行时间。
问题：如果我们不能对源码进行修改，或者你没有源码，比如这个方法是别人提供的包中提供的class文件。
现实意义是我们对java进行性能测试，我们就需要对各个方法前后记录时间，打印日志等。
方法1：使用继承重写方法，把原来的方法前后添加一些逻辑。
对Tank2调用move()方法，它永远调用的是父类的方法，从这个角度上来说它是父类的一个代理。
Tank2.java
package com.proxy;
/**
* 通过继承的方式来实现记录方法move()的运行时间
*/
public class Tank2 extends Tank {
public void move(){
long start = System.currentTimeMillis();
super.move();
long end = System.currentTimeMillis();
System.out.println("time:"+(end-start));
}
}
方法2：使用聚合的方式
Tank3在调用move方法的时候永远调用的是实现Moveable接口的实现类的move()方法。
在这种情况下Tank3相当于Moveable实现类的一个代理，将具体的实现替换成特定类。
Tank3.java
package com.proxy;
import com.proxy.Moveable;
public class TankTimeProxy implements Moveable {
Moveable t;
public TankTimeProxy(Moveable t) {
this.t = t;
}
public void move() {
long start = System.currentTimeMillis();
System.out.println("startTime:" + start);
this.t.move();
long end = System.currentTimeMillis();
System.out.println("time:" + (end - start));
}
}
以上两种方式聚合要好与继承的方式，
原因：当我们需要添加的事物变得比较多时（比如在方法开始结束时不仅还要记录时间，检查权限，日志等），
继承会比较多，而聚合就可以很好的处理各个功能上的叠加的情况。
假设：我们需要在调用move()方法前先记录日志，在记录时间
TankLogProxy.java
package com.proxy;
public class TankLogProxy implements Moveable{
Moveable t;
public TankLogProxy(Moveable t){
super();
this.t = t;
}
@Override
public void move() {
System.out.println("Tank Start ....");
t.move();
System.out.println("Tank Stop ....");
}
package com.proxy;
public class TankTimeProxy implements Moveable {
Moveable t;
public TankTimeProxy(Moveable t){
super();
this.t = t;
}
@Override
public void move() {
long start = System.currentTimeMillis();
System.out.println("startTime:"+start);
t.move();
long end = System.currentTimeMillis();
System.out.println("time:"+(end-start));
}
}package com.proxy;
public class Client {
public static void main (String [] args){
//先记录日志，再记录时间
Tank t = new Tank();
TankTimeProxy ttp = new TankTimeProxy(t);
TankLogProxy tlp = new TankLogProxy(ttp);
Moveable m = tlp;
m.move();
/**先记录时间，再记录日志*/
/**
Tank t = new Tank();
TankLogProxy tlp = new TankLogProxy(t);
TankTimeProxy ttp = new TankTimeProxy(tlp);
Moveable m = ttp;
m.move();
*/
}
}
Tank Start ....
startTime:1465278163874
Tank Moving...
time:4330
Tank Stop ....3.代理模式类图
4.动态代理的引入
动态代理的目标：解决类太多的问题，为了可以对任意的对象、任意的接口方法，实现任意的代理。
静态代理：我们的代理类是需要具体写出来的。
动态代理：不关心生成代理类的名称。用户需要的代理对象由Proxy代理类直接产生。
问题：那么这个代理类Proxy如何产生代理对象。
1.假设我们能够将一段源码的字符串进行编译（动态编译），产生一个新的类（我们实现逻辑的代理类）。
对于以上的例子我们可以这样描述：我们在源文件中删除TankTimeProxy.java文件，把TankTimeProxy.java源码作为字符串，
进行动态编译，就相当于产生了TankTimeProxy对象，这段代码我们想完成什么逻辑，就完成我们自己的业务逻辑。
问题来了：我们如何动态编译这段代码
解决：Jdk6 Complier API, CGLib, ASM
2.把这个新的类Load到内存，再由这个新的类产生新的对象（代理类生成的对象）。
例子：
下面我们来模拟下动态代理的过程（实际上字符串源码部分我们也是可以动态生成的，
为了简单起见，我们先把字符串源码写死）
package com.proxy.test;
import com.proxy.Moveable;
import com.proxy.Tank;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.net.URL;
import java.net.URLClassLoader;
public class Test1 {
public static void main(String[] args) throws Exception {
String rt = "\r\n";
String src = "package com.proxy;" + rt +
" public class TankTimeProxy implements Moveable {" + rt +
" Moveable t;" + rt +
" public TankTimeProxy(Moveable t){" + rt +
" super();" + rt +
" this.t = t;" + rt +
" }" + rt +
" @Override" + rt +
" public void move() {" + rt +
" long start = System.currentTimeMillis();" + rt +
" System.out.println(\"startTime:\"+start);" + rt +
" t.move();" + rt +
" long end = System.currentTimeMillis();" + rt +
" System.out.println(\"time:\"+(end-start));" + rt +
" }" + rt +
" }";
//我们想让这段代码编译，如何做呢？
//1.首先，我们可以把这段代码写到临时文件中
String fileName = System.getProperty("user.dir") +
"/src/com/proxy/TankTimeProxy.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//2.编译生成的Java文件生成class文件
//获取此平台提供的 Java™ 编程语言编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMagr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMagr.getJavaFileObjects(fileName);
JavaCompiler.CompilationTask t = compiler.getTask(null, fileMagr, null, null, null, units);
t.call();
fileMagr.close();
//3.将编译生成的class的load 到内存，生成新对象
//注意：使用ClassLoader（）必须保证那个class在classPath路径下，
//所以我们使用URLClassLoader
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.proxy.TankTimeProxy");
System.out.println(c);
//4.生成代理类对象
Constructor ctr = c.getConstructor(Moveable.class);
Moveable m = (Moveable)ctr.newInstance(new Tank());
m.move();
}
}class com.proxy.TankTimeProxy
startTime:1465283901100
Tank Moving...
time:1043解决：我们把接口也作为参数传进去。
问题2：对于接口的方法是不可以写死的，我们要能够使用户动态指定对接口方法的处理方式
解决：定义处理逻辑的接口InvocationHandler，对方法的处理放在实现中，由具体的子类实现代理逻辑，
封装InvocationHandler中。
下面我们来模拟JDK动态代理的实现来进行讲解。
1.定义InvocationHandler接口，我们将代理对象的方法处理逻辑放在InvocationHandler实现的子类中。
处理的具体方式是由其子类来决定的。
InvocationHandler.java
问题的关键：我们如何动态产生代理对象呢？
解决：这个方法有两个参数，
Class infce：为了对不同的接口进行代理，我们把接口作为参数传递进去。
InvocationHandler h：对方法的逻辑的处理，我们 通过InvocationHandler 具体子类来实现，并做为入参传递给代理类。
这样一来我们就可以对任意的对象（target）、任意的接口方法(infce)、实现任意的代理(InvocationHandler)。
Proxy.java
a.目标类：Tank.java
我们有一个Tank对象，Tank对象实现了Moveable接口，里面有个move方法，现在我想在Tank的move()方法前后增加一些自己的处理逻辑。
首先我们定义了自己的逻辑：这个逻辑就是，TimeHandler（自己写的代理逻辑处理类），可以将代理对象存到这个类中去我会把我定义的Tank的对象交给TimeHandler对象。
这样TimeHandler调用Tank里面的方法的时候，会先执行自己的逻辑然后Tank的方法，最后后面的逻辑。
再举一个数据库添加记录的例子。
UserMgr.java 共同的接口
具体的测试案例
JDK中的动态代理是通过2个类来实现的：
InvocationHandler：
1.定义InvocationHandler接口，我们将代理对象的方法处理逻辑放在InvocationHandler实现的子类中。
处理的具体方式是由其子类来决定的。
InvocationHandler.java
package com.proxy;
import java.lang.reflect.Method;
//为方法处理逻辑定义一个统一的接口
public interface InvocationHandler {
public void invoke(Object o, Method m);
}问题的关键：我们如何动态产生代理对象呢？
解决：这个方法有两个参数，
Class infce：为了对不同的接口进行代理，我们把接口作为参数传递进去。
InvocationHandler h：对方法的逻辑的处理，我们 通过InvocationHandler 具体子类来实现，并做为入参传递给代理类。
这样一来我们就可以对任意的对象（target）、任意的接口方法(infce)、实现任意的代理(InvocationHandler)。
Proxy.java
package com.proxy;
import javax.tools.JavaCompiler;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
import java.io.File;
import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class Proxy {
public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception {
String rt = "\r\n";
String methodStr = "";
Method[] methods = infce.getMethods();
/**写一个循环，将所用的方法都拿出来*/
for(Method m : methods) {
methodStr += "@Override" + rt +
"public void " + m.getName() + "() {" + rt +
" try {" + rt +
" Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
" h.invoke(this, md);" + rt +
" }catch(Exception e) {e.printStackTrace();}" + rt +
"}";
}
String src = "package com.proxy;" + rt +
"import java.lang.reflect.Method;" + rt +
" public class $Proxy1 implements "+infce.getName()+" {" + rt +
" com.proxy.InvocationHandler h;" + rt +
" public $Proxy1(InvocationHandler h){" + rt +
" this.h = h;" + rt +
" }" + rt +
methodStr +
" }";
//1.首先，我们可以把这段代码写到临时文件中
String fileName = System.getProperty("user.dir") +
"/src/com/proxy/$Proxy1.java";
File f = new File(fileName);
FileWriter fw = new FileWriter(f);
fw.write(src);
fw.flush();
fw.close();
//2.编译生成的Java文件生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileMagr = compiler.getStandardFileManager(null, null, null);
Iterable units = fileMagr.getJavaFileObjects(fileName);
JavaCompiler.CompilationTask t = compiler.getTask(null, fileMagr, null, null, null, units);
t.call();
fileMagr.close();
//3.将编译生成的class的load 到内存，生成新对象
URL[] urls = new URL[]{new URL("file:/" + System.getProperty("user.dir") + "/src")};
URLClassLoader ul = new URLClassLoader(urls);
Class c = ul.loadClass("com.proxy.$Proxy1");
System.out.println(c);
//4.生成代理类对象
Constructor ctr = c.getConstructor(InvocationHandler.class);
Object m = ctr.newInstance(h);
return m;
}
}
a.目标类：Tank.java
package com.proxy;
import java.util.Random;
public class Tank implements Moveable{
@Override
public void move() {
System.out.println("Tank Moving...");
try {
Thread.sleep(new Random().nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}package com.proxy;
import java.lang.reflect.Method;
public class TimeHandler implements InvocationHandler {
private Object target; //定义被代理对象的一个引用
public TimeHandler(Object target){
super();
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
long start = System.currentTimeMillis();
System.out.println("startTime :"+start);
try {
m.invoke(target);//调用被代理对象的m方法
} catch (Exception e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("endTime :"+end);
System.out.println("useTime:" + (end-start));
}
}package com.proxy;
public class Client {
public static void main (String [] args) throws Exception {
Tank t = new Tank(); //定义一个被代理的对象
InvocationHandler h = new TimeHandler(t);
//调用Proxy.newProxyInstance()方法生成一个代理对象。
Moveable m = (Moveable) Proxy.newProxyInstance(Moveable.class, h);
m.move();
}
}
我们有一个Tank对象，Tank对象实现了Moveable接口，里面有个move方法，现在我想在Tank的move()方法前后增加一些自己的处理逻辑。
首先我们定义了自己的逻辑：这个逻辑就是，TimeHandler（自己写的代理逻辑处理类），可以将代理对象存到这个类中去我会把我定义的Tank的对象交给TimeHandler对象。
这样TimeHandler调用Tank里面的方法的时候，会先执行自己的逻辑然后Tank的方法，最后后面的逻辑。
再举一个数据库添加记录的例子。
UserMgr.java 共同的接口
package com.proxy.test2;
public interface UserMgr {
void addUser();
}package com.proxy.test2;
public class UserMgrImpl implements UserMgr {
@Override
public void addUser() {
System.out.println("1: 插入记录到user表");
System.out.println("2: 在另外一张表写日志");
}
}package com.proxy.test2;
import com.proxy.InvocationHandler;
import java.lang.reflect.Method;
public class TransactionHandler implements InvocationHandler {
private Object target;
public TransactionHandler(Object target) {
this.target = target;
}
@Override
public void invoke(Object o, Method m) {
System.out.println("Transaction Start");
try {
m.invoke(target);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("Transaction Commit");
}
}具体的测试案例
package com.proxy.test2;
import com.proxy.InvocationHandler;
import com.proxy.Proxy;
public class Client {
public static void main(String[] args) throws Exception {
UserMgr mgr = new UserMgrImpl();
InvocationHandler h = new TransactionHandler(mgr);
//TimeHandler h2 = new TimeHandler(h);
UserMgr u = (UserMgr) Proxy.newProxyInstance(UserMgr.class, h);
u.addUser();
}
}JDK中的动态代理是通过2个类来实现的：
InvocationHandler：
InvocationHandler 是代理实例的
调用处理程序 实现的接口
方法：Object invoke(Object proxy, Method method, Object [ ] args )
三个参数的含义依次是：代理的对象，代理的方法， 方法的参数
Proxy：返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
Static Object newProxyInstance(ClassLoader loader, Class<?> [ ] interfaces , InvocationHandler h ）
动态代理的作用：我不用修改原来的代码，我就可以在原来的代码中插入一些内容。也就是切面编程，AOP()Aspect oriented Programming ,
三个参数的含义依次是：代理的对象，代理的方法， 方法的参数
Proxy：返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
Static Object newProxyInstance(ClassLoader loader, Class<?> [ ] interfaces , InvocationHandler h ）
动态代理的作用：我不用修改原来的代码，我就可以在原来的代码中插入一些内容。也就是切面编程，AOP()Aspect oriented Programming ,
可插拔的【配置文件】，而且互相之间是可以叠加的。我们可以把上一个代理作为下一个代理的对象。
下面我们使用JDK动态代理举2个简单的案例：
PersonDao.java
public interface PersonDao {
public void savePerson();
}public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
}
Transaction.java
public class Transaction {
public void beginTransaction(){
System.out.println("begin transaction");
}
public void commit(){
System.out.println("commit");
}
}
MyInterceptor.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 1、引入personDao和Transaction
* 2、完成invoke方法
*/
public class MyInterceptor implements InvocationHandler{
private Object target;
private Transaction transaction;
public MyInterceptor(Object target,Transaction transaction){
this.target = target;
this.transaction = transaction;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//在invoke()中做事务判断。
if(method.getName().equals("savePerson")||method.getName().equals("updatePerson")){
this.transaction.beginTransaction();
method.invoke(this.target, args);//调用目标类的目标方法
this.transaction.commit();
}else{
method.invoke(this.target, args);//调用目标类的目标方法
}
return null;
}
}import java.lang.reflect.Proxy;
import org.junit.Test;
/**
* 问题：
* 1、拦截器中的invoke方法在什么时候被调用的?
* 在代理对象调用方法的时候，进入了拦截器中的invoke方法
* 2、拦截器中的method参数是什么？在什么时候由实参传递给形参的?
* 代理对象的方法的名称是什么，method参数就是什么
* 代理对象调用方法的时候，进入了拦截器中的invoke方法，这个时候，传递参数
* 3、生成的代理对象实现了接口，代理对象的方法体的内容是什么？
* 方法体的内容就是拦截器中的invoke方法体的内容
*
* jdkproxy的优点: 动态的产生代理对象，所以只需要用一个拦截器就可以了
* jdkproxy的缺点: 如果在invoke方法中做事务的判断，将是一件很复杂的事情
* 比如我们在Service接口中有20个类 ，20个方法。30个方法不需要事务，370 个方法需要事务。
* 在invoke中做事务判断很麻烦。程序员还是写拦截器了，写拦截器中的invoke方法了，所以invoke方法还需要修改 。
* 所以这个解决方式还是不靠谱。
*
* 说明： 目标类和代理类实现了共同的接口
*/
public class ProxyTest {
@Test
public void testProxy(){
PersonDao target = new PersonDaoImpl();
Transaction transaction = new Transaction();
MyInterceptor interceptor = new MyInterceptor(target, transaction);
/**
* 第一个参数: 目标类的类加载器
* 第二个参数: 目标类实现的所有的接口
* 第三个参数: 拦截器
*/
PersonDao personDao = (PersonDao)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), interceptor);
personDao.savePerson();
}
}begin transaction
save person
commit
SalaryManager.java
public interface SalaryManager {
public void showSalary();
}public class SalaryManagerImpl implements SalaryManager{
public void showSalary() {
System.out.println("正在查看工资");
}
}
Logger.java
public class Logger {
public void logging(){
System.out.println("logging");
}
}public class Security {
public void security(){
System.out.println("security");
}
}public class Privilege {
private String access;
public String getAccess() {
return access;
}
public void setAccess(String access) {
this.access = access;
}
}import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInterceptor implements InvocationHandler{
private Object target;
private Logger logger;
private Security security;
private Privilege privilege;
public MyInterceptor(Object target,Logger logger, Security security, Privilege privilege) {
super();
this.target = target;
this.logger = logger;
this.security = security;
this.privilege = privilege;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//启动日志
this.logger.logging();
//安全性的框架
this.security.security();
//判断权限
if(this.privilege.getAccess().equals("admin")){
method.invoke(this.target, args);//调用目标方法
}else{
System.out.println("没有权限执行");
}
return null;
}
}package com.itheima11.spring.proxy.salary;
import java.lang.reflect.Proxy;
import org.junit.Test;
public class SalaryTest {
@Test
public void testSalary(){
Logger logger = new Logger();
Security security = new Security();
Privilege privilege = new Privilege();
privilege.setAccess("xvcz");
SalaryManager target = new SalaryManagerImpl();
MyInterceptor interceptor = new MyInterceptor(target, logger, security, privilege);
SalaryManager salaryManager = (SalaryManager)Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),interceptor);
salaryManager.showSalary();
}
}
运行结果：
logging
security
没有权限执行
6.CGlib动态代理
cglib动态代理需要引入第三方Jar包，他与JDK代理模式的主要区别在于，JDK代理的目标类和代理类实现共同的接口，
CGLIB动态代理则是目标类是代理类的父类。
PersonDao.java
public interface PersonDao {
public void savePerson();
}public class PersonDaoImpl implements PersonDao{
public void savePerson() {
System.out.println("save person");
}
}public class Transaction {
public void beginTransaction(){
System.out.println("begin transaction");
}
public void commit(){
System.out.println("commit");
}
}import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
* 1、引入personDao和Transaction
* 2、完成invoke方法
*/
public class MyInterceptor implements MethodInterceptor{
private Object target;
private Transaction transaction;
public MyInterceptor(Object target,Transaction transaction){
this.target = target;
this.transaction = transaction;
}
//产生代理对象（这是一个代码增强机制，它是在JVM内部去实现的）
public Object createProxy(){
Enhancer enhancer = new Enhancer();
enhancer.setCallback(this);//this代表拦截器对象
enhancer.setSuperclass(target.getClass());//设置代理类的父类为目标类
return enhancer.create();
}
/**
* 该方法的内容和jdkpoxy中的invoke方法的内容是一样的
*/
public Object intercept(Object arg0, Method method, Object[] args,MethodProxy arg3) throws Throwable {
this.transaction.beginTransaction();
method.invoke(this.target, args);
this.transaction.commit();
return null;
}
}import org.junit.Test;
/**
* JDK代理和cglib代理的主要区别：
* Jdk代理的方式：目标类和代理类实现了共同的接口
* Cglib动态代理的方式：目标类是代理类的父类
*/
public class ProxyTest {
@Test
public void testProxy(){
PersonDaoImpl target = new PersonDaoImpl();
Transaction transaction = new Transaction();
MyInterceptor interceptor = new MyInterceptor(target, transaction);
PersonDaoImpl proxy = (PersonDaoImpl)interceptor.createProxy();
proxy.savePerson();
}
}begin transaction
save person
commit
扫一扫
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
