Java--设计模式之代理模式

于 2020-12-07 20:33:35 发布
阅读量110 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H_Q_Li/article/details/110832310
版权
本文详细介绍了Java中的静态代理和动态代理概念，通过代码示例展示了如何实现业务的分工与扩展。静态代理用于在不修改真实角色的基础上增加额外功能，但代码量大。动态代理则在运行时动态创建代理类，解决了静态代理的缺点，降低了代码冗余。通过InvocationHandler接口和Proxy类，动态代理能够在运行时灵活处理代理逻辑，如日志记录、权限校验等。
摘要由CSDN通过智能技术生成
静态代理
1、业务分工

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YlkvAPIT-1607344258660)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\1607074829487.png)]

从上面这张图，我们可以得出一共有四个角色，分别为：

  • 抽象角色：一般使用接口或者抽象类来实现（买房）

  • 真实角色：被代理的角色（房东）

  • 代理角色：代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作 .（中介）

  • 客户：使用代理角色来进行一些操作（客户）

2、步骤

接口

真实角色

代理角色

客户端访问

1、接口

//抽象角色
public interface Rent {
    void rent();
}

2、真实角色

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

3、代理角色

//代理角色(中介)
public class HostProxy implements Rent {

    Host host;

    public HostProxy(Host host) {
        this.host = host;
    }

    public void rent() {
        host.rent();
    }

    public void seeHouse() {
        System.out.println("中介带你看房");
    }

    public void fare() {
        System.out.println("收中介费");
    }

    public void heTong() {
        System.out.println("签合同");
    }
}

4、客户端访问

// 客户
public class Cilent {
    public static void main(String[] args) {
        Host host = new Host();
        HostProxy hostProxy = new HostProxy(host);
        hostProxy.seeHouse();
        hostProxy.heTong();
        hostProxy.fare();
        hostProxy.rent();
    }
}
3、代理模式的好处:
  • 可以是真实的角色的操作更加纯粹！不用过多的关注一些公共的业务
  • 公共的业务就交给代理角色！实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理
4、缺点
  • 一个真实的角色就会产生一个代理角色，代码量会翻一倍，开发效率低
再次理解静态代理

1、接口

//抽象角色
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2、真实角色

// 真实角色
public class UserServiceImpl implements  UserService {
    public void add() {
        System.out.println("增加用户");
    }

    public void delete() {
        System.out.println("删除用户");
    }

    public void update() {
        System.out.println("更新用户");
    }

    public void query() {
        System.out.println("查询用户");
    }
}

3、代理角色

public class UserServiceProxy implements UserService {

    UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void query() {
        log("query");
        userService.query();
    }

    // 日志方法
    public void log(String msg) {
        System.out.println("使用了"+msg+"方法");
    }
}

4、客户端访问

public class Client {
    public static void main(String[] args) {
        // 真实角色
        UserServiceImpl userService = new UserServiceImpl();

        UserServiceProxy proxy = new UserServiceProxy();
        proxy.setUserService(userService);
        proxy.add();
    }
}

代理模式可以在不修改被代理对象的基础上，通过扩展代理类，进行一些功能的附加与增强。值得注意的是，代理类和被代理类应该共同实现一个接口，或者是共同继承某个类。

动态代理

1、为什么需要？解决静态代理的缺点

2、动态代理的角色和静态代理一样

上一节代码中 HostProxy和 UserServiceProxy 类是代理，我们需要手动编写代码让HostProxy和 UserServiceProxy 分别实现 Rent和UserService接口，而在动态代理中，我们可以让程序在运行的时候自动在内存中创建一个实现 Rent和UserService 接口的代理，而不需要去定义 HostProxy和 UserServiceProxy 这两个类。这就是它被称为动态的原因。

1、前提需要了解两个类

InvocationHandler、Proxy

InvocationHandler

1、每个代理的实例都有一个与之关联的 InvocationHandler 实现类，如果代理的方法被调用，那么代理便会通知和转发给内部的 InvocationHandler 实现类，由它决定处理。

2、方法

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

InvocationHandler 内部只是一个 invoke() 方法，正是这个方法决定了怎么样处理代理传递过来的方法调用。

  • proxy 代理对象
  • method 代理对象调用的方法
  • args 调用的方法中的参数

Proxy

1、 通过 Proxy 的静态方法 newProxyInstance 才会动态创建代理。

2、方法

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

下面讲解它的 3 个参数意义。

  • loader :自然是类加载器
  • interfaces :代码要用来代理的接口
  • h: 一个 InvocationHandler 对象

返回值：就是创建好的动态代理对象

2、步骤

1、抽象角色

//抽象角色
public interface Rent {
    void rent();
}

2、真实角色

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

3、 代理角色

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

// 代理角色
public class ProxyInvacationHandler implements InvocationHandler {

    // 被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    // 生成得到代理类
    public Object getProxy() {
       return  Proxy.newProxyInstance(this.getClass().getClassLoader(),
               rent.getClass().getInterfaces(),this);
    }

    // 处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质，就是使用反射机制实现
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return  result;
    }


    public void seeHouse() {
        System.out.println("我要看房子");
    }

    public void fare() {
        System.out.println("收中介费");
    }
}

4、客户端

public class Client {
    public static void main(String[] args) {
        // 真实角色
        Host host = new Host();

        // 代理角色：没有
        ProxyInvacationHandler proxyInvacationHandler = new ProxyInvacationHandler();
        // 通过调用程序处理角色来处理我们要调用的接口对象
        proxyInvacationHandler.setRent(host);

        Rent proxy = (Rent) proxyInvacationHandler.getProxy();// 这里的proxy就是动态生成的

        proxy.rent();
    }
}
3、好处
  • 可以是真实的角色的操作更加纯粹！不用过多的关注一些公共的业务
  • 公共的业务就交给代理角色！实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
