关于Spring核心原理Aop的几种实现方式

最新推荐文章于 2023-07-27 12:06:17 发布
最新推荐文章于 2023-07-27 12:06:17 发布
阅读量301 收藏
点赞数
分类专栏： spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanglei0421/article/details/78194198
版权

我用的是spring4.3.11的jar包

1.配置文件的实现方式

代码写在aop包上

主业务接口，IMainBiz

package aop;

public interface IMainBiz {
	public void doMainBiz();
}

主业务实现类，MainBiz 

package aop;

public class MainBiz  implements IMainBiz{

	public void doMainBiz()
	{
		System.out.println(1/0);
		System.out.println("核心业务");
	}
}
切面业务，SubBiz 

package aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class SubBiz {

	public void doSubBiz(JoinPoint joinPoint)
	{
		//目标对象类信息
		System.out.println(joinPoint.getTarget().getClass().getSimpleName());
		System.out.println(joinPoint.getArgs());
		//切入点，主业务方法
		System.out.println(joinPoint.getSignature());
		System.out.println("切面业务");
		try {
			((ProceedingJoinPoint) joinPoint).proceed();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("横切业务2");
	}
	public void doSubBiz2(Exception ex)
	{
		if(ex instanceof ArithmeticException)
		{
			System.out.println("数字异常");
		}
		else
		{
			System.out.println("未知异常");
		}
	}
}
测试类Main 

package aop;

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

public class Main {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
		//cglib产生的代理对象，继承了mainbiz，经行子类扩展的功能
		//一定要接口接受
		IMainBiz mainBiz= (IMainBiz) applicationContext.getBean("mainbiz");
		mainBiz.doMainBiz();
	}
}
配置文件：applicationContext.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:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	<!--目标对象 -->
	<bean id="mainbiz" class="aop.MainBiz"></bean>
	<!--切面 -->
	<bean id="subbiz" class="aop.SubBiz"></bean>
	<aop:config>
		<!--切入点 -->
		<aop:pointcut expression="execution(public void aop.MainBiz.doMainBiz())"
			id="pointcut" />
			<!--引入切面 -->
		<aop:aspect ref="subbiz">
		<!--切入策略 -->
			<!-- <aop:around method="doSubBiz" pointcut-ref="pointcut" /> -->
			<aop:after-throwing method="doSubBiz2" pointcut-ref="pointcut" throwing="ex"/>
		</aop:aspect>
	</aop:config>
</beans>

2. 实现通知接口并配合配置文件的方式

代码在advisor包上

主业务接口

package advisor;

public interface IMainBiz {
	public void doMainBiz();
}
主业务实现类 

package advisor;

public class MainBiz  implements IMainBiz{

	public void doMainBiz()
	{
		System.out.println("核心业务");
	}
}
切面业务类，实现了接口

使用了advisor配置增强处理，

MethodBeforAdvice前置通知

AfterReturningAdvice后置通知，这个后置通知可以接受返回值,但是别的那几种方法是不能接收返回值

MethodInterceptor环绕通知

ThrowsAdvice异常通知，较为特殊，没有接口方法所以要手动在实现类中加入

public void afterThrowing(Method method,Object[] args,Object target,Exception ex){}

package advisor;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.aop.MethodBeforeAdvice;
//使用了Advisor配置增强处理
public class SubBiz implements MethodBeforeAdvice{
	
	

	@Override
	public void before(Method method, Object[] args, Object obj) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("切面方法");
	
	}
	
}
测试类Main 

package advisor;

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

public class Main {
	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext2.xml");
		IMainBiz iMainBiz = (IMainBiz) applicationContext.getBean("mainbiz");
		iMainBiz.doMainBiz();
	}
}

配置文件applicationContext2.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:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">


	<bean id="mainbiz" class="adcisor.MainBiz"></bean>

	<bean id="subbiz" class="adcisor.SubBiz"></bean>

	<!--Aop配置  -->
	<aop:config>
		<aop:pointcut expression="execution(public void advisor.MainBiz.doMainBiz())" id="pointcut" />
		<!--切入策略  -->
		<aop:advisor advice-ref="subbiz" pointcut-ref="pointcut" />
	</aop:config>
