Spring AOP见解3

最新推荐文章于 2024-11-03 09:30:00 发布
最新推荐文章于 2024-11-03 09:30:00 发布
阅读量948 收藏 20
点赞数 19
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y666__/article/details/135448581
版权

4.Spring AOP

4.1.为什么要学习AOP?

  • 案例：有一个接口Service有一个insert方法，在insert被调用时打印调用前的毫秒数与调用后的毫秒数，其实现为：
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void addUser(){
        System.out.println("方法开始时间："+new Date());
        userDao.addUser();
        System.out.println("方法结束时间："+new Date());
    }
}
  • 问题：输出日志的逻辑还是无法复用

4.2.AOP概述

AOP：全称是Aspect Oriented Programming即：面向切面编程。
在这里插入图片描述
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对程序进行增强：权限校验,日志记录,性能监控,事务控制.

4.3.代理（Proxy）模式

4.3.1.创建工程

在这里插入图片描述

4.3.2.代理（Proxy）模式介绍

  • 作用：通过代理可以控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即： AOP的微观实现！）
    在这里插入图片描述

核心角色

  • 抽象角色(接口)：定义公共对外方法

  • 真实角色（周杰伦）：实现抽象角色，定义真实角色所要实现的业务逻辑，

  • 代理角色（代理人）：实现抽象角色，是真实角色的代理，通过调用真实角色的方法来完成业务逻辑，并可以附加自己的操作。
    在这里插入图片描述

4.3.3.静态代理

4.3.3.1.抽象角色
package com.by.proxy.StaticProxy;

public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}
4.3.3.2.真正角色（周杰伦）
package com.by.proxy.StaticProxy;

public class RealStar implements Star {

	public void bookTicket() {

	}

	public void collectMoney() {

	}

	public void confer() {

	}

	public void signContract() {

	}

	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}
4.3.3.3.代理角色（经纪人）
package com.by.proxy.StaticProxy;

public class ProxyStar implements Star {
	
	private Star star;
	
	public ProxyStar(Star star) {
		super();
		this.star = star;
	}

	public void bookTicket() {
		System.out.println("ProxyStar.bookTicket()");
	}

	public void collectMoney() {
		System.out.println("ProxyStar.collectMoney()");
	}

	public void confer() {
		System.out.println("ProxyStar.confer()");
	}

	public void signContract() {
		System.out.println("ProxyStar.signContract()");
	}

	public void sing() {
		star.sing();
	}
}
4.3.3.4.测试
package com.by.proxy.StaticProxy;

public class Client {
	public static void main(String[] args) {
		Star proxy = new ProxyStar(new RealStar());
		
		proxy.confer();
		proxy.signContract();
		proxy.bookTicket();
		proxy.sing();
		
		proxy.collectMoney();
		
	}
}
4.3.3.5.静态代理的缺点
  1. 代理类和实现类实现了相同的接口，这样就出现了大量的代码重复。
  2. 代理对象只服务于一种类型的对象。如果要服务多类型的对象，例如代码是只为UserService类的访问提供了代理，但是还要为其他类如DeptService类提供代理的话，就需要我们再次添加代理DeptService的代理类。

4.3.4.jdk动态代理

4.3.4.1.抽象角色
public interface Star {
    /**
     * 唱歌
     */
    void sing();
}
4.3.4.2.真正角色（周杰伦）
package com.by.JdkProxy;

//真实角色(周杰伦)
public class RealStar implements Star {
    //优点：此时代码不再重复

    public void sing() {
        System.out.println("周杰伦：快使用双截棍,哼哼哈嘿....");

    }
}
4.3.4.3.代理角色（经纪人）
package com.by.JdkProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//代理类工厂
public class ProxyFactory {

    //优点：此时可以代理任意类型的对象
    //真实角色(周杰伦)
    private Object realObj;

    public ProxyFactory(Object realObj) {
        this.realObj = realObj;
    }

