spring-aop概述、aop面向切面编程

最新推荐文章于 2023-08-20 00:12:59 发布
最新推荐文章于 2023-08-20 00:12:59 发布
阅读量349 收藏
点赞数
分类专栏： Java框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sharpen__/article/details/109744165
版权

AOP，面向切面编程。面向切面编程是从动态角度考虑程序运行过程。
AOP 底层，就是采用动态代理模式实现的。采用了两种代理：JDK 的动态代理，与 CGLIB
的动态代理。

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，可通过运行期动态代理实现程序功能的统一维护的一种技术。AOP 是 Spring 框架中的一个重要内容。利用 AOP
可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程
序的可重用性，同时提高了开发的效率。

面向切面编程，就是将交叉业务逻辑封装成切面，利用 AOP 容器的功能将切面织入到
主业务逻辑中。所谓交叉业务逻辑是指，通用的、与主业务逻辑无关的代码，如安全检查、
事务、日志、缓存等。
若不使用 AOP，则会出现代码纠缠，即交叉业务逻辑与主业务逻辑混合在一起。这样，
会使主业务逻辑变的混杂不清。
例如，转账，在真正转账业务逻辑前后，需要权限控制、日志记录、加载事务、结束事
务等交叉业务逻辑，而这些业务逻辑与主业务逻辑间并无直接关系。但，它们的代码量所占
比重能达到总代码量的一半甚至还多。它们的存在，不仅产生了大量的“冗余”代码，还大
大干扰了主业务逻辑---转账。

面向切面编程对有什么好处？
1.减少重复；
2.专注业务；
注意：面向切面编程只是面向对象编程的一种补充。

使用 AOP 减少重复代码，专注业务实现。

在这里插入图片描述
AOP 编程术语
接上一篇博客：https://blog.csdn.net/Sharpen__/article/details/109741343

（1） 切面（Aspect）
切面泛指交叉业务逻辑。上例中的事务处理、日志处理就可以理解为切面。常用的切面
是通知（Advice）。实际就是对主业务逻辑的一种增强。
（2） 连接点（JoinPoint）
连接点指可以被切面织入的具体方法。通常业务接口中的方法均为连接点。
（3） 切入点（Pointcut）
切入点指声明的一个或多个连接点的集合。通过切入点指定一组方法。
被标记为 final 的方法是不能作为连接点与切入点的。因为最终的是不能被修改的，不
能被增强的。
（4） 目标对象（Target）
目 标对象指将要被增强的对象 。即包含主业务逻辑的类的对象。上例中的StudentServiceImpl 的对象若被增强，则该类称为目标类，该类对象称为目标对象。当然，不被增强，也就无所谓目标不目标了。
（5） 通知（Advice）
通知表示切面的执行时间，Advice 也叫增强。上例中的 MyInvocationHandler 就可以理
解为是一种通知。换个角度来说，通知定义了增强代码切入到目标代码的时间点，是目标方
法执行之前执行，还是之后执行等。通知类型不同，切入时间不同。
切入点定义切入的位置，通知定义切入的时间。

AspectJ 对 AOP 的实现

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向
切面编程。然而，AspectJ 也实现了 AOP 的功能，且其实现方式更为简捷，使用更为方便，而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。
在 Spring 中使用 AOP 开发时，一般使用 AspectJ 的实现方式。

aspectj框架实现aop的两种方式：
1.使用xml配置文件：配置全局事务
2.使用注解，我们在项目中要做aop功能，一般都使用注解，aspectj有5个注解。

AspectJ 简介：AspectJ 是一个优秀面向切面的框架，它扩展了 Java 语言，提供了强大的切面实现。

官网地址：http://www.eclipse.org/aspectj/

好处：1.（一种基于 Java 平台的面向切面编程的语言）
2.（兼容 Java 平台，可以无缝扩展）
3.（易学易用）

AspectJ 的通知类型
切面的执行时间，这个执行时间在规范中叫做Advice（通知、增强）

AspectJ 中常用的通知有五种类型：
（1）前置通知  @Before
（2）后置通知  @AfterReturning
（3）环绕通知  @Around
（4）异常通知  @AfterThrowing
（5）最终通知  @After

AspectJ 的切入点表达式
AspectJ 定义了专门的表达式用于指定切入点。表达式的原型是：

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

解释：

