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

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

2022-12-01 82
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 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日志并进行多维度分析。
小许同学
目录
相关文章
jjczqyjxgdegi
|
1天前
|
NoSQL 前端开发 Java
技术笔记：springboot分布式锁组件spring
技术笔记：springboot分布式锁组件spring
jjczqyjxgdegi
6 1
weixin_836869520
|
1天前
|
前端开发 Java 数据库
浅谈Spring AOP 面向切面编程 最通俗易懂的画图理解AOP、AOP通知执行顺序~
浅谈Spring AOP 面向切面编程 最通俗易懂的画图理解AOP、AOP通知执行顺序~
weixin_836869520
10 0
游客zn7mvnkypuy76
|
1天前
|
Java Linux 程序员
技术笔记：Spring生态研习【五】：Springboot中bean的条件注入
技术笔记：Spring生态研习【五】：Springboot中bean的条件注入
游客zn7mvnkypuy76
6 0
67vpym2vvkfhs
|
1天前
|
XML Java API
经验大分享：Spring实现AOP的三种方式
经验大分享：Spring实现AOP的三种方式
67vpym2vvkfhs
5 0
游客zn7mvnkypuy76
|
1天前
|
XML Java 数据格式
技术好文：Spring基础篇——AOP切面编程
技术好文：Spring基础篇——AOP切面编程
游客zn7mvnkypuy76
5 0
67vpym2vvkfhs
|
1天前
|
XML Java API
经验大分享：Spring实现AOP的三种方式
经验大分享：Spring实现AOP的三种方式
67vpym2vvkfhs
8 0
游客i66wb7w7cg4tk
|
1月前
|
安全 Java Spring
Spring之Aop的底层原理
Spring之Aop的底层原理
游客i66wb7w7cg4tk
30 3
风水道人
|
1月前
|
设计模式 Java uml
Spring AOP 原理
Spring AOP 原理
风水道人
18 0
VincentHu
|
1月前
|
监控 Java Spring
Spring AOP的作用和底层原理、AOP相关术语
Spring AOP的作用和底层原理、AOP相关术语
VincentHu
48 0
我是廖志伟
|
8月前
|
Java Spring 容器
【Spring AOP底层实现原理】
【Spring AOP底层实现原理】
我是廖志伟
94 0

热门文章

最新文章

  • 1
    【Spring系列笔记】AOP
  • 2
    Spring AOP的切点是通过使用AspectJ的切点表达式语言来定义的。
  • 3
    在Spring框架中，IoC和AOP是如何实现的？
  • 4
    如何在Spring AOP中定义和应用通知？
  • 5
    自定义注解,aop实现注解锁
  • 6
    SpringCloud Alibaba
  • 7
    Spring Boot 集成 MyBatis和 SQL Server实践
  • 8
    通过JMX监控Spring Boot应用
  • 9
    Spring Boot文档阅读
  • 10
    Spring Web MVC框架（十二） 使用Thymeleaf
  • 1
    自定义注解实现aop切面
    33
  • 2
    使用AOP+反射实现Excel数据的读取
    59
  • 3
    Spring AOP动态代理
    59
  • 4
    【七】springboot整合AOP实现日志操作
    64
  • 5
    AOP：让你的代码像超级英雄一样飞翔
    45
  • 6
    浅谈基于动态代理的Spring AOP原理
    32
  • 7
    探究 Spring Boot 的核心：IOC 和 AOP
    110
  • 8
    Spring AOP -- 面相切面编程
    96
  • 9
    [Spring]aop的配置与使用
    48
  • 10
    【Spring】AOP实现公共字段填充
    63

    • 相关课程

    更多
  • 全面讲解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
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）