Spring-aop实现切面的四种方式 (2)

最新推荐文章于 2023-02-01 06:05:58 发布
最新推荐文章于 2023-02-01 06:05:58 发布
阅读量182 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/zhabayi/p/6479791.html
版权

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

    xsi:schemaLocation="
            http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd     
              http://www.springframework.org/schema/tx 
              http://www.springframework.org/schema/tx/spring-tx.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
            http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/task
            http://www.springframework.org/schema/task/spring-task.xsd 
              ">


    <!-- 把那个类注入进来 -->
    <bean id="sleepHelper" class="com.test.aop.SleepHelper"/>
    <bean id="human" class="com.test.aop.Human"/>

    <!-- 配置一个切点 -->
    <!-- 配置切点有好几种表达方式 1、配置aspectJ 2.使用正则表达式， 以下使用的是正则表达式 -->
    <!-- pattern属性指定了正则表达式，它匹配所有的sleep方法 -->
    
    <bean id="spleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*sleep" />
    </bean>

    <!-- 切点仅仅是定义了故事发生的地点，还有故事发生的时间以及最重要的故事的内容,就是通知了，我们需要把通知跟切点结合起来，我们要使用的通知者是: -->
    
    <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="sleepHelper" />
        <property name="pointcut" ref="spleepPointcut" />
    </bean>
    <!-- 切入点和通知都配置完成，接下来该调用ProxyFactoryBean产生代理对象了 -->
    <!-- ProxyFactoryBean是一个代理，我们可以把它转换为proxyInterfaces中指定的实现该interface的代理对象: -->
    <bean id="humanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="human" />
        <property name="interceptorNames" value="sleepHelperAdvisor" />
        <property name="proxyInterfaces" value="com.test.aop.Sleepable" />
    </bean>

</beans>

 

//实现接口

package com.test.aop;

public class Human implements Sleepable {

    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("睡觉啦，哈哈");
    }
    
    
}

//定义一个接口实现jdk代理

package com.test.aop;
public interface Sleepable {
    
    void sleep();
}

//实现前后通知
package com.test.aop;

import Java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{

    @Override
    public void afterReturning(Object returnValue, Method method,
            Object[] args, Object target) throws Throwable {
        niaho();
    }

    @Override
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        enen();
    }
    public void niaho(){
        System.out.println("调用前，你应该做的是");
    }
    public void enen(){
        System.out.println("调用后你应该做的事");
    }

}

 

测试创建ioc容器
package com.test.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Tests {

    public static void main(String[] args){
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring/applicationContext-aop1.xml");
        Sleepable sleeper = (Sleepable)appCtx.getBean("humanProxy");
        sleeper.sleep();
        }
}

 

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

    xsi:schemaLocation="
            http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd     
              http://www.springframework.org/schema/tx 
              http://www.springframework.org/schema/tx/spring-tx.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
            http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/task
            http://www.springframework.org/schema/task/spring-task.xsd 
              ">

    <bean id="sleepHelper" class="com.test.aop2.SleepHelper" />

    <bean id="sleepAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="sleepHelper"></property>
        <property name="pattern" value=".*sleep"></property>
    </bean>

    <bean id="human" class="com.test.aop2.Human" />

    <bean
        class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
</beans>

package com.test.aop2;
public class Human implements Sleepable {

    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("睡觉啦，哈哈");
    }
}

package com.test.aop2;
public interface Sleepable {
    
    void sleep();
}

package com.test.aop2;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

public class SleepHelper implements MethodBeforeAdvice,AfterReturningAdvice{

    @Override
    public void afterReturning(Object returnValue, Method method,
            Object[] args, Object target) throws Throwable {
        niaho();
    }

    @Override
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        enen();
    }
    public void niaho(){
        System.out.println("调用前，你应该做的是");
    }
    public void enen(){
        System.out.println("调用后你应该做的事");
    }

}

package com.test.aop2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Tests {

    public static void main(String[] args){
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring/applicationContext-aop2.xml");
        Sleepable sleeper = (Sleepable)appCtx.getBean("human");
        sleeper.sleep();
        }
}

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

    xsi:schemaLocation="
            http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd     
              http://www.springframework.org/schema/tx 
              http://www.springframework.org/schema/tx/spring-tx.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
            http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/task
            http://www.springframework.org/schema/task/spring-task.xsd 
              ">
<!--               自动扫描@Aspect注解 -->
        <aop:aspectj-autoproxy/>
        <context:component-scan base-package="com.test.aop3"/>
    
</beans>

package com.test.aop3;
import org.springframework.stereotype.Component;
@Component
public class Human implements Sleepable {

    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("睡觉啦，哈哈");
    }
}

 

package com.test.aop3;
import org.springframework.stereotype.Component;
@Component
public interface Sleepable {
    
