欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java代理模式的深入了解

程序员文章站 2022-06-16 20:45:51
目录一、静态代理模式1.1、 代理模式的定义:1.2、代理模式的优缺点二、动态代理模式总结一、静态代理模式1.1、 代理模式的定义:由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问...

一、静态代理模式

1.1、 代理模式的定义:

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问对象不适合或者不能直接引用目标对象,代理对象作为访问对象和目标对象之间的中介。

比如在有些情况下,一个客户不能或者不想直接访问另一个对象,这时需要找一个中介帮忙完成某项任务,这个中介就是代理对象。例如,购买火车票不一定要去火车站买,可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

        Java代理模式的深入了解

静态代理:由程序员创建代理类或特定工具自动生成源代码再对其编译,在程序运行前代理类的 .class 文件就已经存在了。

代码实例:实现增删改查操作,通过代理

接口:

package com.proxypattern.staticproxy2;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname userservice
 * @date 2021/12/27 17:54
 * @description 服务接口
 */
public interface userservice {
    void add();
    void delete();
    void update();
    void query();
}

真实类(这里是服务类)

package com.proxypattern.staticproxy2;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname userserviceimp
 * @date 2021/12/27 17:55
 * @description 服务实现类
 */
public class userserviceimp implements userservice{
    @override
    public void add() {
        system.out.println("添加了一条数据");
    }
    @override
    public void delete() {
        system.out.println("删除了一条数据");
    }
    @override
    public void update() {
        system.out.println("修改了一条数据");
    }
    @override
    public void query() {
        system.out.println("查询了一条数据");
    }
}

代理类

package com.proxypattern.staticproxy2;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname userserviceproxy
 * @date 2021/12/27 17:56
 * @description 服务代理类
 */
public class userserviceproxy implements userservice {
    private userserviceimp userserviceimp;
    public userserviceproxy() {
    }
    public void setuserserviceimp(userserviceimp userserviceimp) {
        this.userserviceimp = userserviceimp;
    }
    @override
    public void add() {
        getlog("add");
        userserviceimp.add();
    }
    @override
    public void delete() {
        getlog("delete");
        userserviceimp.delete();
    }
    @override
    public void update() {
        getlog("update");
        userserviceimp.update();
    }
    @override
    public void query() {
        getlog("add");
        userserviceimp.query();
    }
    public void getlog(string message) {
        system.out.println("日志:" + message + "语句执行了");
    }
}

客户端测试类

package com.proxypattern.staticproxy2;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname customer
 * @date 2021/12/27 18:00
 * @description 客户终端测试类
 */
public class customer {
    public static void main(string[] args) {
        userserviceimp userserviceimp = new userserviceimp();
        userserviceproxy p = new userserviceproxy();
        p.setuserserviceimp(userserviceimp);
        p.add();
        p.update();
        p.delete();
        p.query();
    }
}
/**
 * 执行结果:
 * 日志:add语句执行了
 * 添加了一条数据
 * 日志:update语句执行了
 * 修改了一条数据
 * 日志:delete语句执行了
 * 删除了一条数据
 * 日志:add语句执行了
 * 查询了一条数据
 */

        上述代码看到我们并没有使用userserviceimp去执行方法,而是使用了一个代理类去执行,这就是代理模式,类似于你租房并没有找房东租房,而是找的一个中间代理人中介来完成租房这个动作。

1.2、代理模式的优缺点

那么代理模式有哪些优点呢?

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

缺点

1、代理模式会造成系统设计中类的数量增加

2、在客户端和目标对象之间增加一个代理对象,会造成请求处理速度变慢;

3、增加了系统的复杂度;

 如何解决这些问题呢?就靠下面的动态代理模式来解决

二、动态代理模式

动态,是指在程序运行时,运用反射机制动态创建而成

没错,动态的代理模式使用的是反射,而且要自己写一个动态代理类去动态的获取一个代理类

代码实例:案例同上,只不过采用的是动态代理模式

服务实现类(真实类)

package com.proxypattern.staticproxy2;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname customer
 * @date 2021/12/27 18:00
 * @description 客户终端测试类
 */
public class customer {
    public static void main(string[] args) {
        userserviceimp userserviceimp = new userserviceimp();
        userserviceproxy p = new userserviceproxy();
        p.setuserserviceimp(userserviceimp);
        p.add();
        p.update();
        p.delete();
        p.query();
    }
}
/**
 * 执行结果:
 * 日志:add语句执行了
 * 添加了一条数据
 * 日志:update语句执行了
 * 修改了一条数据
 * 日志:delete语句执行了
 * 删除了一条数据
 * 日志:add语句执行了
 * 查询了一条数据
 */

接口:

package com.proxypattern. autoproxy;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname userservice
 * @date 2021/12/27 17:54
 * @description 服务接口
 */
public interface userservice {
    void add();
    void delete();
    void update();
    void query();
}

动态代理类,这个几乎可以做一个工具类使用,因为格式固定        

package com.proxypattern.autoproxy;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.autoproxy
 * @classname proxyinvocationhandler
 * @date 2021/12/27 19:33
 * @description 动态代理类
 */
public class proxyinvocationhandler implements invocationhandler {
    //被代理的接口
    private object target;
    public void settarget(object target) {
        this.target = target;
    }
    /**
     * @date  2021/12/27 19:36
     * @param
     * @return object
     * @metodname getproxy
     * @author wang
     * @description 生成得到代理类
     */
    public object getproxy() {
        return proxy.newproxyinstance(this.getclass().getclassloader(),target.getclass().getinterfaces(),this);
    }
    /**
     * @date  2021/12/27 19:34
     * @param
     * @param proxy
     * @param method
     * @param args
     * @return object
     * @metodname invoke
     * @author wang
     * @description 处理代理实例,并返回结果
     */
    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        log(method.getname());
        object result = method.invoke(target, args);
        return result;
    }
    public void log(string message) {
        system.out.println("日志:" + message + "语句执行了" );
    }
}

客户端测试类:

package com.proxypattern.autoproxy;
/**
 * @author wang
 * @version 1.0
 * @packagename com.proxypattern.staticproxy2
 * @classname customer
 * @date 2021/12/27 18:00
 * @description 客户终端测试类
 */
public class customer {
    public static void main(string[] args) {
       //真实角色
        userservice userservice = new userserviceimp();
        //代理角色
        proxyinvocationhandler pih = new proxyinvocationhandler();
        //动态设置代理的对象
        pih.settarget(userservice);
        //动态生成代理类
        userservice proxy = (userservice) pih.getproxy();
        proxy.query();
        proxy.update();
    }
}
/**
 * 日志:query语句执行了
 * 查询了一条数据
 * 日志:update语句执行了
 * 修改了一条数据
 */

可以看到我们这里可以更方便的去获取代理类了,只需要将动态设置代理类那里的对象改一下,就可以去代理别的类。

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!