Spring学习笔记：详解AOP编程

最新推荐文章于 2024-08-05 16:41:06 发布
最新推荐文章于 2024-08-05 16:41:06 发布
阅读量177 收藏 1
点赞数
分类专栏： spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/studyeglish/article/details/106414358
版权

Spring笔记汇总

AOP编程

AOP编程

1、AOP的概念

AOP (Aspect Oriented Programing) —— 面向切面编程 = Spring动态代理开发

  • 以切面为基本单位的程序开发，通过切面间的彼此协同，相互调用，完成程序的构建

  • 切面 = 切入点 + 额外功能

OOP (Object Oritened Programing)【面向对象编程Java】

  • 以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用，完成程序的构建

POP (Producer Oriented Programing) 【面向过程(方法、 函数)编程C】

  • 以过程为基本单位的程序开发，通过过程间的彼此协同，相互调用，完成程序的构建

AOP的概念:

本质就是Spring得动态代理开发，通过代理类为原始类增加额外功能。

好处：利于原始类的维护

注意：AOP编程不可能取代OOP ，是OOP编程的有益补充。

2、AOP编程的开发步骤

  1. 原始对象
  2. 额外功能（MethodInterceptor）
  3. 切入点
  4. 组装切面( 额外功能+切入点)

3、切面的名词解释

切面 = 切入点 + 额外功能

几何学：面 = 点 + 相同的性质

在这里插入图片描述

动态代理类的创建

1、JDK的动态代理

  • Proxy.newProxyInstance 方法参数详解
    在这里插入图片描述
    在这里插入图片描述

  • 编码

    public class TestJDKProxy {

    /**
     *  用于测试:测试JDK代理对象
     *
     */
    @Test
    public void test(){
        
        /*
        1.借用类加载器		TestJDKProxy
        					UserServiceImpl
        2. JDK8.0前
        		final UserService userService = new UserServiceImpl();
        */

        // 创建原始对象
        UserService userService = new UserServiceImpl();

        // JDK创建动态代理

//        InvocationHandler hander = new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  				......
//            }
//        };
        InvocationHandler hander = (proxy, method, args) -> {
            System.out.println("---log---");
            Object ret = method.invoke(userService, args);
            return ret;
        };

        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(TestJDKProxy.class.getClassLoader(), userService.getClass().getInterfaces(), hander);
        userServiceProxy.login("你好", "123456");
        userServiceProxy.register(new User());

    }
}

2、CGlib的动态代理

CGlib创建动态代理的原理：父子继承关系创建代理对象，原始类作为父类，代理类作为子类，即生成子类。这样既可以保证两者方法一致， 又能在代理类中提供新的实现(额外功能+原始方法)

在这里插入图片描述

public class TestCglibProxy {
    public static void main(String[] args) {
        // 创建原始对象
        UserService userService = new UserService();

        /*
        2通过cglib方式创建动态代理对象
        Proxy.newProxyInstance(classloader, interface, invocationHandler)

        对比:
        Enhancer.setClassLoader()
        Enhancer.setSuperClass()
        Enhancer.setCallback(); ---> MethodInterceptor(cglib)
        Enhancer.create() ---> 代理
        */

        Enhancer enhancer = new Enhancer();

        enhancer.setClassLoader(TestCglibProxy.class.getClassLoader());
        enhancer.setSuperclass(userService.getClass());

        MethodInterceptor interceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("---log---");
                Object invoke = method.invoke(userService, args);
                return invoke;
            }
        };

        enhancer.setCallback(interceptor);

        UserService userService1Proxy = (UserService) enhancer.create();
        userService1Proxy.login("我","45");
        userService.register(new User());

    }
}

总结

  1. JDK动态代理 Proxy.newproxyInstance() 通过接口创建代理的实现类
  2. Cglib动态代理Enhancer通过继承父类创建的代理类
  3. JDK和CGLIB动态代理区别

4、Spring工厂如何加工原始对象

  • 思路分析
    在这里插入图片描述

  • 编码

    public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        InvocationHandler hander = (proxy, method, args) -> {
            System.out.println("---log---");
            Object invoke = method.invoke(bean, args);
            return null;
        };

        return Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),bean.getClass().getInterfaces(),hander);
    }
}

    <bean id="userService" class="com.company.factory.UserServiceImpl"/>

