切面 spring

转载

锦绣前程未央 2024-09-27 16:39:11

文章标签 切面 spring spring System xml 文章分类 架构后端开发

AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。

（1）Aspect(切面): 是通知和切入点的结合,通知和切入点共同定义了关于切面的全部内容—它的功能、在何时和何地完成其功能
（2）joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
（3）Pointcut(切入点):所谓切入点是指我们要对哪些joinpoint进行拦截的定义.（何地）

Spring框架提供以下几种类型的通知：

前置通知：先执行方面功能再执行目标功能

后置通知：先执行目标功能再执行方面功能（目标无异常才执行方面）

最终通知：先执行目标功能再执行方面功能(目标功能有无异常都执行方面)

异常通知：先执行目标，抛出后执行方面

环绕通知：先执行方面强制部分，然后执行目标，最后再执行方面后置部分

可以按照下面的try……catch……finally结构来理解

切面 spring_spring

AOP 就是要对目标进行代理对象的创建， Spring AOP是基于动态代理的，基于两种动态代理机制： JDK动态代理和CGLIB动态代理

下面代码演示
切面xml配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/util
                           http://www.springframework.org/schema/util/spring-util.xsd">
    <!--
        添加注解扫描
    -->
    <context:component-scan base-package="com.sy"/>
    <!--
        配置切面
    -->
    <aop:config>
        <!--
            切入点：哪些类，哪些方法需要被拦截
            expression:切点表达式
        -->
        <aop:pointcut id="pointCut" expression="bean(*ServiceImpl)"></aop:pointcut>//非常关键!!!!!!!!!!!!!!!!!!!!!

        <!--
            配置通知！！！！！！
        -->
        <aop:aspect ref="myAspect">//非常关键!!!!!!!!!!!!!!!!!!!!!
            <!--
                配置前置通知
                method:指定了需要执行的操作，对应的就是切面类中的方法名
                 pointcut-ref:切点对象
            -->
            <aop:before method="beforeAdvice" pointcut-ref="pointCut"></aop:before>
            <!--
                后置通知
                returning:和通知方法中用来表示方法返回的参数相对应
            -->
            <aop:after-returning method="afterAdvice" returning="returnVal"
                                 pointcut-ref="pointCut"></aop:after-returning>

            <!--
                环绕通知
            -->
            <aop:around method="aroundAdvice" pointcut-ref="pointCut"></aop:around>

            <!--
                配置异常通知
                throwing:对应了通知方法中表示异常信息的参数名
            -->
            <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pointCut" throwing="e"></aop:after-throwing>
            <!-- 最终通知 -->
            <aop:after method="finallyAdvice" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

切面代码类

package com.sy.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;

/**
 * 切面类：只要编写一个普通的pojo类即可
 */
@Component("myAspect")
public class MyAspect {
    /**
     * 切面类中的方法就是通知的具体内容
     * Joinpoint:切入点对象，可以从该对象中获取被代理方法的一些参数，例如，方法名，方法参数等
     * 该参数不用做任何声明，Spring框架会在通知方法中自动注入这个对象
     */
    public void beforeAdvice(JoinPoint joinpoint) {
        System.out.println("前置通知...");
        System.out.println("方法名：" + joinpoint.getSignature().getName());
        System.out.println("方法参数：" + Arrays.toString(joinpoint.getArgs()));
    }

    /**
     * @param joinPoint
     * @param returnVal 目标方法调用完以后的返回值
     */
    public void afterAdvice(JoinPoint joinPoint, Object returnVal) {
        System.out.println("后置通知");
        System.out.println("方法名称：" + joinPoint.getSignature().getName());
        System.out.println("方法参数：" + Arrays.toString(joinPoint.getArgs()));
        System.out.println("返回值：" + returnVal);
        System.out.println("=====================================================");
    }


    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知的前置部分...");
        //环绕通知中，目标方法需要通过ProceedingJoinPoint来调用
        Object result = joinPoint.proceed(joinPoint.getArgs());
        System.out.println("result:" + result);
        System.out.println("环绕通知的后置部分...");
        //环绕通知的返回值可以决定最终方法调用后的返回值
        //return false;

        return result;
    }

    public void afterThrowingAdvice(JoinPoint joinPoint, Throwable e) {
        System.out.println("发生了异常...");
        System.out.println("错误信息：" + e.getMessage());

    }

    public void finallyAdvice(JoinPoint joinPoint) {
        System.out.println("最终通知");
    }
}

serviceImpl代码

package com.sy.service.impl;

import com.sy.dao.UserDao;
import com.sy.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

//@Component

@Service

//作用域
//@Scope("prototype")
//@Scope("singleton")

//是否延迟加载
//@Lazy(true)
//@Lazy(false)

//

public class UserServiceImpl implements UserService {
    //init-method
    @PostConstruct
    public void init() {

    }

    //destroy-method
    @PreDestroy
    public void destroy() {

    }

    //1.通过@Value注入简单类型的值
    @Value("Tom")
    private String name;

    //2.通过@Value注入复杂类型
    //语法：@Value("#{要注入的bean的id}")
    //(1)直接标记在属性上：
    // @Value("#{userDao}")
    //private UserDao userDao;

    //(2)标记在属性对应的set方法上
//    private UserDao userDao;
//
//    @Value("#{userDao}")
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

    /**
     * @ Autowired注解默认根据类型来进行注入，但是如果有多个类型匹配，此时如果光光使用@Autowired则无法确定到底哪一个会被注入
     * 此时可以通过@ Qualifier注解来指定类型满足条件时要注入的bean的id
     * <p>
     * 如果用 @ Autowired注解的标注的属性在默认情况下如果无法注入成功，则会出现异常，
     * 可以通过@ Autowired提供的required指定当前属性是否是必须的
     */
    //@Autowired(required = false)

    //@Autowired
    //@Qualifier("adminDao")
    //private UserDao userDao;

    /**
     * 默认根据名称匹配，即匹配与当前属性名称相同的bean的id
     * 如果根据名称匹配没有成功，则根据类型来匹配，如果类型有多个满足条件，则会出现错误
     */
    @Resource(name = "adminDaoImpl")

    //@Resource
    private UserDao userDao;


    public Boolean login(String userName, String userPwd) {
        //故意引发错误，测试异常通知
//        if (1 == 1) {
//            throw new RuntimeException("出现了异常...");
//        }
        System.out.println("调用了login方法");
        System.out.println("属性name中的值：" + name);
        userDao.getUserByName(userName);
        return true;
    }
}

测试

package com.sy.test;

import com.sy.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:aop.xml")
public class Test04 {
    @Autowired
    private UserService userService;

    @Test
    public void test01() {
        System.out.println(userService.getClass().getName());
       Boolean result= userService.login("小明", "123456");
        System.out.println("方法调用后的返回："+result);
    }
}

输出

实例化UserDaoImpl...
com.sun.proxy.$Proxy19
前置通知...
方法名：login
方法参数：[小明, 123456]
环绕通知的前置部分...
调用了login方法
属性name中的值：Tom
admin:小明
最终通知
result:true
环绕通知的后置部分...
后置通知
方法名称：login
方法参数：[小明, 123456]
返回值：true

被包裹的结果

切面 spring_切面 spring_02