Spring框架(详细 三完结)

1.AspectJ

1.1 AspectJ介绍

• AspectJ是一个基于Java语言的AOP框架
• Spring2.0以后新增了对AspectJ切点表达式支持
• @AspectJ是AspectJ1.5新增的功能，通过JDK5注解技术，允许直接在Bean类中定义切面新版本Spring框架，建议使用AspectJ方式来开发AOP
• 主要用途：自定义开发

1.2切入点表达式【掌握】

• 1.2.1 execution（）用于描述方法【重要】
  • 语法：execution(修饰符 返回值 包.类。方法 名（参数）throws异常)
  • 修饰符：一般省略
    • public ：公共方法
    • *： 任意
  • 返回值：不能省略
    • void ：返回没有值
    • String： 返回字符串
    • *：任意
  • 包：可以省略
    • com.rock： 固定包
    • com.rock.*.userService ：rock（例如：com.rock.Aop.userService）
    • com.rock. . ：rock下的所有包（子包、孙子包…）
  • 类：可以省略
    • UserServiceImpl ：指定类
    • User*：pl结尾的
  • 方法名：不能省略
    • addUser：固定方法
    • add*：以add开头
    • *User：以User结尾
    • *：任意
  • （参数）
    • 0：无参
    • (int)：一个整型
    • (. .)：参数任意
    • throws：可以省略，一般不写

模拟联系：

execution(* com.rock.* .A. .* .*(. .))

1.3 AspectJ通知类型

• aop联盟定义通知
  • aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。
  • aspectj 通知类型，自定义类型名称，已经方法格式。
  • 个数：6种，知道5种，掌握1种。
    • before：前置通知（应用，各种校验：在方法执行前执行，如果通知抛出异常，阻止方法运行
    • afterReturning：后置通知（应用：常规数据处理）：方法正常返回后执行，如果方法中抛出异常，通知无法执行。必须在方法执行后才执行，所以可以获得方法的返回值。
    • around：环绕通知（应用：十分强大，可以做任何事情）：方法执行前后分别执行，可以阻止方法的执行，必须手动执行目标方法。
    • afterThrowing：抛出异常通知（应用：包装异常信息）：方法抛出异常后执行，如果方法没有抛出异常，无法在执行。
    • after：最终通知（应用：清理现场）：方法执行完毕后执行，无论方法中是否出现异常。
    • 模拟环绕：
      try{
      //前置：before
      //手动执行目标方法
      //后置：afterReturning

}catch（）{

//抛出异常：afterThrowing

}finally{

//最终 after
}

1.4AspectJ基于xml演示

• 注解都写在了代码里！！！！！！！！！！！！！

• 目录结构

    	![在这里插入图片描述](https://img-blog.csdnimg.cn/2019083016422516.png)
  

• 代码详情
  MyAspect.java

package com.rock.aspectj;

import java.lang.reflect.Method;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;



/*
 * 切面类，含有多个通知
 * 
 */
public class MyAspect{

	public void before(JoinPoint joinPoint){
		System.out.println("前置:"+joinPoint.getSignature().getName());
	}
	
	public void myAfterReturning(JoinPoint joinPoint){
		System.out.println("后置通知："+joinPoint.getSignature().getName());
		
	}
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object object = joinPoint.proceed();
		System.out.println("后");
		return object;
		
	}	
	public void myThrow(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知："+e.getMessage());
	}
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}
	
}

Testaspect.java

package com.rock.aspectj;

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

public class Testaspect {
	@Test
	public void demo01(){
		
	          ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/rock/aspectj/beans.xml");
	          UserService userService = (UserService) applicationContext.getBean("userService");
	          userService.adduser();
	          userService.deleteUser();
	          userService.updateUser();
		
	}
	
			
}

UserService.java

package com.rock.aspectj;

public interface UserService {
	public void adduser();
	public void updateUser();
	public void deleteUser();
}

UserServiceImpl.java

package com.rock.aspectj;

public class UserServiceImpl implements UserService{

	@Override
	public void adduser() {
		// TODO Auto-generated method stub
		System.out.println("UserServiceImpl.adduser()");
	}

	@Override
	public void updateUser() {
		// TODO Auto-generated method stub
		System.out.println("UserServiceImpl.updateUser()");
	}

	@Override
	public void deleteUser() {
		// TODO Auto-generated method stub
		System.out.println("UserServiceImpl.deleteUser()");
	}

}

beans.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"
    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.5.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
   <!-- 1.创建目标类 -->
   <bean id ="userService" class = "com.rock.aspectj.UserServiceImpl"></bean>
   <!-- 2.创建切面类 -->
   <bean id ="myAspect" class="com.rock.aspectj.MyAspect"></bean>
   <!-- 3.AOP编程  
   		<aop:aspect> 将切面类声明“切面”，从而获得通知（方法）
   			ref 切面类引用
   		<aop:pointcut>声明一个切入点，所有的通知都可以使用。
   			expression 切入点表达式
   			id 名称，用于其他引用	
   
   
   
    -->
    <aop:config>
    	<aop:aspect ref="myAspect">
    		<aop:pointcut expression="execution(* com.rock.aspectj.UserServiceImpl.*(..))" id="myPointcut"/>
    	<!-- 3.1前置通知：
    		<aop:before method = "" pointcut="" pointcut-ref=""/>
    			method:通知，及方法名
    			pointcut:切入点表达式，此表达式只能当通知使用。
    			pointcut-ref:切入点引用，可以与其他通知共享切入点 .
    			通知方法格式：public void before(JoinPoint joinPoint) 
    					   参数JoinPoint：用于描述连接点（目标方法），获得目标方法名等
    					   	
    	 -->
    	<aop:before method = "before"  pointcut-ref="myPointcut"/>
    	<!-- 3.2后置通知：目标方法后执行，获得返回值
    	
    	    	<aop:after-returning method="" pointcut-ref="" returning=""/>
    			returning:通知方法的第二个参数名称，返回值
    	
    	
    	 -->
    	<aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut" />
    	<!-- 3.3环绕通知： -->
    	<aop:around method="myAround" pointcut-ref="myPointcut"/>
    	<!-- 3.4异常通知 -->
    	<aop:after-throwing method="myThrow" throwing="e" pointcut-ref="myPointcut"/>
    	<!-- 3.5最终通知 -->
    	<aop:after method="myAfter" pointcut-ref="myPointcut"/>
    	</aop:aspect>
    	
    	
    </aop:config>
  
    
    
    
</beans>

1.5 AspectJ基于注解

• 1.5.1替换目标类

 <!-- 1.创建目标类 -->
   <bean id ="userService" class = "com.rock.aspectj.UserServiceImpl"></bean>   

• 1.5.2 替换切面类和aop

<aop:aspect ref="myAspect">

<!-- 2.创建切面类 -->
   <bean id ="myAspect" class="com.rock.aspectj.MyAspect"></bean>

• 1.5.3 替换前置方法

<aop:aspect ref="myAspect">
    		<aop:pointcut expression="execution(* com.rock.aspectj.UserServiceImpl.*(..))" id="myPointcut"/>
    	
    	<aop:before method = "before"  pointcut-ref="myPointcut"/>
    	

• 1.5.4 替换公共切入点

<aop:pointcut expression="execution(* com.rock.aspectj.UserServiceImpl.*(..))" id="myPointcut"/>

• 1.5.5 替换后置方法

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut" />

• 1.5.6 替换环绕

<aop:around method="myAround" pointcut-ref="myPointcut"/>

抛出异常和最终通知就不一一解释了，都差不多。。。。
此处省略**个字