<!--
    1. 实现BeanPostProcessor进行加工
    2.配置文件中对BeanPostProcessor进行配置
    -->

<bean id="myBeanPostProcessor" class="com.company.factory.MyBeanPostProcessor"/>

基于注解的AOP编程

1、基于注解的AOP编程的开发步骤

  • 原始对象

  • 额外功能

  • 切入点

  • 组装切面

    #通过切面类  定义了 额外功能 @Around
            定义了 切入点   @Around("execution(* login(..))")
            @Aspect切面类

package com.company.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

/*
    之前:

    1.额外功能
        public class MyAround implements MethodInterceptor{

            public Object invoke(MethodInvocation invocation){
                Object ret  = invocation.proceed();

               return ret;
            }
        }
    2.切入点
        <aop:config
            <aop:pointcut id="" expression="execution(* login(..))"/>
 */
@Aspect
public class MyAspect {

    @Around("execution(* login(..))")
    public Object around(ProceedingJoinPoint joinPoint){
        System.out.println("--- aspect log ---");
        Object ret = null;
        try {
            ret = joinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        return ret;
    }

}

        <bean id="userService" class="com.company.aspect.UserServiceImpl"/>

    <!--
        切面
            1.额外功能
            2.切入点
            3.组装切面
    -->
    <bean id="aspect" class="com.company.aspect.MyAspect"/>

	<!--通知Spring基于注解进行AOP编程-->
    <aop:aspectj-autoproxy/>

2、细节

1. 切入点复用

切入点复用：在切面类中定义一个函数上面@Pointcut注解 通过这种方式，定义切入点表达式，后续更加有利于切入点复用。

@Aspect
public class MyAspect {

    @Pointcut("execution(* login(..))")
    public void myPointCut() {
    }

    @Around(value = "myPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--- aspect log ---");
        Object ret = null;
        ret = joinPoint.proceed();

        return ret;
    }

    @Around(value = "myPointCut()")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("--- aspect log ---");
        Object ret = null;
        ret = joinPoint.proceed();

        return ret;
    }

}

2. 动态代理的创建方式

AOP底层实现
2种代理创建方式
    1.JDK 通过实现接口做新的实现类方式创建代理对象
    2.Cglib 通过继承父类 做新的子类
创建代理对象
    默认情况AOP编程底层应用JDK动态代理创建方式
    
<!-- 如果切换Cglib -->
1.基于注解AOP开发
	<aop: aspectj-autoproxy proxy-target-class="true" />
2.传统的AOP开发
	<aop :config proxy-target-class="true"></aop>

AOP开发中的注意点

在同一个业务类中,进行业务方法间的相互调用，只有最外层的方法,才是加入了额外功能(内部的方法，通过普通的方式调用，都调用的是原始方法)。如果想让内层的方法也调用代理对象的方法，通过实现ApplicationAware接口进而实现AppicationContextAware方法获得工厂，进而获得代理对象

@Pointcut("execution(* *..UserService..*(..))")
public void myPointCut() {
}


package com.company.aspect;

import com.company.proxy.User;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ctx = applicationContext;
    }

    @Override
    public void login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        //调用的是原始对象的login方法-- ->核心功能
        /*
        设计目的:代理对象的login方法--->额外功能+核心功能
                AppliCationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
                UserService userService = (UserService) ctx . getBean("userService");
                userService.login();
        不行:Spring工厂重量级资源一个应用中应该只创建一个工厂
        */
//        this.register(new User());
        UserService userService = (UserService) ctx.getBean("userService");
        userService.register(new User());
    }

    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
    }

}

AOP阶段知识总结

在这里插入图片描述

持久层整合

