학습의 AspectJ를 개발 스프링 AOP를 달성

AspectJ의는 AOP가 AOP 그것은 강력한 기능을 제공하는 자바 기반의 프레임 워크이다.

AspectJ의 프로필 :

　　1.Aspectj AOP는 문법을 정의 Java 언어를 확장 양상 지향 프레임 워크이다.

　　2. 그래서 클래스 파일은 자바 언어를 다음 생성하는 특별한 컴파일러를 가지고있다.

　　3.Aspectj는 Java 기반 AOP 프레임 워크.

　　4. spring2.0 후 AspectJ의 진입 점 발현에 대한 지원을 추가했습니다.

　　JDK1.5 주석이 직접 섹션은 클래스 콩에 정의 할 수 후 AspectJ를 @ 5. 새로 추가

　　6. 스프링 프레임 워크의 새로운 버전은 AOP를 개발하기 위해 AspectJ의 방법을 권장합니다.

　　7. AspectJ를은 관련 패키지를 가져올 필요 : AspectJ를하지 봄의 일부가 AOP 작업에 사용하는 스프링, 그것은 spring2.0 후 AspectJ를위한 지원을 추가하기 때문에.

 

AspectJ를 조작 AOP 두 가지 방법을 사용하여 수행 :

　　1. XML 설정 파일은 AOP를 작동하는 데 사용

　　2. 주석이 AOP 작업을 달성했다.

 

XML은 단계 프로필 AOP 작업을 구현하는 데 사용 :

　　1. 기본 패키지 준비 AOP : (2) 타사 종속성; AspectJ의 관련 (3) 패킷 (1) 기본 스프링 패킷;

　　2. 수입 제한 AOP의를 스프링 코어 구성 파일을 만듭니다 :

　　　　(1) 대상 클래스와 빈 클래스 구성 부;

　　　 (2) <AOP : 구성> </ AOP : 구성> 만들 AOP

　　　　　　* <AOP : 구성>　　

　　　　　　　　　　<AOP : 식 포인트 컷 = "실행 ()"ID = ""/> // 엔트리 포인트 설정

　　　　　　　　　　<AOP : 가로 세로 ID = "" REF = " "콩을 사용하기 섹션>　　　　　　　// 구성 섹션 : 진입 점을 향상시키기 위해 사용되는 프로세스

　　　　　　　　　　　　　　<! - 사전 통지를 ->

　　　　　　　　　　　　　　<AOP : 방법 전에 = "사용되는 강화 된 클래스 (메소드 명)에서 (클래스 부)"포인트 컷-REF = "ID되는 엔트리 포인트가 사용되는"/>

　　　　　　　　　　　　　　<! - 통보 후 ->

　　　　　　　　　　　　　　<AOP : 후 복귀 방법 = ""포인트 컷을-REF = ""/>

　　　　　　　　　　　　　　<! - 서라운드 공지 ->

　　　　　　　　　　　　　　<AOP : 메서드 = ""포인트 컷-REF = ""주변 />

　　　　　　　　　　　　　　<! - 이상 통지 ->

　　　　　　　　　　　　　　<AOP : 애프터 던지는 방법 = ""포인트 컷-REF = ""송구 = "전자"/>

　　　　　　　　　　　　　　<! - 최종 통보 ->

　　　　　　　　　　　　　　<AOP : 메서드 = ""포인트 컷-REF = ""후 />

  　　　　　　　　　</ AOP : 태양>

　　　　　　　</ AOP : 구성>

 

　　스프링 구성 파일에서 사용하는 구성 섹션 <AOP :면> 요소, 요소는 빈 섹션 콩으로 전환 정의 봄이되므로, 구성 파일은 이제 완전한 보통 스프링 빈을 구성해야합니다 사용 후 <AOP : 양태> REF 속성은 빈의 요소를 참조한다 .

　　　　

 

 

 는 XML AspectJ를 바탕으로

　　관련 패키지 1. 도입

　　

 　　2. 인터페이스를 만들기 UserDao

패키지 com.itheima.jdk; 

