두 가지 Spring AOP 구현 방법의 코드 공유

이 기사에서는 두 가지 Spring AOP 구현 방법의 코드 공유를 주로 소개합니다. 편집자는 이것이 꽤 좋다고 생각하므로 지금 공유하고 참고용으로 제공하겠습니다. 편집기를 따라 살펴보겠습니다

1. 수동으로 AOP 프로그래밍 구현(에이전트 모드)

AOP는 관점 지향 프로그래밍이며 주요 기능은 "비즈니스 코드"와 "우려 코드"의 분리를 실현하는 것입니다. 보조 비즈니스 코드 중 하나는 핵심 비즈니스 코드이고 나머지는 포커스 코드라고 합니다. 데이터베이스에 데이터를 저장하는 예를 들면 다음과 같습니다.

// 保存一个用户
public void add(User user) { 
        Session session = null; 
        Transaction trans = null; 
        try { 
            session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
            trans = session.beginTransaction();    // 【关注点代码】
             
            session.save(user);     // 核心业务代码
             
            trans.commit();     //…【关注点代码】

        } catch (Exception e) {     
            e.printStackTrace(); 
            if(trans != null){ 
                trans.rollback();   //..【关注点代码】

            } 
        } finally{ 
            HibernateSessionFactoryUtils.closeSession(session);   ////..【关注点代码】

        } 
   }

위 코드에서 여러 메서드가 있는 경우 여러 개의 반복 우려 코드를 작성하는 경우, 이것이 잘 수행되지 않으면 자주 반복되는 코드를 추출한 다음 코드의 메소드에 핵심 비즈니스 코드만 작성하면 됩니다. 이러한 효과를 얻기 위한 가장 좋은 방법은 실제로 AOP 프로그래밍에서 핵심 코드와 관련 코드를 분리하기 위해 프록시 모드를 사용하는 것입니다. 이전 프록시 패턴을 구현하는 방법은 동일하므로 더 이상 게시하지 않겠습니다.

2. AOP 프로그래밍

AOP: Aspect Object 프로그래밍

코드 없이 관심사와 비즈니스를 분리하는 기능

Focus:

반복되는 코드를 관심사라고 합니다.관점:
관심으로 형성된 클래스를 관점(클래스)이라고 합니다.관점 지향 프로그래밍은 여러 기능에 대해 반복되는 코드를 추출한 다음 런타임 중에 비즈니스에 추가하는 것을 말합니다. 동적으로 "관점을 이식합니다." class code" in the method

Pointcut:

대상 객체 메소드를 실행하고 애스펙트 코드를 동적으로 이식합니다. 포인트컷 표현식을 통해 어떤 클래스의 메소드를 가로채서 특정 클래스에 대해 실행할 수 있습니다. 애스펙트 클래스를 이식할 때 code
2.1. 주석 방법에 의한 구현

구현 단계:

1. 총 4개의

spring-aop-3.2.5.RELEASE.jar
aopalliance에 관한 aop 관련 jar 패키지를 소개합니다. jar
aspectjweaver.jar
aspectjrt.jar
참고: Spring2.5 버전에서 jar 파일을 사용할 때 jdk1.7을 다시 사용하면 문제가 발생할 수 있으므로 업그레이드가 필요합니다. aspectj 컴포넌트, 즉 Aspectj-1.8.2 버전에서 제공되는 jar 파일을 사용하세요.

2.bean.xml中引入aop名称空间

xmlns:aop="http://www.springframework.org/schema/aop"

3.开始aop注解扫描

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="e_aop_anno"></context:component-scan>
    
        <!-- 开启aop注解方式 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

4.使用注解来实现

• @Aspect:指定当前类为切面类.

• @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") :指定切入点表达式

• @Before("pointCut_()"): 前置通知:在目标方法之前执行

• @After("pointCut_()"):后置通知:目标方法之后执行(如果拦截到,则始终执行)

• @AfterReturning("pointCut_()"):返回后通知:执行方法结束后执行(异常不执行),@after()之后执行.

• @AfterThrowing("pointCut_()"):异常通知:出现异常时候执行

• @Around("pointCut_()"):环绕通知:环绕目标方法执行

代码示例:
目标对象分两个,一个是实现接口IUserDao的UserDao对象和一个没有实现接口的OrderDao对象.然后是抽取出来的切面类Aop,Spring的配置文件bean.xml,以及测试类App

接口IUserDao.java

// 接口
public interface IUserDao {   
    void save();
}

实现接口的:UserDao.java

/** 
* 目标对象 
*/
@Component   // 加入容器
public class UserDao implements IUserDao{    
        
        @Override
        public void save() {
           System.out.println("-----核心业务：保存！！！------");
    }
}

