【Spring框架08】AOP初步学习

最新推荐文章于 2024-07-12 12:44:48 发布
最新推荐文章于 2024-07-12 12:44:48 发布
阅读量115 收藏
点赞数 2
分类专栏： spring 文章标签： spring aop java maven spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binflcy/article/details/119188632
版权

【Spring框架08】AOP初步学习

思维导图

在这里插入图片描述

一、代理模式

1.jdk实现动态代理

（1）代理的函数

public class MyTest {
    public void Test(){
        System.out.println("我自己的步骤");
    }
}

（2）基于接口思想实现动态代理

public class JdkHandler implements InvocationHandler {

//    目标对象
    private Object target;

    public JdkHandler(Object target){
        this.target=target;
    }

//    程序运行期创建代理对象,动态创建代理对象
    public Object getProxy(){
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                this
        );
    }

    public void before(){
        System.out.println("步骤一");
    }
    public void after(){
        System.out.println("步骤三");
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target,args);
        after();
        return result;
    }
}

（3）调用测试

public class JdkHandlerTest extends TestCase {

    public void testInvoke() throws Throwable {
        MyTest myTest = new MyTest();
        JdkHandler jdkHandler = new JdkHandler(myTest);
//        创建代理对象
        Object proxy=jdkHandler.getProxy();

        jdkHandler.invoke(proxy,MyTest.class.getMethod("Test"),null);
    }
}

2.cglib动态代理

（1）需要引入cglib依赖

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

(2)基于继承思想实现

public class CglibHandlerTest implements MethodInterceptor {

//    目标对象
    private Object target;

    public CglibHandlerTest(Object target) {
        this.target = target;
    }

//    运行期间动态创建代理类
    public Object getProxy(){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public void before(){
        System.out.println("步骤一");
    }
    public void after(){
        System.out.println("步骤三");
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        before();
        Object result = methodProxy.invoke(target,args);
        after();
        return result;
    }
}

(3)编写测试类用于代理继承

public class CglibHandlerTestTest extends TestCase {

    public void testIntercept() {
        MyTest myTest = new MyTest();
        CglibHandlerTest cglibHandlerTest = new CglibHandlerTest(myTest);
        MyTest myTest11 = (MyTest)cglibHandlerTest.getProxy();
        myTest11.Test();
    }
}

配置aop的maven依赖

<?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.lcy</groupId>
  <artifactId>spring08-AOP</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>spring08-AOP</name>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>

<!--    Aop依赖 只支持xml（spring自带）-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.5.RELEASE</version>
    </dependency>
<!--    支持注解（第三方）-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.6.11</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.11</version>
    </dependency>

  </dependencies>

  <build>
  </build>
</project>

二、解决日志处理问题

1.基于注解的方式

配置aop的命名空间和网址并开启AOP

<?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: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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd

       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">
<context:component-scan base-package="com.lcy"/>
<!--    开启aop代理-->
    <aop:aspectj-autoproxy/>
</beans>

模拟类

@Service
public class UserService {
    public void add(){
        System.out.println("UserService add……》》》");
    }
}

切面

package com.lcy.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class LogCut {

    //定义切入点(扫描该包下的所有类所有方法)
    @Pointcut("execution(* com.lcy.service..*.*(..))")
    public void cut(){}

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

    @After("cut()")
    public void after(){
        System.out.println("后置通知");
    }

    @AfterReturning("cut()")
    public void afterReturn(){
        System.out.println("返回通知");
    }

    @AfterThrowing(value = "cut()",throwing = "e")
    public void afterThrow(Exception e){
        System.out.println("异常通知"+e.getMessage());
    }

    @Around("cut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知前");
        //内存信息。。。。访问方法
        System.out.println(pjp.getTarget()+"...."+pjp.getSignature());
        Object result =pjp.proceed();//继续向下执行
        System.out.println("环绕通知后");
        return result;
    }
}

正常运行没有报异常，有返回通知
在这里插入图片描述
不能正常运行，有异常通知，但是没有返回通知
在这里插入图片描述

2.基于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: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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd

       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">
<context:component-scan base-package="com.lcy"/>
<!--    开启aop代理-->
    <aop:aspectj-autoproxy/>

<!--    配置AOP-->
    <bean id="logCut02" class="com.lcy.aop.LogCut02"></bean>
    <aop:config>
        <aop:aspect ref="logCut02">
        <aop:pointcut id="cut" expression="execution(* com.lcy.service..*.*(..))"/>
            <aop:before method="before" pointcut-ref="cut"></aop:before>
            <aop:after method="after" pointcut-ref="cut"></aop:after>
            <aop:after-returning method="afterReturn" pointcut-ref="cut"></aop:after-returning>
            <aop:after-throwing method="afterThrow" pointcut-ref="cut" throwing="e"></aop:after-throwing>
            <aop:around method="around" pointcut-ref="cut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>
