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

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

2022-12-01 93
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 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编程
Spring编程
aop面向切面
Spring aop编程
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
小许同学
目录
相关文章
土木林森
|
20天前
Micronaut AOP与代理机制：实现应用功能增强，无需侵入式编程的秘诀
AOP（面向切面编程）能够帮助我们在不修改现有代码的前提下，为应用程序添加新的功能或行为。Micronaut框架中的AOP模块通过动态代理机制实现了这一目标。AOP将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，提高模块化程度。在Micronaut中，带有特定注解的类会在启动时生成代理对象，在运行时拦截方法调用并执行额外逻辑。例如，可以通过创建切面类并在目标类上添加注解来记录方法调用信息，从而在不侵入原有代码的情况下增强应用功能，提高代码的可维护性和可扩展性。
土木林森
43 1
杀死一只知更鸟debug
|
12天前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识，包括静态代理和动态代理（JDK动态代理和CGLIB），以及AOP（面向切面编程）的概念和在Spring框架中的应用。文章还提供了详细的示例代码，演示了如何使用Spring AOP进行方法增强和代理对象的创建。
杀死一只知更鸟debug
20 1
spring复习04,静态代理动态代理,AOP
喜欢猪猪
|
2天前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
Spring框架以其强大的控制反转（IOC）和面向切面编程（AOP）功能，成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理，并通过源码解析来揭示其实现机制。同时，我们还将探讨Spring事务管理的核心原理，并给出相应的源码示例。
喜欢猪猪
26 9
土木林森
|
1月前
Micronaut AOP与代理机制：实现应用功能增强，无需侵入式编程的秘诀
【9月更文挑战第9天】AOP（面向切面编程）通过分离横切关注点提高模块化程度，如日志记录、事务管理等。Micronaut AOP基于动态代理机制，在应用启动时为带有特定注解的类生成代理对象，实现在运行时拦截方法调用并执行额外逻辑。通过简单示例展示了如何在不修改 `CalculatorService` 类的情况下记录 `add` 方法的参数和结果，仅需添加 `@Loggable` 注解即可。这不仅提高了代码的可维护性和可扩展性，还降低了引入新错误的风险。
土木林森
38 13
程序员小海绵
|
25天前
|
Java 数据库连接 API
【Java笔记+踩坑】Spring Data JPA
从常用注解、实体类和各层编写方法入手，详细介绍JPA框架在增删改查等方面的基本用法，以及填充用户名日期、分页查询等高级用法。
程序员小海绵
91 0
【Java笔记+踩坑】Spring Data JPA
程序员小海绵
|
25天前
|
Java 数据库连接 数据库
Spring基础3——AOP，事务管理
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
程序员小海绵
46 0
Spring基础3——AOP，事务管理
程序员小海绵
|
25天前
|
Java 数据库连接 数据格式
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
IOC/DI配置管理DruidDataSource和properties、核心容器的创建、获取bean的方式、spring注解开发、注解开发管理第三方bean、Spring整合Mybatis和Junit
程序员小海绵
30 0
【Java笔记+踩坑】Spring基础2——IOC,DI注解开发、整合Mybatis,Junit
砖业洋__
|
2月前
|
缓存 Java 开发者
Spring高手之路22——AOP切面类的封装与解析
本篇文章深入解析了Spring AOP的工作机制，包括Advisor和TargetSource的构建与作用。通过详尽的源码分析和实际案例，帮助开发者全面理解AOP的核心技术，提升在实际项目中的应用能力。
砖业洋__
25 0
Spring高手之路22——AOP切面类的封装与解析
土木林森
|
2月前
|
Java Spring XML
掌握面向切面编程的秘密武器：Spring AOP 让你的代码优雅转身，横切关注点再也不是难题！
【8月更文挑战第31天】面向切面编程（AOP）通过切面封装横切关注点，如日志记录、事务管理等，使业务逻辑更清晰。Spring AOP提供强大工具，无需在业务代码中硬编码这些功能。本文将深入探讨Spring AOP的概念、工作原理及实际应用，展示如何通过基于注解的配置创建切面，优化代码结构并提高可维护性。通过示例说明如何定义切面类、通知方法及其应用时机，实现方法调用前后的日志记录，展示AOP在分离关注点和添加新功能方面的优势。
土木林森
40 0
土木林森
|
2月前
|
Java Spring 容器
彻底改变你的编程人生！揭秘 Spring 框架依赖注入的神奇魔力，让你的代码瞬间焕然一新！
【8月更文挑战第31天】本文介绍 Spring 框架中的依赖注入（DI），一种降低代码耦合度的设计模式。通过 Spring 的 DI 容器，开发者可专注业务逻辑而非依赖管理。文中详细解释了 DI 的基本概念及其实现方式，如构造器注入、字段注入与 setter 方法注入，并提供示例说明如何在实际项目中应用这些技术。通过 Spring 的 @Configuration 和 @Bean 注解，可轻松定义与管理应用中的组件及其依赖关系，实现更简洁、易维护的代码结构。
土木林森
37 0

热门文章

最新文章

  • 1
    Spring-boot+Dubbo应用启停源码分析
  • 2
    Spring Boot 中文乱码问题解决方案汇总
  • 3
    spring cloud放弃系列之--5-jwt
  • 4
    Spring+SpringMVC +MyBatis整合配置文件案例
  • 5
    Spring+SpringMVC+Hibernate简单整合（转）
  • 6
    SpringCloud微服务实战——搭建企业级开发框架（四十）：使用Spring Security OAuth2实现单点登录(SSO)系统
  • 7
    开发者学堂课程干货总结——Spring Cloud微服务架构设计与开发实战（一）
  • 8
    Spring MVC配置太多？试试Spring Boot
  • 9
    Spring.Net+NHibenate+Asp.Net mvc +ExtJs 系列 3 ----数据访问层
  • 10
    基于Spring3 MVC实现基于HTML form表单文件上传
  • 1
    Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
    57
  • 2
    自定义注解,aop实现注解锁
    32
  • 3
    如何在Spring AOP中定义和应用通知？
    41
  • 4
    在Spring框架中，IoC和AOP是如何实现的？
    62
  • 5
    【Spring系列笔记】AOP
    75
  • 6
    Java多线程实战-异步操作日志记录解决方案(AOP+注解+多线程)
    452
  • 7
    Springboot 中使用 Redisson+AOP+自定义注解 实现访问限流与黑名单拦截
    322
  • 8
    Spring5深入浅出篇:AOP底层实现原理
    62
  • 9
    通过AOP记录操作日志：提升应用可追踪性与安全性的利器
    158
  • 10
    Javaweb之SpringBootWeb案例之AOP案例的详细解析
    41

    • 相关课程

    更多
  • 全面讲解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
    • 下一篇
    阿里云对象存储OSS怎么收费？包年包月和按量付费价格表