AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

《spring上课笔记》---class3---AOP（面向切面编程）

2022-12-01 95
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 《spring上课笔记》---class3---AOP（面向切面编程）

一：代理模式


代理模式简介：


代理模式是GoF23种常用设计模式之一，可以使用代理模式创建代理对象，让代理对象控制目标对象的访问，并且可以在不改变目标对象原有的逻辑功能之下添加一些额外的功能。


案例分析：


实现一个用户注册功能，现在要在原有注册功能之上添加一个打印日志的功能。为了不破坏原有的业务逻辑，我们可以使用代理模式。


20210317133544727.png

1.静态代理实现：


代理对象与被代理对象必须实现同一接口，在代理对象中实现日志打印服务。

  • UserSevice接口
public interface UserService {
  public boolean login(String userName,String password);
}


  • UserService实现类：
public class UserServiceImpl implements UserService{
  @Override
  public boolean login(String userName, String password) {
    // TODO Auto-generated method stub
    boolean result="zs".equals(userName)&&"123".equals(password);
    System.out.println("原有业务执行结果是:"+result);
    return result;
  }
}
  • 打印日志工具类
public class LogUtil {
  public static void log() {
    System.out.println("日志："+new Date().toLocaleString());
  }
}
  • UserService代理类
public class UserProxy implements UserService{
  private UserService userService;
  @Override
  public boolean login(String userName, String password) {
    userService=new UserServiceImpl();
    boolean result=userService.login(userName, password);
    if(result) {
      LogUtil.log();
    }
    return result;
  }
}
  • 测试类
public class Test {
   public static void main(String[] args) {
  UserProxy userProxy=new UserProxy();
  System.out.println(userProxy.login("zs", "123"));
}
}


  • 缺点：代理对象的接口只服务于一种类型的对象，有局限性

2.动态代理实现：

JDK1.3之后加入了实现动态代理的API，代理类实现InvocationHandler的接口就行。

  • 代理类：
public class LoggerHandler implements InvocationHandler{
    private Object delegate;
    public   Object bind(Object delegate) {
      this.delegate=delegate;
      return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
    }
  @Override
  public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {
    System.out.println(arg0.getClass().getName());//代理对象
    System.out.println(arg1.getName());//代理对象的方法
    System.out.println(arg2.toString());//方法中的参数
    Object result=null;
    result=arg1.invoke(delegate, arg2);
    LogUtil.log();
    return result;
  }
}


  • 测试类：
public class Test {
   public static void main(String[] args) {
  UserService us=new UserServiceImpl();
  UserService proxy=(UserService) new LoggerHandler().bind(us);
  proxy.login("zs", "123");
}
}

二：AOP概述


AOP（Aspect Oriented Programming)意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。


1.SpringAPI传统方式实现AOP


切面通过实现一些接口，来达到通知的作用。分为前置通知，后置通知，环绕通知，异常通知，最终通知。


业务类接口：

package com.user.service;
public interface UserService {
  public boolean login(String userName, String pwd);
  public boolean regist(String userName, String pwd);
}

业务实现类：

public class UserServiceImpl implements UserService {
  @Override
  public boolean login(String userName, String pwd) {
    System.out.println("目标对象中，账号密码是：" + userName + ":" + pwd);
    boolean result = "zs".equals(userName) && "202cb962ac59075b964b07152d234b70".equals(pwd);
    System.out.println("用户登录");
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    int n = 10 / 0;
    return result;
  }
  @Override
  public boolean regist(String userName, String pwd) {
    System.out.println("目标对象中，账号密码是：" + userName + ":" + pwd);
    System.out.println("用户注册成功");
    return true;
  }
}

前置通知：

public class Md5Advice implements MethodBeforeAdvice {
  @Override
  public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
    // TODO Auto-generated method stub
    System.out.println(arg0.getName());// 方法名称
    System.out.println(arg1.toString());// 方法参数
    System.out.println(arg2);// 被代理对象
    String newPwd = Md5Encode.getMD5(arg1[1].toString().getBytes());
    arg1[1] = newPwd;
  }
}

后置通知：

public class ScoreAdvice implements AfterReturningAdvice {
  @Override
  public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
    System.out.println(arg0);// 方法返回的结果
    System.out.println(arg1.getName());// 方法名
    System.out.println(arg3);// 被代理对象
    System.out.println("后置通知：用户登录成功，增加10个积分");
  }
}

