spring AOP 的几种实现方式(能测试)

我们经常会用到的有如下几种
1、基于代理的AOP
2、纯简单Java对象切面
3、@Aspect注解形式的
4、注入形式的Aspcet切面

一、需要的java文件

public class ChenLliNa implements Sleepable {  

    @Override
    public void sleep() {
        // TODO Auto-generated method stub
        System.out.println("乖,该睡觉了！s");
    }

    public void sleep2() {
        // TODO Auto-generated method stub
        System.out.println("乖,该睡觉了！2222");
    }
}  
public interface Sleepable {  

    /**
     * 睡觉方法
     * @author demo
     * @version 2015年5月31日上午9:17:14
     */
    void sleep();
} 
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 {
         System.out.println("睡觉前要敷面膜");
    }  

    @Override
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("睡觉后要做美梦");
    }  

}  
public class SleepHelper02 {
    public void beforeSleep(){
        System.out.println("睡觉前要敷面膜");
    }
    public void afterSleep(){
        System.out.println("睡觉后要做美梦");
    }
} 
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class SleepHelper03 {      

    @Pointcut("execution(* *.sleep2(..))")
    public void sleep2point(){}  

    @Before("sleep2point()")
    public void beforeSleep(){
        System.out.println("睡觉前要敷面膜dddd");
    }  

    @AfterReturning("sleep2point()")
    public void afterSleep(){
        System.out.println("睡觉后要做美梦dd");
    }
}

二、application.xml

<!--  applicationContext01.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <!-- 创建一个增强 advice -->
    <bean id="sleepHelper" class="com.ideal.spdb.common.demo.SleepHelper" />

    <bean id="lina" class="com.ideal.spdb.common.demo.ChenLliNa" />
    <!-- 定义切点 匹配所有的sleep方法 -->
    <bean id="sleepPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*sleep"></property>
    </bean>

    <!-- 切面 增强+切点结合 -->
    <bean id="sleepHelperAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="sleepHelper" />
        <property name="pointcut" ref="sleepPointcut" />
    </bean>

    <!-- 定义代理对象 -->
    <bean id="linaProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="lina" />
        <property name="interceptorNames" value="sleepHelperAdvisor" />
        <!-- <property name="proxyInterfaces" value="com.tgb.springaop.service.Sleepable"/> -->
    </bean>

</beans>
<!-- applicationContext02.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <!-- 创建一个增强 advice -->
    <bean id="sleepHelper" class="com.ideal.spdb.common.demo.SleepHelper" />
    <!-- 目标类 -->
    <bean id="lina" class="com.ideal.spdb.common.demo.ChenLliNa" />

    <!-- 配置切点和通知 -->
    <bean id="sleepAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="sleepHelper"></property>
        <property name="pattern" value=".*sleep" />
    </bean>

    <!-- 自动代理配置 -->
    <bean
        class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
</beans>
<!-- applicationContext03.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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <!--扫描包 -->
     <context:component-scan base-package="com.ideal.spdb.*.*" annotation-config="true"/>
     <!-- ASPECTJ注解 -->
     <aop:aspectj-autoproxy  proxy-target-class="true" />    

     <!-- 目标类 -->
      <bean id="lina" class="com.ideal.spdb.common.demo.ChenLliNa"/>

</beans>
<!-- applicationContext04.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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <!-- 目标类 -->
    <bean id="lina" class="com.ideal.spdb.common.demo.ChenLliNa"/>
    <bean id ="sleepHelper" class="com.ideal.spdb.common.demo.SleepHelper02"/>  

    <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>

三、测试

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

import com.ideal.spdb.common.demo.ChenLliNa;
import com.ideal.spdb.common.demo.Sleepable;

public final class Boot {

    @Test
    public void test0() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        FooService foo = (FooService) ctx.getBean("fooService");
        foo.getFoo("Pengo", 12);
        foo.setFoo("d", 1);

    }

//    通过代理
    @Test
    public void test1() {
        ApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext01.xml");

        Sleepable sleeper = (Sleepable) ct.getBean("linaProxy");

        sleeper.sleep();

    }
//    简答的java对象
    @Test
    public void test2() {
        ApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext02.xml");

        Sleepable sleeper = (Sleepable) ct.getBean("lina");

        sleeper.sleep();

    }
//    通过aspect注解
    @Test
    public void test3() {
        ApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext03.xml");

        ChenLliNa sleeper = (ChenLliNa) ct.getBean("lina");

        sleeper.sleep2();
    }
//    通过apsect配置文件
    @Test
    public void test4() {
        ApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext04.xml");
        Sleepable sleeper = (Sleepable) ct.getBean("lina");

        sleeper.sleep();
    }
}

四、环绕模式

public class DefaultFooService implements FooService {

    public Foo getFoo(String name, int age) {
        try {
            new Thread().sleep(1000);
        } catch (Exception e) {

        }
        return new Foo(name, age);
    }

    @Override
    public Foo setFoo(String fooName, int age) {
        return null;
    }
}
public class Foo {
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }

    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }

    private String name;
    private int age;

    public Foo(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

}
public interface FooService {
    Foo getFoo(String fooName, int age);
    Foo setFoo(String fooName, int age);
}
import java.text.SimpleDateFormat;
import java.util.Date;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.util.StopWatch;
public class SimpleProfiler {

