`
weinan
  • 浏览: 39492 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

spring中AOP实现的4中方式

spring中AOP实现的4中方式aop 
阅读更多
引用
配置可以通过xml文件来进行，大概有四种方式：

1.  配置ProxyFactoryBean，显式地设置advisors, advice, target等

2.  配置AutoProxyCreator，这种方式下，还是如以前一样使用定义的bean，但是从容器中获得的其实已经是代理对象

3.  通过<aop: aspectj-autoproxy>来配置，使用AspectJ的注解来标识通知及切入点

4.  通过<aop:config>来配置

一、基于代理的AOP
1、创建通知 
package com.demo.aop.bean;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
/**
 * 通知
 *
 */
public class ActionAdvice implements MethodBeforeAdvice,AfterReturningAdvice{

    public void afterReturning(Object returnValue, Method method,
            Object[] args, Object target) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("执行方法之后调用"+System.currentTimeMillis());
    }

    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("执行方法之前调用"+System.currentTimeMillis());
        
    }

}

2、Service层 

package com.demo.aop.service;

public interface IPersonService {
    public void doUpdate();
}

3、Service实现层 
package com.demo.aop.service.impl;

import org.springframework.stereotype.Component;

import com.demo.aop.service.IPersonService;

public class PersonService implements IPersonService {

    public void doUpdate() {
        // TODO Auto-generated method stub
        System.out.println("执行更新方法"+System.currentTimeMillis());
    }

}

4、文件配置
第一种：不实用自动代理 
<?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:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
    <!-- 基于代理的AOP -->
    <!-- 创建通知 -->
    <bean id="actionAdvice" class="com.demo.aop.bean.ActionAdvice" />
    <!-- 使用正则表达式切点 -->
    <bean id="actionPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*doUpdate" />
    </bean>
    <!-- 通知 与切点结合-->
    <bean id="actionAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="actionAdvice" />
        <property name="pointcut" ref="actionPointcut" />
    </bean>
    <!-- 代理对象 -->
    <bean id="actionProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="personService" />
        <property name="interceptorNames" value="actionAdvisor" />
        <property name="proxyInterfaces" value="com.demo.aop.service.IPersonService" />
    </bean><!--此种代理，创建：IPersonService actionProxy声明，使用代理进行调用 -->
    <bean id="personService" class="com.demo.aop.service.impl.PersonService"/>
    
</beans>

第二种：使用自动代理 
<?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:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd">
    <!-- 基于代理的AOP -->
    <!-- 创建通知 -->
    <bean id="actionAdvice" class="com.demo.aop.bean.ActionAdvice" />
    <!-- 使用正则表达式切点 -->
    <bean id="actionPointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut">
        <property name="pattern" value=".*doUpdate" />
    </bean>
    <!-- 通知 与切点结合-->
    <bean id="actionAdvisor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
        <property name="advice" ref="actionAdvice" />
        <property name="pointcut" ref="actionPointcut" />
    </bean>
    <!-- 代理对象 -->
    <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/> <!--自动代理，创建对象正常使用，会在调用指定方法时进行执行-->
    <bean id="personService" class="com.demo.aop.service.impl.PersonService"/>
    
</beans>　

5、测试
第一种：不使用自动代理情况下，注意创建对象时要将代理注入 
package com.demo.aop.AopTest;

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.SpringJUnit4ClassRunner;

import com.demo.aop.service.IPersonService;

/**
 * 测试基于代理的AOP
 * @author wwl
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/spring/context-aop.xml" })
public class AopTest {
    /**
     * 用接口声明，注入代理对象
     */
    @Autowired
    private IPersonService actionProxy;
    @Test
    public void testAop(){
        actionProxy.doUpdate();
    }
}

第二种：使用自动代理 
package com.demo.aop.AopTest;

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.SpringJUnit4ClassRunner;

import com.demo.aop.service.IPersonService;

/**
 * 测试基于代理的AOP
 * @author wwl
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/spring/context-aop.xml" })
public class AopTest {
       /**
     * 自动创建代理
     */
    @Autowired
    private IPersonService personService;
    @Test
    public void testAop(){
        personService.doUpdate();
    }
}

二、使用AspectJ提供的注解
1、创建通知 
package com.demo.aop.bean;

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;
/**
 * 通知
 *
 */
@Component
@Aspect
public class Action1Advice{
    @Pointcut("execution(* *.doUpdate())")
    public void actionPoint(){}
    
    @AfterReturning("actionPoint()")
    public void afterAction(){
        System.out.println("执行方法之后调用"+System.currentTimeMillis());
    }
    @Before("actionPoint()")
    public void beforeAction(){
        System.out.println("执行方法之前调用"+System.currentTimeMillis());
        
    }

}

2、Service层 

package com.demo.aop.service;

public interface IPersonService {
    public void doUpdate();
}

3、Service实现层 
package com.demo.aop.service.impl;

import org.springframework.stereotype.Component;

import com.demo.aop.service.IPersonService;
@Component
public class PersonService implements IPersonService {

    public void doUpdate() {
        // TODO Auto-generated method stub
        System.out.println("执行更新方法"+System.currentTimeMillis());
    }

}

4、文件配置 
<?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:util="http://www.springframework.org/schema/util"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"   
    xsi:schemaLocation="
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd  ">
    <!-- @AspectJ注解 -->
    <!-- 激活组件扫描功能-->
    <context:component-scan base-package="com.demo"/>
    <!-- 激活自动代理功能 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

5、测试 
package com.demo.aop.AopTest;

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.SpringJUnit4ClassRunner;

import com.demo.aop.service.IPersonService;

/**
 * 测试使用AspectJ提供的注解切面
 * @author wwl
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:/spring/context-aop1.xml" })
public class Aop1Test {
    @Autowired
    private IPersonService personService;
    @Test
    public void testAop(){
        personService.doUpdate();
    }
}

三、纯POJO切面（不使用注解，只在配置中注入）
1、创建通知 
package com.demo.aop.bean;
import org.springframework.stereotype.Component;
/**
 * 通知
 *
 */
@Component
public class Action1Advice{

    public void afterAction(){
        System.out.println("执行方法之后调用"+System.currentTimeMillis());
    }
    public void beforeAction(){
        System.out.println("执行方法之前调用"+System.currentTimeMillis());
        
    }

}

2、Service层 
...........

3、Service实现层 
...........

4、文件配置 
<?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:util="http://www.springframework.org/schema/util"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd  ">
    <!-- @AspectJ注解 -->
    <!-- 激活组件扫描功能 -->
    <context:component-scan base-package="com.demo" />

    <aop:config>
        <aop:aspect ref="action1Advice">
            <aop:before method="beforeAction" pointcut="execution(* *.doUpdate(..))" />
            <aop:after method="afterAction" pointcut="execution(* *.doUpdate(..))" />
        </aop:aspect>
    </aop:config>
　<!--或者-->

<!--

　　<aop:config>
　　　　<aop:pointcut id="myPointcut" expression="execution(* *.doUpdate(..))"/>
　　　　<aop:aspect id="action1Advice" ref="action1Advice" >
　　　　　　　　<aop:before method="beforeAction" pointcut-ref="myPointcut"/>
　　　　　　　　<aop:after method="afterAction" pointcut-ref="myPointcut"/>
　　　　</aop:aspect>
　　</aop:config>

-->



</beans>

5、测试
引用


...

总结：总体看其实两种方式，一种是使用代理，一种是使用AOP（是否使用注解）。

流程：先创建通知，创建切点，再将通知与切点绑定使用代理进行处理调用


分享到：
| Java多线程系列--synchronized关键字
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring实现AOP的4种方式

    本篇文章将详细探讨Spring实现AOP的四种主要方法：基于代理的方式、基于AspectJ的注解方式、基于XML的AOP配置以及基于Java的AOP配置。 1. 基于代理的实现 Spring的AOP支持两种代理类型：JDK动态代理和CGLIB代理。...

    Spring实现AOP的4种方式 - Java -

    在实际开发中，理解并掌握这四种AOP实现方式对于编写高效、灵活的代码至关重要。Spring的AOP特性使得我们能够更好地组织代码，将横切关注点与业务逻辑分离，从而提升代码的可重用性和可测试性。在学习和应用这些知识...

    Spring实现AOP的四种方式

    本文将详细介绍Spring实现AOP的四种方式，包括基于代理的经典方式、@AspectJ注解驱动、纯POJO切面以及注入式AspectJ切面。 首先，理解AOP的基本概念： 1. **通知(Advice)**：通知定义了切面在何时执行，Spring支持...

    Spring AOP 常用的四种实现方式

    本篇文章将深入探讨Spring AOP的四种常见实现方式。 一、基于接口的代理（Interface-Based Proxy） 这是Spring AOP最基础的实现方式，适用于目标对象实现了特定接口的情况。Spring会创建一个代理对象，该对象实现...

    基于注解实现SpringAop

    基于注解实现SpringAop基于注解实现SpringAop基于注解实现SpringAop

    研究下Spring中AOP的实现？

    Spring AOP有两种实现方式：代理模式和注解驱动。代理模式分为JDK动态代理和CGLIB代理。JDK动态代理适用于实现了接口的目标对象，它通过实现InvocationHandler接口创建代理对象。而CGLIB代理则是在运行时为类生成...

    Spring AOP实现机制

    Spring AOP主要通过两种方式实现：JDK动态代理和CGLIB代理。 - **JDK动态代理**： - 当目标对象实现了至少一个接口时，Spring会使用JDK的java.lang.reflect.Proxy类创建一个代理对象。 - 代理对象在调用实际方法...

    spring-aop-jar

    它被许多AOP框架使用，包括Spring，使得不同的AOP实现可以互相协作。它包含如`org.aopalliance.intercept.MethodInterceptor`和`org.aopalliance.aop.Advice`等核心接口。 2. spring-aop-4.1.6.RELEASE.jar：这是...

    spring aop demo 两种实现方式

    压缩包中的"aop"文件可能包含了一个简单的Spring AOP示例项目，包括了上述两种实现方式的源代码和配置文件。下载后，可以直接运行以观察AOP如何工作。 总结来说，Spring AOP提供了一种强大的方式来实现横切关注点，...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf

    在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态代理。 JDK 动态代理是基于接口的，它要求被代理的目标对象必须实现至少一个接口。Spring 使用 `java.lang.reflect.Proxy`...

    使用Spring的注解方式实现AOP的细节

    在Spring框架中，面向切面编程（AOP）是一种强大的工具，它允许程序员定义横切关注点，如日志、事务管理、权限控制等，这些关注点可以被模块化并独立于业务逻辑进行处理。本篇文章将深入探讨如何通过Spring的注解...

    spring基于AOP实现事务

    总结一下，Spring基于AOP实现的事务管理通过TransactionProxyFactoryBean，结合声明式事务配置，能够提供一种高效且易于维护的事务解决方案。它允许我们在不修改业务逻辑的情况下，统一管理和控制事务，提升了代码的...

    Spring实现AOP的四种方式.pdf

    Spring 实现 AOP 的四种方式 Spring 框架提供了四种方式来实现Aspect-Oriented Programming（AOP），分别是经典的基于代理的 AOP、@AspectJ 注解驱动的切面、纯 POJO 切面和注入式 AspectJ 切面。下面将详细介绍这...

    spring aop实现原理

    NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927

    spring的aop实现

    Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许开发者在不修改源代码的情况下，...在压缩包文件"springAop"中，可能包含了示例代码和配置文件，通过学习这些内容，你可以更好地理解和实践Spring AOP。

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理）

    Spring框架中的AOP模块使用了动态代理来实现AOP概念。Spring AOP允许开发者定义切面，并在这些切面中指定拦截的方法。Spring AOP支持不同的代理策略，包括JDK动态代理和CGLIB代理。如果被代理的类没有实现接口，...

    初探spring aop内部实现 java

    Spring AOP的实现主要依赖于两种技术：动态代理和AspectJ。对于接口，Spring使用Java动态代理（JDK Proxy）创建代理对象；而对于类，Spring则使用CGLIB库生成子类代理。这两种方式都是在运行时生成代理对象，从而在...

    Spring实现AOP的多种方式 切点函数

    里面包括4个例子：（1）Spring实现AOP方式之一：基于XML配置的Spring AOP (2)Spring实现AOP方式之二：使用注解配置 Spring AOP (3)Spring AOP : AspectJ Pointcut 切点 (4)Spring AOP : Advice 声明 （通知注解）

    spring-boot aop

    Spring Boot AOP（面向切面编程）是一种强大的设计模式，它允许我们在不修改现有代码的情况下，插入额外的功能或监控代码。在Spring框架中，AOP主要用于日志记录、事务管理、性能统计等场景。本示例是关于如何在...

    Spring AOP的简单实现

    在Spring AOP中，切面可以通过两种方式定义：使用注解或者XML配置。在这个例子中，我们可能会选择注解方式，因为它更简洁且易于理解。 1. **创建切面类（Aspect）** 我们可以创建一个名为`LoggingAspect`的Java类...

Magicbox
Global site tag (gtag.js) - Google Analytics