再次理解动态代理

1、抽象角色

//抽象角色
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

2、真实角色

// 真实角色
public class UserServiceImpl implements  UserService {
    public void add() {
        System.out.println("增加用户");
    }

    public void delete() {
        System.out.println("删除用户");
    }

    public void update() {
        System.out.println("更新用户");
    }

    public void query() {
        System.out.println("查询用户");
    }
}

3、代理角色

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

// 代理角色
public class ProxyInvacationHandler implements InvocationHandler {


    // 被代理的接口
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    // 生成得到代理类
    public Object getProxy() {
       return  Proxy.newProxyInstance(this.getClass().getClassLoader(),
               object.getClass().getInterfaces(),this);
    }

    // 处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 动态代理的本质，就是使用反射机制实现
        log(method.getName());
        Object result = method.invoke(object, args);
        return  result;
    }

    // 增加日志
    public void log(String msg) {
        System.out.println("执行了"+msg+"方法");
    }
}

4、客户端

import com.hui.jingtaidaili.test.UserService;
import com.hui.jingtaidaili.test.UserServiceImpl;

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();

        ProxyInvacationHandler proxyInvacationHandler = new ProxyInvacationHandler();
        proxyInvacationHandler.setObject(userService);
        UserService proxy = (UserService) proxyInvacationHandler.getProxy();

        proxy.add();
    }
}
会飞的皮卡丘EI
关注
专栏目录
JAVA-设计模式-结构型模式-代理模式
08-10
JAVA-设计模式-结构型模式-代理模式
计算机后端-Java-图解java设计模式094 代理模式(4)-Cg.avi
05-23
计算机后端-Java-图解java设计模式094 代理模式(4)-Cg.avi
对Spring的理解
专注于JAVA WEB开发
11-11 8408
1.Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件中通过元素配置用于创建实例对象的类名和实例对象的属性。 2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），什么叫依赖注入呢
spring理解
z130532的博客
04-16 70
Spring的宣传口号中有以下几点： 1.针对接口编程 2.通过XML配置业务类 3.避免不必要的Singleton 4.DAO的封装 5.异常的处理 6.AOP 7.一些额外功能的支持 整个Spring可以这样说，通过配置文件对业务进行配置。 当然有些口号确实帮助程序减轻了开发工作，也使得Web开发更加容易，但是并不是所有的口号都描述了事实。 我的看法列在下面，供大家参...
Spring理解
zflyg的专栏
08-09 607
Spring 容器 启动容器 创建对象 作用域      scope 单例 多例 生命周期  inint()  destory()     关闭容器 AbstractXmlApplicationContext 延迟加载  lazy IOC 控制反转 DI注入   set注入  property name="" ref=""    构造器注入 constructor-arg index="" r...
计算机后端-Java-图解java设计模式095 代理模式(5).avi
05-23
计算机后端-Java-图解java设计模式095 代理模式(5).avi
计算机后端-Java-图解java设计模式093 代理模式(3).avi
05-23
计算机后端-Java-图解java设计模式093 代理模式(3).avi
计算机后端-Java-图解java设计模式092 代理模式(2).avi
05-23
计算机后端-Java-图解java设计模式092 代理模式(2).avi
Spring 理解
cxydkh的博客
09-18 3527
Spring 个人理解 1.概念 一个轻量级开源框架，拥有多个组件(Spring JDBC 、Spring MVC 、Spring Security(可用作单点登入)、 Spring AOP 、Spring ORM 、Spring Test)，主要解决业务逻辑层与其他各个层的耦合问题，因此将面向接口编程贯彻整个系统应用，核心即控制反转Ioc与面向切面编程Aop，最为典型的当属数据库事务的使用，还能整合开源世界众多著名的第三方框架和类库，应该说Spring框架已经融入到了Java EE的各个开发领域。 2.优
Spring的理解
小魏的博客
10-10 628
Spring是什么？ spring核心：IOC（DI）控制反转+AOP面向切面编程 spring功能： spring中可以使用Java注解以及XML文件对容器内的bean对象进行组合实现复杂功能；spring可以很好的整合其他开源框架以及类库。 在没有spring以前，我们需要一个类似的bean对象，需要自己主动创建，而现在只需要提出这样的一个需求，springIOC就会通过配置文件为我们注入该……
谈谈你对spring的理解？
weixin_30606461的博客
12-15 227
spring么，就是春天了。春天，动物.....不可描述的季节……你懂得！！！ 希望这么说能把面试官逗乐吧。 spring可以实现java模块化开发，贯穿表现层，业务层，逻辑层，实现了各个层之间的解耦合关系。IOC：原来service层需要dao层的对象，我们需要直接new出来，而有了spring之后，各个层对象的创建都交给spring来完成，再通过注入的方式将dao对象注入到service层...
spring的理解
guchuqi的博客
06-24 72
spring概念:Spring是J2EE应用程序框架，是轻量级的框架，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和SpringMVC框架，mybatis框架等组合使用. spring的核心:IOC和AOP; 【IOC】:Inversion of Control，即“控制反转”,不是什么技术而是一种设计思想,在传统Java开发中，我们直接在对象内部通过new进行创...
Java设计模式：代理模式详解
"Java设计模式之代理模式篇上" 在软件开发中，代理模式是一种常用的设计模式，它允许我们创建一个代表另一个对象的对象，这个代表对象（代理）可以在调用真实对象的方法之前或之后添加额外的功能，或者控制对真实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值