环绕通知：

public class TimeAdvice implements MethodInterceptor {
  /**
   * 环绕通知
   */
  @Override
  public Object invoke(MethodInvocation arg0) throws Throwable {
    System.out.println("methodbefore:" + new Date().toLocaleString());
    Object result = arg0.proceed();// 目标方法是否执行
    System.out.println("methodafter:" + new Date().toLocaleString());
    return result;
  }
}

异常通知：

public class LoginExceptionAdvice implements ThrowsAdvice {
  public void afterThrowing(Exception e) {
    e.printStackTrace();
    System.out.println("异常通知");
  }
}

配置文件：

<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"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
  <bean id="UserServiceImpl"
    class="com.user.service.UserServiceImpl"></bean>
  <bean id="Md5Advice" class="com.advice.Md5Advice"></bean>
  <bean id="ScoreAdvice" class="com.advice.ScoreAdvice"></bean>
  <bean id="TimeAdvice" class="com.advice.TimeAdvice"></bean>
  <bean id="LoginExceptionAdvice"
    class="com.advice.LoginExceptionAdvice"></bean>
  <bean id="UserServiceProxy"
    class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces"
      value="com.user.service.UserService"></property>
    <property name="target" ref="UserServiceImpl"></property>
    <property name="interceptorNames">
      <list>
        <!-- <value>Md5Advice</value> <value>ScoreAdvice</value> -->
        <value>TimeAdvice</value>
        <value>LoginExceptionAdvice</value>
      </list>
    </property>
  </bean>
</beans>

测试类：

public class Test {
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    UserService us = (UserService) ctx.getBean("UserServiceProxy");
    us.login("zs", "123");
    // us.regist("zs", "123");
  }
}

2.Spring基于xml方式实现AOP

业务类：

public class Test {
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    UserService us = (UserService) ctx.getBean("UserServiceProxy");
    us.login("zs", "123");
    // us.regist("zs", "123");
  }
}

通知类：

public class BeforeAdvice {
  /**
   * 切点 前置通知
   * 
   * @param joinPoint
   */
  public void methodBefore(JoinPoint joinPoint) {
    System.out.println("前置通知");
    System.out.println(joinPoint.getSignature().getName());// 代理方法名
    System.out.println(joinPoint.getArgs());// 参数数组
    System.out.println(joinPoint.getTarget());// 被代理对象
    System.out.println("================");
  }
  /**
   * 后置通知
   * 
   * @param joinPoint
   * @param result
   */
  public void afterReturning(JoinPoint joinPoint, Object result) {
    System.out.println("后置通知");
    System.out.println("================");
  }
  /**
   * 环绕通知
   * 
   * @param joinPoint
   * @return
   */
  public Object aroundMethod(ProceedingJoinPoint joinPoint) {
    System.out.println("环绕通知开始：");
    System.out.println("================");
    Object[] args = joinPoint.getArgs();// 方法参数
    args[0] = args[0] + "456";
    Object result = null;
    try {
      result = joinPoint.proceed(args);// 原方法是否执行
    } catch (Throwable e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("环绕通知结束");
    System.out.println("================");
    return result;
  }
  /**
   * 异常通知
   * 
   * @param e
   */
  public void throwExMethod(Exception e) {
    System.out.println("异常通知开始");
    System.out.println("异常信息：" + e.getMessage());
    System.out.println("================");
  }
  /**
   * 最终通知
   */
  public void afterMethod(JoinPoint jointPoint) {
    System.out.println("最终通知");
    System.out.println("================");
  }
}

配置文件：

<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-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
  <bean id="UserService" class="com.UserService"></bean>
  <bean id="MyAdvice" class="Advice.BeforeAdvice"></bean>
  <aop:config>
    <aop:aspect id="MyAspect" ref="MyAdvice">
      <aop:before method="methodBefore"
        pointcut="execution(* com.*.*(..))" /> <!-- com下的所有类型，所有参数 -->
      <aop:after-returning method="afterReturning"
        pointcut="execution(* com.*.*(..))" returning="result" />
      <aop:around method="aroundMethod"
        pointcut="execution(* com.*.*(..))" />
      <aop:after-throwing method="throwExMethod"
        pointcut="execution(* com.*.*(..))" throwing="e" />
      <aop:after method="afterMethod"
        pointcut="execution(* com.*.*(..))" />
    </aop:aspect>
  </aop:config>
</beans>

测试类：

public class Test {
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    UserService us = (UserService) ctx.getBean("UserService");
    us.login("zs", "123");
  }
}

