菜鸟的成长之路——切面篇

最新推荐文章于 2024-06-29 08:25:38 发布
原创 最新推荐文章于 2024-06-29 08:25:38 发布 · 771 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring

  我们再来回忆一下切面是什么，切面就是将增强织入到某个切点。上节课我们知道，增强一方面包含了横切逻辑，另一方面包含了连接点（也就是方法的前面、后面、环绕等等），但是增强不能决定给哪个类的哪个方法横切（也就是不能决定切点），这节课我们就能找到这个切点，然后增强和切点共同组成切面。

1、如何研究切面比较简单？

  笼统来说，切面可以分成增强和切点，上节课我们讲过了很多增强，而切面也会有很多种类，可以说增强和切面两两组合可以组成切面，为了方便研究，本节课如果不特殊说明，都默认使用前置增强。
  切面分为以下三类：

  • Advisor：代表一般切面，他仅仅包含一个advice。简单来说就是一个增强给目标类的所有方法进行织入，我们上节课研究的就是一个一般切面。
  • PointcutAdvisor：代表切点切面，包含Advice和Pointcut两个类，他比一般切面多了切点，因此切面更加完整，所以很少用到上面的一般切面。
  • IntroductionAdvisor：代表引介切面，他是对应引介增强的切面，因此研究这个切面不能使用前置增强，必须使用引介增强。

  对于一般切面，我们上节课一直在说，这节课不再赘述。切点切面分很多种类，我们先对引介切面进行研究，然后再仔细研究切点切面。

2、引介切面如何使用？

  前面我们讲过了引介增强，其实引介切面就是对引介增强的一个包装，使用引介切面我们可以更简单灵活的为目标类添加接口。仍然使用上节课的案例，看一下引介切面的代码：
Lecturer.java（目标类）

package com.spring.test;

/**
 * 讲师类，具有上课方法
 * @author beijingduanluo
 *
 */
public class Lecturer {
    public void classBegin() {
        System.out.println("讲师传授新技术，同学们讨论很激烈！");
    }
}

School.java（目标接口）

package com.spring.test;
/**
 * 学校的接口，具有举办活动的方法
 * @author beijingduanluo
 *
 */
public interface School {
    public void setActive(boolean active);
}

LecturerAdvice.java（引介增强类）

package com.spring.test;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
/**
 * 本类继承IntroductionInterceptor接口的支持类DelegatingIntroductionInterceptor，成为引介增强
 * 本增强类实现需要添加的目标接口
 * @author beijingduanluo
 *
 */
public class LecturerAdvice extends DelegatingIntroductionInterceptor implements School{

    private boolean active;
    /**
     * 代理目标类实现接口的方法
     */
    public void setActive(boolean active) {
        // TODO Auto-generated method stub
        this.active = active;
    }

    @Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        // TODO Auto-generated method stub
//      如果目标类调用的不是classBegin方法，不进行横切逻辑
        if(!mi.getMethod().getName().equals("classBegin")) {
            super.invoke(mi);
            return null;
        }
//      判断学校是否有活动
        if(active) {
//          如果有活动，则停止讲师上课
            System.out.println("学校有活动，讲师暂停上课。");
        }else {
//          学校没有活动，讲师点名
            System.out.println("讲师开始点名。");
//          讲师正常上课
            super.invoke(mi);
        }
        return null;
    }

}

  前面的代码和引介增强没有什么区别，下面的开始和引介增强有了区别。
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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    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-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 配置目标类 -->
    <bean id="lecturer" class="com.spring.test.Lecturer"></bean>
    <!-- 配置引介切面，将引介增强包装进去 -->
    <bean id="advisor" class="org.springframework.aop.support.DefaultIntroductionAdvisor">
        <constructor-arg>           
            <bean id="advice" class="com.spring.test.LecturerAdvice"></bean>
        </constructor-arg>
    </bean>
    <!-- 配置代理工厂 -->
    <bean id="proxyFactory" class="org.springframework.aop.framework.ProxyFactory">
        <!-- 注入目标类 -->
        <property name="target" ref="lecturer"></property>
        <!-- 因为引介增强是继承关系，所以使用CGLib，进行下面修改 -->
        <property name="proxyTargetClass" value="true"></property>
        <!-- 没有去注入interfaces属性值，会默认将引介增强中所有接口给到目标类 -->
    </bean>
