spring - AOP 使用方式（二）

这里介绍spring-aop使用方式二，spring配置文件的方式来使用AOP。

spring-applicationContext.xml 部分代码配制如下：

  1. <!-- component scan -->
  2. <context:component-scan base-package="com.lw.rpc"
  3. use-default-filters="false">
  4. <context:include-filter type="annotation"
  5. expression="org.springframework.stereotype.Repository" />
  6. <context:include-filter type="annotation"
  7. expression="org.springframework.stereotype.Service" />
  8. </context:component-scan>
  9. <!-- 声明通知类 -->
  10. <bean id="aspectJAdviceAop" class="com.lw.rpc.test.AspectJAdviceAop" />
  11. <aop:config>
  12. <aop:aspect id="useAapect" ref="aspectJAdviceAop" >
  13. <!-- 配置切点 -->
  14. <aop:pointcut expression="execution(* com.lw.rpc..*.*(..))" id="point_cut"/>
  15. <!-- 前置通知 -->
  16. <aop:before method="beforeAdvice" pointcut-ref="point_cut"/>
  17. <!-- <aop:pointcut id="except_add" expression="execution(* com.lw.rpc..*.*(..)))" /> -->
  18. <!--后置通知 returning指定返回参数  ，如果不设置这个返回参数，你可以亲自试一下，看看是什么效果-->
  19. <!-- <aop:after-returning method="afterAdvice" pointcut-ref="point_cut" returning="result" /> -->
  20. <!--环绕  -->
  21. <!-- <aop:around method="aroundAdvice" pointcut-ref="point_cut"/> -->
  22. <!--throw中  -->
  23. <!-- <aop:after-throwing method="afterThrow" pointcut-ref="point_cut" throwing="e"/> -->
  24. </aop:aspect>
  25. </aop:config>

通知类如下，该类里面实现那四种方式的AOP拦截。

package com.lw.rpc.test;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

public class AspectJAdviceAop {

/**

* 前置通知

*

* @param jp

*/

public void beforeAdvice(JoinPoint jp) {

System.out.println(" 进入连接点前 +++++++++++++++ ");

System.out.println(jp.getTarget().getClass() + "对象正在用这个");

System.out.println(jp.getArgs()[0] + "test");

System.out.println(" 进入到连接点点方法 ");

}

/**

* 后置通知

*

* @param jp

*/

public void afterAdvice(JoinPoint jp, String result) {

System.out.println(" 连接点方法执行完成后 +++++++++++++++ ");

System.out.println(jp.getTarget().getClass() + "对象正在用这个");

System.out.println(jp.getSignature().getName() + "方法");

System.out.println("结果：" + result);

}

/**

* 环绕通知

*

* @param jp

* @param result

* @throws Throwable

*/

public void aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {

System.out.println(" 进入到环绕通知  +++++++++++++++ ");

// 调用方法的参数

Object[] args = pjp.getArgs();

// 调用的方法名

String method = pjp.getSignature().getName();

// 获取目标对象

Object target = pjp.getTarget();

// 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行

Object result = pjp.proceed();

System.out.println("调用方法结束：之后执行！\n");

System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");

}

/**

* 异常通知

*

* @param jp

* @param e

*/

public void afterThrow(JoinPoint jp, Throwable e) {

System.out.println(" 异常通知 ");

}

}

//目标类，对哪个目标进行下手。

package com.lw.rpc.service;

import com.lw.rpc.model.SpiderOrder;

/**

* 提供数据service

*

* @author

*

*/

public interface SpiderOrderService {

/**

* 生成订单信息

* @param spiderOrder

* @return

*/

public int saveSpiderOrder(SpiderOrder spiderOrder);

/**

* 修改订单信息

* @param spiderOrder

*/

public void updateSpiderOrder(SpiderOrder spiderOrder);

/**

* 删除订单信息

* @param spiderId

*/

public void deleteSpiderOrderById(Long spiderId);

}

package com.lw.rpc.service.impl;

import org.springframework.stereotype.Service;

import com.lw.rpc.model.SpiderOrder;

import com.lw.rpc.service.SpiderOrderService;

/**

* 订单实现类

*

* @author

*

*/

@Service("spiderOrderService")

public class SpiderOrderServiceImpl implements SpiderOrderService{

/**

* 生成订单

*/

public int saveSpiderOrder(SpiderOrder spiderOrder) {

//具体的业务逻辑

System.out.println("保存方法");

return 0;

}

@Override

public void updateSpiderOrder(SpiderOrder spiderOrder) {

// TODO Auto-generated method stub

}

@Override

public void deleteSpiderOrderById(Long spiderId) {

// TODO Auto-generated method stub

}

}

测试方法：

package com.lw.rpc.test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lw.rpc.model.SpiderOrder;

import com.lw.rpc.service.SpiderOrderService;

public class SpringAopTest {

public static void main(String[] args) {

ApplicationContext cxt = new ClassPathXmlApplicationContext("/spring/spring-applicationContext.xml");

SpiderOrderService spiderOrderService = (SpiderOrderService) cxt.getBean("spiderOrderService");

spiderOrderService.saveSpiderOrder(new SpiderOrder());

}

}

输出如下：

