spring aop的几种配置方式

1.使用aspect配置aop:

1. 编写切面:

   package com.aligns.spring.aop.aop.aspect;

   import org.aspectj.lang.annotation.After;
   import org.aspectj.lang.annotation.AfterThrowing;
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.Pointcut;

   /**

   • 定义切面：模拟事物
   • @author kefan

   */

   @Aspect
   public class TransactionAspect {

   /**
    * 定义切入点
    */
   @Pointcut("execution(* com.aligns.spring.aop.service.*.*(..))")
   public  void  transactionPointCut(){
   
   }
   
   /**
    * 定义前置通知:开启事物
    */
   @Before("transactionPointCut()")
   public  void  beginTransaction(){
       System.out.println("事物开启....");
   }
   
   /**
    * 定义后置通知：提交事物
    */
   @After("transactionPointCut()")
   public  void  CommitTransaction(){
       System.out.println("事物提交....");
   }
   
   /**
    * 定义异常通知：事物回滚
    */
   @AfterThrowing("transactionPointCut()")
   public  void  rollBackTransaction(){
       System.out.println("事物回滚....");
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31

   }

2. 在spring中配置

   Spring Configuration
   
   
   
   
       
   
   
   
   
   
   
   
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

3. 编写单元测试

   package com.aligns.spring.aop.test;

   import javax.annotation.Resource;

   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.springframework.test.context.ContextConfiguration;
   import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
   import org.springframework.transaction.annotation.Transactional;

   import com.aligns.spring.aop.service.AccountService;
   import com.aligns.spring.aop.service.UserService;

   @RunWith(SpringJUnit4ClassRunner.class)
   //@ContextConfiguration(“classpath*:spring-context.xml,classpath*:spring-context-jedis.xml”)
   @ContextConfiguration(locations = { “classpath*:/spring-context-aspect-test.xml”})
   @Transactional
   public class AspectTest {

   @Resource AccountService accountService;
   @Resource UserService userService;
   
   
   @Test
   public void fun1(){
   
       accountService.inAccount();
       accountService.outAccount();
       userService.addUser();
       userService.deleteUser();
   
       System.out.println(accountService);
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

   }

2.使用编程式配置aop

1. 定义切面

   package com.aligns.spring.aop.aop.programming;

   import org.aspectj.lang.annotation.After;
   import org.aspectj.lang.annotation.AfterThrowing;
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.aspectj.lang.annotation.Pointcut;

   /**

   • 定义切面：模拟事物
   • @author kefan

   */

   public class TransactionAspect {

   /**
    * 定义切入点
    */
   @Pointcut("execution(* com.aligns.spring.aop.service.*.*(..))")
   public  void  transactionPointCut(){
   
   }
   
   /**
    * 定义前置通知:开启事物
    */
   @Before("transactionPointCut()")
   public  void  beginTransaction(){
       System.out.println("事物开启....");
   }
   
   /**
    * 定义后置通知：提交事物
    */
   @After("transactionPointCut()")
   public  void  CommitTransaction(){
       System.out.println("事物提交....");
   }
   
   /**
    * 定义异常通知：事物回滚
    */
   @AfterThrowing("transactionPointCut()")
   public  void  rollBackTransaction(){
       System.out.println("事物回滚....");
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31

   }

2. spring配置

   Spring Configuration
   
   
   
   
       
   
   
   
   
   
   
   
   
   
   
   
   
   
       
       
           
           
           
           
                  
       
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31

3. 编写单元测试

   package com.aligns.spring.aop.test;

   import javax.annotation.Resource;

   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.springframework.test.context.ContextConfiguration;
   import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
   import org.springframework.transaction.annotation.Transactional;

   import com.aligns.spring.aop.service.AccountService;
   import com.aligns.spring.aop.service.UserService;

   /**

   • 测试变成式的创建aop应用
   • @author kefan

   /
   @RunWith(SpringJUnit4ClassRunner.class)
   //@ContextConfiguration("classpath:spring-context.xml,classpath*:spring-context-jedis.xml")
   @ContextConfiguration(locations = { “classpath*:/spring-context-programming-test.xml”})
   @Transactional
   public class ProgrammingTest {

   @Resource AccountService accountService;
   @Resource UserService userService;
   
   
   @Test
   public void fun1(){
   
       accountService.inAccount();
       accountService.outAccount();
       userService.addUser();
       userService.deleteUser();
   
       System.out.println(accountService);
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

   }

3.使用工厂模式配置aop

1. 编写通知:(实现MethodBeforeAdvice等通知接口)
   BeforeLoginAdviser

   package com.aligns.spring.aop.aop.proxyFactory;

   import java.lang.reflect.Method;
   import java.util.Arrays;

   import org.springframework.aop.MethodBeforeAdvice;

   /**

   • 用户登录前检查是否有证书的情况
   • @author kefan

   */
   public class BeforeLoginAdviser implements MethodBeforeAdvice {

   @Override
   public void before(Method method, Object[] args, Object target)
           throws Throwable {
       System.out.println("执行的目标对象为："+target.getClass().getName());
       System.out.println("执行的目标对象的方法为："+method.getName());
       System.out.println("执行的目标对象的方法为："+Arrays.toString(args));
   }
   1
   2
   3
   4
   5
   6
   7

   }

2. 编写业务处理的接口
   UserLogin

   package com.aligns.spring.aop.aop.proxyFactory;

   public interface UserLogin {

   public  void  login();
   1

   }

3. 编写业务处理的实现类

UserLoginImpl

package com.aligns.spring.aop.aop.proxyFactory;

public class UserLoginImpl  implements UserLogin {

    @Override
    public void login() {
        System.out.println("用户登录....");

    }

}
1
2
3
4
5
6
7
8
9
10
11

1. spring中配置代理工厂
   spring-context-factory-test.xml

   Spring Configuration
   
   
   
   
       
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
       
       
       
       
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31

2. 编写单元测试

   package com.aligns.spring.aop.test;

   import javax.annotation.Resource;

   import org.junit.Test;
   import org.junit.runner.RunWith;
   import org.springframework.test.context.ContextConfiguration;
   import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
   import org.springframework.transaction.annotation.Transactional;

   import com.aligns.spring.aop.aop.proxyFactory.UserLogin;

   /**

   • 测试变成式的创建aop应用
   • @author kefan

   /
   @RunWith(SpringJUnit4ClassRunner.class)
   //@ContextConfiguration("classpath:spring-context.xml,classpath*:spring-context-jedis.xml")
   @ContextConfiguration(locations = { “classpath*:/spring-context-factory-test.xml”})
   @Transactional
   public class FactoryTest {

   //@Resource AccountService accountService;
   //@Resource UserService userService;
   
   @Resource UserLogin userLogin;
   
   
   @Test
   public void fun1(){
       userLogin.login();
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

   }