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

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

2022-12-01 101
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 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编程
Spring AOP
aop编程
aop面向切面
Spring笔记
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
小许同学
目录
相关文章
运营研究坊
|
17天前
|
Java Spring
一键注入 Spring 成员变量，顺序编程
介绍了一款针对Spring框架开发的插件，旨在解决开发中频繁滚动查找成员变量注入位置的问题。通过一键操作（如Ctrl+1），该插件可自动在类顶部添加`@Autowired`注解及其成员变量声明，同时保持光标位置不变，有效提升开发效率和代码编写流畅度。适用于IntelliJ IDEA 2023及以上版本。
运营研究坊
42 2
一键注入 Spring 成员变量，顺序编程
互联网课堂
|
1月前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
54 2
Spring Aop该如何使用
一位隐者
|
27天前
|
监控 安全 Java
什么是AOP？如何与Spring Boot一起使用？
什么是AOP？如何与Spring Boot一起使用？
一位隐者
53 5
潇洒洒
|
1月前
|
Java 开发者 Spring
深入解析：Spring AOP的底层实现机制
在现代软件开发中，Spring框架的AOP（面向切面编程）功能因其能够有效分离横切关注点（如日志记录、事务管理等）而备受青睐。本文将深入探讨Spring AOP的底层原理，揭示其如何通过动态代理技术实现方法的增强。
潇洒洒
63 8
游客fmoyiwnvddywe
|
1月前
|
Java 开发者 Spring
Spring AOP 底层原理技术分享
Spring AOP（面向切面编程）是Spring框架中一个强大的功能，它允许开发者在不修改业务逻辑代码的情况下，增加额外的功能，如日志记录、事务管理等。本文将深入探讨Spring AOP的底层原理，包括其核心概念、实现方式以及如何与Spring框架协同工作。
游客fmoyiwnvddywe
64 6
张志凌
|
1月前
|
XML 监控 安全
深入调查研究Spring AOP
【11月更文挑战第15天】
张志凌
44 5
最好zzz
|
1月前
|
Java 开发者 Spring
Spring AOP深度解析：探秘动态代理与增强逻辑
Spring框架中的AOP（Aspect-Oriented Programming，面向切面编程）功能为开发者提供了一种强大的工具，用以将横切关注点（如日志、事务管理等）与业务逻辑分离。本文将深入探讨Spring AOP的底层原理，包括动态代理机制和增强逻辑的实现。
最好zzz
45 4
张飞的猪
|
1月前
|
安全 Java 编译器
什么是AOP面向切面编程？怎么简单理解？
本文介绍了面向切面编程（AOP）的基本概念和原理，解释了如何通过分离横切关注点（如日志、事务管理等）来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例，展示了如何定义和应用切面。
张飞的猪
150 1
什么是AOP面向切面编程？怎么简单理解？
进步`于辰
|
1月前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP（面向切面编程）的基本概念和核心思想。AOP是Spring框架的核心功能之一，通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念，并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
进步`于辰
40 1
喜欢猪猪
|
1月前
|
XML Java 开发者
论面向方面的编程技术及其应用（AOP）
【11月更文挑战第2天】随着软件系统的规模和复杂度不断增加，传统的面向过程编程和面向对象编程（OOP）在应对横切关注点（如日志记录、事务管理、安全性检查等）时显得力不从心。面向方面的编程（Aspect-Oriented Programming，简称AOP）作为一种新的编程范式，通过将横切关注点与业务逻辑分离，提高了代码的可维护性、可重用性和可读性。本文首先概述了AOP的基本概念和技术原理，然后结合一个实际项目，详细阐述了在项目实践中使用AOP技术开发的具体步骤，最后分析了使用AOP的原因、开发过程中存在的问题及所使用的技术带来的实际应用效果。
喜欢猪猪
70 5

热门文章

最新文章

  • 1
    Spring Cloud Alibaba：一站式微服务解决方案
  • 2
    详解Spring Batch：在Spring Boot中实现高效批处理
  • 3
    从单体到微服务：如何借助 Spring Cloud 实现架构转型
  • 4
    深入 Spring Cloud Gateway 过滤器
  • 5
    使用 Spring Boot 执行数据库操作：全面指南
  • 6
    什么是JWT？如何使用Spring Boot Security实现它？
  • 7
    Spring MVC中的请求映射：@RequestMapping注解深度解析
  • 8
    【SpringFramework】Spring初体验
  • 9
    利用Spring Cloud Gateway Predicate优化微服务路由策略
  • 10
    京东面试：聊聊Spring事务？Spring事务的10种失效场景？加入型传播和嵌套型传播有什么区别？
  • 1
    什么是AOP？如何与Spring Boot一起使用？
    53
  • 2
    深入调查研究Spring AOP
    44
  • 3
    Spring AOP 底层原理技术分享
    64
  • 4
    Spring AOP深度解析：探秘动态代理与增强逻辑
    45
  • 5
    深入解析：Spring AOP的底层实现机制
    63
  • 6
    深入调查研究AOP（Aspect Oriented Programming）
    34
  • 7
    AOP中的JDK动态代理与CGLIB动态代理：深度解析与实战模拟
    71
  • 8
    Java开发必读，谈谈对Spring IOC与AOP的理解
    44
  • 9
    [Spring]aop的配置与使用
    40
  • 10
    什么是AOP面向切面编程？怎么简单理解？
    150

    • 相关课程

    更多
  • 全面讲解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
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)