AOP概念
1.什么是AOP
1.1 面向切面编程,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的 耦合度降低 ,提高程序的可重用性,同时提高了开发的效率。
1.2 通俗地讲:不通过修改源代码方式,在主干功能中添加新功能。
AOP底层原理
1.AOP底层使用动态代理
有俩种情况动态代理
第一种,有接口情况,使用JDK动态代理
·创建接口实现类代理对象,增强类的方法
第二种,没有接口情况,使用CGLIB动态代理
·创建当前类子类的代理对象
AOP(JDK动态代理)
1.使用JDK动态代理,使用Proxy类里面的方法创建代理对象
2.调用newProxyInstans方法
方法有三个参数:
1,类加载器
2,增强方法所在的类,这个类实现的接口,支持多个接口
3,实现这个接口 InvocationHandler ,创建代理对象,写增强方法。
3.JDK动态代理代码
3.1 编写接口UserDao
public interface UserDao {
int add(int a,int b);
String update(String id);
}
3.2 实现类UserDaoImpl
public class UserDaoImpl implements UserDao {
@Override
public int add(int a, int b) {
System.out.println("add方法执行了");
return a+b;
}
@Override
public String update(String id) {
return id;
}
}
3.3 使用Proxy类创建接口代理对象
public class JDKProxy {
public static void main(String[] args) {
// 创建接口实现类的代理对象
Class[] interfaces = {UserDao.class};
UserDaoImpl userDao = new UserDaoImpl();
// 使用匿名内部类
UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 方法之前
System.out.println("方法之前执行" + method.getName() + ":传递的参数..." + Arrays.toString(args));
// 被增强的方法
Object res = method.invoke(userDao,args);
// 方法之后
System.out.println("方法之后执行");
return res;
}
});
System.out.println(o.add(2, 1));
// int add = o.add(2, 3);
// System.out.println(add);
// UserDaoImpl userDao = new UserDaoImpl();
// UserDao o = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
// int add = o.add(2, 5);
// System.out.println(add);
}
}
// 创建代理对象代码
class UserDaoProxy implements InvocationHandler {
// 1.把创建的是谁的代理对象,把谁传递过来
// 有参数的构造传递
private Object obj;
public UserDaoProxy(Object obj) {
this.obj = obj;
}
// 增强的逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 方法之前
System.out.println("方法之前执行" + method.getName() + ":传递的参数..." + Arrays.toString(args));
// 被增强的方法
Object res = method.invoke(obj, args);
// 方法之后
System.out.println("方法之后执行" + obj);
return res;
}
}
AOP(术语)
1.连接点
类里面的那些方法可以被增强,这些方法称为连接点
2.切入点
实际被真正增强的方法,称为切入点
3.通知(增强)
3.1 实际增强的逻辑部分称为通知(增强)
3.2 通知有多种类型
·前置通知:之前
·后置通知:之后
·环绕通知:之前之后
·异常通知:出现了异常
·最终通知:相当于finally
4.切面
是动作,把切面应用到切入点过程,例(登录工程中加入了权限管理操作)
AOP操作(准备)
1.Spring框架一般基于AspectJ实现AOP操作
1.1 什么是 AspectJ
·AspectJ 不是Spring组成部分,独立于AOP框架,一般把AspectJ和Spring一起使用,进行AOP操作
2.基于AspectJ实现AOP操作
2.1 基于 xml 配置文件
2.2 基于注解方式实现(开发常用)
3.在项目工程引入AOP相关依赖
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjtools</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.0</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
4.切入点表达式
4.1 切入点表达式作用:知道对那个类里面哪个方法进行增强
4.2 语法结构: Execution([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))
举例1:对com.example.dao.BookDao 类里面的add方法增强
execution(* com.example.dao.BookDao.add(..))
举例2:对com.example.dao.BookDao 类里面的所有方法进行增强
execution(* com.example.dao.BookDao.*(...))
举例3:对com.example.dao 包里面的所有类,类里面的所有方法进行增强
execution(* com.example.dao.*.*(....))
AOP操作-AspectJ基于注解
1.创建类,在类里面定义方法
package com.example.aopanno;
/**
* @author Mr.Zhou
* @version ...
* @ClassName User.java
* @Description TODO
* @createTime 2022年04月09日 18:09:00
*/
public class User {
public void add(){
System.out.println("add...");
}
}
2.创建增强类(编写增强逻辑)
2.1 在增强类里面,创建方法,让不同方法代表不同的通知类型
package com.example.aopanno;
/**
* @author Mr.Zhou
* @version ...
* @ClassName UserProxy.java
* @Description TODO
* @createTime 2022年04月09日 18:10:00
*/
// 增强的类
public class UserProxy {
// 前置通知
public void before(){
System.out.println("before...");
}
}
3.进行通知的配置
3.1 在Spring配置文件,开启注解扫描
<!-- 开启注解扫描-->
<context:component-scan base-package="com.example.aopanno"></context:component-scan>
3.2 使用注解创建 User 和 UserProxy对象
在User和UserProxy类上边添加注解@Component(不设置值,默认为类首字母小写)
3.3 在增强类上边添加注解@Aspect
3.4 在spring配置文件中开启生成代理对象
<!-- 开启AspectJ生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4. 配置不同类型的通知
package com.example.aopanno;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
* @author Mr.Zhou
* @version ...
* @ClassName UserProxy.java
* @Description TODO
* @createTime 2022年04月09日 18:10:00
*/
// 增强的类
@Component
@Aspect // 生成代理对象
@Order(3) // 增强类优先级,值越小等级越高
public class UserProxy {
// 相同切入点抽取--下边有讲
@Pointcut("execution(* com.example.aopanno.User.add(..))")
public void pointdemo() {
}
// 前置通知
// @Before 表示前置通知
@Before("pointdemo()")
public void before() {
System.out.println("before...");
}
// 环绕通知
@Around("pointdemo()")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
proceedingJoinPoint.proceed();
System.out.println("环绕之后");
}
// 后置通知
@AfterReturning("pointdemo()")
public void afterReturning() {
System.out.println("afterReturning...");
}
// 异常通知
@AfterThrowing("pointdemo()")
public void afterThrowing() {
System.out.println("afterThrowing...");
}
// 最终通知
@After("pointdemo()")
public void after() {
System.out.println("after...");
}
}
4.1 在增强类里边,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
// 增强的类
@Component
@Aspect // 生成代理对象
public class UserProxy {
// 前置通知
// @Before 表示前置通知
@Before("execution(* com.example.aopanno.User.add(..))")
public void before() {
System.out.println("before...");
}
5.相同的切入点抽取
在方法上添加注解@Pointcut("execution(* com.example.aopanno.User.add(..))")
// 相同切入点抽取
@Pointcut("execution(* com.example.aopanno.User.add(..))")
public void pointdemo() {
}
// 前置通知
// @Before 表示前置通知
@Before("pointdemo()")
public void before() {
System.out.println("before...");
}
6.有多个增强类对同一个方法进行增强,设置增强类优先级
6.1 在增强类上边添加注解@Order(数字类型值),数字越小,等级越高
@Component
@Aspect
@Order(0)
public class PersonProxy {
@Before("UserProxy.pointdemo()")
public void before() {
System.out.println("Person Before...");
}
}
7.完全使用注解开发
7.1 创建配置类,不需要创建配置类
@Configuration // 声明为配置类
@ComponentScan(basePackages = {"com.example"}) // 组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) //开启AspectJ生成代理对象
public class Config {
}
AOP操作-AspectJ基于XML配置文件
1.创建俩个类,增强类和被增强类,创建方法
public class Book {
public void add(){
System.out.println("add..");
}
}
public class BookProxy {
public void before(){
System.out.println("buy....");
}
}
2.在spring中配置文件中创建的俩个对象
<!-- 创建俩个对象-->
<bean id="book" class="com.example.aopxml.Book"></bean>
<bean id="bookproxy" class="com.example.aopxml.BookProxy"></bean>
3.在spring配置文件中配置切入
<!-- 配置aop增强-->
<aop:config>
<!-- 切入点-->
<aop:pointcut id="p" expression="execution(* com.example.aopxml.Book.add(..))"/>
<!-- 配置切面-->
<aop:aspect ref="bookproxy">
<!-- 配置作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"></aop:before>
</aop:aspect>
</aop:config>
- Time: 2022/4/10 17:42