    void sleep();
}

package com.test.aop3;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class SleepHelper{

    public SleepHelper(){

    }
    @Pointcut("execution(* *.sleep())")
    public void sleeppoint(){}

    @Before("sleeppoint()")
    public void beforeSleep(){
        System.out.println("睡觉前需要脱衣服");
    }
    @After("sleeppoint()")
    public void aftersleep(){
        System.out.println("睡醒了要睁眼");
    }

}

package com.test.aop3;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Tests {

    public static void main(String[] args){
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring/applicationContext-aop3.xml");
        Sleepable sleeper = (Sleepable)appCtx.getBean("human");
        sleeper.sleep();
        }
}



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

    xsi:schemaLocation="
            http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans.xsd     
              http://www.springframework.org/schema/tx 
              http://www.springframework.org/schema/tx/spring-tx.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
            http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/task
            http://www.springframework.org/schema/task/spring-task.xsd 
              ">
<!--               自动扫描@Aspect注解 -->
        <context:component-scan base-package="com.test.aop4"/>
        
    <aop:config>
        <aop:aspect ref="SleepHelper">
            <aop:before method="beforeSleep" pointcut="execution(* *.sleep(..))"/>
            <aop:after method="afterSleep" pointcut="execution(* *.sleep(..))"/>
        </aop:aspect>
    </aop:config>
    
</beans>

package com.test.aop4;
import org.springframework.stereotype.Component;
@Component
public class Human implements Sleepable {
    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("睡觉啦，哈哈");
    }
}

package com.test.aop4;
import org.springframework.stereotype.Component;
@Component
public interface Sleepable {
    
    void sleep();
}

package com.test.aop3;
import org.springframework.stereotype.Component;
@Component
public class Human implements Sleepable {

    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("睡觉啦，哈哈");
    }
}

package com.test.aop4;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Tests {
    public static void main(String[] args){
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring/applicationContext-aop4.xml");
        Sleepable sleeper = (Sleepable)appCtx.getBean("human");
        sleeper.sleep();
        }
}

转载于:https://www.cnblogs.com/zhabayi/p/6479791.html