binflcy
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring框架：AOP的初步理解学习
qq_41833394的博客
09-11 274
1、什么是AOP呢？ AOP的全称是 Aspect-OrientedProgramming，即中文翻译里的面向切面编程。那么什么是面向切面编程，稍后来讲。先回顾一下OOP编程，即面向对象编程，这个我们很熟悉了它是按照纵向顺序来执行的，而AOP则是按照横向执行的。即它是OOP的一个补充。 （来自：https://www.cnblogs.com/zhaozihan/p/5953063.html） ...
自研Spring框架之AOP
我不会java的博客
01-29 273
自研Spring框架之AOP 完成了Spring容器和SpringIoC之后，我们现在进入到SpringAOP的阵地，开始对SpringAOP来一波猛攻。SpringAOP对应于框架之中的aop包 AOP Aspect Oriented Programming:面向切面编程 Spring实现AOP：JDK动态代理和CGLIB代理 JDK动态代理：其代理对象必须是某个接口的实现，它是通过在运行期间创建一个接口的实现类来完成对目标对象的代理；其核心的两个类是InvocationHandler和Proxy。
Spring AOP初步理解及使用
做兴趣使然的Hero
02-22 810
Spring AOP 一、简介 ​ 面向切面编程(Aspect-oriented Programming，俗称AOP)提供了一种面向对象编程(Object-oriented Programming，俗称OOP)的补充，面向对象编程最核心的单元是类(class)，然而面向切面编程最核心的单元是切面(Aspects)。与面向对象的顺序流程不同，AOP采用的是横向切面的方式，注入与主业务流程无关的功能，例如事务管理和日志管理。 ​ Spring的一个关键组件是AOP框架。 虽然Sp
Spring深度学习：AOP创建过程源码解析
Code豪客
04-13 1065
本文小豪将带大家深度学习Spring AOP相关知识，包括AOP标签解析及创建代理的底层源码，经过Spring AOP底层源码的解读，以此掌握更多的编程实践方案，同时进一步提升我们的架构能力。AOP实现核心业务和非核心业务的解耦，也提高了系统的可维护性，在Spring中AOP典型的应用就是事务机制，在后续深入学习Spring事务之前，我们有必要先行学习Spring AOP。
Spring_Aop初步认识
cxy_t的博客
11-09 95
浅谈Aop 什么是Aop AOP为Aspect Oriented Programming的缩写。 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 什么是面向切面编程呢? 当我们在编写程序的时候 难免遇到代码冗余(重复)的问题 这个时候你 可以将重复的代码 专门抽取出来形成一个一个小的方法 再将方法写成一个专门的类
spring aop初步了解
CarrotZsy的博客
01-09 117
- Spring AOP “初步了解和使用SPRING AOP” 一、AOP 1.1 什么是AOP AOP(Aspect Orient Programming)，面向切面编程。AOP是一种编程思想，是对面向对象编程（OOP）的一种补充。 1.2 AOP实现分类 AOP的本质是由AOP框架修改业务组件的字节码，是代理模式的一种应用。按照修改的字节码的时机可以分为两类: 静态AOP: AOP框架在编译阶段进行修改，生成了静态的AOP代理类(生成的.class文件已经被改动)，比如AspecJ框架。 .
SpringAOP的初步学习
余温0218的博客
06-18 117
学习AOP之前，强烈建议大家先复习一下动态代理，可以看一下本人的另一篇博客：设计模式之 代理模式 什么是 AOP AOP 为Aspect Oriented Programming的缩写，意为：面向切面编程。通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象程序设计）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时
【Spring】 AOP面向切面编程
Orion
02-23 1371
横切关注点从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。有十个附加功能，就有十个横切关注点。AOP核心关注点和横切关注点。业务处理的主要流程是核心关注点，非核心代码是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。(分离核心业务代码与非核心代码通知(增强)每一个横切关注点。
Spring框架初步学习
qujiahuiqu的博客
03-18 116
Spring框架一、spring框架简单介绍1.什么是Spring框架2.Spring框架的优点二、spring框架案例（以学生为例）1.配置applicationContext.xml2.bean层（实体类）3.dao层4.service层5.测试类 一、spring框架简单介绍 1.什么是Spring框架 Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBea...
Spring-Boot框架初步搭建
08-31
Spring框架是一个非常广泛使用的Java框架，提供了许多有用的功能，如IoC容器、AOP、MVC等。但是，Spring框架的配置文件较多，需要编写大量的XML配置文件，这对新手来说是一个很大的障碍。因此，Spring-Boot框架诞生...
手写Spring框架之: HelloSpring
02-01
通过这个"HelloSpring"示例，我们对Spring框架的基本运作有了初步了解。Spring不仅提供了依赖注入，还包含其他核心功能，如AOP（用于添加日志、事务管理等跨切面关注点），以及数据访问、Web开发和任务调度等模块。...
SSM框架的学习与应用-Java EE企业级应用开发学习记录-（第六天）初识Spring框架
08-30
本资源是一篇关于学习和应用SSM框架（Spring、SpringMVC、MyBatis）的学习记录系列文章中的第六天...通过学习这篇文章，你将会对Spring框架有一个初步的了解，并能够使用Spring的IoC容器实现控制反转和简单工厂模式。
初识Spring框架-资料.rar
03-26
Spring框架是Java开发领域中...以上是对Spring框架的初步认识，深入学习和实践，可以借助“初识Spring框架-资料.rar”中的教程、文档和示例，逐步掌握Spring的各个方面，从而在实际项目中更加熟练地运用这一强大框架。
JPA+SPRING权限系统初步框架
11-04
标题中的“JPA+SPRING权限系统初步框架”是指基于Java Persistence API (JPA) 和Spring框架构建的一个初步的权限管理系统。这样的系统主要用于管理用户权限，确保不同用户只能访问其被授权的数据或功能。 1. **Java...
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 948
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
Spring常见的自定义和扩展的方法
最新发布
Casual_Lei的博客
07-12 226
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。
5.SpringBoot核心源码-启动类源码分析
流月up的博客
07-12 394
SpringBoot核心源码-启动类源码分析
elk部署springboot
Chihirozy的博客
07-11 411
elk部署springboot。
Spring框架中AOP的实现
04-07
Spring框架中AOP的实现主要基于动态代理和字节码增强两种方式。 1. 基于动态代理 Spring框架中最常用的AOP实现方式就是基于动态代理。动态代理是指在程序运行时，动态地创建一个代理类，该代理类会实现被代理类的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值