Spring Aop 深入讲解

可乐猪小姐 3月前 ⋅ 28 阅读
  1. AOP 是什么? 在不修改源代码的情况下给从程序中的多个点上动态统一添加功能的一种编程技术。
  2. 那么,Spring Aop 是怎么实现的呢?通过预编译时代码增强方式和运行期动态代理功能增强实现。
  3. 下面我们详细介绍 Aop 是如何实现代理的?

        1.   预编辑时代码增强方式 也称为 静态代理【注:代理类实现和被代理类一样的接口;】

 代码:土豪想约会女艺人实现的代理过程

接口类:

public interface Girl {

    boolean dating(float length);
}
子类
public class TeacherCang implements Girl{

    /**
     * 约会方法
     * @param length
     * @return
     */
    @Override
    public boolean dating(float length) {

        if(length>1.7f){

            System.out.println("身高可以,可以约会");
            return true;
        }else{
            System.out.println("不可以约会!");
        }

        return false;
    }
}
代理类:必须 实现和被代理类一样的接口
public class Tony implements  Girl {


    private Girl girl;

    public Tony(Girl girl) {
        this.girl = girl;
    }

    @Override
    public boolean dating(float length) {
        boolean res = false;
        //提前准备工作
        doSomethingBefore();
        //调用被代理对象的目标方法
        this.girl.dating(length);

        //后置服务
        doSomethingAfter();

        return res;
    }

    private void doSomethingAfter() {
        System.out.println("#####老板您觉得我们有什么需要改进.................");
    }

    private void doSomethingBefore() {
        System.out.println("#####老板你好,我们这艺人很优秀,推荐给你...........");
    }


}
public class TuHao {

    public void setLength(float length) {

        this.length = length;
    }

    public float getLength() {
        return length;
    }

    private float length;

    public TuHao(float length){
        super();
        this.length = length;
    }

    public void dating(Girl g){

        g.dating(length);
    }


}
main 运行方法

 public static void main(String[] args){
        //TODO 静态代理:即代理类tony 类是提前写好的,,代理类作用是起到增强类的作用
        TuHao sicong = new TuHao(1.8f);

        Girl teacherCang = new TeacherCang();

        Girl tony = new Tony(teacherCang);

        sicong.dating(tony);
}

   如果Tony 代理类要扩张即也要实现男艺人或者人妖的接口,也分别要实现对应方法,才要在main方法 调用不同的方法,代码量会很大。。。。这是静态代理的缺点。。。

优点:a. 调用者和代理对象的桥梁;b. 无侵入性的增强业务代码,解耦利器;c.增强点多样化(前置,后置,异常处理等);缺点是:a.扩展能力差(横行扩展:代理更多的类;纵向扩展:增强更多的方法);b.可维护性差;

2. 动态代理:弥补了静态代理的缺点

声明动态代理类
public class TonyCompany {


    public static Object proxy(Object target){


     return   Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),new MyInvocationHandler(target));

    }





    private static class MyInvocationHandler implements InvocationHandler{

        private Object target;

        public MyInvocationHandler(Object target) {
            this.target = target;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

           //前置增强
            doSomethingBefore();
            //真正服务是由被代理对象提供的
            Object res = method.invoke(target,args);

            //后置增强

            doSomethingAfter();

           return res;
        }


        private void doSomethingAfter() {
            System.out.println("#####老板您觉得我们有什么需要改进.................");
        }

        private void doSomethingBefore() {
            System.out.println("#####老板你好,我们这艺人很优秀,推荐给你...........");
        }
    }




}
  
main 实现方法
System.out.println("########动态代理++++++++++++++++++++++++++");

        Girl tony1 =  (Girl)TonyCompany.proxy(teacherCang);

        sicong.dating(tony1);

        Boy teacherChen = new TeacherChen();

        Boy tony2 =(Boy) TonyCompany.proxy(teacherChen);

        tony2.dating('E');

 

 


注意:本文归作者所有,未经作者允许,不得转载

全部评论: 0

    我有话说: