spring中AspectJ

最新推荐文章于 2023-03-20 16:53:29 发布
最新推荐文章于 2023-03-20 16:53:29 发布
阅读量362 收藏
点赞数
分类专栏： JavaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_GIA/article/details/54755547
版权

AspectJ

一、介绍

l  AspectJ是一个基于Java语言的AOP框架

l  Spring2.0以后新增了对AspectJ切点表达式支持

l  @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP

l  主要用途：自定义开发

 

二、切入点表达式

1.execution()  用于描述方法【掌握】

       语法：execution(修饰符 返回值  包.类.方法名(参数) throws异常)

              修饰符，一般省略

                     public            公共方法

                     *                   任意

              返回值，不能省略

                     void               返回没有值

                     String            返回值字符串

                     *                  任意

              包，[省略]

                     com.hcx.crm                  固定包

                     com.hcx.crm.*.service     crm包下面子包任意（例如：com.hcx.crm.staff.service）

                     com.hcx.crm..                crm包下面的所有子包（含自己）

                     com.hcx.crm.*.service..   crm包下面任意子包，固定目录service，service目录任意包

              类，[省略]

                     UserServiceImpl                  指定类

                     *Impl                                  以Impl结尾

                     User*                                  以User开头

                     *                                        任意

              方法名，不能省略

                     addUser                               固定方法

                     add*                                   以add开头

                     *Do                                    以Do结尾

                     *                                        任意

              (参数)

                     ()                                        无参

                     (int)                                    一个整型

                     (int,int)                              两个

                     (..)                                      参数任意

              throws,可省略，一般不写。

 

综合1

       execution(* com.hcx.crm.*.service..*.*(..))

综合2

       <aop:pointcutexpression="execution(* com.hcx.*WithCommit.*(..)) ||

                          execution(* com.hcx.*Service.*(..))"id="myPointCut"/>

2.within:匹配包或子包中的方法(了解)   

       within(com.hcx.aop..*)

3.this:匹配实现接口的代理对象中的方法(了解)

       this(com.hcx.aop.user.UserDAO)

4.target:匹配实现接口的目标对象中的方法(了解)

       target(com.hcx.aop.user.UserDAO)

5.args:匹配参数格式符合标准的方法(了解)

       args(int,int)

6.bean(id) 对指定的bean所有的方法(了解)

       bean('userServiceId')

 

三、AspectJ通知类型

l  aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。

l  aspectj 通知类型，只定义类型名称。以及方法格式。

l  个数：6种，知道5种，掌握1中。

       before:前置通知(应用：各种校验)

              在方法执行前执行，如果通知抛出异常，阻止方法运行

       afterReturning:后置通知(应用：常规数据处理)

              方法正常返回后执行，如果方法中抛出异常，通知无法执行

              必须在方法执行后才执行，所以可以获得方法的返回值。

       around:环绕通知(应用：十分强大，可以做任何事情)

              方法执行前后分别执行，可以阻止方法的执行

              必须手动执行目标方法

       afterThrowing:抛出异常通知(应用：包装异常信息)

              方法抛出异常后执行，如果方法没有抛出异常，无法执行

       after:最终通知(应用：清理现场)

              方法执行完毕后执行，无论方法中是否出现异常

环绕

try{
     //前置：before
    //手动执行目标方法
    //后置：afterReturning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

 
 

四、导入jar包

l  4个：

       aop联盟规范

       springaop 实现

       aspect规范

       springaspect 实现

 
 
 

五、基于xml

1.目标类：接口 + 实现

2.切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）

3.aop编程，将通知应用到目标类

4.测试

UserService; 
package com.hcx.d_aspect.a_xml;

public interface UserService {
	
	public void addUser();
	public String updateUser();
	public void deleteUser();

}

 
 
UserServiceImpl: 
package com.hcx.d_aspect.a_xml;

public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("d_aspect.a_xml addUser");
	}

	@Override
	public String updateUser() {
		System.out.println("d_aspect.a_xml updateUser");
		int i = 1/ 0;
		return "阳志就是屌";
	}

	@Override
	public void deleteUser() {
		
		System.out.println("d_aspect.a_xml deleteUser");
	}

}

 
 
MyAspect: 
package com.hcx.d_aspect.a_xml;

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

/**
 * 切面类，含有多个通知
 */