    public void monit(ProceedingJoinPoint call) throws Throwable {
        StopWatch clock = new StopWatch();
        try {
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            clock.start(call.toShortString());
            call.proceed();
            System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        } finally {
            clock.stop();
            System.out.println(clock.getLastTaskName());
            System.out.println(clock.getTotalTimeSeconds());
        }
    }
}
<!-- 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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">

    <bean id="fooService" class="com.ideal.spdb.common.demo.DefaultFooService" />

    <bean id="profiler" class="com.ideal.spdb.common.demo.SimpleProfiler" />

    <aop:config>
        <aop:aspect ref="profiler">
            <aop:pointcut id="theExecutionOfSomeFooServiceMethod"
                expression="execution(* com.ideal.spdb.*.*.*.*(..))" />
            <aop:around pointcut-ref="theExecutionOfSomeFooServiceMethod"
                method="monit" />
        </aop:aspect>
    </aop:config>

</beans>

测试在上面的

Boot -> method = test0
时间： 2025-01-02 15:23:57

spring AOP 的几种实现方式(能测试)的相关文章

Java Spring AOP的两种配置方式

第一种:注解配置AOP java中注解配置AOP(使用 AspectJ 类库实现的),大致分为三步: 1. 使用注解@Aspect来定义一个切面,在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around).2. 开发需要被拦截的类.3. 将切面配置到xml中,当然,我们也可以使用自动扫描Bean的方式.这样的话,那就交由Spring AoP容器管理. 另外需要引用 aspectJ 的 jar

spring AOP的两种配置方式

连接点(JoinPoint) ,就是spring允许你是通知(Advice)的地方,那可就真多了,基本每个方法的前.后(两者都有也行),或抛出异常是时都可以是连接点,spring只支持方法连接点.其他如AspectJ还可以让你在构造器或属性注入时都行,不过那不是咱们关注的,只要记住,和方法有关的前前后后都是连接点. 方式一:xml方式配置 1.配置xml文件 <bean id="dataSourceExchange" class="com.ooper.www.datas

spring ----&gt; aop的两种实现方式

实现1:基于xml 1 package com.rr.spring3.interf; //接口 2 3 public interface SayHello { 4 5 public void sayHello(); 6 } 1 package com.rr.spring3.interf.impl; //接口实现类 2 3 import com.rr.spring3.interf.SayHello; 4 5 public class Hello implements SayHello { 6 pu

AOP的两种实现方式

技术交流群 :233513714 AOP,面向切面编程,可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术.    Aspect Oriented Programming(AOP),是目前软件开发中的一个热点,也是Spring框架中的一个重要内容.利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率.  有两种方式可以实现aop,一种是根据利用jdk自带的proxy,另外一种是利用c

spring定时任务的几种实现方式

Spring定时任务的几种实现 近日项目开发中需要执行一些定时任务,比如需要在每天凌晨时候,分析一次前一天的日志信息,借此机会整理了一下定时任务的几种实现方式,由于项目采用spring框架,所以我都将结合 spring框架来介绍. 一．分类 从实现的技术上来分类,目前主要有三种技术(或者说有三种产品): Java自带的java.util.Timer类,这个类允许你调度一个java.util.TimerTask任务.使用这种方式可以让你的程序按照某一个频度执行,但不能在指定时间运行.一般用的较少,

Spring事务的五种实现方式

前段时间对spring的事务配置做了比较深入的研究,在此之间对Spring的事务配置虽说也配置过,但是一直没有一个清楚的认识.通过这次的学习发觉Spring的事务配置只要把思路理清,还是比较好掌握的. 总结如下: Spring配置文件中关于事务配置总是由三个组成部分,分别是DataSource.TransactionManager和代理机制这三部分,无论哪种配置方式,一般变化的只是代理机制这部分. DataSource.TransactionManager这两部分只是会根据数据访问方式有所变化,

Spring IOC的三种注入方式

Spring IOC三种注入方式: 1.    接口注入 2.    getter,setter方式注入 3.    构造器注入 对象与对象之间的关系可以简单的理解为对象之间的依赖关系:A类需要B类的一个实例来进行某些操作,比如在A类的方法中需要调用B类的方法来完成功能,叫做A类依赖于B类.控制反转是一种将组件依赖关系的创建和管理置于程序外部的技术,由容器控制程序之间的关系,而不是由代码直接控制. 1.接口注入 public class ClassA {  private InterfaceB

Spring IOC 中三种注入方式

项目错误知识点记录 正文 最近在项目的时候,用到Spring框架,Spring框架提供了一种IOC的自动注入功能,可以很轻松的帮助我们创建一个Bean,这样就省的我们四处写new Object()这样的代码了.IOC提供了三种注入方式,接口注入,set方法注入以及构造器注入,三种注入方式使用起来都很easy,具体的使用方法网上都有很多,大家可以自行搜索百度... 那天当我使用接口注入的时候,发现IDEA给我一个警告(以前也有这样的警告,只不过我没太注意),看了看是让我采用构造器注入方式.这就让我

Spring与Hibernate两种组合方式

Spring与Hibernate大致有两种组合方式,主要区别是一种是在Hibernate中的hibernate.cfg.xml中配置数据源,一种是借助Spring的jdbc方式在Spring的applicationContext.xml文件中配置数据源,然后在Spring配置sessionFactory的bean有些区别 下面大致的说明一下 第一种 1.hibernate.cfg.xml文件 xml version='1.0' encoding='utf-8'?> "-//Hibernat