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的本质。