modifiers-pattern] 访问权限类型
ret-type-pattern 返回值类型
declaring-type-pattern 包名类名
name-pattern(param-pattern) 方法名(参数类型和参数个数)
throws-pattern 抛出异常类型
？表示可选的部分以上表达式共 4 个部分。
execution(访问权限 方法返回值 方法声明(参数) 异常类型)

切入点表达式要匹配的对象就是目标方法的方法名。所以，execution 表达式中明显就
是方法的签名。注意，表达式中黑色文字表示可省略部分，各部分间用空格分开。在其中可
以使用以下符号。
在这里插入图片描述
举例：

execution(public * *(..)) 
指定切入点为：任意公共方法。
execution(* set*(..)) 
指定切入点为：任何一个以“set”开始的方法。
execution(* com.xyz.service.*.*(..)) 
指定切入点为：定义在 service 包里的任意类的任意方法。
execution(* com.xyz.service..*.*(..))
指定切入点为：定义在 service 包或者子包里的任意类的任意方法。“..”出现在类名中时，后
面必须跟“*”，表示包、子包下的所有类。
execution(* *..service.*.*(..))
指定所有包下的 serivce 子包下所有类（接口）中所有方法为切入点
execution(* *.service.*.*(..))
指定只有一级包下的 serivce 子包下所有类（接口）中所有方法为切入点
execution(* *.ISomeService.*(..))
指定只有一级包下的 ISomeSerivce 接口中所有方法为切入点
execution(* *..ISomeService.*(..))
指定所有包下的 ISomeSerivce 接口中所有方法为切入点
execution(* com.xyz.service.IAccountService.*(..)) 
指定切入点为：IAccountService 接口中的任意方法。
execution(* com.xyz.service.IAccountService+.*(..)) 
指定切入点为：IAccountService 若为接口，则为接口中的任意方法及其所有实现类中的任意
方法；若为类，则为该类及其子类中的任意方法。
execution(* joke(String,int)))
指定切入点为：所有的 joke(String,int)方法，且 joke()方法的第一个参数是 String，第二个参
数是 int。如果方法中的参数类型是 java.lang 包下的类，可以直接使用类名，否则必须使用
全限定类名，如 joke( java.util.List, int)。
execution(* joke(String,*))) 
指定切入点为：所有的 joke()方法，该方法第一个参数为 String，第二个参数可以是任意类
型，如joke(String s1,String s2)和joke(String s1,double d2)都是，但joke(String s1,double d2,String 
s3)不是。
execution(* joke(String,..))) 
指定切入点为：所有的 joke()方法，该方法第一个参数为 String，后面可以有任意个参数且
参数类型不限，如 joke(String s1)、joke(String s1,String s2)和 joke(String s1,double d2,String s3)
都是。
execution(* joke(Object))
指定切入点为：所有的 joke()方法，方法拥有一个参数，且参数是 Object 类型。joke(Object ob)
是，但，joke(String s)与 joke(User u)均不是。
execution(* joke(Object+))) 
指定切入点为：所有的 joke()方法，方法拥有一个参数，且参数是 Object 类型或该类的子类。
不仅 joke(Object ob)是，joke(String s)和 joke(User u)也是。

在这里插入图片描述
在这里插入图片描述
applicationContext.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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    把对象交给spring容器，由spring容器创建，管理对象-->
<!--    声明目标对象-->
    <bean id="someService" class="com.b204.ba01.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba01.MyAspect"/>

<!--    声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象
        创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象
        所以目标对象就是被修改后的代理对象

        aspectj-autoproxy:会把spring容器中的左右的目标对象，一次性都生成代理对象
    -->
    <aop:aspectj-autoproxy/>

</beans>

myAspect.java