</beans>

SpringTest.java（测试类）

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.test.Lecturer;
import com.spring.test.LecturerAdvice;
import com.spring.test.School;

public class SpringTest{

    public static void main(String[] args) {
        ApplicationContext content = new ClassPathXmlApplicationContext("applicationcontext.xml");
        DefaultIntroductionAdvisor advisor = (DefaultIntroductionAdvisor) content.getBean("advisor");
        ProxyFactory pf = (ProxyFactory) content.getBean("proxyFactory");
//      没有配置引介增强，而是配置引介增强的包装，引介切面
        pf.addAdvisor(advisor);
//      获取讲师的代理对象
        Lecturer lecturer = (Lecturer) pf.getProxy();
//      没有举办活动时候讲师上课
        lecturer.classBegin();
        System.out.println("-------------学校举办活动-------------");
//      此时已经将接口加到目标类Lecturer中，如果调用接口方法，需要将目标对象强转
        School school = (School) lecturer;
//      学校举办活动
        school.setActive(true);
//      举办活动的时候讲师上课
        lecturer.classBegin();
    }
}

3、切点切面的体系结构是什么样的？

  首先看一下切点切面PointcutAdvisor类的结构图：
这里写图片描述
  PointcutAdvisor类有六个具体的实现类，这六个实现类分别是上图中蓝色的部分。这些类没必要深入研究，我们知道有这么几个类，而且他们都实现PointcutAdvisor接口就可以了。
  那这些蓝色标准的类怎么使用呢？我们会在下面一一讨论。切点切面的匹配有这么几种方法：静态普通方法名匹配切面、静态正则表达式方法匹配切面、动态切面、流程切面、符合切点切面。我们只对两种静态切面进行研究。

4、静态普通方法名匹配切面是如何实现的？

  静态普通方法名匹配切面，通过扩展StaticMethodMatcherPointcutAdvisor类实现，是程序运行前就匹配好，而不是匹配静态方法。
  现有如下需求：

学校要求讲师在上课前进行点名。

  上代码：
Lecturer.java（目标类）

package com.spring.test;

/**
 * 讲师类，具有上课方法
 * @author beijingduanluo
 *
 */
public class Lecturer {
    public void classBegin() {
        System.out.println("讲师传授新技术，同学们讨论很激烈！");
    }
}

Others.java（目标类干扰类）

package com.spring.test;

/**
 * 讲师类的干扰类，判断是否定位到Lecturer类中。
 * @author beijingduanluo
 *
 */
public class Others {
    public void classBegin() {
        System.out.println("其他人上课不需要点名");
    }
}

LecturerAdvice.java（增强类）

package com.spring.test;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 使用前置增强
 * @author beijingduanluo
 *
 */
public class LecturerAdvice implements MethodBeforeAdvice{

    public void before(Method method, Object[] args, Object target) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("讲师开始点名");
    }


}

LecturerAdvisor.java（切面类）

package com.spring.test;

import java.lang.reflect.Method;

import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.StaticMethodMatcherPointcutAdvisor;

public class LecturerAdvisor extends StaticMethodMatcherPointcutAdvisor{

    /**
     * 重写matches方法，匹配方法名，但是所有的类都会符合
     */
    public boolean matches(Method method, Class<?> targetClass) {
        // TODO Auto-generated method stub
//      匹配成功classBegin方法返回true
        return method.getName().equals("classBegin");
    }

