Java进阶知识21 Spring的AOP编程

1、概述

Aop：（Aspect Oriented Programming）面向切面编程
          功能： 让关注点代码与业务代码分离！

关注点：重复代码就叫做关注点；
切面： 关注点形成的类，就叫切面(类)！
            面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候往业务方法上动态植入“切面类代码”。
切入点：执行目标对象方法，动态植入切面代码。
               可以通过切入点表达式，指定拦截哪些类的哪些方法；给指定的类在运行的时候植入切面类代码。

2、XML方式实现AOP编程

2.1、我用到的jar包

　　　　

这些Spring包  不一定每个都使用到

2.2、简单实例演示1（需要实现接口，相当于动态代理）Spring的动态代理：https://www.cnblogs.com/dshore123/p/11753623.html

IUserDao 接口类

 package com.shore.dao;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public interface IUserDao {
     public void save();
 }

UserDao 接口的实现类

 package com.shore.dao.impl;

 import com.shore.dao.IUserDao;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public class UserDao implements IUserDao {

     @Override
     public void save() { //3、执行业务方法
         System.out.println("3、保存用户成功！");
     }
 }

Aop 类（程序执行到某一业务时，先去执行指定逻辑代码）

 package com.shore.aop;

 import org.aspectj.lang.ProceedingJoinPoint;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public class Aop {
     //around：环绕； ProceedingJoinPoint：必须添加(执行)
     @SuppressWarnings("unused")
     private void around(ProceedingJoinPoint pjp) throws Throwable {
         System.out.println("2、环绕前....");
         pjp.proceed();  // 执行目标方法（业务代码）
         System.out.println("5、环绕后....");
     }

     public void begin() {
         System.out.println("1、开启事务......");
     }

     public void commit() {
         System.out.println("6、提交事务......");
     }

     public void afterReturning() {
         System.out.println("4、afterReturning()，返回消息");
     }

     //有异常，执行这个第四步；没有异常，则执行上面的第四步
     public void afterThrowing(){
         System.out.println("4、afterThrowing()，返回异常消息");
     }
 }

Spring 配置文件（beans.xml）     切入点表达式：https://www.cnblogs.com/dshore123/p/11823849.html

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

     <!-- dao类 -->
     <bean id="userDao" class="com.shore.dao.impl.UserDao"></bean>
     <!-- 注入切面类 -->
     <bean id="aop" class="com.shore.aop.Aop"></bean>

     <aop:config>
         <!-- 配置切入点 -->
         <aop:pointcut expression="execution(* com.shore.dao.impl.*.*(..))" id="pt" />
         <!-- 配置切面(切入点形成的类，切入点就是重复的代码/方法) -->
         <aop:aspect ref="aop">
             <!-- 1、开启事务。。。。。。 -->
             <aop:before method="begin" pointcut-ref="pt" />
             <!-- 6、提交事务 -->
             <aop:after method="commit" pointcut-ref="pt" />
             <!-- 环绕2/5 -->
             <aop:around method="around" pointcut-ref="pt" />
             <!-- 4、afterReturning -->
             <aop:after-returning method="afterReturning"
                 pointcut-ref="pt" />
             <!-- 4、异常（程序出现异常，执行这个第四步；没有异常，则执行上面的第四步） -->
             <aop:after-throwing method="afterThrowing"
                 pointcut-ref="pt" />
         </aop:aspect>
     </aop:config>
 </beans>

测试类

 package com.shore.test;

 import org.junit.Test;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import com.shore.dao.IUserDao;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public class MyTest {
     @Test
     public void testUserDao() {
         ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
         IUserDao userDao = (IUserDao) context.getBean("userDao");
         //$Proxy4 ：class com.sun.proxy.$Proxy4
         System.out.println("这个相当于动态代理$Proxy4："+userDao); //返回值：com.shore.dao.impl.UserDao@73aecc3a
         userDao.save();
     }
 }

测试结果图

2.3、简单实例演示2（不需要实现接口，相当于Cglib子类代理） Spring的Cglib子类代理：https://www.cnblogs.com/dshore123/p/11753623.html

MessageDao 类（没有实现接口）

 package com.shore.dao.impl;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public class MessageDao {
     public void save() { //3、执行业务方法
         System.out.println("3、保存信息成功！");
     }
 }

Aop 类（和上面2.2中的一样，不变）

 package com.shore.aop;

 import org.aspectj.lang.ProceedingJoinPoint;

 /**
  * @author DSHORE/2019-11-7
  *
  */
 public class Aop {
     //around：环绕； ProceedingJoinPoint：必须添加(执行)
     @SuppressWarnings("unused")
     private void around(ProceedingJoinPoint pjp) throws Throwable {
         System.out.println("2、环绕前....");
         pjp.proceed();  // 执行目标方法（业务代码）
         System.out.println("5、环绕后....");
     }

     public void begin() {
         System.out.println("1、开启事务......");
     }

     public void commit() {
         System.out.println("6、提交事务......");
     }

     public void afterReturning() {
         System.out.println("4、afterReturning()，返回消息");
     }

     //有异常，执行这个第四步；没有异常，则执行上面的第四步
     public void afterThrowing(){
         System.out.println("4、afterThrowing()，返回异常消息");
     }
 }

Spring 配置文件（beans.xml）

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

     <!-- dao类 -->
     <!-- <bean id="userDao" class="com.shore.dao.impl.UserDao"></bean> -->
     <bean id="messageDao" class="com.shore.dao.impl.MessageDao"></bean>
     <!-- 注入切面类 -->
     <bean id="aop" class="com.shore.aop.Aop"></bean>

     <aop:config>
         <!-- 配置切入点 -->
         <aop:pointcut expression="execution(* com.shore.dao.impl.*.*(..))" id="pt" />
         <!-- 配置切面(切入点形成的类，切入点就是重复的代码/方法) -->
         <aop:aspect ref="aop">
             <!-- 1、开启事务。。。。。。 -->
             <aop:before method="begin" pointcut-ref="pt" />
             <!-- 6、提交事务 -->
             <aop:after method="commit" pointcut-ref="pt" />
             <!-- 环绕2/5 -->
             <aop:around method="around" pointcut-ref="pt" />
             <!-- 4、afterReturning -->
             <aop:after-returning method="afterReturning"
                 pointcut-ref="pt" />
             <!-- 4、异常（程序出现异常，执行这个第四步；没有异常，则执行上面的第四步） -->
             <aop:after-throwing method="afterThrowing"
                 pointcut-ref="pt" />
         </aop:aspect>
     </aop:config>
 </beans>

测试类

 @Test
 public void testMessageDao() {
     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
     MessageDao messageDao = (MessageDao) context.getBean("messageDao");
     System.out.println("这个相当于Cglib子类代理："+messageDao);//返回值：com.shore.dao.impl.MessageDao@15412e75
     messageDao.save();
 }

测试结果图

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/11813822.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）