Spring学习笔记(三) --- Spring AOP

最新推荐文章于 2022-08-03 21:50:35 发布

满床清梦覆星河

最新推荐文章于 2022-08-03 21:50:35 发布

阅读量405

点赞数

分类专栏： Spring 文章标签： Spring AOP

本文链接：https://blog.csdn.net/qq_40640228/article/details/103822984

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、AOP概述

2、为什么学习AOP？

可以在不修改源码的情况下对程序进行增强，AOP可以进行权限校验,日志记录,性能监控,事务控制.

AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.

Spring的AOP的底层用到两种代理机制：

* JDK的动态代理 :针对实现了接口的类产生代理.

* Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术生成当前类的子类对象.

3、Spring底层AOP的实现原理

Ⅰ、JDK动态代理增强一个类中方法

public class MyJDKProxy implements InvocationHandler {

	private UserDao userDao;

	public MyJDKProxy(UserDao userDao) {
		this.userDao = userDao;
	}

	// 编写工具方法：生成代理：
	public UserDao createProxy(){
		UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
				userDao.getClass().getInterfaces(), this);

		return userDaoProxy;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if("save".equals(method.getName())){
			System.out.println("权限校验================");
		}
		return method.invoke(userDao, args);
	}
}

Ⅱ、Cglib动态代理增强一个类中的方法

public class MyCglibProxy implements MethodInterceptor{

	private CustomerDao customerDao;

	public MyCglibProxy(CustomerDao customerDao){
		this.customerDao = customerDao;
	}
	
	// 生成代理的方法:
	public CustomerDao createProxy(){
		// 创建Cglib的核心类:
		Enhancer enhancer = new Enhancer();
		// 设置父类:
		enhancer.setSuperclass(CustomerDao.class);
		// 设置回调:
		enhancer.setCallback(this);
		// 生成代理：
		CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
		return customerDaoProxy;
	}

	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		if("delete".equals(method.getName())){
			Object obj = methodProxy.invokeSuper(proxy, args);
			System.out.println("日志记录================");
			return obj;
		}
		
		return methodProxy.invokeSuper(proxy, args);
	}
}

4、AOP的开发中的相关术语

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.

Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target(目标对象):代理的目标对象

Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程，spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切入点和通知（引介）的结合

通知类型：

前置通知	：在目标方法执行之前执行.
后置通知	：在目标方法执行之后执行
环绕通知	：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现 异常的时候 执行
最终通知	：无论目标方法是否出现异常 最终通知都会 执行.

5、切入点表达式

execution(表达式)

[方法访问修饰符] 方法返回值包名.类名.方法名(方法的参数)

示例：

public * spring.dao.*.*(..)

* spring.dao.*.*(..)

* spring.dao.UserDao+.*(..)

* spring.dao..*.*(..)

6、Spring使用AspectJ进行AOP的开发：XML的方式

步骤一：引入相应的jar包

步骤二：引入Spring的配置文件

引入AOP约束:
<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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	
</beans>

步骤三：编写目标类

//创建接口和类

public interface OrderDao {
	public void save();
	public void update();
	public void delete();
	public void find();
}

public class OrderDaoImpl implements OrderDao {

	@Override
	public void save() {
		System.out.println("保存订单...");
	}

	@Override
	public void update() {
		System.out.println("修改订单...");
	}

	@Override
	public void delete() {
		System.out.println("删除订单...");
	}

	@Override
	public void find() {
		System.out.println("查询订单...");
	}

}

步骤四：目标类的配置

    <!-- 目标类================ -->

	<bean id="orderDao" class="cn.itcast.spring.demo3.OrderDaoImpl"></bean>

步骤五：整合Junit单元测试

引入spring-test.jar

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
	@Resource(name="orderDao")
	private OrderDao orderDao;
	
	@Test
	public void demo1(){
		orderDao.save();
		orderDao.update();
		orderDao.delete();
		orderDao.find();
	}
}

步骤六：编写一个切面类

public class MyAspectXml {
	// 前置增强
	public void before(){
		System.out.println("前置增强===========");
	}
}

步骤七：配置完成增强

	<!-- 配置切面类 -->
	<bean id="myAspectXml" class="spring.demo3.MyAspectXml"></bean>
	
	<!-- 进行aop的配置 -->
	<aop:config>
		<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
		<aop:pointcut expression="execution(* spring.demo3.OrderDao.save(..))" id="pointcut1"/>
		<!-- 配置切面 -->
		<aop:aspect ref="myAspectXml">
			<aop:before method="before" pointcut-ref="pointcut1"/>
		</aop:aspect>
	</aop:config>

