spring4 aop annotation

package com.zrd.aop.annotation;
/**
 * 第一步:定义一个接口
 *
 * @author ZRD
 *
 */
public interface IMyService {

	int add(int i, int j);
}
package com.zrd.aop.annotation;

import org.springframework.stereotype.Component;

/**
 * 第二步:定义接口的实现类
 *
 * @author ZRD
 *
 */
@Component
public class MyServiceImpl implements IMyService {

	@Override
	public int add(int i, int j) {
		int result = i +j;
		System.out.println("add 正在执行... " + result);
		return result;
	}

}
package com.zrd.aop.annotation;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 第三步:声明一个切面
 *
 * 记录日记的切面
 *
 * @author ZRD
 *
 */
@Aspect
@Component
public class LogAspect {

	/**
	 * 切入点:表示在哪个类的哪个方法进行切入。配置有切入点表达式
	 */
	@Pointcut("execution(* com.zrd.aop.annotation.*.*(..))")
	public void pointcutExpression() {

	}

	/**
	 * 1 前置通知
	 * @param joinPoint
	 */
	@Before("pointcutExpression()")
	public void beforeMethod(JoinPoint joinPoint) {
		System.out.println("前置通知执行了");
	}

	/**
	 * 2 后置通知
	 */
	@After("pointcutExpression()") // 在方法执行之后执行的代码. 无论该方法是否出现异常
	public void afterMethod(JoinPoint joinPoint) {
		System.out.println("后置通知执行了,有异常也会执行");
	}

	/**
	 * 3 返回通知
	 *
	 * 在方法法正常结束受执行的代码
	 * 返回通知是可以访问到方法的返回值的!
	 *
	 * @param joinPoint
	 * @param returnValue
	 *
	 */
	@AfterReturning(value = "pointcutExpression()", returning = "returnValue")
	public void afterRunningMethod(JoinPoint joinPoint, Object returnValue) {
		System.out.println("返回通知执行,执行结果:" + returnValue);
	}

	/**
	 * 4 异常通知
	 *
	 * 在目标方法出现异常时会执行的代码.
	 * 可以访问到异常对象; 且可以指定在出现特定异常时在执行通知代码
	 *
	 * @param joinPoint
	 * @param e
	 */
	@AfterThrowing(value = "pointcutExpression()", throwing = "e")
	public void afterThrowingMethod(JoinPoint joinPoint, Exception e){
		System.out.println("异常通知, 出现异常 :" + e);
	}

	/**
	 * 环绕通知需要携带 ProceedingJoinPoint 类型的参数.
	 * 环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型的参数可以决定是否执行目标方法.
	 * 且环绕通知必须有返回值, 返回值即为目标方法的返回值
	 */

	@Around("pointcutExpression()")
	public Object aroundMethod(ProceedingJoinPoint pjd){

		Object result = null;
		String methodName = pjd.getSignature().getName();

		try {
			//前置通知
			System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
			//执行目标方法
			result = pjd.proceed();
			//返回通知
			System.out.println("The method " + methodName + " ends with " + result);
		} catch (Throwable e) {
			//异常通知
			System.out.println("The method " + methodName + " occurs exception:" + e);
			throw new RuntimeException(e);
		}
		//后置通知
		System.out.println("The method " + methodName + " ends");

		return result;
	}

}
<!-- 第四步:spring配置文件:配置IOC自动扫描和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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		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.0.xsd">

	<context:component-scan base-package="com.zrd.aop.*"></context:component-scan>

	<!-- 使用注解配置切面 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

	<!-- 使用XML配置切面 -->
	<!--
	<aop:config>
		<aop:pointcut expression="" id=""/>
		<aop:aspect>
			<aop:after method=""/>
		</aop:aspect>
	</aop:config>
	-->

</beans>

package com.zrd.aop.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 第五步:测试
 *
 * @author ZRD
 *
 */
public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ApplicationContext ax = new ClassPathXmlApplicationContext("applicationContext.xml");

		/** 使用切面时,一定要这样写,不然无法注入bean **/
		//IMyService service = ax.getBean(MyServiceImpl.class);
		IMyService service = (IMyService) ax.getBean("myServiceImpl");

		service.add(2, 8);
	}

}