不实现任何接口的OrderDao.java

/** 
* 目标对象 
*/
@Component   // 加入容器
@Scope("prototype")
public class OrderDao{  

  public void save() {
        System.out.println("-----核心业务：保存！！！------");
    }
}

Spring的配置文件bean.xml

抽取出来的切面对象Aop.java

@Component
@Aspect  // 指定当前类为切面类
public class Aop {  

  // 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象

    @Pointcut("execution(* e_aop_anno.*.*(..))")
    //    @Pointcut("execution(* e_aop_anno.UserDao.save(..))")//只拦截UserDao中的save()方法
    public void pointCut_(){
    }  
    
      // 前置通知 : 在执行目标方法之前执行
    @Before("pointCut_()")    public void begin(){
        System.out.println("开始事务/异常");
    }  
    
      // 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】
    @After("pointCut_()")    public void after(){
        System.out.println("提交事务/关闭");
    }  
    
      // 返回后通知： 在调用目标方法结束后执行 【出现异常不执行】
    @AfterReturning("pointCut_()")    public void afterReturning() {
        System.out.println("afterReturning()");
    }    // 异常通知： 当目标方法执行异常时候执行此关注点代码
    @AfterThrowing("pointCut_()")    
    public void afterThrowing(){
        System.out.println("afterThrowing()");
    }  
    
      // 环绕通知：环绕目标方式执行
    @Around("pointCut_()")    
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前....");
        pjp.proceed();  // 执行目标方法
        System.out.println("环绕后....");
    }

}

测试类App.java

public class App {

    ApplicationContext ac =       
         new ClassPathXmlApplicationContext("e_aop_anno/bean.xml");   
   // 目标对象有实现接口，spring会自动选择“JDK代理”,UserDao是实现了接口
    @Test
    public void testApp() {
        IUserDao userDao = (IUserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());//$Proxy001
        userDao.save();
    }    // 目标对象没有实现接口， spring会用“cglib代理”,OrderDao没有实现接口
    @Test
    public void testCglib() {
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }    @Test
    public void testGetObj() throws Exception {
        OrderDao orderDao1 = (OrderDao) ac.getBean("orderDao");
        OrderDao orderDao2 = (OrderDao) ac.getBean("orderDao");

        System.out.println(orderDao1);//e_aop_anno.OrderDao@5b295b
        System.out.println(orderDao2);//e_aop_anno.OrderDao@1e5f737
         System.out.println(orderDao1==orderDao2);//false

    }
}

测试结果:
testApp()和testCglib()的测试结果为:

//测试输出环绕前....
开始事务/异常
-----核心业务：保存！！！------
环绕后....
提交事务/关闭afterReturning()

2.2.XML配置方式实现

使用XML配置方法来实现AOP编程的步骤:
1.引入jar文件
同注解实现AOP中的四个一样
2.引入aop名称空间
同注解实现AOP中
3.AOP配置
配置主要有两部分组成,一个是各种实例对象的创建,一个是aop的配置(拦截哪些方法/拦截到方法后应用通知代码)

代码示例:
同注解方式中的代码是差不多的,两个对象,分别是实现了接口的UserDao和没有实现任何接口的OrderDao.这个两个类跟上面是一样的,没有做改变,改变是在AOP切面类中以及bean.xml的配置中.测试类也没有做改变
UserDao.java和OrderDoa.java不在显示.
切面类aop.java代码:

// 切面类public class Aop {    public void begin(){
        System.out.println("开始事务/异常");
    }    public void after(){
        System.out.println("提交事务/关闭");
    }    public void afterReturning() {
        System.out.println("afterReturning()");
    }    public void afterThrowing(){
        System.out.println("afterThrowing()");
    }    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前....");
        pjp.proceed();  // 执行目标方法
        System.out.println("环绕后....");
    }

}

注意没有注解了.
配置文件bean.xml

测试类:app.java

public class App {

    ApplicationContext ac =            new ClassPathXmlApplicationContext("f_aop_xml/bean.xml");    // 目标对象有实现接口，spring会自动选择“JDK代理”
    @Test
    public void testApp() {
        IUserDao userDao = (IUserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());//$Proxy001
        userDao.save();
    }    // 目标对象没有实现接口， spring会用“cglib代理”
    @Test
    public void testCglib() {
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }
}

2.3.切入点表示式

切入点表达式:可以对指定的方法进行拦截,从而给指定的方法所在的类生成代理对象.

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throes-pattern?)

从语法来看,只有返回类型和方法是必须要写的.返回类型一般用表示,写方法的时候可以通过匹配各种包或者类或者方法.

表示式使用示例:

위 내용은 두 가지 Spring AOP 구현 방법의 코드 공유의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!