其它的增强的配置：

<!-- 配置切面类 -->
	<bean id="myAspectXml" class="spring.demo3.MyAspectXml"></bean>
	
	<!-- 进行aop的配置 -->
	<aop:config>
		<!-- 配置切入点表达式:哪些类的哪些方法需要进行增强 -->
		<aop:pointcut expression="execution(* spring.demo3.*Dao.save(..))" id="pointcut1"/>
		<aop:pointcut expression="execution(* spring.demo3.*Dao.delete(..))" id="pointcut2"/>
		<aop:pointcut expression="execution(* spring.demo3.*Dao.update(..))" id="pointcut3"/>
		<aop:pointcut expression="execution(* spring.demo3.*Dao.find(..))" id="pointcut4"/>
		<!-- 配置切面 -->
		<aop:aspect ref="myAspectXml">
			<aop:before method="before" pointcut-ref="pointcut1"/>
			<aop:after-returning method="afterReturing" pointcut-ref="pointcut2"/>
			<aop:around method="around" pointcut-ref="pointcut3"/>
			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4"/>
			<aop:after method="after" pointcut-ref="pointcut4"/>
		</aop:aspect>
	</aop:config>

7、Spring使用AspectJ进行AOP的开发:注解的方式

AspectJ的AOP的注解：

@Aspect:定义切面类的注解

通知类型:

    * @Before			:前置通知
    * @AfterReturing	:后置通知
    * @Around			:环绕通知
    * @After			:最终通知
    * @AfterThrowing	:异常抛出通知.

@Pointcut:定义切入点的注解

步骤一：引入相关的jar包

步骤二：引入Spring的配置文件

引入AOP约束:
<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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	
</beans>

步骤三：编写目标类

public class ProductDao {
	public void save(){
		System.out.println("保存商品...");
	}
	public void update(){
		System.out.println("修改商品...");
	}
	public void delete(){
		System.out.println("删除商品...");
	}
	public void find(){
		System.out.println("查询商品...");
	}
}

步骤四：配置目标类

     <!-- 目标类============ -->

     <bean id="productDao" class="spring.demo4.ProductDao"></bean>

步骤五：开启aop注解的自动代理

<aop:aspectj-autoproxy/>

步骤六：编写切面类

@Aspect
public class MyAspectAnno {

	@Before("MyAspectAnno.pointcut1()")
	public void before(){
		System.out.println("前置通知===========");
	}
	
	@Pointcut("execution(* spring.demo4.ProductDao.save(..))")
	private void pointcut1(){}
}

步骤七：配置切面

 <!-- 配置切面类 -->

 <bean id="myAspectAnno" class="spring.demo4.MyAspectAnno"></bean>

其它通知的注解：

@Aspect
public class MyAspectAnno {

	@Before("MyAspectAnno.pointcut1()")
	public void before(){
		System.out.println("前置通知===========");
	}
	
	@AfterReturning("MyAspectAnno.pointcut2()")
	public void afterReturning(){
		System.out.println("后置通知===========");
	}
	
	@Around("MyAspectAnno.pointcut3()")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕前通知==========");
		Object obj = joinPoint.proceed();
		System.out.println("环绕后通知==========");
		return obj;
	}
	
	@AfterThrowing("MyAspectAnno.pointcut4()")
	public void afterThrowing(){
		System.out.println("异常抛出通知========");
	}
	
	@After("MyAspectAnno.pointcut4()")
	public void after(){
		System.out.println("最终通知==========");
	}
	
	@Pointcut("execution(* spring.demo4.ProductDao.save(..))")
	private void pointcut1(){}
	@Pointcut("execution(* spring.demo4.ProductDao.update(..))")
	private void pointcut2(){}
	@Pointcut("execution(* spring.demo4.ProductDao.delete(..))")
	private void pointcut3(){}
	@Pointcut("execution(* spring.demo4.ProductDao.find(..))")
	private void pointcut4(){}
}

满床清梦覆星河

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring学习笔记(三) --- Spring AOP

1、AOP概述2、为什么学习AOP？可以在不修改源码的情况下对程序进行增强，AOP可以进行权限校验,日志记录,性能监控,事务控制.AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.Spring的AOP的底层用到两种代理机制： * JDK的动态代理 :针对实现了接口的类产生代理. * Cgl...
复制链接

扫一扫