2020年12月10日星期四

6 代理模式

6 代理模式

module：spring-08-proxy

为什么要学习代理模式，因为AOP的底层机制就是动态代理！

代理模式：

  • 静态代理
  • 动态代理

image-20201210101410810

静态代理

静态代理角色分析

  • 抽象角色 : 一般使用接口或者抽象类来实现。
  • 真实角色 : 被代理的角色。
  • 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作。
  • 客户 : 使用代理角色来进行一些操作。

代码实现

Rent.java 抽象角色

package com.zzb.demo1;public interface Rent { public void rent();}

Host.java 真实角色

package com.zzb.demo1;// 真实角色，房东public class Host implements Rent{ public void rent() {  System.out.println("房东要出租房子！"); }}

Proxy.java 代理角色

package com.zzb.demo1;// 代理角色，中介public class Proxy implements Rent{ private Host host; public Proxy() { } public Proxy(Host host) {  this.host = host; } public void rent() {  seeHouse();  host.rent();  paper();  fare(); } // 中介带你看房 public void seeHouse(){  System.out.println("中介带你看房"); } // 签合同 public void paper(){  System.out.println("中介带你签合同"); } // 收房租 public void fare(){  System.out.println("中介收房租"); }}

Client.java 客户

package com.zzb.demo1;//客户类，一般客户都会去找代理！public class Client { public static void main(String[] args) {  //房东要租房  Host host = new Host();  //中介帮助房东  Proxy proxy = new Proxy(host);		  //你去找中介！  proxy.rent(); }}

分析：在上述代码过程中，客户直接接触到的是中介，就如同现实生活中的样子，客户见不到房东，但客户依旧可以通过中介租到房东的房子，这就是所谓的代理模式。程序源自于生活，所以学编程的人，应该更加抽象的看待生活中的事情。

静态代理的优点:

  • 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情；
  • 公共的业务由代理来完成，实现了业务的分工 ;
  • 公共业务发生扩展时变得更加集中和方便 。

缺点：

  • 类增多，多了代理类，工作量变大，开发效率降低

我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

1、创建一个抽象角色，业务为增删改查

package com.zzb.demo2;public interface UserService { void add(); void query(); void update(); void delete();}

2、创建一个真实对象，实现抽象接口

package com.zzb.demo2;public class UserServiceImpl implements UserService{ public void add() {  System.out.println("add"); } public void query() {  System.out.println("query"); } public void update() {  System.out.println("update"); } public void delete() {  System.out.println("delete"); }}

3、现在来了新需求，需要实现一个日志功能：

  • 思路1：在原实现类上增加日志功能代码！【麻烦】
  • 思路2：使用代理来做，能够在不改变原代码的情况下，实现此功能！

4、设置一个代理类来处理日志功能！代理角色

package com.zzb.demo2;public class UserServiceProxy implements UserService{ private UserService userServiceImpl; public void setUserServiceImpl(UserService userServiceImpl) {  this.userServiceImpl = userServiceImpl; } public void add() {  log("add");  userServiceImpl.add(); } public void query() {  log("query");  userServiceImpl.query(); } public void update() {  log("update");  userServiceImpl.update(); } public void delete() {  log("delete");  userServiceImpl.delete(); } // 输出日志 public void log(String msg){  System.out.println("使用" + msg + "方法"); }}

5、测试

@Testpublic void test(){ // 真实业务 UserServiceImpl userService = new UserServiceImpl(); // 代理类 UserServiceProxy proxy = new UserServiceProxy(); proxy.setUserServiceImpl(userService); proxy.add();}

测试结果：

使用add方法add

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。

纵向开发与横向开发：

image-20201210105557010

image-20201210105605226

动态代理

  • 动态代理的角色和静态代理的一样；
  • 动态代理的代理类是动态生成的，静态代理的代理类是我们提前写好的；
  • 动态代理分为两类 : 一类是基于接口动态代理，一类是基于类的动态代理；
    • 基于接口的动态代理——JDK动态代理；
    • 基于类的动态代理--cglib；
    • 现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist；
    • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类

核心 : InvocationHandler 调用处理程序 和 Proxy 代理

image-20201210111713555

InvocationHandler接口

image-20201210111819582

Proxy类

image-20201210112003108

image-20201210112038399

image-20201210113630245

代码实现：

1、Rent.java 抽象角色

package com.zzb.demo3;public interface Rent { public void rent(); public void goOut();}

2、Host.java 真实角色，房东

package com.zzb.demo3;public class Host implements Rent{ public void rent() {  System.out.println("房东出租房子"); } public void goOut() {  System.out.println("房东来了，快跑！"); }}

3、ProxyInvocationHandler. java 生成代理角色以及方法处理程序

package com.zzb.demo3;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;public class ProxyInvocationHandler implements InvocationHandler { //代理接口 Object target; public void setTarget(Object target) {  this.target = target; } // 生成代理类 public Object getProxy(){  return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } //代理实列的关联调用程序 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  seeHouse();  Object result = method.invoke(target, args);  fare();  return result; } public void seeHouse(){  System.out.println("中介带你看房子"); } public void fare(){  System.out.println("中介来收中介费！"); }}

4、测试，client

package com.zzb.demo3;public class Client { public static void main(String[] args) {  Rent host = new Host();  ProxyInvocationHandler pih = new ProxyInvocationHandler();  pih.setTarget(host);  // 生成代理实例  Rent proxy = (Rent) pih.getProxy();  // 调用代理实例处理应用程序  proxy.rent();  System.out.println("=============================");  proxy.goOut(); }}

测试结果：

中介带你看房子房东出租房子中介来收中介费！=============================中介带你看房子房东来了，快跑！中介来收中介费！

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

**动态代理的优点

静态代理有的它都有，静态代理没有的，它也有！

  • 可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情；
  • 公共的业务由代理来完成 . 实现了业务的分工；
  • 公共业务发生扩展时变得更加集中和方便；
  • 一个动态代理 , 一般代理某一类业务；
  • 一个动态代理可以代理多个类，代理的是接口！








原文转载：http://www.shaoqun.com/a/497506.html

FEN：https://www.ikjzd.com/w/2668

拍拍网：https://www.ikjzd.com/w/2205

dmm.adult：https://www.ikjzd.com/w/2026


6代理模式module：spring-08-proxy为什么要学习代理模式，因为AOP的底层机制就是动态代理！代理模式：静态代理动态代理静态代理静态代理角色分析抽象角色:一般使用接口或者抽象类来实现。真实角色:被代理的角色。代理角色:代理真实角色;代理真实角色后,一般会做一些附属的操作。客户:使用代理角色来进行一些操作。代码实现Rent.java抽象角色packagecom.zzb.demo1;p
易趣：易趣
粉丝通：粉丝通
舌尖上的威宁 ：舌尖上的威宁
麓湖儿童乐园团购多少钱？广州麓湖儿童乐园团购价格？：麓湖儿童乐园团购多少钱？广州麓湖儿童乐园团购价格？
汶川5A级景区再次向全社会征名 ：汶川5A级景区再次向全社会征名
发帖者 时间：

没有评论:

发表评论

订阅： 博文评论 (Atom)