aop 例子(annotation方式实现)

面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

面向切面编程：就是在原直线编程的某处咔嚓一下，加点动西，而且不影响原来的代码。可以用在日志，加权限，事物，异常管理等方面。

 

从简单的例子说起：

现在有一个save（）方法，需要在save（）前、后分别加上日志打印的信息。

1. public class UserDAOImp implements UserDAO
2. {
3. @Override
4. public void save(User u)
5. {
6. System.out.println("a DAO implements!");
7. }
8. }

1.  解决办法一：

直接在源代码save里加一些输出就行了。

前提条件：有源代码！

1. public class UserDAOImp implements UserDAO
2. {
3. @Override
4. public void save(User u)
5. {
6. System.out.println("before!!!!!");
7. System.out.println("a DAO implements!");
8. System.out.println("after!!!!!!");
9. }
10. }

评价：傻瓜式的！可拓展性差！！

2.  解决办法二：

如果没有源代码呢？

可以继承UserDAOImp, 然后在xml中将bean的class改成继承的类。

前提条件：继承

1. public class UserDAOImp1 extends UserDAOImp
2. {
3. @Override
4. public void save(User u)
5. {
6. System.out.println("save start......");
7. super.save(u);
8. }
9. }

评价：继承尽量少用。可拓展性也差！！

 

3.  解决办法三：

针对第二种办法优化，用接口。

1. public class UserDAOImp2 implements UserDAO
2. {
3. private UserDAO userDAO = new UserDAOImp();
4. @Override
5. public void save(User u)
6. {
7. System.out.println("save start.....");
8. userDAO.save(u);
9. }
10. }

评价：比较灵活了，但还是有一个问题, 当有1000个bean时, 就要组合1000次........如何解决?

4. 解决办法四：

AOP

在不修改源代码的情况下给程序动态统一添加功能。

1. /*
2. *面向切面编程, 动态代理. Aspect声明切面, Component初始化.
3. */
4. @Aspect
5. @Component
6. public class LogInterceptor
7. {
8. //这个可用来替代以后重复出现的. 直接在后面的Before("myMethod()")就行了.
9. @Pointcut("execution(public * com.dao.impl..*.*(..))")
10. public void myMethod(){};
11. //下面用到的是织入点语法, 看文档里面有. 就是指定在该方法前执行
12. //@Before("execution(public void com.dao.impl.UserDAOImp.save(com.model.User))")
13. //记住下面这种通用的, *表示所有
14. @Before("execution(public * com.dao.impl..*.*(..))")
15. public void beforeMethod()
16. {
17. System.out.println("save start......");
18. }
19. //正常执行完后
20. @AfterReturning("execution(public * com.dao.impl..*.*(..))")
21. public void afterReturnning()
22. {
23. System.out.println("after save......");
24. }
25. //抛出异常时才调用
26. @AfterThrowing("myMethod()")
27. public void afterThrowing()
28. {
29. System.out.println("after throwing......");
30. }
31. //环绕, 这个特殊点.
32. @Around("myMethod()")
33. public void aroundMethod(ProceedingJoinPoint pjp) throws Throwable
34. {
35. //加逻辑的时候, 不要依赖执行的的先后顺序
36. System.out.println("method around start!");
37. pjp.proceed();
38. System.out.println("method around end!");
39. }
40. }