[main] INFO org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org[email protected]5d6f64b1: startup date [Sun Apr 16 23:28:47 CST 2017]; root of context hierarchy

[main] INFO org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from class path resource [spring/spring-applicationContext.xml]

[main] INFO org.springframework.beans.factory.config.PropertyPlaceholderConfigurer - Loading properties file from class path resource [properties/datasource/init.properties]

[main] INFO org.springframework.beans.factory.config.PropertyPlaceholderConfigurer - Loading properties file from class path resource [properties/redis/redis-conf.properties]

[main] INFO org.springframework.beans.factory.config.PropertyPlaceholderConfigurer - Loading properties file from class path resource [properties/server/server-config.properties]

进入连接点前 +++++++++++++++

class com.lw.rpc.service.impl.SpiderOrderServiceImpl对象正在用这个

com.lw.rpc.model.Sp[email protected]

进入到连接点点方法

保存方法

时间： 2024-11-08 21:26:05

spring - AOP 使用方式（二）的相关文章

Spring AOP实现方式二【附源码】

自动代理模式[和我们说的方式一仅仅是配置不一样~~~]  纯POJO切面 源码结构: 1.首先我们新建一个接口,love 谈恋爱接口. package com.spring.aop; /** * 谈恋爱接口 * * @author Administrator * */ public interface Love { /* * 谈恋爱方法 */ void fallInLove(); } .csharpcode, .csharpcode pre { font-size: small; color:

spring - aop 使用方式总结

方式一:接口 前置增强      MethodBeforeAdvice 后置增强      AfterReturningAdvice 异常抛出增强  ThrowsAdvice 环绕增强      MethodInterceptor 注意:还需要在applicationContext.xml文件中进行aop相关的配置 <aop:config>        <aop:pointcut expression="execution(public void *User())"

Spring AOP 实现原理(二) 使用 Spring AOP

与 AspectJ 相同的是,Spring AOP 同样需要对目标类进行增强,也就是生成新的 AOP 代理类:与 AspectJ 不同的是,Spring AOP 无需使用任何特殊 命令对 Java 源代码进行编译,它采用运行时动态地.在内存中临时生成"代理类"的方式来生成 AOP 代理. Spring 允许使用 AspectJ Annotation 用于定义方面(Aspect).切入点(Pointcut)和增强处理(Advice),Spring 框架则可识别并根据这些 Annotati

Spring AOP实现方式三之自动扫描注入【附源码】

注解AOP实现  这里唯一不同的就是application 里面 不需要配置每个bean都需要配置了,直接自动扫描 注册,主要知识点是怎么通过配置文件得到bean, 注意类前面的@注解. 源码结构: 1.首先我们新建一个接口,love 谈恋爱接口. package com.spring.aop; /** * 谈恋爱接口 * * @author Administrator * */ public interface Love { /* * 谈恋爱方法 */ void fallInLove(); v

Spring AOP实现方式四之注入式AspectJ切面【附源码】

现在我们要讲的是第四种AOP实现之注入式AspectJ切面 通过简单的配置就可以实现AOP了. 源码结构: 1.首先我们新建一个接口,love 谈恋爱接口. package com.spring.aop; /** * 谈恋爱接口 * * @author Administrator * */ public interface Love { /* * 谈恋爱方法 */ void fallInLove(); } .csharpcode, .csharpcode pre { font-size: sma

Spring AOP实现方式三【附源码】

注解AOP实现 源码结构: 1.首先我们新建一个接口,love 谈恋爱接口. package com.spring.aop; /** * 谈恋爱接口 * * @author Administrator * */ public interface Love { /* * 谈恋爱方法 */ void fallInLove(); void test() throws Exception; } .csharpcode, .csharpcode pre { font-size: small; color:

转：Spring AOP 注解方式实现的一些“坑”

使用过Spring AOP的注解方式实现,也入过不少坑,现在做一下记录,希望有同样需求的朋友可以少走弯路 使用之前还是先过一下官方文档吧,至少可以少走弯路,不用担心英文读不懂,其实只看代码例子就能理解很多问题! 1. SpringBoot如何获得Aspect支持? 看这里:Spring Boot 开启AOP的方法 2. 我按照上面的方法开启了AOP支持,为什么始终是不走切入点方法呢? 首先仔细检查一下,Aspect类是不是少了@Component注解(这一点很重要!),只有一个@Aspect注解

Spring AOP注解方式实现

简介 上文已经提到了Spring AOP的概念以及简单的静态代理.动态代理简单示例,链接地址:https://www.cnblogs.com/chenzhaoren/p/9959596.html 本文将介绍Spring AOP的常用注解以及注解形式实现动态代理的简单示例. 常用注解 @aspect:定义切面 @pointcut:定义切点 @Before:前置通知,在方法执行之前执行 @After:后置通知,在方法执行之后执行 @AfterRunning:返回通知,在方法返回结果之后执行 @Aft

Spring AOP实现方式一【附源码】

基本代理模式  纯POJO切面 源码结构: 1.首先我们新建一个接口,love 谈恋爱接口. package com.spring.aop; /** * 谈恋爱接口 * * @author Administrator * */ public interface Love { /* * 谈恋爱方法 */ void fallInLove(); } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: c