java 静态代理

1、定义

　　为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。比如，租房的时候，中介就充当代理角色。

2、静态代理角色

　　抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

　　真实角色：被代理的角色，实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

　　代理角色：代理真实角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

 3、实例分析

　　我们以租房子为例子来解释什么叫静态代理。

　　HostRent.java  抽象角色类。

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

　　Host.java 真实角色(房东)

public class Host implements HostRent {

    @Override
    public void rent() {
        // TODO Auto-generated method stub
        System.out.println("房子出租!");
        
    }
    
}

　　Proxy.java 代理角色(中介)

public class Proxy implements HostRent{
    private Host host;
    @Override
    public void rent() {
        // TODO Auto-generated method stub
        host.rent();
    }
    
    public void setHost(Host host) {
        this.host = host;
    }
    
    public Proxy(Host host)
    {
        this.host = host;
    }
    
}

　　Client.java 客户

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
        
    }
}

这里的例子中，中介就代表了一个代理角色。这样的好处就是真实角色处理业务更加纯粹 ，不再关注一些公共的事情。从上面的例子中，可能还看不出有什么优势，我们再列举一个例子。

　　User.java 抽象角色类

public interface User {
    //添加数据
    public void add();
    // 更新数据
    public void update();
    // 删除数据
    public void delete();
    // 查询数据
    public void select();
}

　　UserImpl.java

package com.spring.staticProxy;

public class UserImpl implements User {

    @Override
    public void add() {
        System.out.println("添加数据");
    }

    @Override
    public void update() {
        System.out.println("更新数据");
    }

    @Override
    public void delete() {
        System.out.println("删除数据");
        
    }

    @Override
    public void select() {
        System.out.println("查询数据");
    }
    
}

　　我们想在UserImpl类里添加日志功能，这时就必须在每个方法里添加日志函数，如下

public class UserImpl implements User {

    @Override
    public void add() {
        System.out.println("添加数据");
    }

    @Override
    public void update() {
        log("update");
        System.out.println("更新数据");
    }

    @Override
    public void delete() {
        log("delete");
        System.out.println("删除数据");
        
    }

    @Override
    public void select() {
        log("select");
        System.out.println("查询数据");
    }
    
    private void log(String methodName)
    {
        System.out.println("执行"+methodName+"方法");
    }
    
}

这时，UserImpl类变得不纯粹，里面处理了逻辑业务，还有很多公共部分的代码，这时就需要一个代理，代理实现日志功能。整个代理类如下

public class Proxy implements User{
    
    private UserImpl user;
    @Override
    public void add() {
        log("add");
        user.add();
    }

    @Override
    public void update() {
        log("update");
        user.update();
    }

    @Override
    public void delete() {
        log("delete");
        user.delete();
    }

    @Override
    public void select() {
        log("select");
        user.select();
    }
    
    private void log(String methodName)
    {
        System.out.println("执行"+methodName+"方法");
    }
}

　　整个代理类就实现了日志功能，避免了在真实类里处理了逻辑业务，使整个真实类更加纯粹，里面只有对数据库的操作函数，并且把公共部分给提取出来。这就是静态代理。

　　在实际使用时，一个真实角色必须对应一个代理角色，但如果大量使用会导致类的急剧膨胀。比如想代理Host类和UserImpl类，则就需要两个代理类。其中动态代理类能够解决这种问题，他只需要一个代理类就能完成。以下是静态代理类的优缺点：

优点：

1、使得真实角色更加纯粹，不再去关注一些公共的业务。

2、公共业务由代理类来完成，实现业务分工。

3、当业务拓展时，只需要修改代理类，变得更加其中和方便

缺点：

1、多了代理类，工作量变大，开发效率变低