2021-07-30阅读小笔记：Spring AOP 之 AOP入门

川长思鸟来 2022-09-02 04:12 180阅读 0赞

# 1、OOP 有什么不足之处？用什么思想设计可以改善不足？ #

当我们需要给已有业务代码增强某方面的能力的时候，会导致出现很多的重复代码；因为 OOP 是面向对象编程的，如果每一个对象都需要增加同一个功能，那么都需要写一遍重复的功能代码。

## 1.1 例子 ##

下面学生会去上课，吃饭和睡觉三个日常生活点，但是现在老师非常关心学生是否准时去做上面的事情，那么想在学生做这三件事情打印一下日志。

增强前：

@Data
    @Accessors(chain = true)
    public class Student implements Serializable { 
    
        private static final long serialVersionUID = 2392021462238048699L;
    
        private String name;
    }
    
    public interface StudentService { 
    
        void goToClass(Student student);
    
        void eat(Student student);
    
        void sleep(Student student);
    }
    
    public class StudentServiceImpl implements StudentService { 
    
        @Override
        public void goToClass(Student student) { 
            System.out.println(student.getName()+" 去上课了");
        }
    
        @Override
        public void eat(Student student) { 
            System.out.println(student.getName()+" 去吃饭了");
        }
    
        @Override
        public void sleep(Student student) { 
            System.out.println(student.getName()+" 去睡觉了");
        }
    }

增强后：

public class StudentServiceEnhanceImpl implements StudentService { 
    
        @Override
        public void goToClass(Student student) { 
            System.out.println("当前时间："+new Date()+"，"+student.getName()+"去上课了");
            System.out.println(student.getName()+" 去上课了");
        }
    
        @Override
        public void eat(Student student) { 
            System.out.println("当前时间："+new Date()+"，"+student.getName()+"去吃饭了");
            System.out.println(student.getName()+" 去吃饭了");
        }
    
        @Override
        public void sleep(Student student) { 
            System.out.println("当前时间："+new Date()+"，"+student.getName()+"去睡觉了");
            System.out.println(student.getName()+" 去睡觉了");
        }
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
            StudentService studentService = new StudentServiceEnhanceImpl();
            studentService.goToClass(student);
            studentService.eat(student);
            studentService.sleep(student);
        }
    }

利用工具类优化：

@AllArgsConstructor
    public class StudentServiceEnhanceImplV2 implements StudentService { 
    
        @Override
        public void goToClass(Student student) { 
            LogUtils.print(student.getName(),"去上课了");
            System.out.println(student.getName()+" 去上课了");
        }
    
        @Override
        public void eat(Student student) { 
            LogUtils.print(student.getName(),"去吃饭了");
            System.out.println(student.getName()+" 去吃饭了");
        }
    
        @Override
        public void sleep(Student student) { 
            LogUtils.print(student.getName(),"去睡觉了");
            System.out.println(student.getName()+" 去睡觉了");
        }
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
            StudentService studentService = new StudentServiceEnhanceImplV2();
            studentService.goToClass(student);
            studentService.eat(student);
            studentService.sleep(student);
        }
    }
    
    public class LogUtils { 
    
        public static void printNow(){ 
            System.out.println("当前时间：" + new Date());
        }
    }

## 1.2 改善 ##

即使上面使用了工具类统一封装增强功能，但是每个业务方法里面还是冗余了一些非业务性的代码。

当然了，此时我们可以利用 GoF 中的某些设计模式来优化此代码。

### 1.2.1 装饰者模式 ###

在行为模式中，装饰者模式可以在原有的逻辑上扩展额外的功能：我们可以理解为装饰者里组合了原目标对象，并实现了原目标对象的接口，在实现方法里对原目标对象做增强。

代码：

@AllArgsConstructor
    public class StudentServiceImplDecorate implements StudentService { 
    
        private StudentService target;
    
        @Override
        public void goToClass(Student student) { 
            LogUtils.print(student.getName(),"去上课了");
            target.goToClass(student);
        }
    
        @Override
        public void eat(Student student) { 
            LogUtils.print(student.getName(),"去吃饭了");
            target.eat(student);
        }
    
        @Override
        public void sleep(Student student) { 
            LogUtils.print(student.getName(),"去睡觉了");
            target.sleep(student);
        }
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
            StudentService studentService = new StudentServiceImpl();
            StudentService studentServiceDecorate  = new StudentServiceImplDecorate(studentService);
            studentServiceDecorate.goToClass(student);
            studentServiceDecorate.eat(student);
            studentServiceDecorate.sleep(student);
        }
    }

这样虽然避免了原有业务逻辑里的非业务逻辑功能代码，但是每一个需要被增强的类都需要抽一个装饰者出来，这也是非常多的重复代码，并且代码量显得更多了。

### 1.2.2 模版模式 ###

在行为模式中，可以抽取逻辑还有一个就是模版方法：我们需要抽象出一个抽象类，实现原目标对象的接口，对原目标对象需要增强的方法抽象多一个子方法，后续的子类都需要重写此方法来做业务逻辑。

代码：

