Spring-AOP面向切面编程

AOP是面向切面编程，区别于oop，面向对象，一个是横向的，一个是纵向。

主要解决代码分散和混乱的问题。

1.概念：

切面：实现AOP共有的类

通知：切面类中实现切面功能的方法

连接点：程序被通知的特定位置

切点：连接点的定义

代理：向目标应用通知而产生的对象

2.配置

 

AOP的实现的基本要求：通过接口创建目标的代理。

1。首先是配置文件，2。然后启动扫描器<context:component-scan>和启动AOP注解支持<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

3.之后再逻辑方法类上定义容器管理@Component（“名称”）若不写名称，则默认是类名首字母小写的名字。

3.定义切面类，

定义容器管理@Component和@Aspect//切面类

4.定义通知

通知可分为@before前置通知、@After后置通知、@AfterReturning返回通知、@AfterThrowing异常通知、@Around环绕通知。

前置通知：

在方法执行前执行，参数JoinPoint，代表连接点

可以得到参数列表和方法名

通过getNmae和        getAtgs，反回的是object[]类型

后置通知；在方法之后执行，同样可以获得参数列表和方法名

异常通知：

throwing=“接受异常对象规定参数”

 环绕通知：

5.定义切点表达式

@通知类型注解（pointCut=“execution（修饰符的返回值类型 包名.类名.方法名（参数类型））”）

6.公共切点@Pioneertcut

之后再调用切点表达式的时候直接写：通知类型（“公共切点表达式的类名piontCut”）

接口=============================

package com.hanqi.test;

import org.springframework.stereotype.Component;

public interface I_jsq {

	double add(double a ,double b);
	double div(double a ,double b);

}

　　实现类业务逻辑类=========

package com.hanqi.test;

import org.springframework.stereotype.Component;

@Component("my1")//容器管理
public class Myjsq implements I_jsq {

	//连接点
	@Override
	public double add(double a, double b) {
		//前置通知的连接点

		//日志记录
//		System.out.println("日志：a = "+a+" ,b = "+b);
		System.out.println(a+"+"+b+"="+(a+b));

		if(a < 0)
		{
			throw new RuntimeException("运行时异常");
		}
		return(a+b);
		//后置通知的连接点
	}
	//连接点
	@Override
	public double div(double a, double b) {
		//日志记录
		//System.out.println("日志：a = "+a+" ,b = "+b);

		//检查
//		if(b==0)
//		{
//			System.out.println("b不能是0");
//			return -1;
//		}
//		else
//		{
			System.out.println(a+"/"+b+"="+(a/b));
			return (a/b);

		//}
	}

}

　　切面类================

package com.hanqi.test;

import java.util.Arrays;
import java.util.List;

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.core.annotation.Order;
import org.springframework.stereotype.Component;

//切面类
@Component//容器管理
@Aspect//切面类
@Order(1)
public class LogAspect {

	//定义公共切点
	@Pointcut("execution(* com.hanqi.test.I_jsq.*(..))")
	public  void pointCut()
	{

	}

	//前置通知@Before
	@Before("pointCut()")//引用公共切点
	public void beforeLog(JoinPoint jp)//通知  JoinPoint表示连接点
	{
		//连接点的方法名
		String ms = jp.getSignature().getName();

		//连接点方法的参数
		List<Object> ls = Arrays.asList(jp.getArgs());

		System.out.println("前置日志,方法名 = "+ms+" 参数列表= "+ls);
	}

	//后置通知
	@After("pointCut()")
	public void afterLog(JoinPoint jp)
	{
		//连接点的方法名
				String ms = jp.getSignature().getName();

				//连接点方法的参数列表
				List<Object> ls = Arrays.asList(jp.getArgs());

				System.out.println("后置日志,方法名 = "+ms+" 参数列表= "+ls);
	}

	//返回通知
	//@AfterReturning(pointcut="execution(* com.hanqi.test.I_jsq.*(..))" ,returning="rtn")
	@AfterReturning(pointcut="pointCut()" ,returning="rtn")
	public void returningLog(double rtn)
	{
		//接收返回值
		System.out.println("返回值="+rtn);
	}

	//异常通知
	@AfterThrowing(pointcut="pointCut()" , throwing="msg")
	public void errorLog(Exception msg)
	{
		System.out.println("异常通知="+msg.getMessage());
	}

	//环绕通知
	@Around("pointCut()")//切点表达式，第一个*表示返回类型，第二个*表示方法名
	public Object aroundLog(ProceedingJoinPoint pjp)
	{
		Object rtn= null;
		//连接点的方法名
		String ms = pjp.getSignature().getName();

		//连接点方法的参数
		List<Object> ls = Arrays.asList(pjp.getArgs());
		//实现四种通知
		//1.前置通知
		System.out.println("这是环绕通知的前置通知,方法名= "+ms+" 参数="+ls);

		//调用目标方法
		try {

			rtn= pjp.proceed();

			//3.返回通知
			System.out.println("这是环绕通知的返回通知，返回值="+rtn );

		} catch (Throwable e) {
			//4.异常通知
			System.out.println("这是环绕通知的异常通知,异常信息="+e.getMessage());
			e.printStackTrace();
		}
		finally
		{
			//2.后置通知
			System.out.println("这是环绕通知的后置通知");
		}

		return rtn;
	}
}

package com.hanqi.test;

import java.util.Arrays;
import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
	//	切面类
@Component
@Aspect
@Order(2)
public class CheckAspect {

	//前置通知
	//@Before("execution(* com.hanqi.test.Myjsq.div(double,double))")
	@Before("LogAspect.pointCut()")//重用切点表达式
	public void beforeCheck(JoinPoint jp)
	{
		//获取参数
		Object[] ob = jp.getArgs();

		if((Double.parseDouble(ob[1].toString()))== 0)
		{
			System.out.println("参数不能等于0");
			System.out.println("1=="+Double.parseDouble(ob[1].toString()));
			System.out.println("0=="+Double.parseDouble(ob[0].toString()));
		}
	}

}

　　测试类

package com.hanqi.test;

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

public class TestMain {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//I_jsq jsq1 = new Myjsq();

		ApplicationContext ac =
				new ClassPathXmlApplicationContext("app.xml");

		I_jsq jsq1 =(I_jsq)ac.getBean("my1");//通过接口创建代理对象

		jsq1.add(123, 456);

		jsq1.div(200, 0);

	}

}