public class MyAspect {
	
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}

 
 
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"
       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">
	<!-- 1 创建目标类 -->
	<bean id="userServiceId" class="com.hcx.d_aspect.a_xml.UserServiceImpl"></bean>
	<!-- 2 创建切面类（通知） -->
	<bean id="myAspectId" class="com.hcx.d_aspect.a_xml.MyAspect"></bean>
	<!-- 3 aop编程 
		<aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
			ref 切面类引用
		<aop:pointcut> 声明一个切入点，所有的通知都可以使用。
			expression 切入点表达式
			id 名称，用于其它通知引用
	-->
	<aop:config>
		<aop:aspect ref="myAspectId">
			<aop:pointcut expression="execution(* com.hcx.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
			
			<!-- 3.1 前置通知 
				<aop:before method="" pointcut="" pointcut-ref=""/>
					method : 通知，即方法名
					pointcut :切入点表达式，此表达式只能当前通知使用。
					pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
				通知方法格式：public void myBefore(JoinPoint joinPoint){
					参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
				例如：
			<aop:before method="myBefore" pointcut-ref="myPointCut"/>
			-->
			
			<!-- 3.2后置通知  ,目标方法后执行，获得返回值
				<aop:after-returning method="" pointcut-ref="" returning=""/>
					returning 通知方法第二个参数的名称
				通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
					参数1：连接点描述
					参数2：类型Object，参数名 returning="ret" 配置的
				例如：
			<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
			-->
			
			<!-- 3.3 环绕通知 
				<aop:around method="" pointcut-ref=""/>
				通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
					返回值类型：Object
					方法名：任意
					参数：org.aspectj.lang.ProceedingJoinPoint
					抛出异常
				执行目标方法：Object obj = joinPoint.proceed();
				例如：
			<aop:around method="myAround" pointcut-ref="myPointCut"/>
			-->
			<!-- 3.4 抛出异常
				<aop:after-throwing method="" pointcut-ref="" throwing=""/>
					throwing ：通知方法的第二个参数名称
				通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
					参数1：连接点描述对象
					参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
				例如：
			<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
			-->
			<!-- 3.5 最终通知 -->			
			<aop:after method="myAfter" pointcut-ref="myPointCut"/>
			
			
			
		</aop:aspect>
	</aop:config>
</beans>

 
 
TestAspectXml: 
package com.hcx.d_aspect.a_xml;

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

public class TestAspectXml {
	
	@Test
	public void demo01(){
		String xmlPath = "com/hcx/d_aspect/a_xml/beans.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		//获得目标类
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}

}

 

六、基于注解

1、替换bean：

 

<!-- 1 创建目标类 -->
    <bean id="userServiceId" class="com.hcx.d_aspect.b_anno.UserServiceImpl"></bean>
    <!-- 2 创建切面类（通知） -->
    <bean id="myAspectId"class="com.hcx.d_aspect.b_anno.MyAspect"></bean>

 

 

替换成：

 

<!-- 1 创建目标类 -->
    <bean id="userServiceId" class="com.hcx.d_aspect.b_anno.UserServiceImpl"></bean>
    <!-- 2 创建切面类（通知） -->
    <bean id="myAspectId"class="com.hcx.d_aspect.b_anno.MyAspect"></bean>

@Component
public class MyAspect {
 

 

l  注意：扫描

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 1.扫描 注解类 -->
	<context:component-scan base-package="com.hcx.d_aspect.b_anno"></context:component-scan>

 

2、替换aop

l  必须进行aspectj 自动代理

<!-- 2.确定 aop注解生效 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 

l  声明切面（前（替换前））

<aop:aspect ref="myAspectId">
 
后：（替换后）： 
@Component
@Aspect
public class MyAspect {
 

l  替换前置通知 ：

前：

<aop:before method="myBefore" pointcut="execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))"/>

后： 
//切入点当前有效
	@Before("execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
 

l  替换 公共切入点

前：

<aop:pointcut expression="execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))" id="myPointCut"/>

后： 
//声明公共切入点
	@Pointcut("execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}

 

l  替换后置

前：

 

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />


后：

 

 

@AfterReturning(value="myPointCut()" ,returning="ret")
public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}

 

l  替换环绕

前： 
<aop:around method="myAround" pointcut-ref="myPointCut"/>
 
后： 
@Around(value = "myPointCut()")
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}

 

l  替换抛出异常

前： 
<aop:after-throwing method="myAfterThrowing" pointcut="execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))" throwing="e"/>

 
后：

 

@AfterThrowing(value="execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}

 

 


全部替好后：

UserService:

 

package com.hcx.d_aspect.b_anno;

public interface UserService {
	
	public void addUser();
	public String updateUser();
	public void deleteUser();

}

 

 


UserServiceImpl:

 

package com.hcx.d_aspect.b_anno;

import org.springframework.stereotype.Service;

@Service("userServiceId")
public class UserServiceImpl implements UserService {

	@Override
	public void addUser() {
		System.out.println("d_aspect.b_anno addUser");
	}

	@Override
	public String updateUser() {
		System.out.println("d_aspect.b_anno updateUser");
		int i = 1/ 0;
		return "阳志就是屌";
	}

	@Override
	public void deleteUser() {
		
		System.out.println("d_aspect.b_anno deleteUser");
	}

}
 

 

MyAspect:

 

package com.hcx.d_aspect.b_anno;

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.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {
	
	//切入点当前有效
//	@Before("execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	
	//声明公共切入点
	@Pointcut("execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}
	
//	@AfterReturning(value="myPointCut()" ,returning="ret")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
//	@Around(value = "myPointCut()")
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
//	@AfterThrowing(value="execution(* com.hcx.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	@After("myPointCut()")
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}

 

 


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: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/aop 
       					   http://www.springframework.org/schema/aop/spring-aop.xsd
       					   http://www.springframework.org/schema/context 
       					   http://www.springframework.org/schema/context/spring-context.xsd">
	
	<!-- 1.扫描 注解类 -->
	<context:component-scan base-package="com.hcx.d_aspect.b_anno"></context:component-scan>
	
	<!-- 2.确定 aop注解生效 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>
 

 

TestAspectAnno:

 

package com.hcx.d_aspect.b_anno;

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

public class TestAspectAnno {
	
	@Test
	public void demo01(){
		String xmlPath = "com/hcx/d_aspect/b_anno/beans.xml";
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
		
		//获得目标类
		UserService userService = (UserService) applicationContext.getBean("userServiceId");
		userService.addUser();
		userService.updateUser();
		userService.deleteUser();
	}

}
 

 

aop注解总结

@Aspect 声明切面，修饰切面类，从而获得 通知。

通知

       @Before前置

       @AfterReturning后置

       @Around环绕

       @AfterThrowing抛出异常

       @After最终

切入点

       @PointCut，修饰方法 privatevoid xxx(){}  之后通过“方法名”获得切入点引用

 
我可能是个假开发
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring——Aspectj
qq_43650773的博客
12-15 1099
spring——Aspectj 1.1 介绍 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 1.2 切入点表达式【掌握】 1.executio...
Spring集成AspectJ
洛卡JAVA架构师每日分享Java架构师知识
05-18 393
我们知道，Spring AOP 是一个简化版的 AOP 实现，并没有提供完整版的 AOP 功能。通常情况下，Spring AOP 是能够满足我们日常开发过程中的大多数场景的，但在某些情况下，我们可能需要使用 Spring AOP 范围外的某些 AOP 功能。 例如 Spring AOP 仅支持执行公共（public）非静态方法的调用作为连接点，如果我们需要向受保护的（protected）或私有的（private）的方法进行增强，此时就需要使用功能更加全面的 AOP 框架来实现，其中使用最多的就是 Aspec
AspectJ在Spring中的使用
weixin_33912638的博客
11-18 319
在上一篇AspectJ的入门中，简单的介绍了下AspectJ的使用，主要是以AspectJ的example作为例子。介绍完后也留下了几个问题：1）我们在spring中并没有看到需要aspectj之类的关键词，而是使用java代码就可以了，这是如何做到的2）Spring中如何做到不使用特殊的编译器实现aop的（AspectJ如何在运行期使用）3）Sprin...
spring中的aspectJ表达式
linchunhua的专栏
01-15 3463
Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:   表　达　式 说明 execution 匹配方法执行连接点。我们可以指定包、类或者方法名，以及方法的可见性、返回值和参数类型。这是应
【归纳总结】Spring之AspectJ
Octavius_的博客
03-31 252
AspectJ实际上是对AOP编程思想的一个实践 有三种实践方式： 切入点表达式 advisor aspect 需要导包： <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.6</version&gt
Spring学习之AspectJ开发
明昕ztoy的博客
03-28 7493
        AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能。Spring 2.0以后，Spring AOP引入了对AspectJ的支持，并允许直接使用AspectJ进行编程，而Spring自身的AOP API也尽量与AspectJ保持一致。所以新版本的Spring框架，建议使用Aspec...
Spring用AspectJ开发AOP(基于Annotation)
08-25
Spring用AspectJ开发AOP(基于Annotation) 作为一名IT行业大师，我将详细介绍Spring用AspectJ开发AOP(基于Annotation)，并对标题、描述、标签和部分内容进行详细解释。 标题: Spring用AspectJ开发AOP(基于...
Spring AOP AspectJ使用及配置过程解析
08-25
AspectJ 1.5 中新增了对注解的支持，允许直接在 Bean 类中定义切面。 Spring AOP AspectJ 配置 新版本的 Spring 框架建议我们都使用 AspectJ 方式来开发 AOP，并提供了非常灵活且强大的切点表达式。当然，无论...
Spring 整合 AspectJ AOP 的使用
最新发布
2301_76607156的博客
03-20 240
Aspect@ComponentSystem.out.println("方法执行开始时间：" + timeStr);System.out.println("方法执行完成时间：" + timeStr);复制代码TimeAspect类上， 使用@Component注解表示它将作为一个 Spring Bean 被容器管理，使用注解@Aspect表示它是一个切面。类中有两个方法beforeafter，分别使用@Before@After注解进行标注。
Spring使用AspectJ注解和XML配置实现AOP
09-01
本主题将深入探讨如何使用AspectJ注解和XML配置在Spring中实现AOP。 首先，我们要了解AOP的基本概念。AOP的核心是切面（Aspect），它将分散在多个对象中的横切关注点（如日志、性能监控）提取出来，形成独立的模块...
【Spring入门】17.Spring使用AspectJ进行AOP开发(基于注解)
CoderX(远离Bug)的博客
04-09 1897
Spring使用AspectJ进行AOP开发（基于注解）
spring 中使用 aspectj
weixin_34019144的博客
11-28 104
为什么80%的码农都做不了架构师？>>> ...
Spring-------AspectJ
qq_32659773的博客
04-22 191
AspectJ简介 AspectJ是一个基于Java语言的AOP框架 Spring2.0以后新增了对AspectJ切点表达式支持 @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面 新版本Spring框架，建议使用AspectJ方式来开发AOP 主要用途：自定义开发 2.2 切入点表达式【掌握】 execution() 用...
spring项目中使用Aspectj
weixin_30411239的博客
05-15 180
1. 到http://www.eclipse.org/aspectj/downloads.php下载一个aspectj的安装jar包（选择一个最新的稳定发布版）。 2. 本地cmd窗口用java -jar命令编译aspectjt-<version>.jar包，出现一个swing程序，按照GUI提示完成Aspectj的安装。 3. 使用时，在项目引入<aspec...
AspectJ 在 Spring 中的使用
weixin_34354173的博客
05-31 155
这是一篇纯实例的博客，网络上关于AspectJ的实例博客非常少，很多的博客都是在讲解AOP思想的一些概念以及从AspectJ语言本身出发去讲解AspectJ，但小编觉得作为急需在项目中使用，换句话说对于初学者来说，没有必要从AspectJ语言本身去深入了解它，如果对AOP思想不明白的，请参考我的博客一起来谈谈 Spring AOP！ 本文将从AspectJ在Spring中的应用入手讲解。 首先明白...
在Spring中使用AspectJ实现AOP
chenhongyong
07-07 131
在spring中使用aspectj有2种方式： xml配置 注解配置（推荐） 这2种方式需要添加的jar包都一样（待修改）： spring-aop.RELEASE.jar aspectjweaver.jar 在spring中使用aspectj，不需要添加aspectjrt.jar，也不需要专门的ajc编译器，使用javac编译即可。 xml配置方式...
Spring 使用AspectJ的三种方式
weixin_30634661的博客
09-22 484
Spring 使用AspectJ 的三种方式 一，使用JavaConfig 二，使用注解隐式配置 三，使用XML 配置 背景知识： 注意 使用AspectJ 的 时候 要导入相应的Jar 包 嗯 昨天还碰到了这样的问题： Caused by: java.lang.IllegalArgumentException: error at ::0 can't find refer...
spring的aspectj简介
wwzuizz的博客
01-08 237
准备工作  导入对应的包 book是被增强，mybook是增强
Spring AOP AspectJ配置与使用详解
AspectJ 1.5引入了注解支持，使得在Spring中使用AOP更加便捷。 在Spring中采用AspectJ进行AOP开发，我们需要首先引入相应的依赖。以下是一个Maven的依赖配置示例： ```xml <groupId>org.springframework ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值