    //获得代理对象
    public Object getProxyObject(){

        /**
         * Proxy：作用创建代理对象
         *      ClassLoader loader：类加载器
         *      Class<?>[] interfaces：真实角色实现的接口，根据接口生成代理类
         *      InvocationHandler h：增强的逻辑，即如何代理(宋吉吉要做的事)
         */
        return Proxy.newProxyInstance(
                realObj.getClass().getClassLoader(),
                realObj.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy：代理类，一般不用
                     * @param method：要调用的方法
                     * @param args：调用方法时的参数
                     * @return
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args)
                        											throws Throwable {

                        System.out.println("真正的方法执行前！");
                        System.out.println("面谈，签合同，预付款，订机票");

                        Object result = method.invoke(realObj, args);

                        System.out.println("真正的方法执行后！");
                        System.out.println("收尾款");

                        return result;
                    }
                }
        );
    }
}
4.3.4.4.测试
public class Client {
    public static void main(String[] args) {
        //获得代理对象
        Star proxyObject = (Star) new ProxyFactory(new RealStar()).getProxyObject();
        System.out.println(proxyObject.getClass());//class com.sun.proxy.$Proxy0
        proxyObject.sing();
    }
}

4.3.5.Cglib动态代理

cglib与动态代理最大的区别就是：

  • 使用jdk动态代理的对象必须实现一个接口
  • 使用cglib代理的对象则无需实现接口

CGLIB是第三方提供的包，所以需要引入jar包的坐标：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>2.2.2</version>
</dependency>

如果你已经有spring-core的jar包，则无需引入，因为spring中包含了cglib。

4.3.5.1.真正角色
package com.by.proxy.CglibProxy;

public class RealStar{

	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}
4.3.5.2.代理角色（经纪人）
package com.by.proxy.CglibProxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

//代理工厂
public class ProxyFactory implements MethodInterceptor {

    //真实角色
    private Object realObj;

    public ProxyFactory(Object realObj) {
        this.realObj = realObj;
    }

    /**'
     * 获得子类代理对象
     * @return
     */
    public Object getProxyObject() {
        //工具类
        Enhancer en = new Enhancer();
        //设置父类
        en.setSuperclass(realObj.getClass());
        //设置回调函数
        en.setCallback(this);
        //创建子类代理对象
        return en.create();
    }
    /*
        在子类中调用父类的方法
            intercept方法参数说明：
                obj ： 代理对象
                method ： 真实对象中的方法的Method实例
                args ： 实际参数
                methodProxy ：代理对象中的方法的method实例
     */
    public Object intercept(Object obj, Method method, Object[] args, 
                            	MethodProxy methodProxy)throws Throwable {
        System.out.println("真正的方法执行前！");
        System.out.println("面谈，签合同，预付款，订机票");

        Object result = method.invoke(realObj, args);

        System.out.println("真正的方法执行后！");
        System.out.println("收尾款");
        return object;
    }
}
4.3.5.3.测试
package com.by.proxy.CglibProxy;

//测试类
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        RealStar proxyObject = 
            (RealStar) new ProxyFactory(new RealStar()).getProxyObject();
        proxyObject.sing();
    }
}

4.4.AOP相关术语

  1. 连接点（joinpoint）

    被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法。

  2. 切入点（pointcut）

    切入点是指我们要对哪些连接点进行拦截的定义

  3. 通知（advice）

    所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

  4. 切面（aspect）

    是切入点和通知的结合

  5. 引介（introduction）

    是一种特殊的通知，在不修改代码的前提下，引介可以在运行期为类动态地添加一些方法或字段

  6. 目标对象（Target）

    要代理的目标对象（要增强的类）

  7. 织入（weave）

    将增强应用到目标的过程将advice应用到target的过程

  8. 代理（Proxy）

    一个类被AOP织入增强之后，就产生一个代理类
    在这里插入图片描述

4.5.Spring的AOP配置

4.5.1.创建工程

在这里插入图片描述

4.5.1.1.pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.by</groupId>
    <artifactId>Spring_AOP_Xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- Spring常用依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
         <!--支持切点表达式 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.1.8.RELEASE</version>
        </dependency>
    </dependencies>
</project>
4.5.1.2.dao
/**
 * 持久层实现类
 */
public class UserDaoImpl implements UserDao {

    @Override
    public void addUser(){
        System.out.println("insert into tb_user......");
    }
}
4.5.1.3.service
/**
 * 业务层实现类
 */
