Spring （AOP、静态代理、动态代理）

最新推荐文章于 2022-05-26 11:28:01 发布
最新推荐文章于 2022-05-26 11:28:01 发布
阅读量355 收藏
点赞数 2
分类专栏： Spring 框架 文章标签： 动态代理 静态代理 AOP Spring Spring （AOP、静态代理、动态代理）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/young_1004/article/details/81916688
版权

1. AOP

 

1.1 AOP简介

 

  1. AOP Aspect Oriented Programing 面向切面编程

  2. AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）

  3. Spring中的Aop是纯Java来实现的,使用动态代理的方式增强代码

  4. Spring使用动态代理的机制是判断委托类是否实现了接口,如果实现了接口则使用jdk的动态代理,如果没有实现接口则使用cglib的动态代理

  5. AOP不是由Spring提出来的,是由AOP联盟定义的

 

1.2 AOP的专业术语

 

Joinpoint(连接点) :委托类中可以被增强的方法

Pointcut(切入点) :切点 ,要被增强的方法

Advice(通知/增强) :增强的代码

Target(目标对象) :委托对象

Weaving(织入) :把增强应用切点的过程

Proxy（代理）: 一个类被AOP织入增强后，就产生一个结果代理类

Aspect(切面): 是切点和通知的结合

 

1.3 Spring中的AOP实现

1.3.1 传统的Spring的AOP

一个切点和一个通知的组合

1.3.2 基于Aspectj的AOP

  1. AspectJ是一个基于Java语言的面向切面的AOP框架

  2. Spring2.0以后新增了对AspectJ切点表达式支持

  3. @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

  4. 新版本Spring框架，建议使用AspectJ方式来开发AOP

1.3.3 Aspectj的切点表达式

  • 语法:execution(表达式)

  • execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

  • public * *(..) ---检索所有的public方法

  • execution(“* cn.uplooking.spring4.demo1.dao.*(..)”) ---只检索当前包

  • execution(“* cn.uplooking.spring4.demo1.dao..*(..)”) ---检索包及当前包的子包.

 

1.3.4 Aspect的增强类型

  • @Before 前置通知，相当于BeforeAdvice

@Before("execution(* com.uplooking.aop.UserDao.add*(..))")

public void beforeAdvice() {

System.out.println("前置通知....");

}

  • @AfterReturning 后置通知，相当于AfterReturningAdvice

@AfterReturning(value = "execution(* com.uplooking.aop.UserDao.add*(..))", returning = "ret")

public void afterReturningAdvice(String ret) {

System.out.println("后置通知.." + ret);

}

  • @Around 环绕通知，相当于MethodInterceptor

@Around("execution(* com.uplooking.aop.UserDao.add*(..))")

public void arounrAdvice(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("环绕通知前..");

pjp.proceed();

System.out.println("环绕通知后..");

}

  • @AfterThrowing抛出通知，相当于ThrowAdvice

@AfterThrowing("execution(* com.uplooking.aop.UserDao.add*(..))")

public void throwAdvice() {

System.out.println("异常通知....");

}

  • @After 最终final通知，不管是否异常，该通知都会执行

@After(value = "execution(* com.uplooking.aop.UserDao.add*(..))")

public void afterAdvice() {

System.out.println("最终通知....");

}

 

1.4 AOP的编程（AspectJ）

 

1.4.1 导入pom依赖

<dependencies>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>4.3.12.RELEASE</version>

</dependency>



<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-aspects</artifactId>

<version>4.3.12.RELEASE</version>

</dependency>

<dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>4.3.12.RELEASE</version>

</dependency>

<dependency>



<groupId>junit</groupId>

<artifactId>junit</artifactId>

<version>4.12</version>

</dependency>



</dependencies>

 

引入约束

<?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.ma.aop"/>



<!--aop自动创建代理-->

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

1.4.2（前置通知）

1.4.2.1 要被增强的类

package com.ma.aop;



import org.springframework.stereotype.Repository;



@Repository

public class UserDao {

public void addUser(){

System.out.println("添加用户...");

}

public void deleteUser(){

System.out.println("删除用户...");

}

public void updateUser(){

System.out.println("修改用户...");

}

public void selectUser(){

System.out.println("查找用户...");

}

}

1.4.2.2 定义切面

package com.ma.aop;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.springframework.stereotype.Component;