공중  인터페이스 UserDao {
     공개  공극 ADDUSER ();
    공개  공극 deleteUser (); 
}

　　3. 인터페이스 UserDao를 구현하는 클래스를 만듭니다

package com.itheima.jdk;

import org.springframework.stereotype.Repository;

public class UserDaoImpl implements UserDao {

    public void addUser() {
        System.out.println("添加用户！");

    }

    public void deleteUser() {
        System.out.println("删除用户！");

    }
}

　　4.创建一个切面类

package com.itheima.aspectj.xml;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 切面类，在此类中编写通知
 * @author 12428
 *
 */
public class MyAspect {
    //前置通知
    public void myBefore(JoinPoint joinPoint) {
        
        System.out.println("前置通知：执行权限检查！");
        
        //joinPoint.getTarget()：获取连接点所在的目标对象
        System.out.println("目标类是："+joinPoint.getTarget());
    
        System.out.println("，被植入曾强的连接点的方法签名："+joinPoint.getSignature().getName());
    }
    
    //后置通知
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("后置通知：模拟记录日志。。。。");
        System.out.println("被植入曾强通知目标方法为："+joinPoint.getSignature().getName());
    }
    
    //环绕通知
    /**
     * 环绕通知必须要返回一个Object对象，并且抛出一个错误
     * @param proceedingJoinPoint
     * @return
     * @throws Throwable
     */
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        
        System.out.println("环绕开始：执行目标方法之前：模拟开启事务。。。");
        //执行当前的目标方法:proceed()通过反射执行目标方法连接点处的方法
        Object object=proceedingJoinPoint.proceed();
        System.out.println("环绕结束：执行目标方法之后，模拟关闭事务!");
        
        return object;
        
    }
    
    //异常通知
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {
        System.out.println("异常通知："+"出错了"+e.getMessage());
    }
    
    //最终通知
    public void myAfter() {
        System.out.println("最终通知：模拟方法结束后的释放资源！");
    }
}

 

　　5.创建spring配置文件，在com.itheima.aspectj.xml里面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
        
   
   <!-- 目标类 -->
   <bean id="userDao" class="com.itheima.jdk.UserDaoImpl"/>
   
   <!-- 切面类 -->
   <bean id="myAspect" class="com.itheima.aspectj.xml.MyAspect"/>
   
   <!-- aop编程 -->
   <aop:config>
           <!-- 配置切面 -->
           <aop:aspect ref="myAspect">
               <!-- 3.1配置切入点:并通知最后增强的方法 -->
               <aop:pointcut expression="execution(* com.itheima.jdk.*.*(..))" id="myPointCut"/>
               <!-- 3.2关联通知advice和切入点pointcut -->
                   <!-- 3.2.1前置通知 -->
                   <aop:before method="myBefore" pointcut-ref="myPointCut"/>
                   <!-- 3.2.2后置通知，在方法返回之后执行 -->
                   <aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut"/>
           </aop:aspect>
   </aop:config>
</beans>

　　6.测试类，测试

package com.itheima.aspectj.xml;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itheima.jdk.UserDao;

/**
 * 测试类：用来测试
 * @author 12428
 *
 */
public class TextMyAspect {
    public static void main(String[] args) {
        String xmlPath ="com/itheima/aspectj/xml/applicationContext.xml";
        //得到容器
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
        //获取UserDao
        UserDao userDao=(UserDao) applicationContext.getBean("userDao");
        //执行增强后的方法
        userDao.addUser();
    }
}

 

 

 

 

Aspectj使用注解来实现AOP

　　使用基于XML的声明式Aspectj开发主要问题是要配置许多的代码信息，为了解决这个问题，Aspectj框架为Aop提供了一套注解，用以取代spring配置文件中为了实现Aop开发所配置的臃肿代码。

aspectj的注解及其描述

 