/**
 * @Aspect :是aspectj框架注解  作用：表示当前类是切面类  切面类：是用来给业务方法增加功能的类，在这个各类中
 * 有切面的功能代码
 * 位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 定义方法，方法是实现切面功能的。
     * 方法的定义要求：
     * 1.公共方法public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法可以有参数，也可以没有参数
     * 如果有参数，参数不是自定义的，有几个参数类型都可以使用
     */
    /**
     * @Before：前置通知注解
     * 属性：value，是切入点表达式，表示切面的功能执行的位置。
     * 位置：在方法的上面
     * 特点：
     * 1.在目标方法之前先执行
     * 2.不会改变目标方法的执行结果
     * 3.不会影响目标方法的执行
     */
    /*@Before(value = "execution(public void com.b204.ba01.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(){
        //切面要执行的功能代码
        System.out.println("前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }*/

    /*@Before(value = "execution(void com.b204.ba01.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(){
        //切面要执行的功能代码
        System.out.println("1=====前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }*/

    /*@Before(value = "execution(void *..SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(){
        //切面要执行的功能代码
        System.out.println("2===前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }*/
    @Before(value = "execution(* *..SomeServiceImpl.do*(..))")
    public void myBefore(){
        //切面要执行的功能代码
        System.out.println("3==前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }
    /*@Before(value = "execution(* *..SomeServiceImpl.do*(..))")
    public void myBefore02(){
        //切面要执行的功能代码
        System.out.println("3==前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }*/
//    给所有的以ServiceImpl结尾的类加功能
    @Before(value = "execution(* com.b204.ba01.*ServiceImpl.*(..))")
    public void myBefore03(){
        //切面要执行的功能代码
        System.out.println("3==前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }

}

接口：

public interface SomeService {
    void doSome(String name,Integer age);
}

接口实现类：

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        //给doSome方法增加功能，在doSome()执行之前，输出方法的执行时间
        System.out.println("目标方法doSome()======");
    }
}

测试类;

public class MyTest01 {
    @Test
    public void test01(){
        String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");
        System.out.println(proxy.getClass().getName());
        //通过我们的代理对象执行方法，实现目标方法执行时，增强了功能
        proxy.doSome("Curry",24);
    }
}

在这里插入图片描述
JoinPoint:
MyAspect.java

@Aspect
public class MyAspect {
    /**
     * 指定通知方法中的参数：JoinPoint
     * JointPoint：业务方法，要加入切面功能的业务方法
     *
     * 作用：可以在通知方法中获取方法执行时的信息，例如方法名称，方法的实参
     * 如果你的切面功能中需要用到方法的信息，就加入JoinPoint
     * 这个JoinPoint参数的值由框架赋予，必须是第一个位置的参数
     */
    @Before(value = "execution(* *..SomeServiceImpl.do*(..))")
    public void myBefore(JoinPoint jp){
        //获取方法的完整定义
        System.out.println("方法的签名（定义）="+jp.getSignature());
        System.out.println("方法的名称（定义）="+jp.getSignature().getName());
        //获取方法的实参
        Object[] args = jp.getArgs();
        for (Object tem:args){
            System.out.println("参数"+tem);
        }
        //就是你切面要执行的功能代码
        System.out.println("3==前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }
}

测试文件：

 String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");
        System.out.println(proxy.getClass().getName());
        //通过我们的代理对象执行方法，实现目标方法执行时，增强了功能
        proxy.doSome("Curry",24);

结果：
在这里插入图片描述
AfterReturning:
在这里插入图片描述
MyAspect.java

@Aspect
public class MyAspect {
    /**
     * 后置通知定义方法，方法是实现切面功能的。
     * 方法定义要求
     * 1.公共方法public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法可以有参数，也可以没有参数
     * 如果有参数，参数不是自定义的，有几个参数类型可以使用
     */
    /**
     * @AfterReturning 后置通知
     * 属性：1.value 切入点表达式
     * 2.returning 自定义的变量 表示目标方法的返回值的
     * 自定义变量名必须和通知方法的参数名一样
     *
     * 位置：在方法定义的上面
     * 特点：
     * 1.在目标方法之后执行的
     * 2.能够获取到目标方法的返回值，可以根据返回值做不同的处理功能
     * Object res=doOther()的调用返回
     * 3.可以修改这个返回值
     * @param res
     */
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "res")
    public void myAfterReturning(Object res){
        //Object res:目标方法执行后的返回值，根据返回值做你的切面的功能处理
        System.out.println("后置通知：在目标方法之后执行的，回去的返回值是"+res);
        if(res.equals("abcd")){

        }else{

        }
    //修改目标方法的返回值，看一下是否会影响最后的方法的调用结果，结果不受影响，返回仍然是abcd
        if(res!=null){
            res="hello aspectj";
        }
    }
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther2(..))",returning = "res")
    public void myAfterReturning2(Object res){
        //Object res:目标方法执行后的返回值，根据返回值做你的切面的功能处理
        System.out.println("后置通知：在目标方法之后执行的，回去的返回值是"+res);
        if(res.equals("abcd")){

        }else{

        }
    //修改目标方法的返回值，看一下是否会影响最后的方法的调用结果
        if(res!=null){
            Student tem = (Student)res;
            tem.setName("lebron");
            tem.setAge(30);
        }
    }
}

接口：

public interface SomeService {
    void doSome(String name, Integer age);
    String doOther(String name,Integer age);
    Student doOther2(String name,Integer age);
}

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        //给doSome方法增加功能，在doSome()执行之前，输出方法的执行时间
        System.out.println("目标方法doSome()======");

    }

    @Override
    public String doOther(String name, Integer age) {
        System.out.println("目标方法doOther()======");
        return "abcd";
    }

    @Override
    public Student doOther2(String name, Integer age) {
        Student student = new Student();
        student.setName("Curry");
        student.setAge(25);
        return student;
    }
}