/**

* 切面 = 切点（切点表达式）+ 通知 （方法）

*/

@Aspect

@Component

public class MyAspect {



@Before("execution(* com.ma.aop.UserDao.addUser())")

public void beforeAdvice(){

System.out.println("前置通知...");

}



}

1.4.2.3测试

import com.ma.aop.UserDao;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringRunner;



@RunWith(SpringRunner.class)

@ContextConfiguration("classpath:applicationContext.xml")

public class TestUserDao {

@Autowired

private UserDao userDao;



@Test

public void testAdd(){

userDao.addUser();

}

}

 

1.4.2.5结果

 

1.4.3（后置通知）

 

1.4.3.1 要被增强的方法

package com.ma.aop;

import org.springframework.stereotype.Repository;

@Repository

public class UserDao {

public void addUser(){

System.out.println("添加用户...");

}

public String deleteUser(){

System.out.println("删除用户...");

return "已删除！";

}

public void updateUser(){

System.out.println("修改用户...");

}

public void selectUser(){

System.out.println("查找用户...");

}

}

1.4.3.2 定义切面

@AfterReturning(value = "execution(* com.ma.aop.UserDao.delete*())",returning = "ret")

public void afterReturningAdvice(String ret){

System.out.println("后置通知..."+"ret");

}

注意：可以得到返回值。

 

1.4.3.3 测试

@Test

public void testDelete(){

userDao.deleteUser();

}

 

1.4.3.4 结果

 

1.4.4（环绕通知）

 

1.4.4.1 要被增强的方法

package com.ma.aop;

import org.springframework.stereotype.Repository;

@Repository

public class UserDao {

public void addUser(){

System.out.println("添加用户...");

}

public String deleteUser(){

System.out.println("删除用户...");

return "已删除！";

}

public void updateUser(){

System.out.println("修改用户...");

}

public void selectUser(){

System.out.println("查找用户...");

}

}

1.4.4.2 定义切面

@Around("execution(* com.ma.aop.UserDao.update*())")

public void afterReturningAdvice(){

System.out.println("环绕通知...");

}

注意：此时环绕通知可以阻止目标方法的执行，需要对目标方法进行放行。

@Around("execution(* com.ma.aop.UserDao.update*())")

public void afterReturningAdvice(ProceedingJoinPoint pjp) throws Throwable {

System.out.println("环绕通知前...");

pjp.proceed();

System.out.println("环绕通知后...");

}

 

 

1.4.4.3 测试

@Test

public void testUpdate(){

userDao.updateUser();

}

 

1.4.4.4 效果

 

1.4.5（异常通知）

 

1.4.5.1 要被增强的方法

package com.ma.aop;

import org.springframework.stereotype.Repository;

@Repository

public class UserDao {

public void addUser(){

System.out.println("添加用户...");

}

public String deleteUser(){

System.out.println("删除用户...");

return "已删除！";

}

public void updateUser(){

System.out.println("修改用户...");

}

public void selectUser(){

int i = 10/0;

System.out.println("查找用户...");

}

}

1.4.5.2 定义切面

@AfterThrowing("execution(* com.ma.aop.UserDao.selectUser())")

public void throwAdvice(){

System.out.println("异常通知...");

}

 

 

1.4.5.3 测试

@Test

public void testSelect(){

userDao.selectUser();

}

 

1.4.5.4 效果

 

2.代理模式

不使用对象的真实操作，使用我们自己创建的代理对象来操作

 

2.1 静态代理

委托类和代理类共同实现同一个接口，在代理类中有委托类的对象。

1、公共接口

package com.ma.aop.agent;



public interface WindWomen {

String say();

}

 

 

2、委托类

package com.ma.aop.agent;

/**

* 委托类

*/

public class Pan implements WindWomen {



public String say() {

return "晚上十点小河边见......";

}

}

3、代理类

package com.ma.aop.agent;



public class Wang implements WindWomen {

private WindWomen windWomen;//委托对象

public Wang(WindWomen windWomen){

/**

* 在代理的构造器中持有一个委托的对象

*/

this.windWomen = windWomen;

}



public String say() {

System.out.println("她找我让我给你带个话：");

System.out.println(windWomen.say());

System.out.println("记得啊！");

return null;

}

}

 


4、测试类

package com.ma.aop.agent;



public class AgentTest {

public static void main(String[] args) {

Pan pan = new Pan();

Wang wang = new Wang(pan);

wang.say();

}

}