3.Spring基于注解方式实现AOP

业务类：

@Component("UserService")
public class UserService {
  public boolean login(String userName, String passWord) {
    System.out.println("登录名是:" + userName);
    System.out.println("密码是:" + passWord);
    System.out.println("==============");
    int n = 10 / 0;
    return true;
  }
}

通知类：

@Component
@Aspect
public class BeforeAdvice {
  /**
   * 切点 前置通知
   * 
   * @param joinPoint
   */
  @Before("execution(* com.*.*(..))")
  public void methodBefore(JoinPoint joinPoint) {
    System.out.println("前置通知");
    System.out.println(joinPoint.getSignature().getName());// 代理方法名
    System.out.println(joinPoint.getArgs());// 参数数组
    System.out.println(joinPoint.getTarget());// 被代理对象
    System.out.println("================");
  }
  /**
   * 后置通知
   * 
   * @param joinPoint
   * @param result
   */
  @AfterReturning(pointcut = "execution(* com.*.*(..))", returning = "result")
  public void afterReturning(JoinPoint joinPoint, Object result) {
    System.out.println("后置通知");
    System.out.println("================");
  }
  /**
   * 环绕通知
   * 
   * @param joinPoint
   * @return
   */
  @Around("execution(* com.*.*(..))")
  public Object aroundMethod(ProceedingJoinPoint joinPoint) {
    System.out.println("环绕通知开始：");
    System.out.println("================");
    Object[] args = joinPoint.getArgs();// 方法参数
    args[0] = args[0] + "456";
    Object result = null;
    try {
      result = joinPoint.proceed(args);// 原方法是否执行
    } catch (Throwable e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    System.out.println("环绕通知结束");
    System.out.println("================");
    return result;
  }
  /**
   * 异常通知
   * 
   * @param e
   */
  @AfterThrowing(pointcut = "execution(* com.*.*(..))", throwing = "e")
  public void throwExMethod(Exception e) {
    System.out.println("异常通知开始");
    System.out.println("异常信息：" + e.getMessage());
    System.out.println("================");
  }
  /**
   * 最终通知
   */
  @After("execution(* com.*.*(..))")
  public void afterMethod(JoinPoint jointPoint) {
    System.out.println("最终通知");
    System.out.println("================");
  }
}

配置文件：

<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-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
  <bean id="UserService" class="com.UserService"></bean>
  <bean id="MyAdvice" class="Advice.BeforeAdvice"></bean>
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  <context:component-scan base-package="com"></context:component-scan>
</beans>

测试类：

public class Test {
  public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
    UserService us = (UserService) ctx.getBean("UserService");
    us.login("zs", "123");
  }
}
文章标签：
日志服务
Java
Spring
API
数据格式
XML
设计模式
关键词：
Spring AOP
aop编程
aop面向切面
Spring笔记
Spring编程
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
小许同学
目录
相关文章
土木林森
|
2月前
Micronaut AOP与代理机制：实现应用功能增强，无需侵入式编程的秘诀
AOP（面向切面编程）能够帮助我们在不修改现有代码的前提下，为应用程序添加新的功能或行为。Micronaut框架中的AOP模块通过动态代理机制实现了这一目标。AOP将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，提高模块化程度。在Micronaut中，带有特定注解的类会在启动时生成代理对象，在运行时拦截方法调用并执行额外逻辑。例如，可以通过创建切面类并在目标类上添加注解来记录方法调用信息，从而在不侵入原有代码的情况下增强应用功能，提高代码的可维护性和可扩展性。
土木林森
60 1
张飞的猪
|
4天前
|
安全 Java 编译器
什么是AOP面向切面编程？怎么简单理解？
本文介绍了面向切面编程（AOP）的基本概念和原理，解释了如何通过分离横切关注点（如日志、事务管理等）来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例，展示了如何定义和应用切面。
张飞的猪
30 1
什么是AOP面向切面编程？怎么简单理解？
砖业洋__
|
17天前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程，从源码角度详细讲解了Bean如何被AOP代理，包括代理对象的创建、配置与执行逻辑，帮助读者全面掌握Spring AOP的核心技术。
砖业洋__
27 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
进步`于辰
|
2天前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP（面向切面编程）的基本概念和核心思想。AOP是Spring框架的核心功能之一，通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念，并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
进步`于辰
9 1
喜欢猪猪
|
8天前
|
XML Java 开发者
论面向方面的编程技术及其应用（AOP）
【11月更文挑战第2天】随着软件系统的规模和复杂度不断增加，传统的面向过程编程和面向对象编程（OOP）在应对横切关注点（如日志记录、事务管理、安全性检查等）时显得力不从心。面向方面的编程（Aspect-Oriented Programming，简称AOP）作为一种新的编程范式，通过将横切关注点与业务逻辑分离，提高了代码的可维护性、可重用性和可读性。本文首先概述了AOP的基本概念和技术原理，然后结合一个实际项目，详细阐述了在项目实践中使用AOP技术开发的具体步骤，最后分析了使用AOP的原因、开发过程中存在的问题及所使用的技术带来的实际应用效果。
喜欢猪猪
29 5
杀死一只知更鸟debug
|
2月前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识，包括静态代理和动态代理（JDK动态代理和CGLIB），以及AOP（面向切面编程）的概念和在Spring框架中的应用。文章还提供了详细的示例代码，演示了如何使用Spring AOP进行方法增强和代理对象的创建。
杀死一只知更鸟debug
32 1
spring复习04,静态代理动态代理,AOP
源码星辰
|
27天前
|
Java 编译器 Spring
Spring AOP 和 AspectJ 的区别
Spring AOP和AspectJ AOP都是面向切面编程（AOP）的实现，但它们在实现方式、灵活性、依赖性、性能和使用场景等方面存在显著区别。‌
源码星辰
44 2
喜欢猪猪
|
1月前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
【10月更文挑战第1天】Spring框架以其强大的控制反转（IOC）和面向切面编程（AOP）功能，成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理，并通过源码解析来揭示其实现机制。同时，我们还将探讨Spring事务管理的核心原理，并给出相应的源码示例。
喜欢猪猪
117 9
Codelinghu
|
29天前
|
Java 数据库连接 Spring
【2021Spring编程实战笔记】Spring开发分享~（下）
【2021Spring编程实战笔记】Spring开发分享~（下）
Codelinghu
25 1
Codelinghu
|
26天前
|
Java 容器
AOP面向切面编程
AOP面向切面编程
Codelinghu
38 0