applicationContext.xml

<!--    把对象交给spring容器，由spring容器创建，管理对象-->
<!--    声明目标对象-->
    <bean id="someService" class="com.b204.ba02.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba02.MyAspect"/>

<!--    声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象
        创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象
        所以目标对象就是被修改后的代理对象

        aspectj-autoproxy:会把spring容器中的左右的目标对象，一次性都生成代理对象
    -->
    <aop:aspectj-autoproxy/>

</beans>

测试文件：

@Test
    public void test01(){
        String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");
        System.out.println(proxy.getClass().getName());
        //通过我们的代理对象执行方法，实现目标方法执行时，增强了功能
        String str= proxy.doOther("zhangsan",28);//结果是abcd
        System.out.println("测试类的str="+str);
    }
    @Test
    public void test02(){
        String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");
        System.out.println(proxy.getClass().getName());
        //通过我们的代理对象执行方法，实现目标方法执行时，增强了功能
        Student stu= proxy.doOther2("zhangsan",28);
        System.out.println("测试类的stu="+stu);//结果受到影响
    }

@Around 环绕通知-增强方法有 ProceedingJoinPoint参数
在目标方法执行之前之后执行。被注解为环绕增强的方法要有返回值，Object 类型。并且方法可以包含一个 ProceedingJoinPoint 类型的参数。接口 ProceedingJoinPoint 其有一个proceed()方法，用于执行目标方法。若目标方法有返回值，则该方法的返回值就是目标方法的返回值。最后，环绕增强方法将其返回值返回。该增强方法实际是拦截了目标方法的执行。
接口增加方法：

public interface SomeService {
    String doFirst(String name,Integer age);
}

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public String doFirst(String name, Integer age) {
        System.out.println("===doFirst()===");
        return "doFirst";
    }
}

MyAspect.java

/**
 * @Aspect :是aspect框架中的注解
 * 作用：：表示当前类是切面类
 * 切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 * 位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 环绕通知方法的定义格式
     * 1.public
     * 2.必须有一个返回值，推荐使用object
     * 3.方法名称自定义
     * 4.方法有参数，固定的参数ProceedingJoinPoint
     */
    /**
     * @param pjp
     * @return
     * @Around 环绕通知
     * 属性：value 切入点表达式
     * 位置：在方法的定义什么
     * 特点：1.它是功能最强的通知
     * 2.在目标方法的前和后都能增强功能
     * 3.控制目标方法是否被调用执行
     * 4.修改原来的目标方法的执行结果，影响最后的调用结果
     * <p>
     * 环绕通知，等同于jdk动态代理的，InvocationHandler接口
     * 参数：ProceedingJoinPoint就等同于 jdk的 Method(用于执行目标方法)
     * 返回值：就是目标方法的执行结果，可以被修改。
     *
     * 环绕通知：经常做事务，在目标方法之前开启事务，执行目标方法，在目标方法之后提交事务
     */
    @Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        //实现环绕通知的功能

        String name="";
        //获取第一个参数值
        Object[] args = pjp.getArgs();
        if (args != null && args.length > 1) {
            Object arg = args[0];
            name= (String) arg;
        }
        Object result = null;
        System.out.println("环绕通知：在目标方法之前，输出时间：" + new Date());
        //1.目标方法的调用
        if("zhangsan".equals(name)){
            //符合，调用目标方法
            result = pjp.proceed();//method.invoke()  Object result=doFirst();
        }
        System.out.println("环绕通知：在目标方法之后，输出时间：" + new Date());

        //2.在目标方法的前或者后增加功能

        //修改返回方法的执行结果
        if(result!=null){
            result = "hello world";
        }
        return result;
    }
}