    /**
     * 手动重写getClassFilter方法，匹配响应的类
     */
    @Override
    public ClassFilter getClassFilter() {
        // TODO Auto-generated method stub
//      返回带有Lecturer或者其子类的类过滤器
        return new ClassFilter() {
            public boolean matches(Class<?> clazz) {
                // TODO Auto-generated method stub
//              匹配Lecturer类或者其子类返回true
                return Lecturer.class.isAssignableFrom(clazz);
            }
        };
    }

}

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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    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-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 配置增强的bean -->
    <bean id="advice" class="com.spring.test.LecturerAdvice"></bean>
    <!-- 配置切面的bean -->
    <bean id="advisor" class="com.spring.test.LecturerAdvisor">
        <!-- 将增强的bean注入到切面中 -->
        <property name="advice" ref="advice"></property>
    </bean>
    <!-- 分别创建两个目标类的bean -->
    <bean id="lecturer" class="com.spring.test.Lecturer"></bean>
    <bean id="others" class="com.spring.test.Others"></bean>

    <!-- 配置代理工厂 -->
    <bean id="proxyFactory" abstract="true" class="org.springframework.aop.framework.ProxyFactory"></bean>
    <!-- 通过继承上面的抽象bean创建Lecturer的代理工厂 -->
    <bean id="lecturerpf" parent="proxyFactory">
        <property name="target" ref="lecturer"></property>
    </bean>
    <!-- 通过继承上面的抽象bean创建Others的代理工厂 -->
    <bean id="otherspf" parent="proxyFactory">
        <property name="target" ref="others"></property>
    </bean>
</beans>

SpringTest.java（测试类）

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.test.Lecturer;
import com.spring.test.LecturerAdvisor;
import com.spring.test.Others;

public class SpringTest{

    public static void main(String[] args) {
        ApplicationContext content = new ClassPathXmlApplicationContext("applicationcontext.xml");
        LecturerAdvisor advisor = (LecturerAdvisor) content.getBean("advisor");
        System.out.println("======lecturer的代理工厂，并调用Lecturer的方法");
        ProxyFactory lpf = (ProxyFactory) content.getBean("lecturerpf");
        lpf.addAdvisor(advisor);
        Lecturer lecturer = (Lecturer) lpf.getProxy();
        lecturer.classBegin();
        System.out.println("======Others的代理工厂，并调用Others的方法");
        ProxyFactory opf = (ProxyFactory) content.getBean("otherspf");
        opf.addAdvisor(advisor);
        Others others = (Others) opf.getProxy();
        others.classBegin();
    }
}

控制台打印

======lecturer的代理工厂，并调用Lecturer的方法
讲师开始点名
讲师传授新技术，同学们讨论很激烈！
======Others的代理工厂，并调用Others的方法
其他人上课不需要点名

  我们发现，对于Lecturer的classBegin方法，织入了增强，而对于Others的classBegin没有织入增强，这就是Advisor进行了类和方法的匹配的结果。

5、静态正则表达式方法匹配切面如何实现？

  静态正则表达式方法匹配切面扩展的是RegexpMethodPointcutAdvisor实现类，这个实现类已经有了完善的功能，我们只需要在配置文件中配置这个实现类，不需要重写去创建advisor了。代码如下：
Lecturer.java（目标类）

package com.spring.test;

/**
 * 讲师类，具有上课方法
 * @author beijingduanluo
 *
 */
public class Lecturer {
    public void classBegin() {
        System.out.println("讲师传授新技术，同学们讨论很激烈！");
    }
}

Others.java（干扰目标类）

package com.spring.test;

/**
 * 讲师类的干扰类，判断是否定位到Lecturer类中。
 * @author beijingduanluo
 *
 */
public class Others {
    public void classBegin() {
        System.out.println("其他人上课不需要点名");
    }
}

LecturerAdvice.java（增强类）

package com.spring.test;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

/**
 * 使用前置增强
 * @author beijingduanluo
 *
 */
public class LecturerAdvice implements MethodBeforeAdvice{

