爱游戏全站app官网入口-爱游戏官网

java进阶知识20 spring的代理模式 -爱游戏全站app官网入口

2023-08-21,,

本文知识点(目录):

1、概念
  2、代理模式
      2.1、静态代理
      2.2、动态代理
      2.3、cglib子类代理



1、概念

1、工厂模式
  2、 单例模式

代理(proxy):是一种设计模式, 提供了 对目标对象的另外一种访问方式;即通过代理来访问目标对象*(好比:某位商家去找某个明星来代言他的产品,这位商家得先去找这位明星的经纪人)。
  这样好处:可以在目标对象实现的基础上,增强额外的功能操作,也就是扩展目标对象的功能,过滤等。[用户------->代理------->目标对象]

2、代理模式

2.1、静态代理(不推荐使用)

用到的jar包:junit-4.7.jar

实例:

 public interface iuserdao {//接口类
public void save();
} //--------------------------------- public class userdao implements iuserdao { //实现类 @override
public void save() {
// system.out.println("开启事务......"); //这一步,交给代理来做 system.out.println("保存用户成功!"); // session.save(obj); // system.out.println("提交事务......"); //这一步,交给代理来做
}
}

静态代理工厂类

 package com.shore.dao.proxy;
 import com.shore.dao.iuserdao;
import com.shore.dao.impl.userdao; /**
* @author dshore/2019-10-28
*
*/
public class userdaoproxy implements iuserdao {
// 目标对象
iuserdao target = new userdao(); // 构造器
public userdaoproxy(iuserdao target) {
super();
this.target = target;
} @override
public void save() {
system.out.println("开启事务......"); target.save(); system.out.println("提交事务......");
}
}

测试类

 package com.shore.test;
 import org.junit.test;
 import com.shore.dao.iuserdao;
import com.shore.dao.impl.userdao;
import com.shore.dao.proxy.userdaoproxy; /**
* @author dshore/2019-10-28
*
*/
public class mytest {
@test
public void teststaticproxy() {
//目标
iuserdao target = new userdao();
//代理
iuserdao userdaoproxy = new userdaoproxy(target);
userdaoproxy.save();
}
}

测试结果图:

  总结:

      a) 开闭原则:对功能的扩展是开放的,对功能的修改是关闭的。(一般情况下,一个成熟的项目发布后,不建议再对源码进行修改)
      b) 代理对象,要实现与目标对象一样的接口
  缺点:
      a) 如果每一个类都需要代理,就会产生很多代理对象
      b) 一旦接口增加方法,目标对象和代理对象都需要维护

2.2、动态代理

1、代理对象,不需要实现接口;
    2、代理对象的生成,是利用jdkapi,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象、实现的接口的类型);
    3、动态代理,jdk代理,接口代理;

用到的jar包:junit-4.7.jar

实例:

 public interface iuserdao {//接口
public void save();
} //------------------------------------------ public class userdao implements iuserdao { //实现类 @override
public void save() {
// system.out.println("开启事务======="); //动态代理,这一步交给代理工厂做了 system.out.println("保存用户成功!"); // 相当于session.save(obj); //持久化操作 // system.out.println("提交事务======="); //动态代理,这一步也是交给代理工厂做了
}
}

动态代理工厂类 (不需要 实现接口)

 package com.shore.dao.factory;
 import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy; /**
* @author dshore/2019-10-28
*
*/
public class proxyfactory { // 维护一个目标对象
private object target; public proxyfactory(object target) {
super();
this.settarget(target);
} // 创建代理
public object getproxyinstance() throws illegalargumentexception {
return proxy.newproxyinstance(target.getclass().getclassloader(), // 定义代理类的类加载器
target.getclass().getinterfaces(), // 代理类要实现的接口列表(获取所有接口)
new invocationhandler() { // 指派方法调用的调用处理程序
@override
public object invoke(object proxy, method method,
object[] args) throws throwable {
system.out.println("开启事务======="); object returnvalue = method.invoke(target, args); // 放行 system.out.println("提交事务=======");
return returnvalue;
}
});
} public object gettarget() {
return target;
} public void settarget(object target) {
this.target = target;
}
}

测试类

 package com.shore.test;
 import org.junit.test;
 import com.shore.dao.iuserdao;
