Spring学习(二)

Spring AOP

AOP的主要编程对象是切面（aspect），而切面模块化横切关注点
    在应用AOP编程，仍然需要定义公共功能，但可以明确的定义这个功能在那里，以什么方式应用，并且不必修改受影响的类，这样依赖横切关注点就被模块化到特殊的对象（切面）里。
    
    切面(aspect)：横切关注点被模块化的特殊对象
    通知(Advice)：切面必须要完成的工作
    目标（Target）：被通知的对象
    代理(Proxy):向目标对象应用通知之后创建的对象
    连接点(JoinPoint)：程序执行的某个特定位置。
    切点（Pointcut）：每个类都有多个连接点，AOP通过切点定位到特定的连接点。类别：连接点相当于数据库中的记录，切点相当于查询条件。

    切点("execution(*（*表示任意修饰符以及任意返回值） 包名+类名.方法名(..（..表示任意数量的参数）))")
    
    连接点JoinPoint join 类似于被代理对象的信息

    环绕通知：能够全名的控制连接点，可以控制是否执行连接点
    对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint,他是JoinPoint的子接口，允许控制合适执行，是否执行连接点

    在环绕通知中需要明确调用ProceedingJoinPoint的Proceed()方法来

注解声明优于配置声明

声明切面：
所有的Spring AOP配置都必须定义在<aop:config>元素内部
每一个切面都必须有<aop:aspect>标签

说到切面就不得不说动态代理：

以下转载自：https://blog.csdn.net/qq_26545305/article/details/77890606

动态代理的特点：在不改变源代码的情况下，对功能进行增强。符合开闭原则

  到底“动态代理”动态在哪里？是不是指在运行时才将它实例化并和handler联系起来？

       不是的，动态代理之所以被称为动态，是因为运行时才能将它的类创造出来，代码开始执行时，还没有proxy类。它是根据需要从你传入的接口集创建的。

       动态代理：本该是自己做的事情，请了别人来做，被请的人就是代理对象。

（一）：

       现在，我们有一个简单的需求：对User进行增删改查操作。我们常常说面向接口编程，首先呢，我们需要声明一个UserManager接口类。

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;">package JDKProxy;  
2.   
3. public interface UserManager {  
4.   
5.     public void addUser();  
6.     public void delUser();  
7.     public String findUserById();  
8.     public void modifyUser();  
9. }</span>  

       然后我们定义一个实现UserManager接口的类UserManagerImpl。

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;">package JDKProxy;  
2.   
3. public class UserManagerImpl implements UserManager {  
4.   
5.     @Override  
6.     public void addUser() {  
7.         System.out.println("添加功能");  
8.           
9.     }  
10.   
11.     @Override  
12.     public void delUser() {  
13.         System.out.println("删除功能");  
14.           
15.     }  
16. </span>  

      现在我们需要对上述方法进行测试。

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;">package JDKProxy;  
2.   
3. import java.lang.reflect.Proxy;  
4.   
5. public class Client {  
6.   
7.     /** 
8.      * @param args 
9.      */  
10.      public static void main(String args[]) {   
11.          UserManager user=new UserManagerImpl();  
12.          user.addUser();  
13.          user.delUser();  
14.          System.out.println("--------------------");  
15.         }   
16.   
17. }  
18. </span>  

测试结果如下：

       后来呢，我们的需求变了，对User进行增删改查操作之前先进行校验，之后添加日志操作记录。传统的方法是直接修改UserManagerImpl类的四个方法。简单示例如下：

但这样是不符合开闭原则的。

（二）

       JDK动态代理需要java.lang.reflect包中的InvocationHandler、Method、Proxy，声明一个实现InvocationHandler接口的类SecurityHandler。

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;">package JDKProxy;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. public class SecurityHandler implements InvocationHandler {  
6.     //定义调用的目标类对象  
7.      private Object targetObject;    
8.     //创建一个代理实例   
9.      public  SecurityHandler(Object targetObject)  
10.      {  
11.          this.targetObject=targetObject;  
12.   
13.      }  
14.     //代理类的执行过程  
15.     @Override  
16.     public Object invoke(Object proxy, Method method, Object[] args)  
17.             throws Throwable {  
18.         checkSecurity();  
19.         //调用目标方法，代理模式思想的体现  
20.         Object obj=method.invoke(targetObject, args);  
21.         operationLog();  
22.         return obj;  
23.     }  
24.     //权限校验功能  
25.     private void checkSecurity(){  
26.         System.out.println("权限校验功能");  
27.     }   
28.     //记录操作日志  
29.     private void operationLog(){  
30.         System.out.println("操作日志功能");  
31.     }  
32. }  
33. </span>  

        在Client类的main方法中添加如下代码：

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;"> //希望在添加和删除之前做一个校验，之后写操作日志  
2.    SecurityHandler s=new SecurityHandler(user);  
3.    //动态代理是面向接口的代理  
4. </span><span style="font-size:12px;"><span style="font-family:'KaiTi_GB2312';">     UserManager u=(UserManager) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), s);</span><span style="font-family:'KaiTi_GB2312';">  </span></span>  

[java]  view plain  copy

1. <span style="font-family:'KaiTi_GB2312';font-size:24px;">//这个U就是代理后的对象了 (user是被代理的对象)  
2.    u.addUser();  
3.    u.delUser();</span>  

     运行main后的结果如下所示：