Spring入门（三）AOP

基于子类的动态代理

代码：

/**
* 一个演员
*/
public class Actor{//没有实现任何接口
	public void basicAct(float money){
		System.out.println("拿到钱，开始基本的表演： "+money);
	}
	public void dangerAct(float money){
		System.out.println("拿到钱，开始危险的表演： "+money);
	}
}
public class Client {
	/**
	* 基于子类的动态代理
	* 要求：
	* 被代理对象不能是最终类
	* 用到的类：
	* Enhancer
	* 用到的方法：
	* create(Class, Callback)
	* 方法的参数：
	* Class：被代理对象的字节码
	* Callback：如何代理
	* @param args
	*/
	public static void main(String[] args) {
		final Actor actor = new Actor();
		Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
			new MethodInterceptor() {
			/**
			* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
			方法进行增强。
			*
			* 参数：
			* 前三个和基于接口的动态代理是一样的。
			* MethodProxy：当前执行方法的代理对象。
			* 返回值：
			* 当前执行方法的返回值
			*/
			@Override
			public Object intercept(Object proxy, Method method, Object[] args,
			MethodProxy methodProxy) throws Throwable {
				String name = method.getName();
				Float money = (Float) args[0];
				Object rtValue = null;
				if("basicAct".equals(name)){
					//基本演出
					if(money > 2000){
						rtValue = method.invoke(actor, money/2);
					}
				}
				if("dangerAct".equals(name)){
					//危险演出
					if(money > 5000){
						rtValue = method.invoke(actor, money/2);
					}
				}
				return rtValue;
			}
		});
		cglibActor.basicAct(10000);
		cglibActor.dangerAct(100000);
	}
}

Spring的AOP

配置步骤

第一步：把通知类用 bean 标签配置起来

<!-- 配置通知 -->
<bean id="txManager" class="com.itheima.utils.TransactionManager">
<property name="dbAssit" ref="dbAssit"></property>
</bean>

第二步：使用 aop:config 声明 aop 配置

作用： 用于声明开始 aop 的配置

第三步：使用 aop:aspect 配置切面
作用：
用于配置切面。
属性：
id： 给切面提供一个唯一标识。
ref： 引用配置好的通知类 bean 的 id。

第四步：在aop：aspect内部使用对应标签

如aop：before（前置通知）
属性：
method ：用于指定txManager类（通知类）那个方法通知（前置通知）
id： 用于给切入点表达式提供一个唯一标识
pointcut属性：用于指定切入点表达式，指的是对业务层那些方法增强
切入点表达式写法：
关键字：execution（表达式）
表达式语法： execution([修饰符] 返回值类型 包名.类名.方法名(参数))

写法说明：
全匹配方式：
public void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
访问修饰符可以省略
void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
返回值可以使用*号，表示任意返回值
*
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
包名可以使用*号，表示任意包，但是有几级包，需要写几个*
* *.*.*.*.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
使用..来表示当前包，及其子包
* com..AccountServiceImpl.saveAccount(com.itheima.domain.Account)
类名可以使用*号，表示任意类
* com..*.saveAccount(com.itheima.domain.Account)
方法名可以使用*号，表示任意方法
* com..*.*( com.itheima.domain.Account)
参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
* com..*.*(*)
参数列表可以使用..表示有无参数均可，有参数可以是任意类型
* com..*.*(..)
全通配方式：
* *..*.*(..)
注：
通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
execution(* com.itheima.service.impl.*.*(..))

方式一：

代码:

<aop:config>
<!-- 配置的代码都写在此处 -->
	<!--配置切面-->
	<aop:aspect id="txAdvice" ref="txManager">
	<!--配置通知的类型要写在此处-->
		<aop:before method="beginTransaction" pointcut="execution(
			public void com.itheima.service.impl.AccountServiceImpl.transfer(
			java.lang.String, java.lang.String, java.lang.Float))" >
		</aop:before>
	</aop:aspect>
</aop:config>

方式二 用aop：pointcut标签配置切入点表达式 再引用
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id： 用于给切入点表达式提供一个唯一标识

