6.AspectJ的xml方式完成AOP的开发

**AspectJ的XML方式完成AOP的开发**
	
	1. AspectJ的XML的方式的快速入门，前面的步骤都是一样的
	2. 具体的开发步骤
		1. 步骤一：创建JavaWEB项目，引入具体的开发的jar包
			* 先引入Spring框架开发的基本开发包，还需要引入AOP的开发包（AOP联盟和AOP的开发包）
			* 再引入AspectJ的开发包
				* aspectj 本身jar包			-- com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
				* spring支持aspectj的包		-- spring-aspects-3.2.0.RELEASE.jar
		
		2. 步骤二：创建Spring的配置文件，引入具体的AOP的schema约束
			<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"
			       xsi:schemaLocation="
					http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
					http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
		
		3. 步骤三：创建包结构，编写具体的实现类代码
			* com.itheima.demo2
				* OrderDao
		
		4. 步骤四：将目标类配置到Spring中
			<!-- 目标类 -->
			<bean id="orderDao" class="com.itheima.demo2.OrderDao"/>
		
		5. 步骤五：定义切面（注意不用使用注解了）
			public class MyAspectXml {
				public void myBefore(){
					System.out.println("前置通知====");
				}
			}

		6. 步骤六：在配置文件中定义切面类
			<bean id="myAspectXml" class="com.itheima.demo2.MyAspectXml"/>
		
		7. 步骤七：在配置文件中完成aop的配置
			<!-- 配置aop -->
			<aop:config>
				<!-- 先定义切入点 -->
				<aop:pointcut expression="execution(public * com.itheima.demo2.OrderDao.save(..))" id="myPointcut"/>
				<!-- 定义切面 -->
				<aop:aspect ref="myAspectXml">
					<!-- 配置通知的类型，还需要配置引入哪一个切入点 -->
					<aop:before method="myBefore" pointcut-ref="myPointcut"/>
				</aop:aspect>
			</aop:config>
		
		8. 完成测试
			@RunWith(SpringJUnit4ClassRunner.class)
			@ContextConfiguration("classpath:applicationContext2.xml")
			public class SpringDemo2 {
			
				@Resource(name="orderDao")
				private OrderDao orderDao;
				
				@Test
				public void run1(){
					orderDao.save();
				}
			}

----------

**AspectJ的XML方式的AOP的通知类型的配置**
	
	1. 测试后置通知
		* 在切面类中编写方法
			public void myAfterReturnint(Object result){
				System.out.println("后置通知===="+result);
			}

		* 在配置文件中编写具体的配置
			<aop:after-returning method="myAfterReturnint" pointcut-ref="myPointcut2" returning="result"/>
	
	2. 测试环绕通知
		* 在切面类中编写方法
			public void myAroundt(ProceedingJoinPoint joinPoint) throws Throwable{
				System.out.println("方法之前通知====");
				joinPoint.proceed();
				System.out.println("方法之后通知====");
			}
		
		* 在配置文件中编写具体的配置
			<aop:around method="myAroundt" pointcut-ref="myPointcut2"/>
	
	3. 测试异常抛出
		* 在切面类中编写方法
			public void myThrowable(Throwable e){
				System.out.println("异常通知===="+e.getMessage());
			}
		
		* 在配置文件中编写具体的配置
			<aop:after-throwing method="myThrowable" pointcut-ref="myPointcut3" throwing="e"/>
	
	4. 测试最终通知
		* 在切面类中编写方法
			public void myAfter(){
				System.out.println("最终通知====");
			}
		
		* 在配置文件中编写具体的配置
			<aop:after method="myAfter" pointcut-ref="myPointcut3"/>

<?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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

	<bean id="orderDao" class="demo1.OrderDao"></bean>
	<!-- 定义切面类 -->
	<bean id="myAspectXml" class="demo1.MyAspectXml"></bean>
	<!-- 完成aop的配置 -->
	<aop:config>
		<!-- 先定义切入点 -->
		<aop:pointcut expression="execution(public * demo1.OrderDao.save(..))" id="myPointcut"/>
		<aop:pointcut expression="execution(public * demo1.OrderDao.update(..))" id="myPointcut2"/>
		<aop:pointcut expression="execution(public * demo1.OrderDao.delete(..))" id="myPointcut3"/>
		<!-- 定义切面 -->
		<aop:aspect ref="myAspectXml">
			<!-- 配置 通知的类型，还需要配置引入哪一个切入点 -->
			<aop:before method="myBefore" pointcut-ref="myPointcut"/>
			<aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut2" returning="result"/>
			<aop:around method="myAround" pointcut-ref="myPointcut3"/>
		</aop:aspect>
	</aop:config> 
	
</beans>

package demo1;

import org.apache.tomcat.util.collections.SynchronizedStack;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAspectXml {
	public void myBefore(){
		System.out.println("前置通知====");
	}
	
	public void myAfterReturning(Object result){
		System.out.println("后置通知======"+result);
	}
	
	public void myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("方法之前通知====");
		joinPoint.proceed();
		System.out.println("方法之后通知====");
	}
	
	public void myThrowable(Throwable e){
		System.out.println("异常通知===="+e.getMessage());
	}
	
	
}

package demo1;

public class OrderDao {

	public void save() {
		System.out.println("保存订单");
	}
	
	public String update(){
		System.out.println("修改订单...");
		return "修改订单成功哦爷！";
	}
	
	public void delete(){
		System.out.println("删除订单...");
	}
	
	public void find(){
		System.out.println("查询订单...");
	}
}

package demo1;

import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {

	@Resource(name="orderDao")
	private OrderDao orderDao;
	
	@Test
	public void run1(){
		orderDao.save();
		orderDao.update();
		orderDao.delete();
	}
}