测试方法：

public void test01(){
        String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");

        //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        String first = proxy.doFirst("zhangsan", 20);
        System.out.println(first);
    }

在这里插入图片描述
@AfterThrowing
接口：

public interface SomeService {
    void doSecond();
}

//目标类
public class SomeServiceImpl implements SomeService {

    @Override
    public void doSecond() {
        System.out.println("执行方法doSecond"+(10/0));
    }
}

MyAspect.java

/**
 * @Aspect :是aspect框架中的注解
 * 作用：：表示当前类是切面类
 * 切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 * 位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 异常通知方法的定义格式
     * 1.public
     * 2.没有有一个返回值
     * 3.方法名称自定义
     * 4.方法有一个参数Exception，如果还有是JoinPoint
     */
    /**
     * @AfterThrowing :异常通知
     * 属性：1.value 切入点表达式
     * 2.throwing 自定义的变量 表示目标方法抛出的异常对象
     * 变量名必须和方法的参数名一样
     *
     * 特点：1.在目标方法抛出异常时执行的
     * 2.可以做异常的监控程序，监控目标方法执行时是不是有异常。
     * 如果有异常，可以发送邮件，短信进行通知
     *
     * 执行的是：
     * try{
     *     SomeServiceImpl.doSecond(..)
     * }catch(Exception e){
     *     myAfterThrowing(e);
     * }
     */
    @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing = "ex")
    public void myAfterThrowing(Exception ex){
        System.out.println("异常通知：方法发生异常时，执行"+ex.getMessage());
        //发送短信通知开发人员
    }
}

<?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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    把对象交给spring容器，由spring容器创建，管理对象-->
<!--    声明目标对象-->
    <bean id="someService" class="com.b204.ba04.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba04.MyAspect"/>

<!--    声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象
        创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象
        所以目标对象就是被修改后的代理对象

        aspectj-autoproxy:会把spring容器中的左右的目标对象，一次性都生成代理对象
    -->
    <aop:aspectj-autoproxy/>
</beans>

测试：

 String config= "applicationContext.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    //从容器中获取目标对象
    SomeService proxy = (SomeService)ac.getBean("someService");

    //通过代理的对象执行方法，实现目标方法执行时，增强了功能
    proxy.doSecond();

在这里插入图片描述
@After
接口：

public interface SomeService {
    void doThird();
}

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doThird() {
        System.out.println("执行方法doThird()");
    }
}

MyAspect.java

/**
 * @Aspect :是aspect框架中的注解
 * 作用：：表示当前类是切面类
 * 切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 * 位置：在类定义的上面
 */

/**
 * 最红通知方法的定义格式：
 * 1.public
 * 2.没有返回值
 * 3.方法名称自定义
 * 4.方法没有参数，如果有是JoinPoint
 * 特点：
 * 1.总是会执行
 * 2.在目标方法之后执行
 *
 * try{
 *
 * }catch(Exception e){}finally{
 *     myAfter();
 * }
 */
@Aspect
public class MyAspect {
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter(JoinPoint jp){
        System.out.println("最后通知：方法的执行总会被执行的代码");
        //一般做资源清除工作的
    }
}

<?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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    把对象交给spring容器，由spring容器创建，管理对象-->
<!--    声明目标对象-->
    <bean id="someService" class="com.b204.ba05.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba05.MyAspect"/>

<!--    声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象
        创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象
        所以目标对象就是被修改后的代理对象

        aspectj-autoproxy:会把spring容器中的左右的目标对象，一次性都生成代理对象
    -->
    <aop:aspectj-autoproxy/>
</beans>

String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeService proxy = (SomeService)ac.getBean("someService");

        //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        proxy.doThird();

@Pointcut管理切入点

@Aspect
public class MyAspect {
    @After(value = "mypt()")
    public void myAfter(JoinPoint jp){
        System.out.println("最后通知：方法的执行总会被执行的代码");
        //一般做资源清除工作的
    }
    @Before(value = "mypt()")
    public void myBefore(JoinPoint jp){
        System.out.println("前置通知：目标方法之前先执行的");
    }
    /**
     * @Pointcut: 定义和管理切入点，如果你的项目中有多个切入点表达式是重复的，可以复用的。
     * 可以使用@Pointcut
     *
     * 属性：value 切入点表达式
     * 位置：在自定义的方法上面
     * 特点：当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名。
     * 其它的通知中，value属性就可以使用这个方法名称，代替切入点表达式了
     */
    @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void mypt(){
        //mypt就是别名
    }
}

