Spring中静态代理与动态代理的实现及区别对比分析_Java

spring中静态代理与动态代理的区别

前言

代理模式在java中特别常见，如spring aop功能就是用代理来实现的。代理模式作用是：在不修改被代理对象功能的基础上，通过对代理类进行扩展，进行一些功能上的附加与增强。
一般使用代理模式我们需要先定义一个接口，静态代理只是一种简单的java代码功能扩展。而动态代理利用了反射机制，使用更简单。

无论是静态代理还是动态代理，都有四大角色：

抽象角色：一般会使用接口或者抽象类来解决
真实角色:被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人

静态代理（中介租房案例）

首先，定义一个接口（rent），房东类（host）实现该接口，并输出自己房子的相关信息。

//租房
public interface rent {
    public  void rent();
}

//房东
public class host implements rent{
    public void rent() {
        system.out.println("我的房子是蓝色的，准备出租房子！");
    }
}

房东将房子交给中介，此时的中介相当于代理类，故创建代理类（proxy），代理类在不修改被代理对象功能的基础上(host类的rent方法)，可以对代理类进行扩展，进行一些功能上的附加与增强（增加seehouse、hetong、fare方法）。

public class proxy implements rent{
    private host host;
    public proxy(){ }
    public proxy(host host){
        this.host=host;
    }
    public void rent() {
        seehouse();
        host.rent();
        hetong();
        fare();
    }
    //看房
    public void seehouse(){
        system.out.println("中介带你看房子");
    }
    //签合同
    public void hetong(){
        system.out.println("签合同");
    }
//    收费
    public void fare(){
        system.out.println("收中介费");
    }
}

客户购房不用面对房东，只需与中介对接。

public class client {
    public static void main(string[] args) {
        host host=new host(); //房东要出租房子
        //代理，中介帮房东租房子，但是代理角色一般会有一些附属操作
        proxy proxy=new proxy(host);
        //客户不用面对房东，直接找中介租房即可
        proxy.rent();
    }
}

上述代码就实现了静态代理，客户只需面向代理类操作即可。

运行截图：

静态代理的优点：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共也就交给代理角色，实现了业务的分工
业务发生扩展的时候，方便集中管理

静态代理的缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率变低。

动态代理

静态代理中，每个真实对象都会拥有一个代理类，这样将会十分繁琐，采用动态代理将会解决这种问题！我们在上述的中介租房案例中进行修改。

首先创建一个rent接口，并创建两个房东类实现rent接口。

//租房
public interface rent {
    public  void rent();
}

//房东1
public class host implements rent {
    public void rent() {
        system.out.println("我的房子是蓝色的，准备出租房子！");
    }
}

//别的房东
public class host_other implements rent{
    public void rent() {
        system.out.println("我的房子是红色的，准备出租房子！");
    }
}

如果采用静态代理，我们将要编写两个代理类，当房东数量很大时，这种处理方法明显不妥，因此我们可以编写一个代理工具类，该类并未指明代理的真实对象是哪一个，相当于我们之前学java时编写的math类（完成某种特定的计算过程)。

import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
//我们会用这个类自动生成代理类
public class proxyinvocationhandler implements invocationhandler {
    //被代理的接口
    private 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("收中介费");
    }
}

其中的target变量，就是未来客户类传入的真实对象。很明显，动态代理也能在不改变原有业务代码的基础上，实现对功能的扩展（seehouse等方法的加入）。

在客户类中，只需new多个代理工具类，并为他们传入相应的真实对象，就可以获取各个真实对象的rent方法。

public class client {
    public static void main(string[] args) {
        //真实角色
        host host=new host();
        //代理角色：现在没有
        proxyinvocationhandler pih=new proxyinvocationhandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.settarget(host);
        rent proxy=(rent)pih.getproxy();//这里的proxy就是动态生成的，我们并没有写这个类
        proxy.rent();
        system.out.println("--------------------------");
        //真实角色
        host_other host_other=new host_other();
        //代理角色：现在没有
        proxyinvocationhandler pih1=new proxyinvocationhandler();
        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih1.settarget(host_other);
        rent proxy1=(rent)pih1.getproxy();//这里的proxy1就是动态生成的，我们并没有写这个类
        proxy1.rent();
    }
}

运行结果见下图：

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给代理角色，实现了业务分工
公共业务发生扩展的时候，方便集中管理
一个动态代理类代理的是一个接口，一般就是对应的一类业务(多个类实现同一个接口，只要重写方法，客户端可以通过修改代理的真实对象来实现动态的代理）
多个房东同时卖房，他们的房子信息不一样，如果采用静态代理，需要为他们各自写一个代理类，就十分麻烦。我们可以采用动态代理的方法，让这些房东同时实现一个接口（rent）,这样我们在客户类只需要修改代理的真实对象，就可以得到每个房东各自的房子信息。