首页 > 其他分享> 文章详细

Spring AOP知识点复习

2021-04-22 17:32:30 阅读：142 来源： 互联网

标签：知识点 Spring add AOP println execution com public out

AOP概念

面向切面编程。利用AOP可以对业务逻辑重要部分进行隔离，降低各部分逻辑之间的耦合度。

AOP底层原理

底层使用动态代理

有接口情况：
使用JDK动态代理创建接口代理对象

没有接口情况：
使用CGLIB动态代理创建当前类子类代理对象

jdk动态代理实现

（1）调用 newProxyInstance 方法
方法有三个参数：

第一参数，类加载器
第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

//（1）创建接口，定义方法
public interface UserDao {
 public int add(int a,int b);
 public String update(String id);
}

//（2）创建接口实现类，实现方法
public class UserDaoImpl implements UserDao {
 @Override
 public int add(int a, int b) {
 return a+b;
 }
 @Override
 public String update(String id) {
 return id;
 } }
 
 
//（3）使用 Proxy 类创建接口代理对象
public class JDKProxy {
 public static void main(String[] args) {
 //创建接口实现类代理对象
 Class[] interfaces = {UserDao.class};
 UserDaoImpl userDao = new UserDaoImpl();
 UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
 int result = dao.add(1, 2);
 System.out.println("result:"+result);
 } }
 
 
//创建代理对象代码
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部分术语

连接点

类中可以被增强的方法，称为连接点

切入点

真正被增加的方法，称为切入点

通知（增强）

实际增加的部分被称为通知（增强）
有多种类型

前置通知：前
后置通知：后
环绕通知：前后
异常通知：异常时
最终通知：类似finally

切面

把通知应用到切入点过程叫切面

操作

spring中基于AspectJ实现AOP操作

AspectJ不是Spring的组成部分，是独立的AOP框架，一般把AspecJ和Spreing框架一起使用，进行AOP操作。

基于xml配置
基于注解（一般使用这个）

切入点表达式

语法结构： execution([权限修饰符] [返回类型] [类全路径] 方法名称 )

举例 1：对 com.test.dao.BookDao 类里面的 add 进行增强

execution(* com.test.dao.BookDao.add(..))

举例 2：对 com.test.dao.BookDao 类里面的所有的方法进行增强

execution(* com.test.dao.BookDao.* (..))

举例 3：对 com.test.dao 包里面所有类，类里面所有方法进行增强

execution(* com.test.dao.. (..))

基于注解实现

//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
 //前置通知
 //@Before 注解表示作为前置通知
 @Before(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void before() {
 System.out.println("before.........");
 }
 //后置通知（返回通知）
 @AfterReturning(value = "execution(* 
com.atguigu.spring5.aopanno.User.add(..))")
 public void afterReturning() {
 System.out.println("afterReturning.........");
 }
 //最终通知
 @After(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void after() {
 System.out.println("after.........");
 }
 //异常通知
 @AfterThrowing(value = "execution(* 
com.atguigu.spring5.aopanno.User.add(..))")
 public void afterThrowing() {
 System.out.println("afterThrowing.........");
 }
 //环绕通知
 @Around(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
 public void around(ProceedingJoinPoint proceedingJoinPoint) throws 
Throwable {
 System.out.println("环绕之前.........");
 //被增强的方法执行
 proceedingJoinPoint.proceed();
 System.out.println("环绕之后.........");
 } }

相同切入点抽取出来

//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
 System.out.println("before.........");
}

在增强类上面添加注解 @Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(1)
public class PersonProxy

标签：知识点,Spring,add,AOP,println,execution,com,public,out
来源： https://www.cnblogs.com/dylijq/p/14690561.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9