</beans>

3.注解方式（个人觉得最简单的）

主业务接口ArithmeticCalculator

package test1;

public interface ArithmeticCalculator {
	int add(int a,int b);
	int sub(int a,int b);
	int multiply(int a,int b);
	int divide(int a,int b);
}
主业务实现类 

package test1;

import org.springframework.stereotype.Component;
@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {

	@Override
	public int add(int a, int b) {
		int result = a + b;
		return result;
	}

	@Override
	public int sub(int a, int b) {
		int result = a - b;
		return result;
	}

	@Override
	public int multiply(int a, int b) {
		int result = a * b;
		return result;
	}

	@Override
	public int divide(int a, int b) {
		int result = a / b;
		return result;
	}

}
切面业务类 

package test1;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
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.springframework.stereotype.Component;
//可以使用@order()来设置优先级，数字越小，优先级越高
@Aspect
@Component
public class LogginAspect {

	@Before("execution(public int test1.ArithmeticCalculatorImpl.*(int , int))")
	public void beforMethod(JoinPoint joinPoint)
	{
		String name = joinPoint.getSignature().getName();
		Object[] args = joinPoint.getArgs();
		List<Object> list = Arrays.asList(args);
		System.out.println("前置通知："+name+" args "+list);
	}
	@After("execution(public int test1.ArithmeticCalculatorImpl.*(int , int))")
	public void afterMethod(JoinPoint joinPoint)
	{
		String name = joinPoint.getSignature().getName();
		Object[] args = joinPoint.getArgs();
		List<Object> list = Arrays.asList(args);
		System.out.println("后置通知："+name+" args "+list);
	}
	@AfterReturning(value="execution(public int test1.ArithmeticCalculatorImpl.*(int , int))",
			returning="result")
	public void returnMethod(JoinPoint joinPoint,Object result)
	{
		
		String name = joinPoint.getSignature().getName();
		Object[] args = joinPoint.getArgs();
		List<Object> list = Arrays.asList(args);
		System.out.println("返回通知："+name+" args "+list+" result "+result);
	}
	@AfterThrowing(value="execution(public int test1.ArithmeticCalculatorImpl.*(int , int))",
			throwing="ex")
	public void throwMethod(JoinPoint joinPoint,Exception ex)
	{
		
		String name = joinPoint.getSignature().getName();
		Object[] args = joinPoint.getArgs();
		List<Object> list = Arrays.asList(args);
		System.out.println("异常通知："+name+" args "+list+" result "+ex);
	}
	@Around("execution(public int test1.ArithmeticCalculatorImpl.*(int , int))")
	public Object around(ProceedingJoinPoint pjd)
	{
		String methodname=pjd.getSignature().getName();
		Object proceed =null;
		//执行目标方法
		try {
			//前置通知
			System.out.println("the method :"+methodname+"  begins with" +Arrays.asList(pjd.getArgs()));
			proceed=pjd.proceed();
			//返回通知
			System.out.println("the method return  with "+ proceed);
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			System.out.println("the method pccurs exception "+e);
		}
		//后置通知
		System.out.println("the method end ");
		return proceed;
	}

 测试类Main 

 

 

package test1;

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

import com.sun.media.sound.AiffFileReader;

public class Main {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext3.xml");
		ArithmeticCalculator arithmeticCalculator = (ArithmeticCalculator) applicationContext
				.getBean("arithmeticCalculator");
		arithmeticCalculator.divide(3, 1);
//		System.out.println(add);
	}
}
配置文件applicationContext3.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:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	<!--开启扫描包  -->
	<context:component-scan base-package="test1" />
	<!-- 开启aop注解驱动 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

在切面类加入支持的注解: 

 
@before 

 
@after  

 
@afterThrowing 

 
@afterReturning 

 
@aroud 

 
@aspect 

 
@pointcut 

 4. 
通过实现接口方式 

 