import com.shore.dao.factory.proxyfactory;
import com.shore.dao.impl.userdao; /**
* @author dshore/2019-10-28
*
*/
public class mytest {
@test
public void testdynamicproxy() {
// 目标
iuserdao target = new userdao();
// 代理
iuserdao userdaoproxy = (iuserdao) new proxyfactory(target).getproxyinstance();
//system.out.println(userdaoproxy.getclass()); // 返回值:class $proxy4 (com.sun.proxy.$proxy4)
userdaoproxy.save();
}
}

测试结果图:

  总结:
      代理对象不需要实现接口,但是目标对象一定要实现接口;否则不能用动态代理!

      (class  $proxy0  implements iuserdao),在内存中创建了一个代理对象$proxy0

2.3、cglib子类代理

2.3.1、cglib代理,也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

1、jdk的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类,就可以使用cglib实现。 
    2、cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口。它广泛的被许多aop的框架使用,例如spring aop和dynaop,为他们提供方法的interception(拦截)。 
    3、cglib包的底层是通过使用一个小而快的字节码处理框架asm,来转换字节码并生成新的类。不鼓励直接使用asm,因为它要求你必须对jvm内部结构包括class文件的格式和指令集都很熟悉。

2.3.2、 实例:

用到的jar包:junit-4.7.jar 和 spring-core-3.2.5.jar

 package com.shore.dao;
 /**
* @author dshore/2019-10-28
*
*/
public class userdao{ public void save() {
// system.out.println("开启事务......"); //这一步,交给代理来做 system.out.println("保存用户成功!"); // session.save(obj); // system.out.println("提交事务......"); //这一步,交给代理来做
}
}

代理工厂类

 package com.shore.dao.proxy;
 import java.lang.reflect.method;
 import org.springframework.cglib.proxy.enhancer;
import org.springframework.cglib.proxy.methodinterceptor;
import org.springframework.cglib.proxy.methodproxy; /**
* @author dshore/2019-10-28
*
*/
public class proxyfactory implements methodinterceptor {
// 维护一个目标对象
private object target; public proxyfactory(object target) {
super();
this.target = target;
} // 给目标对象创建一个代理对象
public object getproxyinstance() {
// 1、调用工具类
enhancer enhancer = new enhancer();
// 2、设置父类
enhancer.setsuperclass(target.getclass());
// 3、设置回调函数,执行target方法的时候,触发拦截器intercept方法
enhancer.setcallback(this);
return enhancer.create();
} @override
public object intercept(object object, method method, object[] objects,
methodproxy proxy) throws throwable {
system.out.println("开启事务-------"); object returnvalue = method.invoke(target, objects); //放行 system.out.println("提交事务-------");
return returnvalue;
} public object gettarget() {
return target;
} public void settarget(object target) {
this.target = target;
}
}

测试类:

 package com.shore.test;
 import org.junit.test;
 import com.shore.dao.userdao;
import com.shore.dao.proxy.proxyfactory; /**
* @author dshore/2019-10-28
*
*/
public class mytest {
@test
public void testcglibproxy() {
//目标
userdao target = new userdao();
//代理
userdao userdaoproxy = (userdao) new proxyfactory(target).getproxyinstance();
/**
* java定义class,英文字符中仅支持 $ 和 _
*/
//system.out.println(userdaoproxy.getclass()); //返回值:class com.shore.dao.userdao$$enhancerbycglib$$1543b6de
userdaoproxy.save();
}
}

测试结果图:

  注意:

      1、代理的类不能为final, 否则报错。
      2、目标对象的方法如果为final/static, 那么就不会被拦截,即不会执行目标对象额外的业务方法。

总结:虽然三种工厂模式都能实现一样的效果,但,静态工厂代理模式不推荐使用,如果,需要代理的类很多,就会很麻烦。

原创作者:dshore

作者爱游戏全站app官网入口主页:http://www.cnblogs.com/dshore123/

原文出自:https://www.cnblogs.com/dshore123/p/11753623.html

欢迎转载,转载务必说明出处。(如果本文对您有帮助,可以点击一下右下角的 推荐,或评论,谢谢!

java知识20 spring的代理模式的相关教程结束。

网站地图