spring4 aop annotation

时间: 2024-11-03 03:46:15

spring4 aop annotation的相关文章

Spring Aop Annotation

实体: 1 package com.bxw.aop.vo; 2 3 public class User { 4 private String loginId; 5 6 public User() { 7 } 8 9 public String getLoginId() { 10 return loginId; 11 } 12 13 public void setLoginId(String loginId) { 14 this.loginId = loginId; 15 } 16 17 } Us

Spring AOP annotation 错误

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'userService' defined in class path resource [applicationContext.xml]: Initialization of bean failed; nested exception is java.lang.IllegalArgumentException: error

spring中的AOP 以及各种通知

理解了前面动态代理对象的原理之后,其实还是有很多不足之处,因为如果在项目中有20多个类,每个类有100多个方法都需要判断是不是要开事务,那么方法调用那里会相当麻烦. spring中的AOP很好地解决了这个问题,通过 execution表达式 指定哪些包中的那些类 哪些方法 用到事务 execution(public * *(..))  所有的公共方法 execution(* set*(..))  以set开头的任意方法 execution(* com.xyz.service.AccountSer

Spring AOP 的实现

1 使用 API 实现 AOP 新建一个用户接口:UserService 1 package com.cqvie.aop.api; 2 3 public interface UserService { 4 5 public void add(String name); 6 public void update(String name); 7 public void delete(String name); 8 public void select(String name); 9 } 实现接口类:

(转)spring aop(下)

昨天记录了Spring AOP学习的一部分(http://www.cnblogs.com/yanbincn/archive/2012/08/13/2635413.html),本来是想一口气梳理完的.但是大晚上时间不够(无奈一场奥运篮球总决赛耗费掉了2小时,不过的确相当精彩),又考虑到篇幅太长,阅读性比较差,所以将后半部分更偏于应用的重起一篇随笔. 利用方式一的配置起来,可见代码还是非常的厚重的,定义一个切面就要定义一个切面类,然而切面类中,就一个通知方法,着实没有必要.所以Spring提供了,依

【Spring五】AOP之使用注解配置

AOP使用注解配置流程: 1.当spring容器启动时候,    < context:component- scan base-package= "cn.itheima03.spring.aop.annotation" ></context :component-scan> 2.在上面的包及子包中查询所有的类,按照类扫描注解的机制把类放入到spring容器中 3. 检查是否配置:<aop:aspectj-autoproxy> </aop: as

Spring学习(20)--- Schema-based AOP(基于配置的AOP实现) -- 配置切入点pointcut

execution用于匹配方法执行的连接点 execution(public * *(..)) execution(* set*(..)) execution(* com.xyz.service.AccountService.*(..)) execution(* com.xyz.service..(..)) execution(* com.xyz.service...(..)) within(com.xyz.service.*) (only in Spring AOP) within(com.x

JavaEE开发之Spring中的依赖注入与AOP编程

一.快速创建Mava管理的Spring工程 因为本篇博客是讨论关于Spring的东西,所以我们就不创建WebApp的工程了.我们使用Spring来快速的创建一个Maven管理的工程.如下所示找到File->New->Maven Project选项来创建一个新的Maven Project,具体如下所示: 下方我们选择创建一个简单的Maven工程,跳过模板的选择.上篇博客我们在创建Maven工程时,是没有选择下方这个选项的,然后我们选择了一个WebApp的模板.而本篇博客,我们不需要WebApp的

Spring AOP 学习例子

http://outofmemory.cn/code-snippet/3762/Spring-AOP-learn-example 工作忙,时间紧,不过事情再多,学习是必须的.记得以前的部门老大说过:“开发人员不可能一天到晚只有工作,肯定是需要自我学习.第一:为了更充实自己,保持进步状态.第二:为了提升技术,提高开发能力.第三:保持程序员对技术和学习的热情,工作的激情.程序员还是需要把基础打扎实,修炼自己的内功.” 所以赶紧把学习的东西总结一下,加深印象.之前有说了下AOP的原理 (http://