主业务接口IMainBiz
 

 

package aop2;

public interface IMainBiz {
	public void doMainBiz();
}

 

 主业务实现类MainBiz 

 

 

package aop2;

public class MainBiz  implements IMainBiz{

	public void doMainBiz()
	{
		System.out.println("核心业务");
	}
}
切面类SubBiz 

 

 

package aop2;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.aop.MethodBeforeAdvice;

public class SubBiz implements MethodBeforeAdvice {

	public void doSubBiz() {
		System.out.println("切面方法");
	}

	@Override
	public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
		doSubBiz();
	}

}
测试类Main 

 

 

package aop2;

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

public class Main {

	public static void main(String[] args) {
		ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext4.xml");
			//这里getBean得到的不算主业务的id，而是ProxyFactoryBean的id
		IMainBiz  imMainBiz= (IMainBiz) applicationContext.getBean("myproxy");
		imMainBiz.doMainBiz();
	}
}

 

 配置文件applicationContext4.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:context="http://www.springframework.org/schema/context"
	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-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">


	<!-- 目标类-->
	<bean id="mainbiz" class="aop2.MainBiz"></bean>
	<!--切面类:实现通知接口-->
	<bean id="subbiz" class="aop2.SubBiz"></bean>
	
	<!-- 使用spring提供工厂类ProxyFactoryBean -->
	<bean id="myproxy"  class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="proxyInterfaces">
			<list>
				<value>aop2.IMainBiz</value>
			</list>
		</property>
		<!-- 目标类信息 -->
		<property name="targetName" value="mainbiz"></property>
		<!-- 切面类信息 -->	
		<property name="interceptorNames">
			<list>
				<value>subbiz</value>
			</list>
		</property>
	</bean>
</beans>
 

创建ProxyFactoryBean代理对象
 

 

<bean id="myproxy"  class="org.springframework.aop.framework.ProxyFactoryBean">
					//指定的目标类实现的接口
					<property name="proxyInterfaces">
						<list>
							<value>接口的完全限定名</value>
						</list>
					</property>
					<!-- 目标类信息 -->
					<property name="targetName" value="目标类ID"></property>
					<!-- 切面类信息 -->	
					<property name="interceptorNames">
						<list>
							<value>切面类的ID</value>
						</list>
					</property>
				</bean>
 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  磊磊磊磊磊磊磊磊磊
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
springIOC及AOP底层原理Demo实现

				
			

			

				

					11-13
				

			

		

		

			
				
具体实现上，Spring AOP有两种实现方式：基于代理的AOP和基于ASM字节码的AOP。基于代理的AOP主要使用JDK动态代理或CGLIB库生成目标对象的代理对象，代理对象在方法调用时拦截并执行通知。而基于字节码的AOP则在运行...

			
		

	



                

              
                



	

		

			

				
					
Spring基于注解方式的AOP编程

				
			

			

				

					LOST JACK
				

				

					10-17
					
					213
					
				

			

		

		

			
				
第一步 导包



第二步 编写UserDaoIfac接口以及UserDaoImpl实现类

UserDaoIfac接口


package dao;

public interface UserDaoIfac {
	public void login(String name);
}

UserDaoImpl类


package dao;

public class UserDaoImpl im...

			
		

	



                


  
              

                


	

		

			

				
					
JAVA开发（AOP之ProceedingJoinPoint）

				
			

			

				

					JAVA领域优质创作者，基于分片网络查询方法专利发明者。
				

				

					01-12
					
					6068
					
				

			

		

		

			
				
我们在开发过程中经常使用到自定义注解来实现在一些类或者方法执行过程中切面，统一实现某些业务操作。例如自定义注解

			
		

	





	

		

			

				
					
spring aop拦截指定方法和自定义注解

				
			

			

				

					mnhpo_Q的博客
				

				

					04-11
					
					5190
					
				

			

		

		

			
				
1、使用aop需要加入maven依赖 
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop...

			
		

	



		

			
		



	

		

			

				
					
