这篇文章主要介绍“Spring AOP标签怎么使用”，在日常操作中，相信很多人在Spring AOP标签怎么使用问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Spring AOP标签怎么使用”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
创新互联是专业的五华网站建设公司，五华接单;提供网站设计制作、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行五华网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
1
有一个接口Dao有insert、delete、update三个方法，在insert与update被调用的前后，打印调用前的毫秒数与调用后的毫秒数
首先定义一个Dao接口：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public interface Dao {
public void insert();
public void delete();
public void update();
}然后定义一个实现类DaoImpl：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class DaoImpl implements Dao {
@Override
public void insert() {
System.out.println("DaoImpl.insert()");
}
@Override
public void delete() {
System.out.println("DaoImpl.delete()");
}
@Override
public void update() {
System.out.println("DaoImpl.update()");
}
}最原始的写法，我要在调用insert()与update()方法前后分别打印时间，就只能定义一个新的类包一层，在调用insert()方法与update()方法前后分别处理一下，新的类我命名为ServiceImpl，其实现为：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class ServiceImpl {
private Dao dao = new DaoImpl();
public void insert() {
System.out.println("insert()方法开始时间：" + System.currentTimeMillis());
dao.insert();
System.out.println("insert()方法结束时间：" + System.currentTimeMillis());
}
public void delete() {
dao.delete();
}
public void update() {
System.out.println("update()方法开始时间：" + System.currentTimeMillis());
dao.update();
System.out.println("update()方法结束时间：" + System.currentTimeMillis());
}
}这是最原始的写法，这种写法的缺点也是一目了然：
方法调用前后输出时间的逻辑无法复用，如果有别的地方要增加这段逻辑就得再写一遍
如果Dao有其它实现类，那么必须新增一个类去包装该实现类，这将导致类数量不断膨胀
使用装饰器模式
接着我们使用上设计模式，先用装饰器模式，看看能解决多少问题。装饰器模式的核心就是实现Dao接口并持有Dao接口的引用，我将新增的类命名为LogDao，其实现为：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class LogDao implements Dao {
private Dao dao;
public LogDao(Dao dao) {
this.dao = dao;
}
@Override
public void insert() {
System.out.println("insert()方法开始时间：" + System.currentTimeMillis());
dao.insert();
System.out.println("insert()方法结束时间：" + System.currentTimeMillis());
}
@Override
public void delete() {
dao.delete();
}
@Override
public void update() {
System.out.println("update()方法开始时间：" + System.currentTimeMillis());
dao.update();
System.out.println("update()方法结束时间：" + System.currentTimeMillis());
}
}在使用的时候，可以使用”Dao dao = new LogDao(new DaoImpl())”的方式，这种方式的优点为：
透明，对调用方来说，它只知道Dao，而不知道加上了日志功能
类不会无限膨胀，如果Dao的其它实现类需要输出日志，只需要向LogDao的构造函数中传入不同的Dao实现类即可
不过这种方式同样有明显的缺点，缺点为：
输出日志的逻辑还是无法复用
输出日志的逻辑与代码有耦合，如果我要对delete()方法前后同样输出时间，需要修改LogDao
但是，这种做法相比最原始的代码写法，已经有了很大的改进。
使用代理模式
接着我们使用代理模式尝试去实现最原始的功能，使用代理模式，那么我们就要定义一个InvocationHandler，我将它命名为LogInvocationHandler，其实现为：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class LogInvocationHandler implements InvocationHandler {
private Object obj;
public LogInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if ("insert".equals(methodName) || "update".equals(methodName)) {
System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());
Object result = method.invoke(obj, args);
System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());
return result;
}
return method.invoke(obj, args);
}
}其调用方式很简单，我写一个main函数：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public static void main(String[] args) {
Dao dao = new DaoImpl();
Dao proxyDao = (Dao)Proxy.newProxyInstance(LogInvocationHandler.class.getClassLoader(), new Class[]{Dao.class}, new LogInvocationHandler(dao));
proxyDao.insert();
System.out.println("----------分割线----------");
proxyDao.delete();
System.out.println("----------分割线----------");
proxyDao.update();
}结果就不演示了，这种方式的优点为：
输出日志的逻辑被复用起来，如果要针对其他接口用上输出日志的逻辑，只要在newProxyInstance的时候的第二个参数增加Class数组中的内容即可
这种方式的缺点为：
JDK提供的动态代理只能针对接口做代理，不能针对类做代理
代码依然有耦合，如果要对delete方法调用前后打印时间，得在LogInvocationHandler中增加delete方法的判断
使用CGLIB
接着看一下使用CGLIB的方式，使用CGLIB只需要实现MethodInterceptor接口即可：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class DaoProxy implements MethodInterceptor {
@Override
public Object intercept(Object object, Method method, Object[] objects, MethodProxy proxy) throws Throwable {
String methodName = method.getName();
if ("insert".equals(methodName) || "update".equals(methodName)) {
System.out.println(methodName + "()方法开始时间：" + System.currentTimeMillis());
proxy.invokeSuper(object, objects);
System.out.println(methodName + "()方法结束时间：" + System.currentTimeMillis());
return object;
}
proxy.invokeSuper(object, objects);
return object;
}
}代码调用方式为：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public static void main(String[] args) {
DaoProxy daoProxy = new DaoProxy();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(DaoImpl.class);
enhancer.setCallback(daoProxy);
Dao dao = (DaoImpl)enhancer.create();
dao.insert();
System.out.println("----------分割线----------");
dao.delete();
System.out.println("----------分割线----------");
dao.update();
}使用CGLIB解决了JDK的Proxy无法针对类做代理的问题，但是这里要专门说明一个问题：使用装饰器模式可以说是对使用原生代码的一种改进，使用Java代理可以说是对于使用装饰器模式的一种改进，但是使用CGLIB并不是对于使用Java代理的一种改进。
前面的可以说改进是因为使用装饰器模式比使用原生代码更好，使用Java代理又比使用装饰器模式更好，但是Java代理与CGLIb的对比并不能说改进，因为使用CGLIB并不一定比使用Java代理更好，这两种各有优缺点，像Spring框架就同时支持Java Proxy与CGLIB两种方式。
从目前看来代码又更好了一些，但是我认为还有两个缺点：
无论使用Java代理还是使用CGLIB，编写这部分代码都稍显麻烦
代码之间的耦合还是没有解决，像要针对delete()方法加上这部分逻辑就必须修改代码
最后来看一下使用AOP的方式，首先定义一个时间处理类，我将它命名为TimeHandler：
/**
* @author 五月的仓颉http://www.cnblogs.com/xrq730/p/7003082.html
*/
public class TimeHandler {
public void printTime(ProceedingJoinPoint pjp) {
Signature signature = pjp.getSignature();
if (signature instanceof MethodSignature) {
MethodSignature methodSignature = (MethodSignature)signature;
Method method = methodSignature.getMethod();
System.out.println(method.getName() + "()方法开始时间：" + System.currentTimeMillis());
try {
pjp.proceed();
System.out.println(method.getName() + "()方法结束时间：" + System.currentTimeMillis());
} catch (Throwable e) {
}
}
}
}到第8行的代码与第12行的代码分别打印方法开始执行时间与方法结束执行时间。我这里写得稍微复杂点，使用了 aop:around的写法，其实也可以拆分为 aop:before与 aop:after两种，这个看个人喜好。
这里多说一句，切面方法printTime本身可以不用定义任何的参数，但是有些场景下需要获取调用方法的类、方法签名等信息，此时可以在printTime方法中定义JointPoint，Spring会自动将参数注入，可以通过JoinPoint获取调用方法的类、方法签名等信息。由于这里我用的 aop:around，要保证方法的调用，这样才能在方法调用前后输出时间，因此不能直接使用JoinPoint，因为JoinPoint没法保证方法调用。此时可以使用ProceedingJoinPoint，ProceedingPointPoint的proceed()方法可以保证方法调用，但是要注意一点，ProceedingJoinPoint只能和 aop:around搭配，换句话说，如果aop.xml中配置的是 aop:before，然后printTime的方法参数又是ProceedingJoinPoint的话，Spring容器启动将报错。
接着看一下aop.xml的配置：