如果把接口去掉，使用cglib的代理

//目标类
public class SomeServiceImpl{
    public void doThird() {
        System.out.println("执行方法doThird()");
    }
}

@Aspect
public class MyAspect {
    @After(value = "mypt()")
    public void myAfter(JoinPoint jp){
        System.out.println("最后通知：方法的执行总会被执行的代码");
        //一般做资源清除工作的
    }
    @Before(value = "mypt()")
    public void myBefore(JoinPoint jp){
        System.out.println("前置通知：目标方法之前先执行的");
    }
    /**
     * @Pointcut: 定义和管理切入点，如果你的项目中有多个切入点表达式是重复的，可以复用的。
     * 可以使用@Pointcut
     *
     * 属性：value 切入点表达式
     * 位置：在自定义的方法上面
     * 特点：当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名。
     * 其它的通知中，value属性就可以使用这个方法名称，代替切入点表达式了
     */
    @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void mypt(){
        //mypt就是别名
    }
}

<?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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">

<!--    把对象交给spring容器，由spring容器创建，管理对象-->
<!--    声明目标对象-->
    <bean id="someService" class="com.b204.ba06.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba06.MyAspect"/>

<!--    声明自动代理生成器：使用aspectj框架内部的功能，创建目标对象的代理对象
        创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象
        所以目标对象就是被修改后的代理对象

        aspectj-autoproxy:会把spring容器中的左右的目标对象，一次性都生成代理对象
    -->
    <aop:aspectj-autoproxy/>
</beans>

测试：

String config= "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //从容器中获取目标对象
        SomeServiceImpl proxy = (SomeServiceImpl)ac.getBean("someService");
        System.out.println("proxy="+proxy.getClass().getName());
        //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        proxy.doThird();

结果：
在这里插入图片描述
有接口也可使用cglib代理方式

public interface SomeService {
    void doThird();
}

//目标类
public class SomeServiceImpl implements SomeService {
    @Override
    public void doThird() {
        System.out.println("执行方法doThird()");
    }
}

MyAspect.java

@Aspect
public class MyAspect {
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter(JoinPoint jp){
        System.out.println("最后通知：方法的执行总会被执行的代码");
        //一般做资源清除工作的
    }
}

配置文件
<aop:aspectj-autoproxy proxy-target-class=“true”/>

<?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.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="someService" class="com.b204.ba07.SomeServiceImpl"/>

<!--    声明切面类对象-->
    <bean id="myAspect" class="com.b204.ba07.MyAspect"/>
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

在这里插入图片描述

