SpringAOP

最新推荐文章于 2024-11-14 09:38:13 发布
最新推荐文章于 2024-11-14 09:38:13 发布
阅读量198 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Answer0902/article/details/89598402
版权

Spring存在意义：

    Java是一个面向对象(OOP)的语言，但它有一些弊端,比如当我们需要为多个不具有继承关系的对象引入一个公共行为，例如日志,权限验证,事务等功能时，只能在在每个对象里引用公共行为，这样做不便于维护，而且有大量重复代码。AOP的出现弥补了OOP的这点不足。

1.代理模式：

      代理模式：为其他对象提供一种代理以控制对这个对象的访问。即A要做一件事，在没有代理的时候需要自己动手，当有了代理B以后就可以让B去替他完成；

2.静态代理：

   

public interface IUserDAO {
    public void run();
}

public class UserDAO implements IUserDAO {
    @Override
    public void run() {
        System.out.println("事务运行");
    }
}

public class Proxy implements IUserDAO {
    private IUserDAO target=new UserDAO();
    @Override
    public void run() {
        System.out.println("事务运行前");
        target.run();
        System.out.println("事务运行后");
    }
}
public class Test {
    public static void main(String[] args) {
        IUserDAO proxy=new Proxy();
        proxy.run();
    }
}

静态代理虽然保证了业务类只需关注逻辑本身，代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理。再者，如果增加一个方法，除了实现类需要实现这个方法外，所有的代理类也要实现此方法。增加了代码的维护成本，为了减少成本就需要使用动态代理。

3.动态代理：

动态代理模式:动态代理类的源码是在程序运行期间通过JVM反射等机制动态生成，代理类和委托类的关系是运行时才确定的。

public interface IUserDAO {
    public void save();
    public void find();
}
class RealUser implements IUserDAO{

    @Override
    public void save() {
        System.out.println("模拟：保存用户");
    }

    @Override
    public void find() {
        System.out.println("查询");
    }
}
class ProxyFactory{
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
    public Object getProxyInstance(){
        Object proxy=Proxy.newProxyInstance(
                target.getClass().getClassLoader(),//目标对象使用的类加载
                target.getClass().getInterfaces(),//目标对象实现的接口
                //执行代理对象方法是触发，
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //执行方法名
                        String name=method.getName();
                        //返回值
                        Object result=null;
                        if("find".equals(name)){
                            result=method.invoke(target,args);
                        }else {
                            System.out.println("开始事务");
                            result=method.invoke(target,args);
                            System.out.println("事务提交");
                        }return result;

                    }
                }
        );return proxy;
    }
}
class Client{
    public static void main(String[] args) {
        IUserDAO target=new RealUser();
        System.out.println("目标对象："+target.getClass());
        IUserDAO proxy=(IUserDAO) new ProxyFactory(target).getProxyInstance();
        System.out.println("代理对象："+proxy.getClass());
        proxy.save();
    }
}

 

JDK代理：目标类要有实现的接口；

CGLIB代理：目标类没有实现接口，其是以动态生成目标类的子类来实现的，目标类不能被final修饰（不能继承）；

4.SpringAOP原理：

SpringAOP基本理论：

  • 面向切面编程：

       DI有助于对象之间的解耦；

       AOP实现横切关注点与其所影响的对象之间的解耦；（散布与应用中多处的功能为横切关注点）

  • 通知（Advice）：

      定义了切面是什么以及何处使用，即做什么和什么时候做；

  • 连接点（JoinPoint）:

      spring允许使用通知的地方，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点；

  • 切入点（PointCut）:

     在连接点的基础上，来定义切入点，一个类里，有许多方法，就有许多个连接点，但是你并不想在所有方法附近都使用通知（使用叫织入），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法；

"execution(* com.answer.springAOP2.IUserDAO.save())"
  • 切面（Aspect）:

     即通知和切入点的结合，通知是做什么和什么时候做，切入点是在哪做；

  • 引入（Introduction）：

      允许我们向现有的类添加新方法属性，就是把切面（也就是新方法属性：通知定义的）用到目标类中；

  • 织入（Weaving）:

       把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时。

　　关键就是：切点定义了哪些连接点会得到通知;

  1. 编译期：切面在目标类编译时被织入，需要特殊的编译器；
  2. 类加载期：切面在目标类加载到JVM时织入，需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前加强该目标类的字节码；
  3. 运行期：切面在运行的某个时刻被织入，AOP为目标类动态创建代理对象；

A.SpringAOP是动态代理模式；

B.创建容器对象的时候，根据切入点表达式拦截的类，生成代理对象;

C.如果目标对象有实现接口，使用jdk代理。如果目标对象没有实现接口，则使用Cglib代理。然后从容器获取代理后的对象，在运行期植入"切面"类的方法;

