java写了个接口并写了个实现类：

1. package myspring.calculator;
2. public interface IArithmeticCalculator {
3. public double add(double a, double b);
4. public double sub(double a, double b);
5. public double mul(double a, double b);
6. public double div(double a, double b);
7. }

1. package myspring.calculator;
2. import org.apache.commons.logging.Log;
3. import org.apache.commons.logging.LogFactory;
4. public class ArithmeticCalculatorImp implements IArithmeticCalculator {
5. public double add(double a, double b) {
6. double result = a + b;
7. System.out.println(a + " + " + b + " = " + result);
8. return result;
9. }
10. public double sub(double a, double b) {
11. double result = a - b;
12. System.out.println(a + " - " + b + " = " + result);
13. return result;
14. }
15. public double mul(double a, double b) {
16. double result = a * b;
17. System.out.println(a + " * " + b + " = " + result);
18. return result;
19. }
20. public double div(double a, double b) {
21. if (b == 0) {
22. throw new IllegalArgumentException("Division by zero");
23. }
24. double result = a / b;
25. System.out.println(a + " / " + b + " = " + result);
26. return result;
27. }
28. }

在spring配置文件aop-base.xml中配置好

1. <bean id="arithmeticCalculator" class="myspring.calculator.ArithmeticCalculatorImp" />
2. <bean id="arithmeticCalculatorProxy"
3. class="org.springframework.aop.framework.ProxyFactoryBean">
4. <property name="target" ref="arithmeticCalculator"></property>
5. <property name="interceptorNames"><!--定义使用何种方式拦截-->
6. <list>
7. <!-- <value>logBeforeAdvice</value>
8. <value>logAfterReturning</value>
9. <value>logThrowsAdvice</value> -->
10. <value>logAroundAdvice</value>
11. </list>
12. </property>
13. </bean>

在用到接口里方法的地方加载配置文件并获得代理类：

1. ApplicationContext ac = new ClassPathXmlApplicationContext("aop-base.xml");
2. IArithmeticCalculator calculatorProxy =
3. (IArithmeticCalculator)ac.getBean("arithmeticCalculatorProxy");
4. calculatorProxy.add(2, 3);
5. calculatorProxy.sub(5, 3);
6. calculatorProxy.mul(3, 4);
7. calculatorProxy.div(6, 1);

在配置文件中可以看到，使用了logAroundAdvice这个拦截器（我也不知道是不是叫拦截器）

1. 配置文件中还要配置拦截器：
2. <bean id="logAroundAdvice" class="myspring.aop.LogAroundAdvice" />

拦截器的实现类为：

1. package myspring.aop;
2. import org.aopalliance.intercept.MethodInterceptor;
3. import org.aopalliance.intercept.MethodInvocation;
4. public class LogAroundAdvice implements MethodInterceptor{
5. //MethodInvocation相当于Method的包装类
6. public Object invoke(MethodInvocation methodInvocation) throws Throwable {
7. MyLogger logger = new MyLogger();
8. try{
9. logger.log("before: "+methodInvocation.getMethod().getName()+
10. ",    args"+methodInvocation.getArguments());
11. //须执行目标方法！
12. Object result = methodInvocation.proceed();
13. logger.log("after: "+methodInvocation.getMethod().getName());
14. //注意返回目标方法的返回值
15. return result;
16. }
17. catch(Exception e)
18. {
19. logger.log("Exception: "+e.getMessage());
20. throw e;
21. }
22. }
23. }

这个类实现了MethodInterceptor这个接口，表示在调用目标方法之前与之后都执行拦截。

以上拦截方式中完整的配置文件如下：

1. <beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://www.springframework.org/schema/beans
4. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
5. <!-- Target -->
6. <bean id="arithmeticCalculator" class="myspring.calculator.ArithmeticCalculatorImp" />
7. <!-- Advice -->
8. <bean id="logBeforeAdvice" class="myspring.aop.LogBeforeAdvice" />
9. <bean id="logAfterReturning" class="myspring.aop.LogAfterReturningAdvice" />
10. <bean id="logThrowsAdvice" class="myspring.aop.logThrowsAdvice" />
11. <bean id="logAroundAdvice" class="myspring.aop.LogAroundAdvice" />
12. <!-- Proxy -->
13. <bean id="arithmeticCalculatorProxy"
14. class="org.springframework.aop.framework.ProxyFactoryBean">
15. <property name="target" ref="arithmeticCalculator"></property>
16. <property name="interceptorNames">
17. <list>
18. <!-- <value>logBeforeAdvice</value>
19. <value>logAfterReturning</value>
20. <value>logThrowsAdvice</value> -->
21. <value>logAroundAdvice</value>
22. </list>
23. </property>
24. </bean>
25. </beans>

以上的方法可以拦截目标类中的所有方法，如果只拦截指定方法就不能用这个了。

配置文件要换一下

1. <bean id="arithmeticCalculatorProxy"
2. class="org.springframework.aop.framework.ProxyFactoryBean">
3. <property name="target" ref="arithmeticCalculator"></property>
4. <property name="interceptorNames">
5. <list>
6. <value>nameMatchAdvisor</value>                             </list>
7. </property>
8. </bean>
9. <bean id="nameMatchAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
10. <property name="mappedNames">
11. <list>
12. <value>add</value><!--只拦截这两个方法-->
13. <value>sub</value>
14. </list>
15. </property>
16. <property name="advice" ref="logAroundAdvice" /><!--按照这个拦截器的方式拦截那两个方法-->
17. </bean>

以上拦截方式中的完整配置文件如下：

1. <beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://www.springframework.org/schema/beans
4. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
5. <!-- Target -->
6. <bean id="arithmeticCalculator" class="myspring.calculator.ArithmeticCalculatorImp" />
7. <!-- Advice -->
8. <bean id="logBeforeAdvice" class="myspring.aop.LogBeforeAdvice" />
9. <bean id="logAfterReturning" class="myspring.aop.LogAfterReturningAdvice" />
10. <bean id="logThrowsAdvice" class="myspring.aop.logThrowsAdvice" />
11. <bean id="logAroundAdvice" class="myspring.aop.LogAroundAdvice" />
12. <bean id="nameMatchAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
13. <property name="mappedNames">
14. <list>
15. <value>add</value>
16. <value>sub</value>
17. </list>
18. </property>
19. <property name="advice" ref="logAroundAdvice" />
20. </bean>
21. <bean id="arithmeticCalculatorProxy"
22. class="org.springframework.aop.framework.ProxyFactoryBean">
23. <property name="target" ref="arithmeticCalculator"></property>
24. <property name="interceptorNames">
25. <list>
26. <value>nameMatchAdvisor</value>
27. </list>
28. </property>
29. </bean>
30. </beans>