Sharpen__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP概念及代码演示
weixin_69036336的博客
03-28 406
AOP概念及代码演示
spring-Aop切面编程
永远不会懂
09-24 679
**　什么是面向切面编程？ 面向切面编程主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。定义还挺邪乎的，其实我个人目前的理解就是把一个方法中重复使用的代码提取出来[类似于代理]，建立一个专门的类来处理，并且是一种非侵入式的方式实现[比代理高端]。   ** 熟悉AOP编程中的几个关键术语
理解AOP@Before,@After,@AfterReturning,@AfterThrowing执行顺序
Jay Chang
01-06 7167
实现AOP的切面主要有以下几个要素： 使用@Aspect注解将一个java类定义为切面类 使用@Pointcut定义一个切入点，可以是一个规则表达式，比如下例中某个package下的所有函数，也可以是一个注解等。 根据需要在切入点不同位置的切入内容 使用@Before在切入点开始处切入内容 使用@After在切入点结尾处切入内容 使用@AfterReturning在切入点return...
AOP的详解及代码演示
weixin_68829057的博客
03-28 400
所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。然而需求总是变化的，有一天，新增了一个需求，需要再多出做修改，我们需要再抽象出一个方法，然后再在需要的地方分别调用这个方法，又或者我们不需要这个方法了，我们还是得删除掉每一处调用该方法的地方。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的复用。
AOP的应用以及代码实现（详细剖析）
我是老伯的博客
02-20 2230
AOP的应用以及代码实现（详细剖析）
Spring中AOP的实现
nigulasizp的博客
06-13 536
主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。 可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是设计模式的延续，设计模式是调用者和被调用者之间的解耦,提高代码的灵活性和可扩展性，AOP可以说也是这种目标的一种实现。 在Spring中提供了面向切面编程的丰富支持，
spring基础之AOP面向切面编程
weixin_36276193的博客
01-24 114
1、什么是Spring AOP（面向切面编程）         AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日...
16.2 Spring框架-AOP面向切面编程
最新发布
04-12
面向切面编程（AOP，Aspect Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种模块化和声明式的方式来处理程序中的横切关注点，如日志、事务管理、性能监控等。在传统的OOP（面向对象编程）中...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
spring-aop-jar
12-14
在IT领域，Spring框架是一个广泛使用的Java应用框架，它提供了许多功能，包括依赖注入、面向切面编程（AOP）等。"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨...
spring-AOP面向切面编程所需jar包.zip
06-22
该压缩包包含--学习笔记(05):轻松搞定Spring全家桶(初识篇)-面向切片编程AOP：--系列博客中新需要的三个jar包。包括spring-aspects-5.2.7.RELEASE.jar和spring-aop-5.2.7.RELEASE.jar和...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
AOP(面向切面编程)
StudyJava01的博客
12-08 1300
  我们在编写代码时，只想关注逻辑代码的实现。但是我们的程序是要放到服务器上去跑的，我们在代码中如果只有业务逻辑代码。虽然代码简洁，但是万一程序在服务器跑的时候数据出现问题时，没办法快速定位到问题所在。但是将日志等非逻辑代码和我们的逻辑代码放在一起，会使得代码冗余，代码的可读性难度加大。   基于上面的问题，Spring为我们提供了一种解决方案，将业务功能逻辑代码和非功能代码分开来写，然后使用动态代理，将非功能性代码嵌入到功能代码中，这就是所谓的AOP(面向切面编程)。  1、我们要使用Aop对我们的bea
J2EE系列之Spring4学习笔记（八）--AOP详解（AOP实例）
feidie436的专栏
06-01 601
上一讲中写了一个实例，这个实例中日志记录代码（非业务代码）跟逻辑代码耦合在了一起。当工程庞大，代码量非常大的时候这样的代码维护非常困难。Spring使用AOP技术可以实现这种非业务代码与业务代码的隔离。 AOP面向切面编程可以使非业务代码能够动态的切入到逻辑代码中。AOP之所以能够实现这种功能，是基于一种通知机制（与struts2的拦截机制挺像的），当要执行或者执行完成某个业务代码时向非业务类发
Spring AOP详解一文搞懂@Aspect、@Pointcut、@Before、@Around、@After、@AfterReturning、@AfterThrowing
热门推荐
u011047968的专栏
02-20 2万+
文章目录1、AOP是什么2、AOP中注解的含义3、Pointcut切入点的语法4、AOP代码实现 1、AOP是什么 AOP：Aspect Oriented Programming，翻译过来就是大名鼎鼎的“面向切面编程”，它是对面向对象的一种补充和完善。 AOP的使用场景一般有：数据源切换、事务管理、权限控制、日志打印等。根据它的名字我们不难理解，它的实现很像是将我们要实现的代码切入业务实现的逻辑中...
SpringBoot-AOP深入浅出通俗易懂—看不懂你捶鹅
看一看吧，说不定就学到新知识了呢。
08-02 5145
本文主要讲解AOP的主要思想和两种实现AOP的方式，以及详细代码举例。
Spring源码之AOP实现
qq_38706652的博客
08-20 1268
Spring源码之AOP
Spring AOP代码实现：实例演示与注解全解
Marion的博客
04-10 1万+
1 理解AOP 1.1 什么是AOP AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。 那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，非常冗余且不利于维护。例如下面这个示意图： 有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。当然，用面向对象的思想，我们可以把这些重复的代码抽离出来，写
创建Maven项目显示一直加载不停
Sharpen__的博客
11-24 1462
解决办法： 1.设置IDEA的Maven配置 按下快捷键：Ctrl+Alt+S即可打开IDEA设置面板，依次选择Build->Build Tools->Maven->Runner->定位到VM Options输入框填写上： -DarchetypeCatalog=internal IDEA-Maven设置 2.在创建项目时设置其Properties 创建项目时，在Properties属性面板中添加一项：archetypeCatalog = internal即可。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值