Don’t care.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习笔记——AOP
qq_47102228的博客
04-11 702
Spring AOP，AspectJ
Spring系列课程--AOP编程
Jujuxiaer的博客
04-19 128
Spring系列课程–AOP编程 第一章 静态代理设计模式 1. 为什么需要代理设计模式 1.1 问题 在JavaEE分层开发中，哪个层次对于我们来说最重要 DAO --> Service --> Controller Service层最重要，业务逻辑都写在了Service层 Service层中包含了哪些代码？ Service层 = 核心功能（几十行 上百行代码） + 额外功能（附加功能） 1. 核心功能 业务运算 DAO调用 2. 额外功能 1）不属于业务 2）可有可无 3
Spring5学习笔记—AOP编程
分享思想，留下痕迹。
08-18 444
实现MethodBeforeAdvice接口//作用：给原始方法添加额外功能//注意：会在原始方法运行之前运行此方法@Override1. 切入点：额外功能加入的位置2. 目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法register()login()简单的测试：所有方法都做为切入点，都加入额外的功能。1. JDK动态代理 Proxy.newProxyInstance()# 通过目标类实现的接口创建代理类2. Cglib动态代理 Enhancer。
spring框架学习笔记04（AOP）
08-03 754
目录
Spring学习笔记（四）：Spring AOP详解
Jin_Kwok的博客
09-21 352
Spring AOP详解 一.前言 最近一直在学习Spring，关于其核心概念—AOP，充满疑惑，今天看到一篇不错的文章，研读之后觉得有必要转载记录一下。博文地址：http://www.cnblogs.com/xrq730/p/4919025.html 二、什么是 AOP？ AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Or...
Spring学习笔记---AOP详解 XML方式
m0_64916709的博客
01-14 157
<properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring.version>3.2.13.RELEASE</spring.version> </properties> <dependencies>
Spring学习笔记 | 详解AOP及其配置
小白菜的博客
10-17 145
AOP简介 AOP（面向切面编程）是一种新的方法论，是对传统OOP的补充。AOP的主要编程对象是切面，而切面模块化横切关注点。 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能在哪里，以什么方式应用，并且不必修改受影响的类，这样一来横切关注点就被模块化到特殊的对象（切面）里。 AOP的好处： 每个事务逻辑位于一个位置，代码不分散，便于维护和升级。 业务模块更简洁...
Spring学习笔记:使用代理实现AOP
渐入佳境Coder
10-08 211
AOP基础知识Spring AOP 即 Aspect-oriented programming，面向切面编程，是作为面向对象编程的一种补充，专门用于处理系统中分布于各个模块（不同方法）中的交叉关注点的问题。简单地说，就是一个拦截器（ interceptor ）拦截一些处理过程。例如，当一 个method 被执行，Spring AOP 能够劫持正在运行的 method ，在 method 执行前或者后
Spring学习笔记2——AOP
bains的博客
07-07 182
AOP概念 简介 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。OOP的延续，Spring框架中的一个重要内容，函数式编程的一种衍生范型；利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分的耦合度降低，提高程序的可重用性，同时提高开发效率。 作用和优势 作用：在程序云溪期间，在不修改源码的情况下对方法进行功能增强； 优势：减少重复代码，提高开发效率，便于维护。 底层实现 AOP的底
枚举工具类
qq_43049583的博客
08-04 284
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 328
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 662
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
深入理解Java注解
weixin_55745942的博客
08-01 668
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 616
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1102
C++ string的功能函数实现
SpringMVC02
2301_78875117的博客
08-02 1041
参数异常/** 自定义异常：参数异常*/private String msg="参数异常";super("参数异常！");super(msg);super("参数异常！");super(msg);return msg;业务异常private String msg="业务异常";super("业务异常！");super(msg);super("业务异常！");super(msg);return msg;
Spring-包扫描
Promise_J_Z
08-03 209
二次判断类是否可独立实例化对象，内部类或者接口，抽象类都会对应生成一个.class文件，但是这些文件部分是不能够实例化的，不可以生成bean，所以在生成BeanDefinition之前需要进行过滤判断。对扫描到的BeanDefinition进行赋值，但是此时只是将className赋值到BeanDefinition中，因为还没有创建该类。spring在启动的时候就会往includeFilters中加入component注解。判断当前类是否需要当作bean进行处理。
【SpringBoot】数据验证之分组校验
最新发布
Jacker
08-05 222
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
Spring学习笔记：Bootstrap框架详解
"这是一份关于Spring框架的资料笔记，主要涵盖了Spring的使用基础和一些相关的Web开发技术，如Bootstrap前端框架的介绍和应用。" 本文将深入探讨Spring框架的基础知识以及Bootstrap的常见功能，帮助读者更好地理解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值