Spring面向切面编程AOP(ApplicationContext.xml配置)

Spring面向切面编程(ApplicationContext.xml配置)

---

• AOP概念  : Aspect oriented programming  面向切面编程
  我们在某个方面的功能提出来与一批对象进行隔离，这样与一批对象之间降低了耦合性，可以就某个功能进行编程。在程序中运行期间  不修改源代码 对已经有的方法进行增强

• AOP的相关术语

  1. jointpoint（连接点）:连接点是应用程序提供给切面插入的地方(切面对象的所有方法)，可以添加新的方法。
  2. pointcut（切点）：把通知advice要插入的点(切面对象类中被aop代理的方法)
  3. advice（通知）：advice是我们切面功能的实现，它通知程序新的行为。(要为切点添加的功能)
  4. target（目标类）：切点所在的类
  5. proxy（代理类）：被置入advice后形成的类,target+advice
  6. aspect（切面）：是切点和通知的结合
  7. weaving(织入）：是指应用aspects到一个target对象创建proxy对象的过程：complie time(编译期)，classload time(加载期)，runtime(运行期) 

• 具体案例代码实现

  1. 项目目录结构+mevan依赖
     
     
     

  2. AccountServiceImpl

     package cn.kgc.service.impl;
     
     import cn.kgc.service.AccountService;
     import org.springframework.stereotype.Service;
     
     @Service
     public class AccountServiceImpl implements AccountService {
         public void transfer(String name) {
             System.out.println(name+":正在转账....");
         }
     }
     

      

  3. UserServiceImpl

     package cn.kgc.service.impl;
     
     import cn.kgc.service.UserService;
     import org.springframework.stereotype.Service;
     
     @Service
     public class UserServiceImpl implements UserService {
         public void print() {
             System.out.println("UserServiceImple:打印方法...");
         }
     }
     

      

  4. 通知类Logger

     package cn.kgc;
     
     import org.aspectj.lang.JoinPoint;
     import org.aspectj.lang.ProceedingJoinPoint;
     import org.aspectj.lang.Signature;
     import org.springframework.stereotype.Service;
     
     @Service
     public class Logger {
         public void before(JoinPoint joinPoint){
             Object target = joinPoint.getTarget();
             String className = target.getClass().getName();
             System.out.println("截取的类名:" + className);
             Signature signature = joinPoint.getSignature();
             String name = signature.getName();
             System.out.println("截取方法名字:" + name);
             System.out.println("前置通知代码.....");
     
         }
         public void afterReturing(){
             System.out.println("后置通知代码...");
         }
         public void after(){
             System.out.println("finally终置代码...");
         }
     
         public void afterThrowing(Exception e) {
             System.out.println("方法运行异常:" + e);
         }
     
         public void around(ProceedingJoinPoint proceedingJoinPoint) {
             System.out.println("前置代码");
             try {
                 proceedingJoinPoint.proceed();
             } catch (Throwable throwable) {
                 throwable.printStackTrace();
                 System.out.println("异常执行代码");
             }finally{
                 System.out.println("finally终置通知代码");
             }
         }
     }
     

      

  5. 配置文件applicationContext.xml

      

• 测试类TestAop

• package cn.kgc;
  
  import cn.kgc.service.AccountService;
  import cn.kgc.service.UserService;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.test.context.ContextConfiguration;
  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  
  @RunWith(SpringJUnit4ClassRunner.class)
  @ContextConfiguration("classpath:applicationContext.xml")
  public class TestAop {
      @Autowired
      private UserService userService;
      @Autowired
      private AccountService accountService;
      @Test
      public void test(){
          userService.print();
          System.out.println("--------------------------");
          accountService.transfer("小芳");
      }
  
  }