AOP代理模式理解及使用

代理模式的定义

定义：给目标对象提供一个代理对象，并控制对目标对象的引用。
目的：1.通过代理对象，对原有的对象进行增强。2.通过引入代理对象的方式访问目标对象，简化目标对象给系统带来的复杂性。

1）静态代理模式类图

//接口
public interface InsertOp {
    void insertLog(String params);
}

//被代理对象
public class InserOpImp implements InsertOp {
    @Override
    public void insertLog(String params) {
        System.out.println("正在插入一条数据,参数为：" + params);
    }
}

//静态代理实现
public class StaticFactory implements InsertOp {
    InsertOp insertOp;

    public StaticFactory(InsertOp insertOp) {
        this.insertOp = insertOp;
    }

    @Override
    public void insertLog(String params) {
        dosomthingBefore();
        this.insertOp.insertLog(params);
        dosomethingAfter();
    }

    private void dosomthingBefore() {
        System.out.println("---------操作前--------");
    }

    private void dosomethingAfter() {
        System.out.println("---------操作后--------");
    }
}

public class Master {
    public static void main(String[] args) {
        //静态代理
        InsertOp insertOp =new InserOpImp();
        StaticFactory staticFactory = new StaticFactory(insertOp);
        staticFactory.insertLog("insert into user(user_id,user_name,sex) values(1,'lucy',1)");
    }
}

执行结果

---------操作前--------
正在插入一条数据,参数为：insert into user(user_id,user_name,sex) values(1,'lucy',1)
---------操作后--------

Process finished with exit code 0

静态代理模式搭建起来简单，但是却违反了开闭原则，因为如果要扩展就需要实现更多的接口类，扩展的接口多了就需要修改大量的代码，具有扩展能力差，维护性差的缺点，下面我们使用动态代理做这个事情

2）动态代理

//接口
public interface InsertOp {
    void insertLog(String params);
}

//被代理对象
public class InserOpImp implements InsertOp {
    @Override
    public void insertLog(String params) {
        System.out.println("正在插入一条数据,参数为：" + params);
    }
}

//代理实现类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class LogFatory implements InvocationHandler {

    private Object handler;

    public Object getHandler() {
        return handler;
    }

    public void setHandler(Object handler) {
        this.handler = handler;
    }

    public Object getInstance() {
        return Proxy.newProxyInstance(handler.getClass().getClassLoader(), handler.getClass().getInterfaces(), this);
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        dosomthingBefore();
        Object ret = method.invoke(handler, args);
        dosomethingAfter();
        return ret;
    }

    private void dosomthingBefore() {
        System.out.println("---------操作前--------");
    }

    private void dosomethingAfter() {
        System.out.println("---------操作后--------");
    }
}

测试

    public static void main(String[] args) {

        InsertOp insertOp = new InserOpImp();
        LogFatory logFatory = new LogFatory();
        logFatory.setHandler(insertOp);
        //返回一个增强的对象
        InsertOp insertOp1 =(InsertOp) logFatory.getInstance();
        insertOp1.insertLog("insert into user(user_id,user_name,sex) values(1,'lucy',1)");
    }

执行结果

---------操作前--------
正在插入一条数据,参数为：insert into user(user_id,user_name,sex) values(1,'lucy',1)
---------操作后--------

Process finished with exit code 0

动态代理的方式通过多态的方式进行实例化，将具体的类传给代理类进行增强，有效的将具体实现类与代理类解耦，便于后期修改和维护。