Spring AOP(基于代理类的AOP实现)

#基于代理类的AOP实现：
step1:
 1 package com.sjl.factorybean;
 /**切面类*/
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;

 public class MyAspect implements MethodInterceptor {
     @Override
     public Object invoke(MethodInvocation mi) throws Throwable {
         check_Permission();
          //用proceed方法来执行当前对象
         Object obj=mi.proceed();
         log();
         return obj;
     }

          //目标方法执行前执行check_Permission方法
     public void check_Permission(){
         System.out.println("模拟检查权限日志");
     }

          //目标方法执行后执行log()方法
     public void log(){
         System.out.println("模拟记录日志");
     }
 }

#目标类：

 package com.sjl.jdk;

 /**
  * UserDaoImpl是目标类，对其中的方法进行增强处理；
  */
 public class UserDaoImpl implements UserDao{

     @Override
     public void addUser() {
         System.out.println("添加用户");
     }

     @Override
     public void deleteUser() {
         System.out.println("删除用户");
     }
 }

#step2:创建配置文件，并指定代理对象：

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

     <!-- 1 目标类 id为"userDao"  class="目标类的全限定名" -->
     <bean id="userDao" class="com.sjl.jdk.UserDaoImpl"></bean>

     <!-- 2 切面类 id为"myAspect"  class="切面类的全限定名"-->
     <bean id="myAspect" class="com.sjl.factorybean.MyAspect"></bean>

     <!-- 3 使用Spring代理工厂定义一个名称为userDaoProxy的代理对象，而aop
      实现的就是代理工厂   bean  id全限定名为如上图-->
     <bean id="userDaoProxy"
           class="org.springframework.aop.framework.ProxyFactoryBean">

         <!-- 3.1 指定代理实现的接口proxyInterfaces value为com.sjl.jdk.UserDao-->
         <property name="proxyInterfaces" value="com.sjl.jdk.UserDao" />

         <!-- 3.2 指定目标对象名为target 目标类的对象属性ref为目标类的id-->
         <property name="target" ref="userDao" />

         <!-- 3.3 指定切面名interceptorNames,织入环绕通知myAspect -->
         <property name="interceptorNames" value="myAspect" />

         <!-- 3.4 指定代理方式，true：使用cglib，false(默认)：使用jdk动态代理 -->
         <property name="proxyTargetClass" value="true" />

     </bean>
 </beans>

 <!--用配置文件指定代理对象，包括目标类、切面类，并指定Spring代理工厂定义一个名称为
 userDaoProxy的代理对象，其中包含接口的id 代理工厂的类，从aop的包中找，指定接口，再
 指定属性，接口，目标对象，切面和代理方式等-->

#step3:测试类

 package com.sjl.factorybean;
 import org.springframework.context.ApplicationContext;
 import
     org.springframework.context.support.ClassPathXmlApplicationContext;
 import com.sjl.jdk.UserDao;
 // 测试类
 public class ProxyFactoryBeanTest {
     public static void main(String args[]) {
        String xmlPath = "applicationContext.xml";
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext(xmlPath);
        // 从Spring容器获得内容
        UserDao userDao =  (UserDao) applicationContext.getBean("userDaoProxy");
        // 执行方法
        userDao.addUser();
        userDao.deleteUser();
     }
 }

说明：动态代理的本质是反射，动态代理分为实现有两种：jdk代理（实现接口的实例，拦截接口定义的目标方法）、cglib代理（生成代理类的子类的实例，可以拦截任意一共有方法，

无论目标方法是否定义在接口中），而动态代理是AOP的本质。