热门文章

最新文章

  • 1
    非侵入式AOP监控之——AspectJ使用
  • 2
    bboss aop 远程服务介绍-远程服务调用实例
  • 3
    AOP动态代理解析4-代理的创建
  • 4
    PostSharp AOP编程：1.基于PostSharp的AOP日志记录和异常捕捉【附带源码】
  • 5
    一起谈.NET技术，IoC+AOP的简单实现
  • 6
    利用Spring的AOP来配置和管理你的二级缓存(EHCache)
  • 7
    AOP动态代理解析4-jdk代理的实现
  • 8
    spring.net aop 讲解
  • 9
    PostSharp AOP编程：3.PostSharp的LocationInterceptionAspect类基本组成
  • 10
    MSBuild + MSILInect实现编译时AOP之预览
  • 1
    Spring之Aop的注解使用
    45
  • 2
    Spring(一)IOC小案例
    41
  • 3
    作为Java程序员还不知道Spring中Bean创建过程和作用？
    44
  • 4
    Spring 框架中 Bean 的生命周期
    70
  • 5
    开发必懂的Spring循环依赖图解 Spring 循环依赖
    59
  • 6
    【深入浅出Spring原理及实战】「EL表达式开发系列」深入解析SpringEL表达式理论详解与实际应用
    463
  • 7
    【深入浅出Spring原理及实战】「缓存Cache开发系列」带你深入分析Spring所提供的缓存Cache功能的开发实战指南（一）
    431
  • 8
    Spring Boot 应用可视化监控
    60
  • 9
    天天用 Spring，bean 实例化原理你懂吗
    46
  • 10
    SpringBoot 项目瘦身指南
    140

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月