/** * 学生Service增强第四版：利用模版模式抽取增强代码 * @author winfun **/
    public abstract class StudentServiceTemplate implements StudentService { 
    
        @Override
        public void goToClass(Student student) { 
            LogUtils.print(student.getName(),"去上课了");
            doGoToClass(student);
        }
    
        protected abstract void doGoToClass(Student student);
    
        @Override
        public void eat(Student student) { 
            LogUtils.print(student.getName(),"去吃饭了");
            doEat(student);
        }
    
        protected abstract void doEat(Student student);
    
        @Override
        public void sleep(Student student) { 
            LogUtils.print(student.getName(),"去睡觉了");
            doSleep(student);
        }
    
        protected abstract void doSleep(Student student);
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
    
        }
    }
    
    /** * 学生Service增强第四版：模版实现类 * @author winfun **/
    public class StudentServiceTemplateImpl extends StudentServiceTemplate { 
    
    
        @Override
        protected void doGoToClass(Student student) { 
            System.out.println(student.getName()+" 去上课了");
        }
    
        @Override
        protected void doEat(Student student) { 
            System.out.println(student.getName()+" 去吃饭了");
        }
    
        @Override
        protected void doSleep(Student student) { 
            System.out.println(student.getName()+" 去睡觉了");
        }
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
            StudentService studentService = new StudentServiceTemplateImpl();
            studentService.goToClass(student);
            studentService.eat(student);
            studentService.sleep(student);
        }
    }

我们可以发现，即使这样优化，冗余代码也是一点都没变少，甚至还变多了；并且由于使用了继承，所以如果业务实现类想继续扩展其他功能，也就无计可施了。

# 2、动态代理如何解决相同逻辑的重复代码？ #

代理模式分为静态代理和动态代理：

而静态代理需要编写代理类，组合原有的目标对象，并实现原有目标对象的接口，以此来做原有对象的方法功能的增强。这么一看，静态代理的代码和装配者模式的基本一样，所以说，如果单纯使用静态代理，和使用装配者模式基本没啥区别。

动态代理：动态代理是在运行时动态将增强逻辑类组合原有的目标对象，然后生成代理对象，以此完成对目标对象方法的功能增强。

> 既然静态代理有对应的动态代理，那么如果装配者模式也有动态装配者模式的话，也是可以完美完成增强的  
> 。

还是上面的例子，不过这次增强是简单的日志打印，在方法执行时，打印对应的参数和方法，借此记录学生的行为和对应的时间。

增强逻辑，实现 InvocationHandler 接口。

/** * invocation handler * @author winfun **/
    public class LogAdvisor implements InvocationHandler { 
    
        private Object target;
    
        public LogAdvisor(Object target) { 
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
            LogUtils.print(method.getName(),args);
            return method.invoke(target,args);
        }
    }

日志工具类：

/** * 日志工具类 * @author winfun **/
    public class LogUtils { 
    
        public static void print(String action,Object... args){ 
    
            StringJoiner argsMsg = new StringJoiner(",");
            if (args.length > 0){ 
                for (Object arg : args) { 
                    argsMsg.add(arg.toString());
                }
            }
            System.out.println("当前时间：" + new Date()+"，参数："+argsMsg+"，方法："+action);
        }
    }

创建代理类进行测试：

public class Application { 
    
        public static void main(String[] args) { 
            Student student = new Student();
            student.setName("winfun");
            StudentService studentService = new StudentServiceImpl();
            // 利用Proxy创建代理类，ps：不能用 StudentService.class.getXxx()
            StudentService proxy = (StudentService) Proxy.newProxyInstance(studentService.getClass().getClassLoader(), studentService.getClass().getInterfaces(), new LogAdvisor(studentService));
            proxy.goToClass(student);
            proxy.eat(student);
            proxy.sleep(student);
        }
    }

运行结果：

当前时间：Thu Jul 29 22:36:53 CST 2021，参数：Student(name=winfun)，方法：goToClass
    winfun 去上课了
    当前时间：Thu Jul 29 22:36:53 CST 2021，参数：Student(name=winfun)，方法：eat
    winfun 去吃饭了
    当前时间：Thu Jul 29 22:36:53 CST 2021，参数：Student(name=winfun)，方法：sleep
    winfun 去睡觉了

# 3、如何理解面向切面编程？ #

横切面，英文表示为 Aspect ，它表示的是分布在一个 / 多个类的多个方法中的相同逻辑。利用动态代理，将这部分相同的逻辑抽取为一个独立的 Advisor 增强器，并在原始对象的初始化过程中，动态组合原始对象并产生代理对象，同样能完成一样的功能增强。在此基础上，通过指定增强的类名、方法名（甚至方法参数列表类型等），可以更细粒度的对方法增强。使用这种方式，可以在不修改原始代码的前提下，对已有任意代码的功能增强。而这种针对相同逻辑的扩展和抽取，就是所谓的面向切面编程（Aspect Oriented Programming，AOP）。

> 摘自 LinkedBear 作者

# 4、jdk 动态代理与 Cglib 动态代理有什么区别？ #

jdk 动态代理是基于接口来实现的，底层利用的是 Proxy 的 newInstance 方法来创建代理对象，而 Cglib 的动态代理是基于类实现的，会基于原目标对象生成子类。