Spring AOP介绍与使用
AOP：Aspect Oriented Programming 面向切面编程
OOP：Object Oriented Programming 面向对象编程
面向切面编程：基于OOP基础之上新的编程思想，OOP面向的主要对象是类，而AOP面向的主要对象是切面，在处理日志、安全管理、事务管理等方面有非常重要的作用。AOP是Spring中重要的核心点，虽然IOC容器没有依赖AOP，但是AOP提供了非常强大的功能，用来对IOC做补充。通俗点说的话就是在程序运行期间，将某段代码动态切入到指定方法的指定位置进行运行的这种编程方式。
1、AOP的概念
为什么要引入AOP?
Calculator.java
package com.courage.inter;
public interface Calculator {
public int add(int i,int j);
public int sub(int i,int j);
public int mult(int i,int j);
public int div(int i,int j);
}
MyCalculator.java
package com.courage.inter;
public class MyCalculator implements Calculator {
public int add(int i, int j) {
int result = i + j;
return result;
}
public int sub(int i, int j) {
int result = i - j;
return result;
}
public int mult(int i, int j) {
int result = i * j;
return result;
}
public int div(int i, int j) {
int result = i / j;
return result;
}
}
MyTest.java
public class MyTest {
public static void main(String[] args) throws SQLException {
MyCalculator myCalculator = new MyCalculator();
System.out.println(myCalculator.add(1, 2));
}
}
此代码非常简单，就是基础的javase的代码实现，此时如果需要添加日志功能应该怎么做呢，只能在每个方法中添加日志输出，同时如果需要修改的话会变得非常麻烦。
MyCalculator.java
package com.courage.inter;
public class MyCalculator implements Calculator {
public int add(int i, int j) {
System.out.println("add 方法开始执行，参数为："+i+","+j);
int result = i + j;
System.out.println("add 方法开始完成结果为："+result);
return result;
}
public int sub(int i, int j) {
System.out.println("sub 方法开始执行，参数为："+i+","+j);
int result = i - j;
System.out.println("add 方法开始完成结果为："+result);
return result;
}
public int mult(int i, int j) {
System.out.println("mult 方法开始执行，参数为："+i+","+j);
int result = i * j;
System.out.println("add 方法开始完成结果为："+result);
return result;
}
public int div(int i, int j) {
System.out.println("div 方法开始执行，参数为："+i+","+j);
int result = i / j;
System.out.println("add 方法开始完成结果为："+result);
return result;
}
}
可以考虑将日志的处理抽象出来，变成工具类来进行实现：
LogUtil.java
package com.courage.util;
import java.util.Arrays;
public class LogUtil {
public static void start(Object ... objects){
System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
}
public static void stop(Object ... objects){
System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
}
}
MyCalculator.java
package com.courage.inter;
import com.courage.util.LogUtil;
public class MyCalculator implements Calculator {
public int add(int i, int j) {
LogUtil.start(i,j);
int result = i + j;
LogUtil.stop(result);
return result;
}
public int sub(int i, int j) {
LogUtil.start(i,j);
int result = i - j;
LogUtil.stop(result);
return result;
}
public int mult(int i, int j) {
LogUtil.start(i,j);
int result = i * j;
LogUtil.stop(result);
return result;
}
public int div(int i, int j) {
LogUtil.start(i,j);
int result = i / j;
LogUtil.stop(result);
return result;
}
}
按照上述方式抽象之后，代码确实简单很多，但是大家应该已经发现在输出的信息中并不包含具体的方法名称，我们更多的是想要在程序运行过程中动态的获取方法的名称及参数、结果等相关信息，此时可以通过使用动态代理的方式来进行实现。
CalculatorProxy.java
package com.courage.proxy;
import com.courage.inter.Calculator;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
* 帮助Calculator生成代理对象的类
*/
public class CalculatorProxy {
/**
*
* 为传入的参数对象创建一个动态代理对象
* @param calculator 被代理对象
* @return
*/
public static Calculator getProxy(final Calculator calculator){
//被代理对象的类加载器
ClassLoader loader = calculator.getClass().getClassLoader();
//被代理对象的接口
Class<?>[] interfaces = calculator.getClass().getInterfaces();
//方法执行器，执行被代理对象的目标方法
InvocationHandler h = new InvocationHandler() {
/**
* 执行目标方法
* @param proxy 代理对象，给jdk使用，任何时候都不要操作此对象
* @param method 当前将要执行的目标对象的方法
* @param args 这个方法调用时外界传入的参数值
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//利用反射执行目标方法,目标方法执行后的返回值
// System.out.println("这是动态代理执行的方法");
Object result = null;
try {
System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(args));
result = method.invoke(calculator, args);
System.out.println(method.getName()+"方法执行完成，结果是："+ result);
} catch (Exception e) {
System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
} finally {
System.out.println(method.getName()+"方法执行结束了......");
}
//将结果返回回去
return result;
}
};
Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
return (Calculator) proxy;
}
}
我们可以看到这种方式更加灵活，而且不需要在业务方法中添加额外的代码，这才是常用的方式。如果想追求完美的同学，还可以使用上述的日志工具类来完善。
LogUtil.java
package com.courage.util;
import java.lang.reflect.Method;
import java.util.Arrays;
public class LogUtil {
public static void start(Method method, Object ... objects){
// System.out.println("XXX方法开始执行，使用的参数是："+ Arrays.asList(objects));
System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
}
public static void stop(Method method,Object ... objects){
// System.out.println("XXX方法执行结束，结果是："+ Arrays.asList(objects));
System.out.println(method.getName()+"方法开始执行，参数是："+ Arrays.asList(objects));
}
public static void logException(Method method,Exception e){
System.out.println(method.getName()+"方法出现异常："+ e.getMessage());
}
public static void end(Method method){
System.out.println(method.getName()+"方法执行结束了......");
}
}
CalculatorProxy.java
package com.courage.proxy;
import com.courage.inter.Calculator;
import com.courage.util.LogUtil;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
* 帮助Calculator生成代理对象的类
*/
public class CalculatorProxy {
/**
*
* 为传入的参数对象创建一个动态代理对象
* @param calculator 被代理对象
* @return
*/
public static Calculator getProxy(final Calculator calculator){
//被代理对象的类加载器
ClassLoader loader = calculator.getClass().getClassLoader();
//被代理对象的接口
Class<?>[] interfaces = calculator.getClass().getInterfaces();
//方法执行器，执行被代理对象的目标方法
InvocationHandler h = new InvocationHandler() {
/**
* 执行目标方法
* @param proxy 代理对象，给jdk使用，任何时候都不要操作此对象
* @
最低0.47元/天 解锁文章
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