org.aspectj.lang.ProceedingJoinPoint

				
			

			

				

					qq_38793958的博客
				

				

					08-27
					
					8454
					
				

			

		

		

			
				
一，ProceedingJoinPoint的概述：

（1）它是一个对象；

（2）作为参数：定义增强处理方法时，将第一个参数定义为该类型，当该增强处理方法被调用时，该类型的对象就代表织入增强处理的连接点。

（3）该对象常用方法：

    1，Object[ ]  getArgs ：返回目标方法的参数；

    2，Signature getSignature：返回目标方法的签名；

   ...

			
		

	





	

		

			

				
					
AspectJ使用

				
			

			

				

					赶路人儿
				

				

					03-19
					
					1万+
					
				

			

		

		

			
				
一、AOP介绍

AOP：Aspect-Oriented Programming，面向切面编程，是一种新的方法论（编程范式），是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。旨在通过允许横切关注点的分离，提高模块化。如在方法执行前、或执行后、或是在执行中出现异常后这些地方进行拦截处理或叫做增强处理。主要应用于：日志收集、事务管理、安全检查、缓存、对象池管理等。

AOP实现的关键就在于AOP框架自动创建的AOP代理，AOP代理则可分为静态代理（例如：sprin

			
		

	





	

		

			

				
					
深入浅析Spring AOP的实现原理1

				
			

			

				

					08-08
				

			

		

		

			
				
Spring AOP的实现原理包括以下几个关键点：  1. **切面（Aspect）**：切面是AOP的核心，它封装了特定的横切关注点，如日志、事务管理。切面通常由一个或多个通知（advises）组成。  2. **通知（Advice）**：通知是切...

			
		

	





	

		

			

				
					
springboot+aspect实现springaop拦截指定方法.zip

				
			

			

				

					10-21
				

			

		

		

			
				
综上所述，SpringBoot结合AspectJ实现SpringAOP拦截指定方法，主要涉及到Spring AOP的原理、切点和通知的定义、自定义注解的使用，以及如何在SpringBoot项目中整合AspectJ进行更复杂的切面编程。通过这些知识点，...

			
		

	





	

		

			

				
					
spring_aop1.rar_spring aop

				
			

			

				

					09-22
				

			

		

		

			
				
在Spring AOP中，主要涉及以下几个核心概念：  1. **切面（Aspect）**：切面是关注点的模块化，它封装了横切关注点，如日志、事务管理等。在Spring AOP中，切面通常由一个或多个通知（advice）和一个切入点...

			
		

	





	

		

			

				
					
spring-aop.rar_java aop_spring aop

				
			

			

				

					09-23
				

			

		

		

			
				
Spring AOP是Spring框架的一个重要组成部分，它提供了一种声明式的方式来实现切面。开发者可以定义切点（pointcut）、通知（advice）、切面（aspect）等，Spring AOP会自动在适当的时候插入这些通知，从而简化代码...

			
		

	





	

		

			

				
					
org.aspectj.lang.annotation.Around所需要的包

				
			

			

				

					10-24
				

			

		

		

			
				
java错误-java.lang.ClassNotFoundException: org.aspectj.lang.annotation.Around
Spring的AOP需要上述三个jar包

			
		

	





	

		

			

				
					
AOP中ProceedingJoinPoint获取目标方法，参数，注解

					
热门推荐

				
			

			

				

					m0_54423474的博客
				

				

					08-23
					
					1万+
					
				

			

		

		

			
				
【代码】AOP中ProceedingJoinPoint获取目标方法，参数，注解。

			
		

	





	

		

			

				
					