    public void before(Method method, Object[] args, Object target) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("讲师开始点名");
    }


}

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:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    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-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <!-- 配置增强的bean -->
    <bean id="advice" class="com.spring.test.LecturerAdvice"></bean>
    <!-- 配置切面的bean -->
    <bean id="advisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <!-- 将增强的bean注入到切面中 -->
        <property name="advice" ref="advice"></property>
        <!-- 使用正则表达式匹配方法的全限定名 -->
        <property name="patterns">
            <list>
                <value>com.spring.test.Lecturer.classBegin</value>
            </list>
        </property> 
    </bean>
    <!-- 分别创建两个目标类的bean -->
    <bean id="lecturer" class="com.spring.test.Lecturer"></bean>
    <bean id="others" class="com.spring.test.Others"></bean>

    <!-- 配置代理工厂 -->
    <bean id="proxyFactory" abstract="true" class="org.springframework.aop.framework.ProxyFactory"></bean>
    <!-- 通过继承上面的抽象bean创建Lecturer的代理工厂 -->
    <bean id="lecturerpf" parent="proxyFactory">
        <property name="target" ref="lecturer"></property>
    </bean>
    <!-- 通过继承上面的抽象bean创建Others的代理工厂 -->
    <bean id="otherspf" parent="proxyFactory">
        <property name="target" ref="others"></property>
    </bean>
</beans>

SpringTest.java（测试类）

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultIntroductionAdvisor;
import org.springframework.aop.support.RegexpMethodPointcutAdvisor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.spring.test.Lecturer;
import com.spring.test.Others;

public class SpringTest{

    public static void main(String[] args) {
        ApplicationContext content = new ClassPathXmlApplicationContext("applicationcontext.xml");
        RegexpMethodPointcutAdvisor advisor = (RegexpMethodPointcutAdvisor) content.getBean("advisor");
        System.out.println("======lecturer的代理工厂，并调用Lecturer的方法");
        ProxyFactory lpf = (ProxyFactory) content.getBean("lecturerpf");
        lpf.addAdvisor(advisor);
        Lecturer lecturer = (Lecturer) lpf.getProxy();
        lecturer.classBegin();
        System.out.println("======Others的代理工厂，并调用Others的方法");
        ProxyFactory opf = (ProxyFactory) content.getBean("otherspf");
        opf.addAdvisor(advisor);
        Others others = (Others) opf.getProxy();
        others.classBegin();
    }
}

控制台打印

======lecturer的代理工厂，并调用Lecturer的方法
讲师开始点名
讲师传授新技术，同学们讨论很激烈！
======Others的代理工厂，并调用Others的方法
其他人上课不需要点名

  我们发现，这样也可以将增强织入到响应的类的响应方法上。在配置文件中，我写的是方法的全限定名，如果使用正则表达式也是可以匹配多个对应方法的。

