标题:Spring学习—Aop
学习内容:
1、Aop基本概念
2、Aop底层原理
3、Aop操作术语
4、切入点表达式
5、基于AspectJ注解进行Aop操作
6、基于AspectJ配置文件进行Aop操作
内容详情:
1、Aop基本概念
什么是AOP·
(1)面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
(2)通俗描述:不通过修改源代码方式,在主千功能里面添加新功能,
2、Aop底层原理
AOP底层使用动态代理
有两种情况动态代理
有接口情况,使用JDK动态代理
没有接口情况,使用CGLIB动态代理
JDK动态代理代码
相关内容
使用Proxy类里面的newProxyInstance方法创建代理对象。
newProxyInstance的三个参数
第一参数,类加载器
第二参数,增强方法所在的类,这个类实现的接口,支持多个接口·
第三参数,实现这个接口InvocationHandler,创建代理对象,写增强的部分·
创建User接口,Userlmpl类实现User接口,创建一个JDKProxy类,里面写一个主方法,主方法里面使用proxy类
1.创建User接口,Userlmpl类实现User接口
//User接口
package jr.xiaobai;
public interface User {
public int add(int a,int b);
public String update(String id);
}
//Userlmpl类
package jr.xiaobai;
public class Userlmpl implements User {
@Override
public int add(int a, int b) {
System.out.println("方法执行了");
return a+b;
}
@Override
public String update(String id) {
return id;
}
}
2.创建一个JDKProxy类,使用 Proxy.newProxyInstance来创建代理对象,该方法的第三个参数,另外用一个UserlmplProxy类去实现这个接口,里面的 invoke方法就是写的增强的那部分。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JDkProxy {
public static void main(String[] args) {
Class[] interfaces={User.class};
Userlmpl userlmpl = new Userlmpl();
//使用 Proxy.newProxyInstance来创建代理对象
User user = (User) Proxy.newProxyInstance(JDkProxy.class.getClassLoader(), interfaces, new UserlmplProxy(userlmpl));
System.out.println(user.add(2,3));
}
}
//创建代理对象
class UserlmplProxy implements InvocationHandler{
// 创建谁的代理对象,就传进来谁
private Object object;
public UserlmplProxy(Object object){
this.object=object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法执行之前
System.out.println("方法执行之前");
//方法执行
Object invoke = method.invoke(object, args);
//方法执行之后
System.out.println("方法执行之后");
return invoke;
}
}
3、 Aop操作术语
1、连接点
类里面哪些方法可以被增强,这些方法称为连接点
2、切入点
实际被真正增强的方法,称为切入点
3、通知(增强)
(1)实际增强的逻辑部分称为通知〔增强)
(2)通知有多钟类型
前置通知
后置通知
环绕通知
异常通知
最终通知finally
4、切面是动作
把通知应用到切入点过程
4、 切入点表达式
切入点表达式作用
知道对哪个类里面的哪个方法进行增强
语法结构:
execution([权限修饰符][返回类型][类全路径][方法名称] ([参数列表]))
举例:对 jr.xiaobai.dao.BookDao类里面的add进行增强
execution(* jr.xiaobai.dao.BookDao.add(…))
注意:*后面有空格,方法里面的…表示参数列表
5、基于AspectJ注解进行Aop操作
相关内容
1.创建三个类
User被增强类,UserProxy增强类,AopTest测试类
2.一个配置文件bean1.xml
User类
package jr.xiaobai.zhujie;
import org.springframework.stereotype.Component;
@Component
public class User {
public void add(){
System.out.println("add......");
}
}
UserProxy类
package jr.xiaobai.zhujie;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.junit.jupiter.api.Order;
import org.springframework.stereotype.Component;
//增强类
@Component
@Aspect
@Order(1)//增加优先级,数值越小越先执行
public class UserProxy {
@Pointcut(value = "execution(* jr.xiaobai.zhujie.User.add(..))")
public void pointDemo(){
}
@Before(value ="pointDemo()")
// @Before(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法前面执行
@After(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法后面执行
@AfterReturning(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//返回值之后执行
@AfterThrowing(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法异常执行
public void add(){
System.out.println("增强");
}
@Around(value = "execution(* jr.xiaobai.zhujie.User.add(..))")//方法前后都执行
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
//被争强的方法执行
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
}
AopTest类
package jr.xiaobai.zhujie;
import javafx.application.Application;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class AopTest {
@Test
public void test1(){
ApplicationContext Context = new FileSystemXmlApplicationContext("C:\\ideacode\\Aop\\src\\main\\java\\bean1.xml");
User user = Context.getBean("user", User.class);
user.add();
}
@Test
public void test2(){
ApplicationContext Context = new FileSystemXmlApplicationContext("C:\\ideacode\\Aop\\src\\main\\java\\bean2.xml");
User user = Context.getBean("user", User.class);
user.add();
}
}
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: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="jr.xiaobai"></context:component-scan>
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
用法很简单,就是在类上面加一个注解,然后切入表达式
可以用order增加优先级
还有下面这段代码提取出切入表达式
@Pointcut(value = "execution(* jr.xiaobai.zhujie.User.add(..))")
public void pointDemo(){
}
6、基于AspectJ配置文件进行Aop操作
这个跟IOC差不多,一般用注解,代码简要看一下怎么配置的
<?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 class="jr.xiaobai.zhujie.User" id="user"></bean>
<bean class="jr.xiaobai.zhujie.UserProxy" id="userProxy"></bean>
<!-- 配置增强aop-->
<aop:config>
<!--切入点-->
<aop:pointcut id="p" expression="execution(* jr.xiaobai.zhujie.User.add(..))"/>
<!--配置切面-->
<aop:aspect ref="userProxy">
<!-- 增强作用在具体的方法上-->
<aop:before method="add" pointcut-ref="p"></aop:before>
</aop:aspect>
</aop:config>
</beans>