【AOP基础学习】代理模式和AOP

1.什么是代理模式

读不懂的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

定义解释：举一个例子，比如生活中租房： 我使用“x如”app，这个房源，我只需要找这个“x如”中介，看房，交钱我不用去找房东，这个中介帮房东把这些事情都做好了。

用代码来解释就是：

(租房子这个动作)

public interface Rent {
    public void rent();
}

(房东有房子出租)

房东类:

public class Host implements Rent{
    public void rent()
    {
        System.out.println("我有房子出租.");
    }

}

(中介帮房东挂房源)

中介类:

public class Proxy implements Rent{
    private Host host;

    public Proxy() {
    }

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

    @Override
    public void rent() {
        host.rent();
        inspectHouse();
        signContract();
    }
    public void inspectHouse()
    {
        System.out.println("找中介看房子.");
    }
    public void signContract()
    {
        System.out.println("找中介签合同");
    }
}

(我去租房)

客户类：

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

我只需要找租房中介就可以租到想要的房子，我也不知道这个房子是谁的房子，我只需要交钱入住就行。

2.为什么要使用代理模式

• 中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

　　　　解释：例如，我要租房，但是我找不到房源，所以我就只能去找中介。 而中介和房东都有 租房这一相同接口。他们都是向外租房的。

• 开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

　　这里就和面向切面编程有一点联系了，一个已经上线的程序，我想修改程序中某个方法的功能，这时候如果直接修改源程序代码，就会产生导致程序崩溃的可能性，这时候，我们可以通过一个代理类来完成这些方法。再像方法中加入我要增加的新功能。

代码示例：

我们要实现增删改查功能，首先定义一个接口。

public interface Service {
    public void add();
    public void delete();
    public void update();
    public void query();
}

定义一个实现增删改查接口的 ServiceImpl类。

public class ServiceImpl implements Service{
    public void add()
    {
        System.out.println("增加用户");
    }
    public void delete()
    {
        System.out.println("删除用户");
    }
    public void update()
    {
        System.out.println("更新用户");
    }
    public void query()
    {
        System.out.println("查询用户");
    }

}

我们项目已经上线了，这时候，我要给增删改查方法中加入日志功能。此时就不能再在源代码的基础上进行修改了。这样有可能导致程序崩溃。

这时候建立一个代理类。

public class ServiceProxy implements Service {
    private ServiceImpl service;

    public void setService(ServiceImpl service) {
        this.service = service;
    }

    @Override
    public void add() {
        log("add");
        service.add();
    }

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

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

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

我们就可以通过用实现代理类的方法从而达到我们预期的目标。

public class Client {
    public static void main(String[] args) {
        ServiceImpl service = new ServiceImpl();
        ServiceProxy proxy = new ServiceProxy();
        proxy.setService(service);

        proxy.add();
    }
}

这时候输出结果就为：

 

增加了一行日志输出效果。这就是所谓的 “开闭原则，增加功能。“

3.动态代理

• 动态代理类：在程序运行时，通过反射机制动态生成。

• 动态代理类通常代理接口下的所有类。

• 动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。

• 动态代理的调用处理程序必须事先InvocationHandler接口，及使用Proxy类中的newProxyInstance方法动态的创建代理类。

• Java动态代理只能代理接口，要代理类需要使用第三方的CLIGB等类库。

　　该文章通过代码比较详细的介绍了动态代理。

　　作者写的非常详细，可以帮助理解动态代理的机制。

　　https://blog.csdn.net/zs520ct/article/details/79593196

　　动态代理在后续AOP中，有很多的知识点对应，所以需要先理解深刻。再进行AOP学习。