程序人生：从菜鸟到架构师的系统思考与成长路径
AI天才研究院
06-06 1162
你是否遇到过这些困惑？工作3年还在写CRUD（增删改查），感觉技术没成长；想转型架构师却不知道从哪下手，学了一堆技术栈但不会用；带团队后发现“会写代码”和“能带人”完全是两回事……本文专为解决程序员职业发展中的“迷茫期”而写，覆盖从初级到架构师的全阶段成长逻辑，重点讲解“系统思考”如何贯穿每个阶段，帮助你跳出“碎片化努力”的陷阱。
怎样成为一个优秀的架构师？
热门推荐
AI天才研究院
10-08 17万+
怎样才算是架构师？ 架构师是一个既能掌控整体又能洞悉局部瓶颈并依据具体的业务场景给出解决方案的团队领导型人物。看似完美的“人格模型”背后，是艰辛的探索。 架构师不是一个人，他需要建立高效卓越的体系，带领团队去攻城略地，在规定的时间内完成项目。 架构师的分类 从业界来看对于架构师的理解可以大概区分为： 企业架构师：专注于企业总体 IT 架构的设计。 IT 架构师-软件产品架构...
菜鸟认知--AOP面向切面编程
weixin_30537391的博客
09-28 96
AOP：面向切面编程 　　将与核心代码块关联性不强且可复用的代码块和核心代码块分离出来，当需要的时候再插入。 一些概念： 　　1.横切关注点：要插入的代码快（方法） 　　2.切面：切面是对横切关注点的抽象（横切点组合的类） 　　3.连接点：需要插入的位置（spring只拦截方法，也可为字段或者是构造器） 　　4.切入点：对连接点的具体操作（如：对什么连接点插入什么横切关注点） 　　5...
面向切面编程（AOP）
aixianer
03-29 298
面向切面编程是Spring中的重要思想。本文也主要针对是Spring中的面向切面编程。 面向切面编程是执行某些功能前后执行执行另外的代码，是程序更加灵活，扩展性更好。Servlet中的Filter就是面向切面编程思想的应用。
在Spring2中使用引介
软件开发资料汇总
04-12 492
今天基本上把《深入Spring2:轻量级J2EE开发框架原理与实践》中的AOP一章的最后的示例程序理清了，将会在这两天整理好后发出来。实在太困了，清理一下头绪，这里随便写一点关于Spring2中最简单的引介Introduction使用方法！ 引介(Introduction)是指在不更改源代码的情况，给一个现有类增加属性、方法，以及让现有类实现其它接口或指定其它父类等，从而改变类的静态结构。Sp
Spring AOP APIs
听海边涛声
03-06 847
Spring AOP APIs
Spring另一种增强的切面IntroductionAdvisor
JavaMyDream的博客
03-02 154
【代码】Spring另一种增强的切面IntroductionAdvisor。
[网盘]java程序员由菜鸟到笨鸟.pdf
03-21
### Java程序员成长之路——从菜鸟到笨鸟 #### 一、引言 《Java程序员由菜鸟到笨鸟》是一本由曹胜欢编写的书籍，旨在帮助初学者掌握Java编程的基础知识，并逐步进阶至更高级的应用场景。本书不仅适合初学者作为...
《通关！游戏设计之路》笔记（未整理完）
Convallaria_Z的博客
08-20 6735
第一关序言 第一关攻略与秘籍 游戏是有规则和胜利条件的活动 游戏的目标应该设定得很简单，就像20世纪50年代的桌游那样 游戏种类多样，放手去做你想要的游戏 游戏技术总是在不断更新，要去适应，否则就会落后 做一款游戏需要具有各种技能的人合作 第二关创意 好的创意与愚蠢的创意只有一线之隔。——米歇尔·冈瑞 如果你觉得某个东西创意爆棚，那只能说明你对它的关注还不够。——斯科特·罗杰斯 如何获得及如何把握创意： 塞满自己的脑袋 看/读/听许多许多东西，然后将其消化 让那些图片、故..
精心整理 | R语言中文社区历史文章整理（类型篇）
R语言中文社区
07-07 5647
2018年过去一半了~又到了盘点的时间~感谢长时间来各位好友的关注，我们的成长与你们的爱护是分不开的。更感谢各位老师的投稿，支撑起了我们的这个社区，让更多R语言的爱好者和...
AOP组合使用切面和自定义注解
huofuman960209的博客
09-03 8718
添加切面依赖 &lt;dependency&gt; &lt;groupId&gt;org.aspectj&lt;/groupId&gt; &lt;artifactId&gt;aspectjrt&lt;/artifactId&gt; &lt;version&gt;1.8.5&lt;/version&gt; &lt;/dependency&gt;
Spring切入点表达式常用写法
lisj0731的专栏
03-31 389
Spring切入点表达式常用写法(2009-07-09 17:03:50)转载标签： it 分类： spring 自从使用AspectJ风格切面配置，使得Spring的切面配置大大简化，但是AspectJ是另外一个开源项目，其规则表达式的语法也稍稍有些怪异。 下面给出一些常见示例的写法： 比如，下面是一个对Service包上所有方法的切面配置 ...
如何理解面向切面编程中的切面？
WS的小屋
09-09 1979
在学习 Spring 中，有一个很重要的内容就是 AOP，面向切面编程。 很多人疑惑为什么叫做面向切面？ 切面是什么意思，切入点是什么意思？ 下面我以一种通俗易懂的方式谈谈我的理解。 切面与切入点 切面 = 切入点 + 额外功能。 我们先从几何的角度出发，我们都知道点构成面，任何一个面都是由很多个点构成的，比如桌面是由很多个木头点构成的，而这些木头点都有相同的特性：他们都是木头，如果我们想给这些木头点加一些额外的功能，让他们都变成红色的，只需要用红色的油漆将桌子刷成红色，相当于我们给桌子上的所有的.
springboot中什么是切面？如何实现一个切面？实现切面时如何选择合适的切入点？
最新发布
DKPT的博客
06-29 1732
在Spring Boot中，切面（Aspect）是面向切面编程（Aspect Oriented Programming，AOP）的一个核心概念。面向切面编程是一种编程范式，用于处理系统中分布于各个模块的横切关注点（cross-cutting concerns），如日志记录、事务管理、性能监控、安全控制等。这些横切关注点通常与业务逻辑无关，但在系统各处都有可能出现。在Spring Boot中，切面是对这些横切关注点进行模块化封装的特殊类。1、通知（Advice）定义了切面何时以及如何应用其增强功能。
aop面向切面编程原理,这个比喻我服辣,6翻了
凤歌
01-08 8406
aop面向切面编程原理讲解
Spring-AOP 静态正则表达式方法匹配切面
小工匠
08-19 2万+
概述 实例 正则表达式语法 正则表达式工具 RegexBuddy概述在Spring-AOP 静态普通方法名匹配切面案例中 StaticMethodMatcherPointcutAdvisor中，仅能通过方法名定义切点，这种描述方式不够灵活，假设目标类中有多个方法，切满足一定的命名规范，使用正则表达式进行匹配就灵活多了。 RegexpMethodPointcutAdvisor是正则表达式方法匹配的切
Spring-aop实现切面的四种方式 上篇
Seven__________7的博客
11-08 1万+
Spring实现AOP的4种方式     先了解AOP的相关术语: 1.通知(Advice): 通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。 2.连接点(Joinpoint): 程序能够应用通知的一 个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。 3.切入点(Pointcut) 通知定义了切面要发生的“故事”和时间，那么
Spring核心技术：AOP面向切面，前置增强和后置增强
骑着蜗牛行天下
10-05 1354
Spring核心技术：AOP面向切面 所谓的面向切面编程，是一种通过预编译和运行期动态代理的方式，实现在不修改源代码的情况下给程序动态添加功能的技术。 面向对象的延续，Spring框架的重要内容，是函数式编程的一种衍生泛型。 利用AOP可以对业务逻辑各部分之间耦合度降低，提高程序的重用性，提高开发效率。 AOP的原理：(1)将复杂的需求分解出不同的方面，将散布在系统中的公共功能集中解决。 (2)采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能。 AOP相
spring的AOP基础、前置通知与后置通知
youjiangtengwan1的博客
01-07 5482
AOP（Aspect-Oriented Programming,面向切面编程）是一种新的方法论，是对传统OOP（Object-Oriented Programming，面向对象编程）的补充 AOP的主要编程对象是切面(aspect),而切面模块化横切关注点 在应用AOP编程时，仍然需要定义公众功能，并且不必修改受影响的类，这样一来横切关注点就被模块化到特殊的对象(切面)里 AOP的好处 每
面向对象编程成长之路：从菜鸟到高手
这篇资源是伍迷所著的《小菜编程成长记》，通过作者的个人经历，讲述了从编程新手到熟练掌握各种编程技巧的过程。文章主要分为十三个章节，每个章节都围绕一个特定的主题展开，旨在帮助读者理解并提升编程能力。以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值