本文详细介绍了Spring AOP的运用案例，包括基于注解、XML配置以及Java配置的实现。通过动态代理技术，如JDK和CGLIB，实现方法增强，同时讲解了Spring AOP的核心术语、环境配置和切入点表达式。通过多个案例展示了如何对类的不同功能进行增强，并探讨了异常处理的情况。
1、运用案例
在不改变源代码的情况上，增强权限拦截的方法
2、Aop——面向切面——实现方法
（1）、有接口使用JDK动态代理—动态代理技术
a) 创建实现接口的子类
（2）、没有接口使用cglib实现动态代理
b)创建子类来增强父类
3、Spring中aop的核心术语
4、Spring-aop环境配置
（1）、aspectj和spring联合使用
aspecj不是spring 容器的组成部分，他是独立的aop的框架，一般将这个aop框架技术整合到spring中，与spring一起使用
给没有接口的类，创建一个子类进行指定方法增强
（2）、基于aspectj技术实现spring的aop功能
Xml方式配置
注解的方式配置（推荐）
（3）、引入相关的环境库
（4）、切入点的展现形式
切入点表达式的功能是告诉spring，哪一个代理对象的那个|那些方法需要被增强
–初体验
execution(* com.spring.aop.User.add(…))
对这个包下面的user类的add方法做增强处理
–切入点语法格式
execution([权限修饰符* public等][空格][返回类型-可以不写][类全路径][方法名([参数列表 通常用…表示])])
–具体案例
1，对com.spring.aop.User的add方法进行增强，见上面初体验,
a)execution(* com.spring.aop.User.add(…))
2，对com.spring.aop.User的所有方法进行增强
a)execution(* com.spring.aop.User.(…))
3，对com.spring.aop中所有类的所有方法进行增强
a)execution（ com.spring.aop..(…)）
5、案例类型
（1）、基于注解
A.需在src下配置bean.xml，
名字可以自定义*.xml
Bean1.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/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="com.spring.aop"></context:component-scan>
<!-- 在类上找aop代理类对象的注解，使用aspectj技术生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
B.被增强类
------被spring容器管理—spring==beanFactory.newBean(User.class),bean工厂new出一个bean
package com.spring.aop;
import org.springframework.stereotype.Component;
//被增强的类--被spring容器管理--spring==beanfactory.newBean(User.class)
@Component
public class User {
public void add() {
// int i = 10/0;
System.out.println("add.......");
}
}
C.被增强类的代理
UserProxy.java
package com.spring.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.core.annotation.Order;
import org.springframework.stereotype.Component;
//增强的类
@Component//交给容器管理
@Aspect //生成代理对象
@Order(1)//不同的代理类代理同一个类，定义增强顺序，字母越小的级别越高
public class UserProxy {
/**
不报错
环绕之前.........
before.........
add.......
环绕之后.........
after.........
afterReturning.........
报错
环绕之前.........
before.........
after......... 无论是否报错，都将执行最终通知
afterThrowing.........
*/
//相同切入点抽取
//主要是用来替换切入点中的路径，后续调用的时候少写一点路径代码，减少出错概率
@Pointcut(value = "execution(* com.spring.aop.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before注解表示作为前置通知，表示在user.add方法之前，执行了before（）方法
// @Before(value = "execution(* com.spring.aop.User.add(..))")
// public void before() {
// System.out.println("before.........");
// }
@Before(value="pointdemo()")
public void before() {
System.out.println("before.........");
}
//后置通知（返回通知）
@AfterReturning(value = "pointdemo()")
public void afterReturning() {
System.out.println("afterReturning.........");
}
//最终通知
//无论程序是否出现异常，都将执行最终通知
@After(value = "execution(* com.spring.aop.User.add(..))")
public void after() {
System.out.println("after.........");
}
//异常通知
@AfterThrowing(value = "execution(* com.spring.aop.User.add(..))")
public void afterThrowing() {
System.out.println("afterThrowing.........");
}
//环绕通知
@Around(value = "execution(* com.spring.aop.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前.........");
//被增强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后.........");
}
}
D.测试类
TestAop.java
package com.spring.aop;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAop {
@Test
public void testAop() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
User user = context.getBean("user", User.class);
user.add();
}
}
E.对一个类多个功能增强
@Order()-----括号里的字母数字越小，级别越高
package com.spring.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Aspect
@Order(2)
public class User2Proxy {
@Before("execution(* com.spring.aop.User.add(..))")
public void before() {
System.out.println("before2.........");
}
}
结果：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4qmClk8k-1617600878075)(https://imgblog.csdnimg.cn/20210405133334639.png)]](https://i-blog.csdnimg.cn/blog_migrate/ce1a2aa84bc3ef5d6dc36977d5eadf4d.png)
F.异常:
当报错后，不会将结果返回回去
在被增强类中，加一句一定会报错的
package com.spring.aop;
import org.springframework.stereotype.Component;
//被增强的类--被spring容器管理--spring==beanfactory.newBean(User.class)
@Component
public class User {
public void add() {
int i = 10/0;
System.out.println("add.......");
}
}
结果：
（2）、基于xml
A.Book.java
package com.spring.xmlaop;
public class Book {
public void buy() {
System.out.println("buy.............");
}
}
B.BookProxy.java
package com.spring.xmlaop;
public class BookProxy {
public void before() {
System.out.println("before.........");
}
}
C.在src下配置bean2.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/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">
<!--创建对象-->
<bean id="book" class="com.spring.xmlaop.Book"></bean>
<bean id="bookProxy" class="com.spring.xmlaop.BookProxy"></bean>
<!--配置aop增强-->
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(* com.spring.xmlaop.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"/>
</aop:aspect>
</aop:config>
</beans>
D.测试类
package com.spring.xmlaop;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAop {
@Test
public void testAopXml() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.buy();
}
}
结果：
（3）、基于java配置类
A. @Configuration—替换xml文件
B. @ComponentScan(basePackages = {})—包扫描
C. @EnableAspectJAutoProxy(proxyTargetClass = true)—开启@aspect识别
ConfigAop.java
package com.spring.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan(basePackages = {"com.spring"})//包扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//开启@aspect识别
public class ConfigAop {
}
TestAop.java
package com.spring.aop;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestAop {
@Test
public void testAop() {
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
User user = context.getBean("user", User.class);
user.add();
}
}
扫一扫
6505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
