简介

AOP：面向切面编程，是OOP的扩展和延申，解决OOP中遇到的问题
可以进行权限校验，日志记录，性能监控，事务校验
Spring底层的AOP实现原理：动态代理
JDK动态代理 ：只能对实现了接口的类产生代理
Cglib动态代理（类似于Javassist第三方代理技术）：对没有实现接口的类产生代理对象，生成子
对象

两种动态代理

JDK动态代理实例

1.建立一个接口：

public interface UserDao {
    public void insert();
    public void update();
}

2.接口实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void insert() {
        System.out.println("insert方法");
    }
    @Override
    public void update() {
        System.out.println("update方法");
    }
}

3.编写代理类JdkProxy

public class JdkProxy{
    //将被增强的对象传递到代理当中
    private UserDao userDao;
    public JdkProxy(UserDao userDao) {
        this.userDao = userDao;
    }
    public UserDao creatProxy() {
        UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
        return userDaoProxy;
    }
}

4. 实现InvocationHandler接口，并重写其中方法，用于权限管理

public class JdkProxy implements InvocationHandler{
        ······
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            if("insert".equals(method.getName())) {
            System.out.println("权限增强");
            return method.invoke(userDao, args);
        }
        return method.invoke(userDao, args);
    }

5.测试类

    @Test
    public void demo1() {
        UserDao userDao=new UserDaoImpl();
        //创建代理
        UserDao proxy = new JdkProxy(userDao).creatProxy();
        proxy.insert();
        proxy.update();
    }

Cglib动态代理

第三方开源代码生成类库，动态添加类的属性和方法
1.编写接口和测试类（同上）
2.编写代理类CglibProxy

public class CglibProxy {
    private UserDaoImpl userDaoImpl;
    public CglibProxy(UserDaoImpl userDaoImpl) {
        this.userDaoImpl=userDaoImpl;
    }
    public UserDaoImpl createProxy() {
        //1.创建Cglib的代理对象
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(userDaoImpl.getClass());
        //3.设置回调
        enhancer.setCallback(this);
        //4.创建代理
        UserDaoImpl proxy=(UserDaoImpl) enhancer.create();
        return  proxy;
    }

3.CglibProxy 继承MethodInterceptor类，并重写其中方法

public class CglibProxy implements MethodInterceptor{
    ······
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 判断是否是insert方法
        if("insert".equals(method.getName())) {
            //增强
            System.out.println("权限校验");
            return methodProxy.invokeSuper(proxy, args);
        }
        return methodProxy.invokeSuper(proxy, args);
    }
}

4.测试类

    @Test
    public void demo1() {
        UserDaoImpl userDao=new UserDaoImpl();
        //创建代理
        UserDaoImpl proxy = new CglibProxy(userDao).createProxy();
        proxy.insert();
        proxy.update();
    }

Spring的AOP开发

简介

AOP思想最早是由AOP联盟组织提出的，Spring是使用这种思想最好的框架
Spring的AOP有自己实现的方式（非常繁琐）AspectJ是一个AOP框架，Spring引入了AspectJ作为自身开发

相关代码编写

1.新建切面类，并在切面类中MethodInterceptor类（环绕通知）

//环绕通知
public class MyAspectXML implements MethodInterceptor{
    @Override
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("0000000000");
        Object obj=arg0.proceed();
        System.out.println("0000000000");
        return obj;
    }
 }

2.在xml文件中配置

<!-- 配置目标对象，被增强的对象-->
<bean id="productDao" class="com.zut.aopTest.ProductDaoImpl"></bean>
<!-- 将切面类交给Spring管理 -->
<bean id="myAspect" class="com.zut.aopTest.MyAspectXML"></bean>

3.在xml文件中配置通知

<!-- 创建代理对象  默认JDK动态代理  如果没有proxyInterfaces 则默认cglib-->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" name="proxyBean">
        <property name="targetName" value="productDao"></property>
        <!-- 拦截器名字 -->
        <property name="interceptorNames" value="myAspect">
            <!-- 如果通知在多个类中 -->
            <!-- <array>
                <value></value>
            </array> -->
        </property>
            <property name="proxyInterfaces" value="com.zut.aopTest.ProductDao"></property>
    </bean>

4.编写测试类

public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        ProductDao productDao=context.getBean("proxyBean",ProductDao.class);
        productDao.save();
}

前置通知接口：MethodBrforeAdvice
后置通知接口：AfterReturningAdvice 注意： 有异常时后置通知不执行
异常通知接口：ThrowsAdvice
最终通知接口：AfterAdvice

在此方式下，xml文件可以采用自动织入编写

1.xml文件

<!-- 配置目标对象，被增强的对象 -->
    <bean id="productDao" class="com.zut.aopTest.ProductDaoImpl"></bean>
    <!-- 将切面类交给Spring管理 -->
    <bean id="myAspect" class="com.zut.aopTest.MyAspectXML"></bean>