avj65874
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java切面的实现方式
weixin_49151141的博客
04-04 5034
是指在软件开发中，将某些横跨多个组件的功能，如日志记录、性能监控、权限控制等，抽象出来形成一个独立的模块，称之为切面。切面可以被应用到多个模块中，提供相同的功能。基于继承的切面实现 这种实现方式需要通过继承的方式实现，具体操作为：首先定义一个抽象类，实现该类时可以重写一些方法，从而达到切面的目的。以上是三种实现切面的方式，分别基于继承、代理和注解。其中，基于注解的方式是。的实现方式，而基于继承和代理的方式可以使用。中实现切面的技术有多种，下面分别介绍。
Spring面向切面编程(AOP)方式二
光何
01-01 158
使用注解进行实现：减少xml文件的配置。 1 建立切面类 不需要实现任何特定接口，按照需要自己定义通知。 package org.guangsoft.utils; import java.util.Date; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; i
spring-aop切面实现
x_u_xiang的博客
02-16 363
aop是什么 我们将记录日志功能解耦为日志切面，它的目标是解耦。进而引出AOP的理念：就是将分散在各个业务逻辑代码中相同的代码通过横向切割的方式抽取到一个独立的模块中！ 著作权归https://pdai.tech所有。 AOP 有哪些应用场景？ 举几个例子： 记录日志(调用方法后记录日志) 监控性能(统计方法运行时间) 权限控制(调用方法前校验是否有权限) 事务管理(调用方法前开启事务，调用方法后提交关闭事务 ) 缓存优化(第一次调用查询数据库，将查询结果放入内存对象， 第二次调用，...
spring-aop 三种实现切面的方式
butcher的博客
07-09 8492
1、概念 AOP (Aspect Oriented Programming)意为∶面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、实现方式 使用之前需要导入aspectj织入包 <dependency> &
Spring-aop实现切面的四种方式 上篇
热门推荐
Seven__________7的博客
11-08 1万+
Spring实现AOP的4种方式     先了解AOP的相关术语: 1.通知(Advice): 通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。 2.连接点(Joinpoint): 程序能够应用通知的一 个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。 3.切入点(Pointcut) 通知定义了切面要发生的“故事”和时间，那么
AOP切面的实现
gonglei181818的博客
07-25 894
AOP切面的实现 AOP的全称是Aspect Orient Programming，即面向切面编程。是对OOP（Object Orient Programming）的一种补充，战门用于处理一些具有横切性质的服务。常常用于日志输出、安全控制等。 最近遇到增加操作日志记录功能问题，网上推荐使用切面技术实现，可以在不修改其它模块代码的前提下实现各个模块日志记录。 实现方法： 第一步：添加切面注解@Asp...
Spring面向切面编程AOP的三种方式!史上最详细
qq_40631968的博客
10-09 868
123
spring-aop面向切面系统日志案例
07-17
在IT行业中，Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的核心特性之一，它使得我们能够以一种声明式的方式处理系统中的横切关注点，如日志记录、事务管理、性能监控等。这个“spring-...
16.2 Spring框架-AOP面向切面编程
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
spring-aop-jar
12-14
Spring AOP模块提供了实现AOP规范的功能，它允许开发者定义“切面”来封装系统中的横切关注点，如日志、事务管理等。该jar文件包含了Spring AOP的核心类和接口，如`org.springframework.aop.*`包下的`...
AVProVideo19年8月版本超新.rar
06-04
网上多是17年 16年 18年版本。这个是19，20最新版。超级好用2018版本也支持！
aop的四种实现方式
05-07
aop的四种实现方式代码示例，包括javassist cglib instrument dynamicproxy四种，里面都有注释。
最简单的aop切面方法
01-18
最简单的aop切面方法，配置好后，自动扫描需要切面的方法，无需添加其他冗余代码。简洁实用@！@
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
spring-aop切面编程使用
04-27
最近公司要求和别的公司对接，但是不想破坏原有的架构，就只有用切面了，百度了下都不全面，就自己写了个小demo，只要导入spring4.2.3的jar就直接可以用，注解实现spingaop机制，1分意思下
面向切面编程的两种实现
yunshixin的专栏
09-05 9729
1、面向切面的定义自行百度 2、面向切面编程的应用场景自己想象，大概就是日志之类的地方 3、上面两句话基本是废话 实现方式一，在XML中声明切面 1、编写一个原始类 package com.hsb.beans; import org.springframework.stereotype.Repository; @Repository public class Perform
Spring AOP面向切面的2种实现方式
小道士写程序
02-01 176
面向切面-的实现方式（基于JDK代理例子）
AOP解析——含简单AOP框架实现（包括Proxy模式实现与Attribute实现）实现Castle的AR事务低侵入性...
weixin_30737363的博客
03-09 446
AOP简介： AOP（Aspect Oriented Programming）“面向切面编程”，其实和OOP（Object Oriented Programming）“面向对象编程”一样是一种编程思路，而且个人以为翻译为“切面导向编程”更为妥当，OOP也应翻译为“对象导向编程”。因为正是有了“切面”和“对象”的想法和概念才产生了“Aspect Oriented Programming”和“Obj...
Spring中的AOP切面编程的三种实现方式
xzy的博客
03-09 1666
文章目录Spring中的AOP切面编程的三种实现方式1.最基本AOP的实现a.引入jar包b.编写通知类，这里以后置通知和环绕通知类为例子进行说明c.在SpringIOC容器中配置d.测试2.使用注解对AOP进行实现a.引入jar包b.编写基于注解的AOP通知类c.在SpringIOC容器中配置d.测试3.基于自定义形式的AOP的实现a.引入jar包b.编写基于自定义形式的AOP切面编程类c.在SpringIOC容器中配置切入点execution的使用方法 Spring中的AOP切面编程的三种实现方式 1.
spring-aop四个切面的实现
最新发布
06-29
Spring AOP (Aspect-Oriented Programming) 的四个主要切面通常包括：通知（Advice）、切入点（Pointcut）、连接点（Join Point）和切面（Aspect）。下面是它们的简要介绍： 1. **通知（Advice）** - 是AOP的核心，它是定义在切面中的行为，可以是前置通知（Before）、后置通知（After）、返回通知（After Returning）或异常通知（AfterThrowing）。通知可以在特定的连接点执行，如方法调用前后。 ```java @Before("execution(* com.example.service.*(..))") // 前置通知 public void beforeAdvice(JoinPoint joinPoint) { // 业务逻辑... } ``` 2. **切入点（Pointcut）** - 定义了通知应该何时执行，它描述了一个或者一组方法签名。Spring AOP使用Spring Expression Language (SpEL) 来编写表达式来匹配方法或类型。 3. **连接点（Join Point）** - 是AOP的核心概念，它是指程序执行过程中的一个特定时刻，比如方法调用、构造函数调用等。通知就是在这些连接点上插入的。 4. **切面（Aspect）** - 是一个模块化的、可重用的代码单元，它包含了一组相关的通知。切面由一个或多个通知组成，它们共享相同的切入点。 例如，一个简单的切面可能如下定义： ```java @Aspect @Component public class LoggingAspect { @Before("execution(* com.example.service.*(..))") public void logBefore(JoinPoint joinPoint) { // 打印日志... } // 其他通知... } ``` 这里，`LoggingAspect`是一个切面，它定义了一个`logBefore`前置通知，会在`com.example.service`包下的所有方法执行之前被调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值