Spring AOP (面向切面编程）原理与代理模式—实例演示

					
最新发布

				
			

			

				

					白白白鲤鱼的博客
				

				

					07-27
					
					2713
					
				

			

		

		

			
				
Spring AOP 原理与代理模式

			
		

	





	

		

			

				
					
Spring AOP核心原理分析

				
			

			

				

					wh柒八九的博客
				

				

					05-10
					
					590
					
				

			

		

		

			
				
“横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect”，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

文章目录概述

概述

...

			
		

	





	

		

			

				
					
最简单的AOP实现方式：Spring + AspectJ，带你飞速入门

				
			

			

				

					weixin_37468339的博客
				

				

					10-29
					
					365
					
				

			

		

		

			
				
AOP是一种区别于OOP的编程思想，具体概念想必大家都懂，废话不多说，直接进入正题

AOP的实现和配置有多种方式，如题，今天我们先来最简单，最高效的编写方式。

演示用的框架是spring boot：

1、导入pom依赖：


&lt;dependency&gt;
	&lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
	&lt;art...

			
		

	





	

		

			

				
					
springAop看这篇就够了--  Spring AOP是什么？你都拿它做什么？

				
			

			

				

					大碍桃花开
				

				

					01-13
					
					923
					
				

			

		

		

			
				
为什么会有面向切面编程（AOP）？我们知道Java是一个面向对象（OOP）的语言，但它有一些弊端，比如当我们需要为多个不具有继承关系的对象引入一个公共行为，例如日志、权限验证、事务等功能时，只能在在每个对象里引用公共行为。这样做不便于维护，而且有大量重复代码。AOP的出现弥补了OOP的这点不足。
为了阐述清楚Spring AOP，我们从将以下方面进行讨论：
代理模式
静态代理原理及实践
动态代理原...

			
		

	





	

		

			

				
					
关于AOP的实现原理

				
			

			

				

					m0_56065322的博客
				

				

					11-20
					
					3844
					
				

			

		

		

			
				
什么是AOP，AOP即面向切面编程，和OOP（面向对象编程）类似，也是一种编程思想。AOP采取横向抽取机制（动态代理），取代了传统纵向继承机制的重要性代码，其应用主要体现在事务处理，日志管理、权限控制、异常处理等方面。主要作用是分离功能性需求和非功能性需求，使开发人员可以集中处理某一个关注点或者横切逻辑，减少业务代码的侵入，增强代码的可读性和可维护性。简单的来说，AOP的作用就是保证开发者在不修改源代码的前提下，为系统中的业务组件添加某种通用功能。AOP就是代理模式的典型应用。

			
		

	





	

		

			

				
					
利用AOP监控Java接口响应超时

				
			

			

				

					MIYAOW
				

				

					10-11
					
					3164
					
				

			

		

		

			
				
 

为什么要监控

　　服务化接口是提供服务的，接口正确性、稳定性是最最重要的，在保证正确的同时需要尽量提高接口响应时间。

　　有的团队会有专门的工具来对系统响应时间、吞吐量做监控，但如果团队没有这种“待遇”就需要自己来做一些工具为自己的代码提供服务。

自己动手,丰衣足食

　　AOP + Annotation 简陋实现，能达到目的

　　AOP : 使用环绕方式对接口拦截,在拦截接口前后记...

			
		

	





	

		

			

				
					
SpringBoot项目切面编程AOP之@Aspect

				
			

			

				

					hkl_Forever的博客
				

				

					11-26
					
					1万+
					
				

			

		

		

			
				
aop切面编程想必大家都不陌生了，aspect可以很方便开发人员对请求指定拦截层，一般是根据条件切入到controller控制层，做一些鉴权、分析注解、获取类名方法名参数、记录操作日志等。2、aop默认无法切入 private 修饰的方法，切入点表达式定义的修饰符要和被切入的方法修饰符一致，否则无法切入。5、@Around：环绕增强，包围一个连接点的增强，最强大的一个方式，且常用。3、使用切入点切入标记注解@Before、@After、@Around等。2、定义切入点标记注解@Pointcut。

			
		

	





	

		

			

				
					
spring aop实现原理

				
			

			

				

					05-14
				

			

		

		

			
				
切面是 Spring AOP 中最核心的概念，它定义了横切逻辑的实现方式。在 Spring AOP 中，切面通常是一个 Java 类，它包含了一些通知（Advice）和切点（Pointcut），用来描述横切逻辑的具体实现。  3. 通知（Advice）  ...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值