【Spring】AOP编程

于 2017-10-24 15:55:55 发布
阅读量336 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： Java学习 Spring 文章标签： aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Evan_QB/article/details/78330537
本文介绍面向切面编程(AOP)的基本概念与应用方法，通过注解和XML两种方式实现AOP编程，涵盖切入点表达式的使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

AOP编程概述:

　AOP: Aspect Oriented Programming 面向切面编程。
　　面向切面编程(也叫面向方面):是目前软件开发中的一个热点。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
　　主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
　　主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改  变这些行为的时候不影响业务逻辑的代码。


关注点

         重复代码就叫做关注点；

切面

          关注点形成的类，就叫切面(类)！

          面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。

切入点

         执行目标对象方法，动态植入切面代码。

         可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

一.注解方式实现AOP编程:

步骤:

1.先引入spring-aop相关的jar包


2.在bean.xml中引入aop相应的名称空间

xmlns:aop="http://www.springframework.org/schema/aop"


3.开启aop注解

<!-- 开启注解扫描 -->
<context:component-scan base-package="cn.qblank.d_myaop"></context:component-scan>

4.使用注解

@Aspect  指定一个类为切面类


@Pointcut("execution(* cn.lfsenior.e_aop_anno.*.*(..))")  指定切入点表达式


@Before("pointCut_()") 前置通知: 目标方法之前执行


@After("pointCut_()") 后置通知：目标方法之后执行（始终执行）


@AfterReturning("pointCut_()")     返回后通知： 执行方法结束前执行(异常不执行)


@AfterThrowing("pointCut_()") 异常通知:  出现异常时候执行


@Around("pointCut_()") 环绕通知： 环绕目标方法执行

配置bean.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 开启注解扫描 -->
	<context:component-scan base-package="cn.qblank.e_aop"></context:component-scan>
	
	<!-- 开启aop注解方式 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>


编写IUserDao接口

public interface IUserDao {
	void save();
}

然后编写UserDao实现接口 

package cn.qblank.e_aop;

import org.springframework.stereotype.Component;

/**
 * 目标对象
 * @author Administrator
 *
 */
@Component //加入IOC容器
public class UserDao implements IUserDao{
	@Override
	public void save() {
		System.out.println("保存数据");
	}
}

使用注解编写切面类 

package cn.qblank.e_aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面类
 * @author evan_qb
 */
//加入IOC容器
@Component
@Aspect		//指定为切面类
public class Aop {
	/**
	 * 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象
	 */
	@Pointcut("execution(* cn/qblank/e_aop.*.*(..))")
	public void pointCut_(){
		
	}
	
	// 前置通知 : 在执行目标方法之前执行
	@Before("execution(* cn/qblank/e_aop.*.*(..))")
	public void begin(){
		System.out.println("开启事务/异常");
	}
	
	// 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
	@After("execution(* cn/qblank/e_aop.*.*(..))")
	public void after(){
		System.out.println("提交事务");
	}
	
	// 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
	@AfterReturning("pointCut_()")
	public void afterRunning(){
		System.out.println("调用方法结束后,出现异常不执行");
	}
	
	// 异常通知： 当目标方法执行异常时候执行此关注点代码
	@AfterThrowing("pointCut_()")
	public void afterThrowing(){
		System.out.println("出现异常");
	}
	
	// 环绕通知：环绕目标方式执行
	@Around("pointCut_()")
	public void around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("环绕前....");
		pjp.proceed();
		System.out.println("环绕后...");
	}
}

测试类Tests 

package cn.qblank.e_aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Tests {
	static ApplicationContext ac = new ClassPathXmlApplicationContext("cn/qblank/e_aop/bean.xml");
	// 目标对象有实现接口，spring会自动选择“JDK代理”
	// 目标对象没有有实现接口，spring会自动选择“ciglib代理”
	public static void main(String[] args) {
		IUserDao userDao = (UserDao) ac.getBean("userDao");
		System.out.println(userDao.getClass());
		userDao.save();
	}
}

二.xml方式实现AOP编程

1）引入jar文件  【aop相关jar，4个】

2）引入aop名称空间

3) 在bean.xml进行aop的配置 

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- userDao实例 -->
	<bean id="userDao" class="cn.qblank.f_xml.UserDao"></bean>
	
	<!-- 切面类 -->
	<bean id="aop" class="cn.qblank.f_xml.Aop"></bean>
	<!-- aop配置 -->
	<aop:config>
		<!-- 定义一个切入点表达式 -->
		<aop:pointcut expression="execution(* cn.qblank.f_xml.*.*(..))" id="pt"/>
		<aop:aspect ref="aop">
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pt"/>
			<!-- 前置通知： 在目标方法调用前执行 -->
			<aop:before method="begin" pointcut-ref="pt"/>
			<!-- 后置通知 -->
			<aop:after method="after" pointcut-ref="pt"/>
			<!-- 返回后通知 -->
			<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
			<!-- 异常通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
		</aop:aspect>
	</aop:config>
</beans>

三.切入点表达式

可以对指定的“方法”进行拦截；  从而给指定的方法所在的类生层代理对象。

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	<!-- dao实例 -->
	<bean id="userDao" class="cn.qblank.g_pointcut.UserDao"></bean>
	<!-- 切面类 -->
	<bean id="aop" class="cn.qblank.g_pointcut.Aop"></bean>
	<!-- aop配置 -->
	<aop:config>
		<!-- 定义 一个切面方法拦截对应包下面的所有方法 -->
		<aop:pointcut expression="execution(* cn.qblank.g_pointcut.*.*(..))" id="pt"/>
		<!-- 拦截所有public方法 -->
		<aop:pointcut expression="execution(public * *.*(..))" id="pt"/>
		<!-- 拦截所有save开头的方法 -->
		<aop:pointcut expression="execution(* save*(..))" id="pt"/>
		<!-- 拦截指定类的指定方法  -->
		<aop:pointcut expression="execution(public * cn.qblank.g_pointcut.UserDao.save(..))" id="pt"/>
		<!-- 拦截指定类的所有方法 -->
		<aop:pointcut expression="execution(* cn.qblank.g_pointcut.UserDao.*(..))" id="pt"/>
		<!-- 拦截指定包以及其子包所有类的所有方法 -->
		<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>
		<!-- 【逻辑表达式】 -->
		<aop:pointcut expression="execution(* cn.qblank.g_pointcut.UserDao.save()) || execution(* cn.qblank.g_pointcut.OrderDao.save())" id="pt"/>
		<!--<aop:pointcut expression="execution(* cn.qblank.g_pointcut.UserDao.save()) or execution(* cn.qblank.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!-- 下面2个且关系的，没有意义 -->
		<!--<aop:pointcut expression="execution(* cn.qblank.g_pointcut.UserDao.save()) && execution(* cn.qblank.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn.qblank.g_pointcut.UserDao.save()) and execution(* cn.qblank.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!-- 取非值 -->
		<aop:pointcut expression="!execution(* cn.qblank.g_pointcut.UserDao.save())" id=""/>
		<!-- <aop:pointcut expression="not execution(* cn.qblank.g_pointcut.UserDao.save())" id=""/> -->
		<!-- 引入切面类 -->
		<aop:aspect ref="aop">
			<aop:around method="around" pointcut-ref="pt"/>
		</aop:aspect>
	</aop:config>
</beans>







评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值