注解名称	描叙
@Aspect	用于定义一个切面
@PointCut	用于定义切入点表达式，在使用时要定义一个包含名字和任意参数的方法来表示切入点名称，实际上，就是一个返回值为void，且方法体为空的普通方法
@Before	用于定义一个前置通知，在使用时，通常需要制定一个value的属性值，该属性值用于指定一个切入点表达式（可以时已有的切入点表达式，也可以直接定义切入点表达式）
@AfterReturning	用于定义后置通知
@Around	用于定义环绕通知
@AfterThrowing	用于定义异常通知来处理程序中为处理的异常，
@After	用于定义最终通知，不管是否异常，该通知都会执行。

 

 

使用注解来实现AOP操作

　　1.引入相关的包

　　

 　　2.创建一个接口UserDao

package com.itheima.jdk;

public interface UserDao {
    public void addUser();
    public void deleteUser();
}

　　3.创建一个类实现接口UserDao

package com.itheima.jdk;

import org.springframework.stereotype.Repository;

@Repository("userDao")
public class UserDaoImpl implements UserDao {

    public void addUser() {
        System.out.println("添加用户！");

    }

    public void deleteUser() {
        System.out.println("删除用户！");

    }
}

　　4.创建切面类

package com.itheima.aspectj.annotation;

import org.aopalliance.intercept.Joinpoint;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 设置一个切面类，使用注解来执行
 * @author 12428
 *
 */
@Aspect  //声明这是一个切面类
@Component //声明这是一个Bean
public class MyAspect {
    
    //定义一个切入点表达式,并且在下面声明一个方法体为空的
    @Pointcut("execution(* com.itheima.jdk.*.*(..))")
    private void myPointCut() {}
    
    //前置通知
    @Before("myPointCut()")
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("前置通知：模拟执行权限检查..");
        System.out.println("目标类是："+joinPoint.getTarget());
        System.out.println("被植入的增强处理的目标方法是："+joinPoint.getSignature().getName());
    }
    
    //后置通知
    @AfterReturning("myPointCut()")
    public void myAfterReturning(JoinPoint joinPoint) {
        System.out.println("后置通知：模拟记录日志。。。。");
        System.out.println("被植入增强的方法是："+joinPoint.getSignature().getName());
    }
    
    //环绕通知
    @Around("myPointCut()")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //开始
        System.out.println("环绕通知开始：执行目标方法之前，模拟开启事务。。。");
        //执行当前目标方法
        Object object=proceedingJoinPoint.getTarget();
        
        //结束
        System.out.println("环绕开始：执行目标方法之后，模拟关闭事务。。。");
        return object;
    }
    
    //异常通知
    @AfterThrowing(value="myPointCut()",throwing="e")
    public void myAfterThrowing(JoinPoint joinPoint,Throwable e) {
        System.out.println("异常通知："+"出错了"+e.getMessage());
    }
    
    //最终通知
    @After("myPointCut()")
    public void myAfter() {
        System.out.println("最终通知：模拟方法结束后的释放资源！");
    }
    
}

　　首先使用了@Aspect注解定义了一个切面类，因为是需要在spring中使用，因此还需要定义一个@Component注解才能生效。然后使用@PointCut注解来定义一个切入点，并通过定义方法来表示一个切入点的名称。

　　注意要在目标类UserDaoImpl中添加注解@Respository（"UserDao"）.

　　5.创建配置文件，在com.itheima.aspectj.annotation

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:context="http://www.springframework.org/schema/context"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
  http://www.springframework.org/schema/aop 
  http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
  http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context-4.3.xsd">
        
    <!-- 指定需要扫描的包，是注解生效 -->
    <context:component-scan base-package="com.itheima"/>
    <!-- 开启基于注解的声明式Aspectj支持 -->
    <aop:aspectj-autoproxy/>
</beans>

 

　　6.测试类

package com.itheima.aspectj.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itheima.jdk.UserDao;

//测试类
public class TestAnnotation {
    public static void main(String[] args) {
        String xmlPath="com/itheima/aspectj/annotation/applicationContext.xml";
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(xmlPath);
        //1.从spring容器获得内容
        UserDao userDao=(UserDao) applicationContext.getBean("userDao");
        userDao.addUser();
    }
}