SpringAOP(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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="cglib" class="com.answer.springAOP1.Cglib"></bean>
    <bean id="jdk" class="com.answer.springAOP1.Jdk"></bean>
    <bean id="transcantionaop" class="com.answer.springAOP1.TranscationAOP"></bean>
    <aop:config>
        <!-- 切入点表达式定义-->
        <aop:pointcut id="transcationPointcut" expression="execution(* com.answer.springAOP1.*.*(..))"></aop:pointcut>
        <aop:aspect ref="transcantionaop">
            <aop:before method="beforeTransaction" pointcut-ref="transcationPointcut"></aop:before>
            <aop:after method="afterTranscation" pointcut-ref="transcationPointcut"></aop:after>
            <aop:after-returning method="afterReturn" pointcut-ref="transcationPointcut" returning="result"></aop:after-returning>
            <aop:around method="round" pointcut-ref="transcationPointcut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>
public interface IUserDAO {
    public String save();
}
class Cglib{
    public String save(){
        System.out.println("Cglib代理");
        return "不需要接口实现";
    }
}
class Jdk implements IUserDAO{

    @Override
    public String save() {
        System.out.println("JDK代理");
        return "需要一个接口实现";
    }
}
class TranscationAOP{
    public void beforeTransaction(){
        System.out.println("前置增强");
    }
    public void afterTranscation(){
        System.out.println("后置增强");
    }
    public void afterReturn(Object result){

        System.out.println("后置返回增强"+result);
    }
    public void afterThrow(){
        System.out.println("后置异常增强");
    }
    public Object round(ProceedingJoinPoint pjp) throws Throwable {
        Object result=null;
        System.out.println("环绕前：");
        result=pjp.proceed();
        System.out.println("环绕后：");
        return result;
    }
}
class Test{
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("aop1.xml");
        IUserDAO userDAO=(IUserDAO) applicationContext.getBean("jdk");
        //System.out.println(userDAO.getClass());
        userDAO.save();
        Cglib cglib=(Cglib) applicationContext.getBean("cglib");
        cglib.save();
    }
}

SpringAOP(注解)：

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

    <context:component-scan base-package="com.answer.springAOP2">
        <context:include-filter type="annotation"	expression="org.aspectj.lang.annotation.Aspect"/>
    </context:component-scan>
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
public interface IUserDAO {
    public String save();
    public void mine();
}

@Component("jdk")
public class Jdk implements IUserDAO {
    @Override
    public String save() {
        System.out.println("JDK动态代理");
        return "需要接口";
    }

    @Override
    public void mine() {
        System.out.println("我不需要切面");
    }
}

@Component("cglib")
public class Cglib {
    public String save(){
        System.out.println("CGLIB动态代理");
        return "不需要接口";
    }
}
@Aspect
public class MyAspect {
    @Before("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void beforeTransaction(){
        System.out.println("前置增强");
    }
    @After("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void afterTranscation(){
        System.out.println("后置增强");
    }
    @AfterReturning(value = "execution(* com.answer.springAOP2.IUserDAO.save())",returning = "result")
    public void afterReturn(Object result){

        System.out.println("后置返回增强"+result);
    }
    @AfterThrowing("execution(* com.answer.springAOP2.IUserDAO.save())")
    public void afterThrow(){
        System.out.println("后置异常增强");
    }
    @Around("execution(* com.answer.springAOP2.IUserDAO.save())")
    public Object round(ProceedingJoinPoint pjp) throws Throwable {
        Object result=null;
        System.out.println("环绕前：");
        result=pjp.proceed();
        System.out.println("环绕后：");
        return result;
    }
}

 

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("aop2.xml");
        IUserDAO iUserDAO=(IUserDAO) applicationContext.getBean("jdk");
        iUserDAO.save();
        iUserDAO.mine();
        //Cglib cglib=(Cglib) applicationContext.getBean("cglib");
        //cglib.save();
    }
}

 

SpringAOP用处：

    1.Spring声明式事务管理配置。

    2.Controller层的参数校验。

    3.使用Spring AOP实现MySQL数据库读写分离案例分析

    4.在执行方法前,判断是否具有权限。

    5.对部分函数的调用进行日志记录。监控部分重要函数，若抛出指定的异常，可以以短信或邮件方式通知相关人员。

    6.信息过滤，页面转发等；

 

