SpringÖ®AOPÊÊÅäÆ÷ģʽ

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>4.3.21.RELEASE</version>
</dependency>
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.12</version>
</dependency>
<dependency>
	<groupId>aopalliance</groupId>
	<artifactId>aopalliance</artifactId>
	<version>1.0</version>
</dependency>

/**
 * Ä¿±ê¶ÔÏó ½Ó¿Ú
 * @author ²¨²¨¿¾Ñ¼
 * @email dengpbs@163.com
 *
 */
public interface SomeService {

	public void doSome();
}

/**
 * Ä¿±ê¶ÔÏó
 * @author ²¨²¨¿¾Ñ¼
 * @email dengpbs@163.com
 *
 */
public class SomeServiceImpl implements SomeService {

	@Override
	public void doSome() {
		System.out.println("Ä¿±ê¶ÔÏó....·½·¨Ö´ÐÐÁË");
	}
}

/**
 * Ç°ÖÃ֪ͨ
 * 		ÐèҪʵÏÖMethodBeforeAdvice½Ó¿Ú
 * @author ²¨²¨¿¾Ñ¼
 * @email dengpbs@163.com
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	/**
	 * method Ä¿±ê·½·¨
	 * args Ä¿±ê·½·¨²ÎÊýÁбí
	 * target Ä¿±ê¶ÔÏó
	 */
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("Ç°ÖÃִ֪ͨÐÐÁË....");
	}
}

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
	<!-- ×¢²áÄ¿±êÀà -->
	<bean id="someServiceImpl" class="com.dpb.service.SomeServiceImpl" ></bean>
	<!-- ×¢²áÇ°ÖÃ֪ͨ -->
	<bean class="com.dpb.schema.MyMethodBeforeAdvice" id="myMethodBeforeAdvice"></bean>

	<!-- ×¢²á´úÀíÀà -->
	<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- Ö¸¶¨Ä¿±ê¶ÔÏó -->
		<property name="target" ref="someServiceImpl"/>
		<!-- Ö¸¶¨Ä¿±êÀàʵÏÖµÄËùÓÐ½Ó¿Ú -->
		<property name="interfaces" value="com.dpb.service.SomeService"/>
		<!-- Ö¸¶¨ÇÐÃæ -->
		<property name="interceptorNames" >
			<list>
				<value>myMethodBeforeAdvice</value>
			</list>
		</property>
	</bean>
</beans>

@Test
public void test1() {
	ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	// ×¢Òâͨ¹ýgetBean»ñÈ¡ÔöÇ¿µÄ´úÀíÀ࣡£¡£¡
	SomeService some = ac.getBean("proxyFactoryBean",SomeService.class);
	some.doSome();
}

public interface MethodBeforeAdvice extends BeforeAdvice {

	void before(Method method, Object[] args, Object target) throws Throwable;

}

public interface AdvisorAdapter {
	// ÅжÏ֪ͨÀàÐÍÊÇ·ñÆ¥Åä
	boolean supportsAdvice(Advice advice);
	// »ñÈ¡¶ÔÓ¦µÄÀ¹½ØÆ÷
	MethodInterceptor getInterceptor(Advisor advisor);

}

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

	@Override
	public boolean supportsAdvice(Advice advice) {
		return (advice instanceof MethodBeforeAdvice);
	}

	@Override
	public MethodInterceptor getInterceptor(Advisor advisor) {
		MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
		// ֪ͨÀàÐÍÆ¥Åä¶ÔÓ¦µÄÀ¹½ØÆ÷
		return new MethodBeforeAdviceInterceptor(advice);
	}
}

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

	private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);


	/**
	 * Create a new DefaultAdvisorAdapterRegistry, registering well-known adapters.
	 */
	public DefaultAdvisorAdapterRegistry() {
		// ×¢²áÏàÓ¦µÄÊÊÅäÆ÷
		registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
		registerAdvisorAdapter(new AfterReturningAdviceAdapter());
		registerAdvisorAdapter(new ThrowsAdviceAdapter());
	}

	// °ü×°Àà  ½«Í¨Öª×ª»»ÎªÁË ¶ÔÓ¦µÄÊÊÅäÆ÷
	// ±¾°¸ÀýÖн« MyMethodBeforeAdviceת»»ÎªÁËMethodBeforeAdviceAdapter
	@Override
	public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
		if (adviceObject instanceof Advisor) {
			return (Advisor) adviceObject;
		}
		if (!(adviceObject instanceof Advice)) {
			throw new UnknownAdviceTypeException(adviceObject);
		}
		Advice advice = (Advice) adviceObject;
		if (advice instanceof MethodInterceptor) {
			// So well-known it doesn't even need an adapter.
			return new DefaultPointcutAdvisor(advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			// Check that it is supported.
			if (adapter.supportsAdvice(advice)) {
				return new DefaultPointcutAdvisor(advice);
			}
		}
		throw new UnknownAdviceTypeException(advice);
	}
	// »ñÈ¡ÊÊÅäÆ÷¶ÔÓ¦µÄËùÓеÄÀ¹½ØÆ÷
	@Override
	public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
		List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
		Advice advice = advisor.getAdvice();
		if (advice instanceof MethodInterceptor) {
			interceptors.add((MethodInterceptor) advice);
		}
		for (AdvisorAdapter adapter : this.adapters) {
			if (adapter.supportsAdvice(advice)) {
								// µ÷ÓÃÁËÊÊÅäÆ÷µÄ·½·¨
				interceptors.add(adapter.getInterceptor(advisor));
			}
		}
		if (interceptors.isEmpty()) {
			throw new UnknownAdviceTypeException(advisor.getAdvice());
		}
		return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
	}

	@Override
	public void registerAdvisorAdapter(AdvisorAdapter adapter) {
		this.adapters.add(adapter);
	}
}

@Override
public Object invoke(MethodInvocation mi) throws Throwable {
	// Ç°ÖÃ֪ͨ·½·¨
	this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
	// Ä¿±ê¶ÔÏóµÄ·½·¨
	return mi.proceed();
}