<aop:config>
<!-- 配置的代码都写在此处 -->
	<!--配置切面-->
	<aop:aspect id="txAdvice" ref="txManager">
		<!--配置通知的类型要写在此处-->
		<aop:pointcut expression="execution(
			public void com.itheima.service.impl.AccountServiceImpl.transfer(
			java.lang.String, java.lang.String, java.lang.Float)
		)" id="pt1"/>
		<aop:before method="beginTransaction" pointcut-ref="pt1"/>
	</aop:aspect>
</aop:config>

其他通知类型

aop:before
作用：
用于配置前置通知。 指定增强的方法在切入点方法之前执行
属性：
method:用于指定通知类中的增强方法名称
ponitcut-ref：用于指定切入点的表达式的引用
poinitcut：用于指定切入点表达式
执行时间点：
切入点方法执行之前执行
<aop:before method=“beginTransaction” pointcut-ref=“pt1”/>

aop:after-returning
作用：
用于配置后置通知
属性：
method： 指定通知中方法的名称。
pointct： 定义切入点表达式
pointcut-ref： 指定切入点表达式的引用
执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行
<aop:after-returning method=“commit” pointcut-ref=“pt1”/>

op:after-throwing
作用：
用于配置异常通知
属性：
method： 指定通知中方法的名称。
pointct： 定义切入点表达式
pointcut-ref： 指定切入点表达式的引用
执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个
<aop:after-throwing method=“rollback” pointcut-ref=“pt1”/>

aop:after
作用：
用于配置最终通知
属性：
method： 指定通知中方法的名称。
pointct： 定义切入点表达式
pointcut-ref： 指定切入点表达式的引用
执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。
<aop:after method=“release” pointcut-ref=“pt1”/>

环绕通知

配置方式:

<aop:config>
	<aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))"
id="pt1"/>
	<aop:aspect id="txAdvice" ref="txManager">
		<!-- 配置环绕通知 -->
		<aop:around method="transactionAround" pointcut-ref="pt1"/>
	</aop:aspect>
</aop:config>

aop:around：
作用：
用于配置环绕通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
说明：
它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
通常情况下，环绕通知都是独立使用的
代码

/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口： ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时， spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
//通知类
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行业务层方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

基于注解的AOP

第一步： 代码jar包略
第二步：配置文件导入context名称空间略
第三步：资源注解配置

/**
* 账户的业务层实现类
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
	@Autowired
	private IAccountDao accountDao;
}
/**
* 账户的持久层实现类
* @author 黑马程序员
* @Company http://www.ithiema.com
* @Version 1.0
*/
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
	@Autowired
	private DBAssit dbAssit ;
}

第四步：在配置文件中指定 spring 要扫描的包

<!-- 告知 spring，在创建容器时要扫描的包（配置在beans标签里面） -->
<context:component-scan base-package="com.itheima"></context:component-scan>

开始配置

第一步：把通知类也使用注解配置

@Component("txManager")
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ;
}

第二步：在通知类上使用@Aspect 注解声明为切面

@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {
	//定义一个 DBAssit
	@Autowired
	private DBAssit dbAssit ;
}

第三步：在增强的方法上使用注解配置通知

//开启事务
@Before("execution(* com.itheima.service.impl.*.*(..))")
public void beginTransaction() {
	try {
		dbAssit.getCurrentConnection().setAutoCommit(false);
	} catch (SQLException e) {
		e.printStackTrace();
	}
}

其他类型分别对应：@AfterReturning @AfterThrowing @After
第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持（beans标签中）
aop:aspectj-autoproxy/

环绕通知注解

@Around
作用：
把当前方法看成是环绕通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用

/**
* 环绕通知
* @param pjp
* @return
*/
@Around("execution(* com.itheima.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

切入点表达式注解

@Pointcut
属性：
value：指定表达式内容

value：指定表达式的内容
@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1() {}

//引用方式：
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
	//定义返回值
	Object rtValue = null;
	try {
		//获取方法执行所需的参数
		Object[] args = pjp.getArgs();
		//前置通知：开启事务
		beginTransaction();
		//执行方法
		rtValue = pjp.proceed(args);
		//后置通知：提交事务
		commit();
	}catch(Throwable e) {
		//异常通知：回滚事务
		rollback();
		e.printStackTrace();
	}finally {
		//最终通知：释放资源
		release();
	}
	return rtValue;
}

不用XML的配置方式

@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}