Spring AOP 详解
2301_80035594的博客
10-19 6006
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
Spring AOP
2303_78892316的博客
04-20 1749
AOP即 Aspect Oriented Programming 面向切面编程。切面指的是某一类特定的问题，面向切面编程即解决某一类问题，例如前面我们介绍的拦截器，统一数据返回，统一异常处理。AOP 是一种思想，它的实现方法有很多，如：Spring AOP，AspectJ，CGLIB 等.
spring AOP详解
是程序喵呀
11-07 3362
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
Spring Aop
会写Bug的攻城狮
08-30 1671
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP详解
2302_77758423的博客
07-21 1655
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
Spring AOP术语
yuehua00的专栏
11-11 1640
Spring AOP 中的核心术语和概念包括切面、通知、切入点、连接点、引介、目标对象、代理对象、织入、通知方法、切点表达式、切面优先级、织入器、AOP 代理和 AOP 框架。理解这些术语有助于更好地掌握 Spring AOP 的使用和原理，从而在实际开发中有效地应用 AOP 技术。通过合理使用 AOP，可以提高代码的模块化程度和可维护性，减少重复代码，提高开发效率。
Spring AOP 使用详解
lzz的博客
11-14 1402
Spring AOP 使用详解。核心概念+实现示例+注意事项
Spring AOP 源码剖析
LHY537200的博客
08-08 1313
Spring AOP通过动态代理技术提供了一种灵活的方式来增强现有方法的功能，而无需修改源代码。其源码实现涉及Bean生命周期管理、动态代理技术、责任链模式等多个方面，深入理解这些机制有助于更好地使用和维护Spring AOP。
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
spring aop实现接口参数变更前后对比和日志记录
05-12
spring aop实现接口参数变更前后对比和日志记录完整代码，拿到项目代码，只需要做数据库连接的修改即可运行起来使用，代码案例详细，真是可靠，代码原文地址：...
Socket TCP通信C# Winform控件封装，集成简单，服务端与客户端全涵盖，源码及应用案例一键下载
05-03
内容概要：本文详细介绍了在C# Winform环境中实现Socket TCP通信的一种高效方式，即通过封装的服务端和客户端控件来简化开发流程。文中不仅讲解了控件的基本使用方法，如服务端监听、客户端连接、数据传输等核心功能，还探讨了控件内部的工作原理，包括异步通信、事件驱动机制以及线程安全管理等方面。此外，文章还提供了一些典型应用场景的具体实现，如聊天程序、文件传输等，帮助开发者更快地上手并解决实际问题。 适合人群：具有一定C#编程基础，希望快速掌握Socket TCP通信开发的程序员。 使用场景及目标：适用于需要在网络编程中快速搭建稳定可靠的通信系统的项目，旨在提升开发效率，降低开发难度，使开发者能够专注于业务逻辑而非底层通信细节。 其他说明：控件源码公开，便于进一步学习和定制化开发；附带多个应用案例源码，涵盖常见网络通信任务，有助于理解和实践。
欧姆龙PLC CJ2M标准程序：12伺服电机与气缸控制，含轴点动等，模块齐全，流程明晰，含机器人通讯与界面操作指南
05-03
内容概要：本文详细解析了欧姆龙CJ2M PLC控制系统的架构及其对12个伺服电机和气缸的控制方法。主要内容涵盖主控程序、手动模式、复位逻辑、定位控制、通讯与HMI交互以及生产计数模块。文中介绍了状态切换逻辑、伺服使能与时序处理、绝对与相对定位、EtherNet/IP通讯协议的应用、以及各种实用的调试技巧和常见问题解决方案。此外，强调了模块化设计思想和异常处理机制的重要性。 适合人群：从事自动化控制领域的工程师和技术人员，尤其是对PLC编程有一定基础并希望深入了解欧姆龙CJ2M系列产品的读者。 使用场景及目标：帮助读者掌握复杂的多轴伺服控制系统的设计思路与实现方法，提高实际项目的开发效率和稳定性。适用于工业生产线、机器人集成等应用场景。 其他说明：文章提供了丰富的实战经验和代码片段，有助于读者更好地理解和应用相关技术和理念。
QT步进电机上位机控制程序源代码：跨平台支持串口/TCP/UDP三种通信类型
最新发布
05-03
内容概要：本文介绍了基于QT框架开发的步进电机上位机控制程序，该程序支持串口、TCP、UDP三种通信方式，适用于不同操作系统（Windows、Linux、macOS）。文章详细讲解了各个通信方式的具体实现方法，包括代码示例和相关技术要点。此外，还讨论了跨平台适配、异常处理、线程安全等问题，并提供了实用的开发经验和优化建议。通过这种方式，开发者可以根据实际需求灵活选择最适合的通信方式，提高步进电机控制的精度和效率。 适合人群：具有一定编程基础，尤其是熟悉C++和QT框架的研发人员，以及从事自动化控制系统开发的技术人员。 使用场景及目标：①适用于各种自动化控制项目，如工业生产线、实验室设备等；②帮助开发者掌握跨平台开发技能，提升程序的兼容性和灵活性；③提供详细的代码实现和技术指导，便于快速搭建稳定的步进电机控制系统。 其他说明：文中不仅涵盖了基本的通信实现，还包括一些高级功能，如运动轨迹预测、电机参数自动识别等。同时强调了程序的稳定性和安全性，建议加入异常处理机制和紧急停止功能。
少儿编程scratch项目源代码文件案例素材-回拨电话.zip
05-03
少儿编程scratch项目源代码文件案例素材-回拨电话.zip
少儿编程scratch项目源代码文件案例素材-回声石.zip
05-03
少儿编程scratch项目源代码文件案例素材-回声石.zip
Spring AOP源码示例解析
Spring-AOP是Spring框架中的一个核心模块，全称为面向切面编程（Aspect-Oriented Programming）。它提供了与Spring IoC容器整合的切面编程实现，允许开发者通过分离横切关注点（cross-cutting concerns），比如日志...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dream答案

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值