public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public void addUser(){
        userDao.addUser();
    }
}
4.5.1.4.applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--注意：添加约束-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       			   http://www.springframework.org/schema/beans/spring-beans.xsd
       			   http://www.springframework.org/schema/aop
       			   http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <bean id="userDao" class="com.by.dao.UserDaoImpl"></bean>
    <bean id="userService" class="com.by.service.UserServiceImpl">
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>
4.5.1.5.web
/**
 * 模拟表现层
 */
public class Client {
    public static void main(String[] args) {
        ApplicationContext ac = 
            new ClassPathXmlApplicationContext("applicationContext.xml");
        //使用对象
        UserService userService = ac.getBean("userService",UserService.class);
        System.out.println(userService.getClass());
        userService.addUser();
    }
}

4.5.2.增强

  1. 创建增强类

    package com.by.advice;

import org.aspectj.lang.ProceedingJoinPoint;

import java.util.Date;

public class MyLogAdvice {

    //前置通知
    public void before(){
        System.out.println("前置通知");
    }

    //后置通知【try】
    public void afterReturning(){
        System.out.println("后置通知");
    }

    //异常通知【catch】
    public void afterThrowing(){
        System.out.println("异常通知");
    }

    //最终通知【finally】
    public void after(){
        System.out.println("最终通知");
    }

