为什么要说动态代理：

动态代理可以实现为对象提供一种代理，以控制这个对象的访问。

我们通常会用到在执行一批操作之前，例如对数据库数据进行增删改，需要保证这一部分操作的完整性，如果出现问题需要回滚到操作之前的状态。而这样的操作在业务上有很多。

最简单粗暴的做法，就是在每一个方法调用之前先加载这一步安全控制方法。

代理模式正是做了这样一件事情，它实现被代理类的接口，并引入被代理类，我们调用UserManagerImpleProxy类来通过代理类实现添加的功能。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3htbDE5OTY_size_16_color_FFFFFF_t_70

/*
* 静态代理类
* 实现接口UserManager
* 引入UserManagerImpl
* */
public class UserManagerImplProxy implements UserManager {
   private UserManagerImpl userManagerImpl;
   // 构造方法
   public UserManagerImplProxy(UserManagerImpl userManagerImpl) {
      this.userManagerImpl = userManagerImpl;
   }
   // 具体方法
   public void addUser(String username, String password) {
      // 执行检查方法
      checkSecurity();
      // 调用具体类的实现方法
      userManagerImpl.addUser(username, password);
   }
   public void delUser(int userId) {
      checkSecurity();
      userManagerImpl.delUser(userId);
   }
   public String findUserById(int userId) {
      checkSecurity();
      return userManagerImpl.findUserById(userId);
   }
   public void modifyUser(int userId, String username, String password) {
      checkSecurity();
      userManagerImpl.modifyUser(userId, username, password);
   }
   // 检查的方法
   private void checkSecurity() {
      System.out.println("-------checkSecurity-------");
   }  
}

这是典型的静态代理，也就是在运行之前代码编辑好的，静态代理避免了修改原有的类，为了实现基本的开闭原则，在不修改原代码的基础上重新写一个代理类，来实现需要添加的功能。

但是同时这也是它的局限，它并没有避免多次调用checkSecurity()这个方法，每一个需要被代理的类都要有一个代理类，每一个代理类下的每一个方法前面都需要添加这样的方法，在代码量很大的情况下，就会很冗余。

所以出现了动态代理，不需要提前写好代理类，在程序运行的时候加载创建需要的代理类。

这也就是为什么要用动态代理的原因。

动态代理的实现：

采用最原始的动态代理模式

来实现在加载add方法之前，打印一句话———-checkSecurity———

public class SecurityHandler implements InvocationHandler {
   private Object targetObject;
   public Object createProxyInstance(Object targetObject) {
      this.targetObject = targetObject;
      return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                        targetObject.getClass().getInterfaces(),
                        this);
   }
   public Object invoke(Object proxy, Method method, Object[] args)
         throws Throwable {
      System.out.println("-------checkSecurity-------");
      //调用目标方法
      Object ret = method.invoke(targetObject, args);
      return ret;
   }
}

这里method.invoke(目标类，目标类参数)；只需要把需要被代理的类传给这个SecurityHandler类，它就可以动态创建代理类并执行invoke方法在执行方法之前添加上需要的内容

PS：动态代理，相当于在火腿肠出厂之前，把所有这一批生成的火腿肠，都打上生产日期的码，返回的东西，都是打码后的火腿肠，你在吧火腿肠放入打码器之前，需要先告诉它这个是什么食品：火腿肠。

也就是在需要告诉动态代理，这个需要被代理的类是谁，之后动态代理会执行相应的加工方法invoke(),对传入的类进行处理。

执行结果：

动态代理的分类：

动态代理也分两种，一种是，提供的这个要被代理的类有接口，一个是没有接口的。

JDK动态代理，是有接口的类的代理
CGlib动态代理，是没有接口的

Spring 的AOP

spring框架实现了这样的功能，不需要我们自己手动去写动态代理来实现这样的功能，减轻了开发过程中的工作量，更加规范方便。并且，spring会根据需要代理的这个类有无接口来自己选择需要使用的代理类型。

但也不是绝对的，我们也可以在有接口的情况下，强制使用CGlib动态代理：

在spring的配置文件中添加（applicationConfiger.xml）：

spring AOP管理的两种风格：实现方式不同

一、使用AspectJ

通过在spring的配置文件中配置

把刚刚动态代理的部分，用这样注解的方式代替标识。

@Aspect
public class SecurityHandler {
   /**
    * 定义Pointcut，Pointcut的名称为addAddMethod()，此方法没有返回值和参数
    * 该方法就是一个标识，不进行调用
    */
   @Pointcut("execution(* add*(..))")
   private void addAddMethod(){};
   /**
    * 定义Advice，表示我们的Advice应用到哪些Pointcut订阅的Joinpoint上
    */
   @Before("addAddMethod()")
   //@After("addAddMethod()")
   private void checkSecurity() {
      System.out.println("-------checkSecurity-------");
   }     
}

这里涉及到一些AOP的基础概念：

* 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用通用类（基于模式的风格）或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。

* 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是代表一个方法的执行。通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。

* 通知（Advice）：在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

* 切入点（Pointcut）：匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

* 引入（Introduction）：（也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。

* 目标对象（Target Object）：被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做被通知（advised）对象。既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

* AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。

* 织入（Weaving）：把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。

二、使用xml配置文件

可以直接省略掉标识@Aspect,直接使用配置文件配置需要切入的类，切入的方法位置，以及具体执行的内容都可以在这里配置

  <!--
  以add开头的方法
  <aop:pointcut id="addAddMethod" expression="execution(\* add\*(..))"/>
   -->
   <!--
   com.bjpowernode.spring包下所有的类所有的方法
  <aop:pointcut id="addAddMethod" expression="execution(\* com.bjpowernode.spring.\*.\*(..))"/>
   -->
  <aop:pointcut id="addAddMethod" expression="execution(\* com.bjpowernode.spring.\*.add\*(..)) || execution(\* com.bjpowernode.spring.\*.del\*(..))"/>
  <aop:before method="checkSecurity" pointcut-ref="addAddMethod"/>

// 这是具体的执行类
public class SecurityHandler {
   private void checkSecurity(JoinPoint joinPoint) {
      for (int i=0; i<joinPoint.getArgs().length; i++) {
         System.out.println(joinPoint.getArgs()[i]+"-----这是joinPoint.getArgs()的第"+ i);
      }
      System.out.println(joinPoint.getSignature().getName()+"------这是joinPoint.getSignature().getName()");
      System.out.println("-------checkSecurity-------");
   }     
}