<aop:config>
        <aop:pointcut expression="execution(* com.zut.springAOP.UserImpl.*(..))" id="pointcut"/>
        <aop:advisor advice-ref="myAspect" pointcut-ref="pointcut"/>
    </aop:config>
 //id 与 pointcut-ref 相等

2.测试类

public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        ProductDao productDao=context.getBean("productDao",ProductDao.class);
        productDao.save();
}

采用AspectJ的XML的方式

相关配置文件

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>
<dependency>
    <groupId>aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.5.3</version>
</dependency>

xml文件

clipboard.png

相关代码编写

1.编写接口和测试类
2.编写切面类

public class MyAspectXML {
    public void checkPri() {
        System.out.println("权限校验。。。。。。。。。");
    }
}

3.在xml文件里进行配置

<!-- 配置目标对象，被增强的对象 -->
    <bean id="productDao" class="com.aopTest.ProductDaoImpl"></bean>
    <!-- 将切面类交给Spring管理 -->
    <bean id="myAspect" class="com.aopTest.MyAspectXML"></bean>
    <!-- 通过AOP的配置实现对目标产生代理 -->
    <aop:config>
        <!-- 表达式配置那些类哪些方法需要进行增强   ()里面只写参数类型  可以写成 save(int ,String) and args(a,b)  -->
        <aop:pointcut expression="execution(* com.aopTest.ProductDaoImpl.save(..))" id="pointcut1"/>
        <!-- 配置切面  myAspect指向切面 与上文要对应上  checkPri 切面类里的方法名-->
        <aop:aspect ref="myAspect">
                      <!--匹配参数  这里的名字要一致-->
            <aop:before method="checkPri" pointcut-ref="pointcut1" arg-names="a"/></aop:aspect>   
    </aop:config>
</beans>

4.测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:Spring-config.xml")
public class SpringDemo1 {
    @Resource(name="productDao")
    private ProductDao productDao;
    @Test
    public void demo1() {
        productDao.save();
        productDao.update();
        productDao.find();
        productDao.delete();
    }
}

通知类型

前置通知

在目标方法执行之前执行此操作
1.xml文件

<!-- 配置切面 -->
<aop:aspect ref="myAspect">
<aop:before method="checkPri" pointcut-ref="pointcut1"/>
</aop:aspect>

2.获得切入点信息（几种通知均可实现）
在切入类中

public void checkPri(JoinPoint joinPoint) {
        System.out.println("权限校验。。。。。。。。。"+joinPoint);
}

后置通知

在目标方法之后执行的操作
1.在xml文件中

<aop:pointcut expression="execution(* com.aopTest.ProductDaoImpl.delete(..))" id="pointcut2"/>

<!-- 后置通知 -->
<aop:after-returning method="write" pointcut-ref="pointcut2" returning="result"/>
//returning表示获取返回值

2.获得方法返回值
在切入类中

/**
 * 后置通知
 */
    public void write(Object result) {
        System.out.println("日志通知。。。。。。。。。。"+result);
    }
 //这里的reult必须与前面配置里的returning一致

环绕通知

在目标方法执行之前和之后进行操作
1.xml文件

<aop:pointcut expression="execution(* com.aopTest.ProductDaoImpl.update(..))" id="pointcut3"/>

<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pointcut3"/>

2.在切入类

/**
 * 环绕通知
 * 性能监控
 * @throws Throwable 
 */
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("环绕通知前。。。");
    Object obj=joinPoint.proceed();
    System.out.println("环绕通知后。。。");
    return obj;
}

异常抛出通知

在程序出现异常时，进行的操作
1.xml文件中

<aop:pointcut expression="execution(* com.aopTest.ProductDaoImpl.find(..))" id="pointcut4"/>

<!-- 异常通知 -->
<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>
//throwing:得到异常类型

2.切入类

/**
 * 异常抛出
 */
public void afterThrowing(Throwable ex) {
    System.out.println("异常抛出。。。"+ex);
}
 //ex必须与上文配置中的throwing一致

最终通知

无论代码是否有异常，总是会执行，相当于finally代码块
1.xml文件里

<!-- 最终通知 -->
<aop:after method="after" pointcut-ref="pointcut4"/>

2.切面类

/**
* 最终通知
*/
public void after() {
    System.out.println("最终通知。。。...");
}

spring的切入点表达式写法

基于execution的函数完成的
语法：
[访问修饰符] 方法返回值 包名.类名.方法名(参数)
public void com.zut.aopTest.ProductDao.save(..)
星号（*）代表任意，参数不能写 * ，可以写 ..
*****Dao.save(..)
*com.zut.aopTest.ProductDao+save(..)