    //环绕通知
    public void around(ProceedingJoinPoint joinPoint){
        try {
            System.out.println("方法执行前的环绕通知");
            joinPoint.proceed();
            System.out.println("方法执行后的环绕通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}

  2. 配置增强类

    <!--增强-->
<bean id="myLogger" class="com.by.advice.MyLogger"></bean>

4.5.3.切点

  1. 切点表达式

    表达式语法：

    ​ execution([修饰符] 返回值类型 包名.类名.方法名(参数))

    例如：

    ​ execution(* com.by.service.UserService.add(..))

    ​ execution(* com.by.service.UserService.*(..))

    ​ execution(* com.by.service.*.*(..))

  2. 配置切点

    <aop:config>
    <!--切点-->
    <aop:pointcut id="pointcut" expression="execution(* com.by.service.*.*(..))"/>
</aop:config>

4.5.4.切面

  1. 增强的类型

    • aop:before：用于配置前置通知
    • aop:after-returning：用于配置后置【try】通知，它和异常通知只能有一个执行
    • aop:after-throwing：用于配置异常【catch】通知，它和后置通知只能执行一个
    • aop:after：用于配置最终【finally】通知
    • aop:around：用于配置环绕通知

  2. 配置切面

    <!--切面-->
<aop:aspect ref="myLogger">
    <!-- 用于配置前置通知：指定增强的方法在切入点方法之前执行 
		method:用于指定通知类中的增强方法名称
		ponitcut-ref：用于指定切入点
	-->
	<aop:before method="before" pointcut-ref="pointcut"/>
    <aop:after-returning method="afterReturning" pointcut-ref="pointcut"/>
    <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut"/>
    <aop:after method="after" pointcut-ref="pointcut"/>
    <aop:around method="around" pointcut-ref="pointcut"/>
</aop:aspect>

4.5.5.测试

  1. 测试service实现接口时的类型

在这里插入图片描述

  1. 测试service不实现接口时的类型
    在这里插入图片描述
Digimon-Y
关注
Spring AOP的应用
qq_45119519的博客
07-27 160
使用AOP对方法进行增强
Spring AOP实现原理解析
qq_28834355的博客
03-06 641
1
SpringAop 相关学习见解
qq_41501226的博客
08-06 211
1Spring AOP简介 1.1AOP 概述 1.1.1AOP 是什么？ AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。如图所示： AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象
spring切面-AOP见解
一步一个脚印_binding
09-06 198
对于aop的理解是对业务代码的增强，比如，记录日志，事务控制，异常处理等等，aop是采用动态代理实现的一种技术，也可以启动降低代码的耦合的作用。 aop具体的概念不做解释，切点，切面这些都可以查到，这里只做代码的实现 切入点表达式execution /** * execution表达式-切入点表达式： * 语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常) * 修饰符：一般省略不写， * 示例: public 公共方法
Spring AOP源码学习：创建 AOP 代理
2401_85239883的博客
07-23 352
小编在这里分享些我自己平时的学习资料，由于篇幅限制，pdf文档的详解资料太全面，细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！程序员代码面试指南 IT名企算法与数据结构题目最优解这是” 本程序员面试宝典!书中对IT名企代码面试各类题目的最优解进行了总结，并提供了相关代码实现。针对当前程序员面试缺乏权威题目汇总这一-痛点， 本书选取将近200道真实出现过的经典代码面试题，帮助广“大程序员的面试准备做到万无一失。“刷”完本书后，你就是“题王”!
浅析Spring Aop源码
javashareauthor的博客
06-28 141
Aop作为Spring的一个重要组成部分，有着举足轻重的位置，因此有必要去深入了解实现原理。 在现在的面试或者同事之间聊天的时候，我们都习惯去这样回答Aop：Aop就是面向切面编程，实现原理就是动态代理（jdk代理或者cglib代理），应用于Spring的事务和日志打印等场景。 不知道你发现问题没有，上述的回答很虚（评论性见解，并非工程学见解），...
SpringAop日志管理实现方式
你能找到这里，说明你有经天纬地之才，扭转乾坤只能，鬼神不测之计包藏宇宙之志，真乃乱世之枭雄，治世之能臣也
04-10 789
1、Aop切面注解： 1.1@Aspect注解将一个Java类定义为切面类； 1.2@Pointcut定义一个切入点，可以是一个表达式，例：package下的所有函数，也可是一个注解； 根据切入点的不同位置切入内容 1.3@Before在切入点开始处切入内容； 1.4@After在切入点的结尾处切入内容； 1.5@AfterReturning在切入点return内容之后切入内容 1....
Spring 之AOP的个人见解
qq_43713840的博客
12-17 99
Spring学习之AOP 一、AOP基本概念 AOP:Aspect Oriented Programming (面向切面编程) 功能：分离与逻辑无关的代码，处理日志、权限、拦截功能… AOP横向编程分离逻辑无关的功能、OOP纵向编程实现逻辑功能，两者配合代码简化，代码复用性更强； 与逻辑代码无关的日志…等等模块，AOP提取出来并设计成一个服务对象称为Aspect（类）；与逻辑代码无关的行为称为横切关注点（Cross-cutting-concern）:拦截什么方法、拦截后如何处理 AOP术语
Spring见解3 AOP
jyx_boy的博客
01-05 940
AOP：全称是Aspect Oriented Programming即：面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对程序进行增强：权限校验,日志记录,性能监控,事务控制.作用：通过代理可以控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即： AOP的微观实现！核心角色抽象角色(接口)：定义公共对外方法真实角色（周杰伦）：实现抽象角色，定义真实角色所要实现的业务逻辑。
Spring IOC AOP常见的面试题及概念
qq_43012792的博客
09-12 8867
本篇部分内容来源于网络，加上个人总结归纳，另外加上一些自己的见解，于是本篇文章诞生。感谢部分内容的提供者。 1、 Spring的 IOC和AOP机制 ？ （1）我们是在使用 Spring框架的过程中，其实就是为了使用 IOC（控制反转）、依赖注入（DI与IOC一样）和AOP（面向切面编程），这两个也是 Spring 的灵魂。 （2）主要用到的设计模式有工厂模式和代理模式 IOC就是典型的工厂模式，AOP就是典型的代理模式的体现。 代理模式是常用的Java设计模式，他的特征是代理类与委托类有同样的接口，代理
十年架构师面试经验之谈，如何回答 Spring AOP 和代理
weixin_44174165的博客
03-29 156
我们知道，Spring 中 AOP 是一大核心技术，也是面试中经常会被问到的问题，最近我在网上也看到很多面试题，其中和 Spring AOP 相关的就有不少，这篇文章主要来总结下相关的技术点，希望对大家有用。 十年架构师面试经验之谈，如何回答 Spring AOP 和代理 0. 几个常见的问题 针对这一块的东西，一般下面几个问题面试官问的比较多： Spring AOP用的是哪种设计模式？ ...
SpringBoot-AOP环绕通知记录日志/鉴权
软件老王
08-13 2585
1、问题描述 微信公号h5开发，前后端分离，因为是在微信公号里面操作页面，还有涉及到不同手机操作也不一样，导致联调比较麻烦，定位问题也麻烦，以前写过通过aop记录所有前端http请求，就又拿出来梳理了下，记录日志，记录下，希望可以帮到有需要的朋友。 2、解决方案 项目是springboot项目，通过springboot-aop，配置环绕通知，记录调用地址、入参、返回参数、ip，同时记录执行时间等，以便定位问题。具体的入库就是弄个表，保存下获取到的值，这里就不多做介绍了。 2.1 AOP简要说明 （1）什么是
spring-aop源码（三）调用aop代理方法过程
qq_33230747的博客
11-16 295
spring-aop源码（三）调用aop代理方法过程 提示：本篇文章是继【spring-aop源码（一）创建AnnotationAwareAspectJAutoProxyCreator过程】和【spring-aop源码（二）创建代理对象过程】后的spring-aop源码系列的第三篇，也是这个系列的最后一篇。如有问题或者其它见解，敬请指正，peace！与前两篇文章一样，本篇文章主要使用SpringBoot源码。 SpringBoot源码地址：https://github.com/spring-projec
浅读Spring源码，说说我对Bean的生命周期，Aop，Ioc理解（学习笔记）
feitao1818的博客
11-01 978
最近刚通过视频学习了Spring的一些底层原理，为了方便理解记忆，配合代码作为整理笔记 1.Spring是什么 2.Spring Bean的创建周期 3.IOC 4.AOP 1.Spring是什么 首先谈一下Spring是什么，相信网上也有很多的对Spring的定义，Spring是一个J2EE的轻量级的开源的框架，他是一个容器框架，用来装我们的javaBaen对象，是一个中间层框架，它可以起到一个连接的作用，比如说可以把不同的框架粘合在一起进行使用，可以让我们的企业开发更快速，更简洁，所以.
【FL0013】基于SpringBoot和微信小程序的机电公司管理信息系统
最新发布
Wo_Hui12138的博客
11-03 624
如今社会上各行各业，都喜欢用自己行业的专属软件工作，互联网发展到这个时候，人们已经发现离不开了互联网。新技术的产生，往往能解决一些老技术的弊端问题。因为传统机电公司管理信息系统信息管理难度大，容错率低，管理人员处理数据费工费时，所以专门为解决这个难题开发了一个机电公司管理信息系统管理系统，可以解决许多问题。 机电公司管理信息系统管理系统按照操作主体分为管理员和用户。管理员的功能包括字典管理、公告管理、考勤管理、客户管理、机电零件管理、机电零件订单管理、请假管理、机电设备管理、机电设备订单管理、用户管理、管理
在Springboot中更好的打印日志
nullPoninter的博客
11-02 215
1
基于SSM+VUE历史车轮网站JAVA|VUE|Springboot计算机毕业设计源代码+数据库+LW文档+开题报告+答辩稿+部署教+代码讲解
卓越软件开发的博客
11-01 786
源代码+数据库+LW文档（1万字以上）+开题报告+答辩稿部署教程+代码讲解+代码时间修改教程。
SpringSession源码分析
lkr_lkr的博客
11-01 267
默认对常规Session的理解和使用，如何使用Set-Cookie。
Spring事件监听机制
mrguif的博客
10-31 876
在容器刷新的 initApplicationEventMulticaster(); 步骤中 会初始化一个事件多播器ApplicationEventMulticaster（默认为SimpleApplicationEventMulticaster） 赋值给 AbstractApplicationContext 所持有的多播器成员 applicationEventMulticaster
Spring MVC开发详解：从入门到AOP的全面指南
该指南起源于2004年，作者以其亲身经历为背景，分享了他在使用Spring MVC框架时的经验和见解。书中涵盖了Spring MVC的核心结构，如控制器、模型和视图的交互，以及如何构建和管理业务逻辑。随着版本升级，作者还加入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值