Spring 切面 AOP基础 之一

时至五月，北京的天气大大的热起来了，为了凉爽和舒适，呆在家里撸代码才是正事。光自己撸代码不乐，众撸代码才是趣事。Spring刚离开不久，我们就来温习回味一下吧。

1、从基础讲起

切面有助于实现交叉事物的模块化，交叉事物是指会影响到多个程序位置的地方。因此得采用重用技术，常见的重用就是继承和代理，切面提供了一种取代继承和委托的方式，使之更简洁。使用切面，我们仍然在一个地方定义公用功能，但是可以明确指定这个功能在哪里，以何种方式应用，而不用修改被影响的类。这样，交叉事物被模块化到特殊的对象里，这些对象被称为 切面。   这样有2个好处，一是每个事物的逻辑位于一个位置，而不是分散到多处，其次服务模块更加简洁，因为辅助事物的代码被转移到切面了。

2、从一个简单的例子讲开来

搭建spring的maven工程

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.mkyong.common</groupId>
	<artifactId>SpringExamples</artifactId>
	<packaging>jar</packaging>
	<version>1.0-SNAPSHOT</version>
	<name>SpringExamples</name>
	<url>http://maven.apache.org</url>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>3.8.1</version>
			<scope>test</scope>
		</dependency>

		<!-- Spring framework -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring</artifactId>
			<version>2.5.6</version>
		</dependency>

		<!-- Proxy class need this library -->
		<dependency>
			<groupId>cglib</groupId>
			<artifactId>cglib</artifactId>
			<version>2.2.2</version>
		</dependency>

	</dependencies>
</project>

建立服务类：CustomService

public class CustomerService {
	private String name;
	private String url;

	public void setName(String name) {
		this.name = name;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public void printName() {
		System.out.println("Customer name : " + this.name);
	}

	public void printURL() {
		System.out.println("Customer website : " + this.url);
	}

	public void printThrowException() {
		throw new IllegalArgumentException();
	}

}

写一个AOP的前置通知：HijackBeforeMethod

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class HijackBeforeMethod implements MethodBeforeAdvice {
 	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		System.out.println("HijackBeforeMethod : Before method hijacked!");
	}
}

我们把前置通知配置到spring的配置文件,在里面把service和advice组装起来：Spring-Custom.xml

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

	<bean id="customerService" class="CustomerService">
		<property name="name" value="Yong Mook" />
		<property name="url" value="http://www.baidu.com" />
	</bean>

	<bean id="hijackBeforeAdviceBean" class="HijackBeforeMethod"/>

	<bean id="customerServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">

		<property name="target" ref="customerService" />

		<property name="interceptorNames">
			<list>
				<value>hijackBeforeAdviceBean</value>
			</list>
		</property>
	</bean>
</beans>

然后，我们在客户端调用把，首先加载这个xml文件，用代理获取服务类，调用服务类:App.java

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

import com.mkyong.customer.services.CustomerService;

public class App {
	public static void main(String[] args) {
		ApplicationContext appContext = new ClassPathXmlApplicationContext(
				new String[] { "Spring-Customer.xml" });

		CustomerService cust = (CustomerService) appContext
				.getBean("customerServiceProxy");
		
		System.out.println("*************************");
		cust.printName();
		System.out.println("*************************");
		cust.printURL();
		System.out.println("*************************");
		try {
			cust.printThrowException();
		} catch (Exception e) {

		}

		
		
	}
}

附，这里讲了前置通知，其实后置通知，前后通知，异常通知都是一样的用法。写法也只有一点不同

后置通知:HijackAfterMehod.java

import java.lang.reflect.Method;
import java.util.Date;

import org.springframework.aop.AfterReturningAdvice;

public class HijackAfterMethod implements AfterReturningAdvice {
	@Override
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		long time = System.currentTimeMillis();
		System.out.println("currentTime is:"+new Date()+" times:"+time);
	}
}

前后通知:HijackAroundMethod

import java.util.Arrays;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class HijackAroundMethod implements MethodInterceptor {
 	public Object invoke(MethodInvocation methodInvocation) throws Throwable {

		System.out.println("Method name : "
				+ methodInvocation.getMethod().getName());
		System.out.println("Method arguments : "
				+ Arrays.toString(methodInvocation.getArguments()));

		// same with MethodBeforeAdvice
		System.out.println("HijackAroundMethod : Before method hijacked!");

		try {
			// proceed to original method call
			Object result = methodInvocation.proceed();

			// same with AfterReturningAdvice
			System.out.println("HijackAroundMethod : Before after hijacked!");

			return result;

		} catch (IllegalArgumentException e) {
			// same with ThrowsAdvice
			System.out
					.println("HijackAroundMethod : Throw exception hijacked!");
			throw e;
		}
	}
}

异常通知:HijavaThrowException.java

import org.springframework.aop.ThrowsAdvice;

public class HijackThrowException implements ThrowsAdvice {
	public void afterThrowing(IllegalArgumentException e) throws Throwable {
		System.out.println("HijackThrowException : Throw exception hijacked!");
	}
}