5、效果

 

 

 

 

2.1动态代理

 

2.2.1 基于原生的JDK的动态代理

package com.ma.aop.agent;



import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;



public class AgentTest {

public static void main(String[] args) {

final Pan pan = new Pan();

WindWomen windWomen = (WindWomen) Proxy.newProxyInstance(AgentTest.class.getClassLoader(), Pan.class.getInterfaces(), new InvocationHandler() {

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

System.out.println("她找我让我给你带个话：");

Object object = method.invoke(pan,args);

System.out.println("记得啊！");

return object;

}

});

windWomen.say();

}

}

实现

 

 

 

效果

2.2.2 基于CGLIB的动态代理

因为原生的jdk的动态代理存在缺陷,代理类和委托类必须实现同一个接口

所以有个开源的动态代理框架出现了(CGLIB)

CGLIB不要求委托类必须实现接口:因为CGLIB底层是基于继承实现的

 

 

 

 

 

 

 

AOP、ASPECT、Spring AOP、JDK动态代理、CGLib动态代理
Simpier的博客
10-07 746
AOP、ASPECT、Spring AOP、JDK动态代理、CGLib动态代理
Spring 面试题，静态代理和动态代理的区别是什么？什么是 AOP 编程？
最新发布
程序员学习园地。
06-15 409
总结起来，静态代理和动态代理都是Java中常见的设计模式，它们通过引入代理的方式，给我们的代码带来了很大的灵活性。代理类与被代理类实现同样的接口，然后在代理类中维护一个对被代理对象的引用，从而可以操作被代理对象，增加额外的功能。其实，从广义上来说，动态代理就是AOP的实现方式之一，AOP的功能就是通过预编译方式和运行期间动态代理实现程序功能的统一维护的编程模式。AOP是Spring框架中的一个重要组成部分，在Spring中提供了丰富的AOP实施方式，而其中最常用的就是基于动态代理的AOP实现。
Spring——AOP学习（静态代理和动态代理模式）
qq_43411550的博客
08-12 290
Spring——AOP学习（静态代理和动态代理模式） 一、代理模式 我们知道学习Spring最重要的两个知识点就是IOC和AOP，AOP的主要思想就是动态代理模式。在了解AOP之前我们必须学习动态代理模式。 代理模式又分为静态代理和动态代理。 二、静态代理 在学习多线程的时候我们已经学了了静态代理，我们这里回顾一下。什么是静态代理？ 拿出之前学习静态代理的例子： 加入你要结婚，是不是需要找个婚庆公...
2020-09-16 个人学习记录（更新githun代码，单例，linux命令，动态代理）
weixin_41130226的博客
09-21 214
今日计划 1.设计模式—复习下单例 2.spring aop学习 git将本地代码更新到github仓库 git clone https://github.com/Suddee/zhj_design_patterns.git git add . git commit -m “” git push -u origin master(分支） 今天学到的linux命令 grep error * 查看目录下所有文件的错误信息，检测日志的时候很好用 在libmkl_intel_lp64.so: cannot
Spring——静态代理模式
Silly011的博客
04-15 709
使用Java的方式配置Spring JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能
Spring AOP基础组件 Joinpoint
我家有猫已长成的博客
02-13 1025
Spring AOP基础组件 Joinpoint 简介。
Spring AOP里的静态代理和动态代理用法详解
08-18
Spring AOP里的静态代理和动态代理用法详解 Spring AOP里的静态代理和动态代理用法详解是关于 Spring AOP里的静态代理和动态代理的详细介绍。代理是一种设计模式，通过创建一个代理对象来控制对委托类对象的直接...
关于Spring AOP，除了动态代理、CGLIB，你还知道什么？
12-20
- Spring AOP主要通过动态代理来实现，包括JDK动态代理和CGLIB。对于接口实现类，Spring使用JDK动态代理；对于没有接口的类，使用CGLIB生成子类来实现切面。 - **Pointcut**在Spring中通过`org.springframework....
Spring—AOP(静态代理与动态代理)+案例分析
Starry Sea
05-21 699
目录介绍AOP 介绍AOP AOP为（Aspect Oriented Programming）的缩写，意为： 面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 ...
springAop默认代理方式.zip
07-26
1. **静态代理**：Spring AOP 提供了两种代理方式，一种是静态代理，另一种是动态代理。静态代理是在编译时就确定了代理类，这种代理方式通常通过实现相同接口的方式创建。然而，Spring AOP默认并不使用静态代理，...
使用@Aspect面向切面编程，SpringBoot的AOP编程和动态代理
zzzgd_666的博客
12-23 758
1.了解 1. 动态代理和静态代理 静态代理: 由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。 动态代理: 动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 2.jdk代理和cglib代理 动态代理又可分为：JDK...
spring的AOP思想（动态代理）
weixin_45063957的博客
03-26 1030
1、spring的AOP面向切面编程的思想 核心思想：在不改变原有代码的基础上，添加其他的功能；即把原来的代码调过来，然后再原来代码的基础上，在其前面或者后面添加额外的功能； 场景：权限控制、缓存、日志处理、事务控制； 拦截器也是aop思想的一种利用； 利用aop的代码中，一般分为两部分核心与非核心；核心部分一般就是原来的代码，非核心就是通过切入点，额外加入的功能； spring的AOP 本质是一种动态代理，分为JDK动态代理(实现了接口) 和CGlab动态代理两种； 2、核心概念：..
Spring_AOP_Annotation使用Aspect实现动态代理
Sunlight
09-16 6087
spring_aop_annotation 的实现： 1.1在beans.xml中加入aop的schema 1.2在xml中打开aop的自动检索 1.3创建一个需要实现动态代理的类 1.4导入aspectj包，Spring使用的是aspect这个包来实现AOP，所以需要导入这个包。 1.5在这类上面使用@Aspect来声明这个类是一个切面类 1.6在相应的要进行横切点上面加入PointCut的说明 1.7如果希望获取相应的调用信息，可以通过joinPoint 传递
代理模式：aspectj静态代理和jdk,cglib的动态代理的对比
yellow__star的博客
10-11 3454
1.使用jdk的动态代理来增强接口实现类。 原理：使用Proxy类的newProxyInstance方法运行期通过反射动态的生成代理对象 优点：不需要修改具体的业务代码，动态的增强方法，降低耦合性。 缺点：代理的对象必须有接口实现。 代码如下： 接口： package com.yellow.proxy.jdk; public interface Iwork { publ...
java中代理，静态代理，动态代理以及spring aop代理方式，实现原理统一汇总
w475484467的博客
10-23 193
http://www.cnblogs.com/hadoop-dev/p/7095464.html
Spring AOP的实现原理
Eaphy's Blog
05-30 534
AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；而动态代理则以Spring AOP为代表。本文会分别对AspectJ和Spring AO
Spring AOP 静态代理和动态代理
技术札记
06-28 402
静态代理 一次只能代理一个具体的类 接口类 public interface InterfaceA { void exec(); } 接口类的具体实现类 public class InterfaceAlmpl implements InterfaceA { @Override public void exec() { System.o...
Spring AOP之ProceedingJoinPoint和JoinPoint一些概念和机制
lisheng19870305的专栏
05-26 1956
spring AOP之proceedingjoinpoint和joinpoint区别（获取各对象备忘）、动态代理机制及获取原理代理对象、获取Mybatis Mapper接口原始对象 现在AOP的场景越来越多，所以我们有必要理解下和AOP相关的一些概念和机制。基础知识和原理类大家搜索spring aop/aspectj，有大量现成的可以参考，基本上只要理解了jdk动态代理、cglib字节码动态生成代理就足够了，而且必须知道这个代理类是spring托管的（如果是自己创建的代理类，是无法被拦截的，此时只能使用
AOP的实现原理 —— 静态代理 和 动态代理（ Spring AOP）
热门推荐
猎人在吃肉
03-08 1万+
这里的AOP指的是面向切面编程思想，而不是Spring AOP 。 AOP（Aspect Orient Programming），我们一般称为面向方面（切面）编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理、日志、缓存等等。 AOP实现主要分为 静态代理 和 动态代理 。 - 静态代理 主要是 `AspectJ` - 动态代理 主要是 `Spring AOP`
Spring AOP静态代理模拟案例深入解析
在详细讨论Spring中模拟AOP静态代理的案例之前，我们需要先理解几个关键概念，即AOP(面向切面编程)、静态代理以及Spring框架中的AOP实现。 AOP(面向切面编程)是一种编程范式，旨在将横切关注点（cross-cutting ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值