Spring学习日记：Aop五种增强+注解开发Ioc/Aop_java环绕增强

自述：此篇文章主要记录了本人学习Spring的日常，在CSDN上发表，一是为了方便今后回顾，二也是想分享给有需要的人。

目录

1.Aop五种增强

一.概念

二.前置增强

三.后置增强

四.环绕增强

五.异常增强

六.最终增强

2.P命名空间注入

3.不同数据类型注入 

一.使用list

二.使用set

三.使用Map

四.使用prop

4.使用注解实现Spring Ioc

一.Ioc常用注解

二.实现

5.使用Java标准注解完成装配

6.使用注解实现Spring Aop

---

1.Aop五种增强

一.概念

以下是AOP的五种增强概念：

二.前置增强

前置增强的特点包括：

1. 执行时机：前置增强在目标方法执行之前执行，可以在目标方法执行之前干预和处理。

2. 参数获取：在前置增强中可以获取目标方法的参数信息，并对参数进行校验或者使用参数进行一些预处理。

3. 控制流程：通过前置增强可以决定是否继续执行目标方法，可以根据具体场景判断是否需要终止目标方法的执行。

使用前置增强可以实现以下功能：

1. 参数校验：在前置增强中可以对目标方法的参数进行验证，确保参数满足要求，避免不合法的参数进入目标方法。

2. 权限验证：前置增强可以用于验证用户的权限，检查当前用户是否有权执行目标方法。

3. 日志记录：在前置增强中可以记录目标方法的调用信息，如方法名、参数值等，用于跟踪代码执行流程和排查问题。

4. 缓存数据：在前置增强中可以检查缓存中是否存在所需数据，如果存在则直接返回缓存数据，避免执行耗时的数据库查询操作。

前置增强可以与其他增强概念结合使用，例如返回后通知、异常通知等，以实现更复杂的切面逻辑。通过AOP的前置增强，可以在目标方法执行前加入额外的处理逻辑，提高代码的可维护性和重用性。 

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @Before("execution(* com.example.MyService.myMethod(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        // 在目标方法执行之前执行的通知逻辑
        
        // 可以在此处编写需要在目标方法执行之前执行的代码或操作
        
    }
}

三.后置增强

后置增强的特点包括：

1. 执行时机：后置增强在目标方法成功执行并返回结果后执行，不会在目标方法抛出异常时执行。

2. 获取返回值：在后置增强中可以获取目标方法的返回值，并进行相应的处理。

3. 不会改变返回结果：后置增强不能修改目标方法的返回结果，只能对其进行处理或记录。

使用后置增强可以实现以下功能：

1. 返回结果处理：可以对目标方法的返回结果进行一些后续处理，如数据加工、格式转换等。

2. 日志记录：在后置增强中可以记录目标方法的执行结果或其他相关信息，用于跟踪代码执行流程和调试。

3. 缓存数据：在后置增强中可以将目标方法的返回结果缓存起来，以提高后续相同请求的性能。

4. 资源释放：后置增强可以用于执行一些资源的释放操作，例如关闭数据库连接、释放文件句柄等。 

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @After("execution(* com.example.MyService.myMethod(..))")
    public void afterMethod(JoinPoint joinPoint) {
        // 在目标方法执行之后执行的通知逻辑
        
        // 可以在此处编写需要在目标方法执行之后执行的代码或操作
        
    }
}

四.环绕增强

环绕增强的特点包括：

1. 完全控制：环绕增强可以完全控制目标方法的执行，包括在目标方法执行前、执行后甚至替代目标方法的执行。

2. 参数获取和修改：在环绕增强中可以获取目标方法的参数信息，并且有能力修改这些参数。

3. 返回结果处理：环绕增强可以获取目标方法的返回结果，并且可以决定返回什么样的结果或者是否返回结果。

使用环绕增强可以实现以下功能：

1. 性能监控：通过环绕增强可以统计目标方法的执行时间，收集性能指标，用于系统性能监控和优化。

2. 事务管理：环绕增强可以在目标方法执行前后开启和提交事务，确保数据操作的一致性和完整性。

3. 异常处理：通过环绕增强可以捕获目标方法抛出的异常，并根据需要进行处理、记录或者转换。

4. 权限验证：在环绕增强中可以检查用户的权限，决定是否允许调用目标方法。

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @Around("execution(* com.example.MyService.myMethod(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // 在目标方法前后执行的通知逻辑
        
        // 可以在此处编写需要在目标方法前后执行的代码或操作
        
        Object result;
        try {
            // 调用proceed()方法执行目标方法
            result = joinPoint.proceed();
            
            // 目标方法执行后的操作
            // 可以获取目标方法的返回值：result
            
        } catch (Exception ex) {
            // 异常处理操作
            throw ex;
        }
        
        return result;
    }
}

五.异常增强

异常增强的特点包括：

1. 执行时机：异常增强在目标方法抛出异常后执行，不会在目标方法正常返回时执行。

2. 获取异常信息：在异常增强中可以获取目标方法抛出的异常及其相关信息。

3. 异常处理：异常增强可以对目标方法抛出的异常进行处理，例如记录日志、发送通知、回滚事务等。

使用异常增强可以实现以下功能：

1. 异常处理与转换：通过异常增强可以捕获目标方法抛出的异常，并根据需要进行处理、记录或者将异常转换成其他类型的异常。

2. 事务管理：异常增强可以在目标方法抛出异常时进行事务的回滚操作，保证数据的一致性和完整性。

3. 异常通知：异常增强可以用于向管理员或用户发送异常通知，以便及时处理和修复问题。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @AfterThrowing(pointcut = "execution(* com.example.MyService.myMethod(..))", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Exception ex) {
        // 在目标方法抛出异常后执行的通知逻辑
        
        // 可以在此处编写需要在目标方法抛出异常后执行的代码或操作
        
    }
}

六.最终增强

最终增强的特点包括：

1. 执行时机：最终增强在目标方法执行完毕后执行，无论目标方法是否抛出异常。

2. 无法获取返回结果：最终增强无法获取目标方法的返回结果，因为该结果在最终增强执行时已经确定或失效。

3. 能够处理异常：最终增强可以捕获目标方法抛出的异常，并进行相应的处理或记录。

使用最终增强可以实现以下功能：

1. 资源释放：最终增强可以用于执行一些资源的释放操作，例如关闭数据库连接、释放文件句柄等。

2. 清理操作：最终增强可以用于执行一些清理操作，如清除临时文件、释放线程相关资源等。

3. 异常处理：最终增强可以捕获目标方法抛出的异常，并执行相应的处理逻辑，以便进行错误处理或日志记录。

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @After("execution(* com.example.MyService.myMethod(..))")
    public void afterMethod(JoinPoint joinPoint) {
        // 在目标方法执行之后执行的通知逻辑
        
        // 可以在此处编写需要在目标方法执行之后执行的代码或操作
        
    }
}

2.P命名空间注入

在Spring框架中，p命名空间注入是一种简化XML配置的方式，它允许我们使用更简洁的语法来进行属性注入。这种方式可以减少配置的冗余代码，使配置文件更加清晰易读。

使用p命名空间注入时，我们通过在XML配置文件中使用xmlns:p="http://www.springframework.org/schema/p"来引入命名空间，并使用p:前缀来指定属性值。

<bean id="唯一标识" class="类的全路径"
	p:"属性1"="注入的值" p:"属性2"="注入的值"  />
<bean id="唯一标识" class="类的全路径"
	p:属性-ref="注入的Bean" />

注：配置文件中使用p命名空间时，需要先添加p命名空间的声明 xmlns:p="http://www.springframework.org/schema/p"

3.不同数据类型注入 

一.使用list

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入  集合 有序  允许重复 有下标
    List manList;
}

    <!--注入不同数据类型 list-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manList">
            <list>
                <value>List01</value>
                <value>List02</value>
                <value>List03</value>
                <value>List04</value>
            </list>
        </property>
    </bean>

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
    collection.getManList().stream().forEach(item->{
            System.out.println(item);
    });

 二.使用set

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入  set集合 无序 不允许重复
    Set manSet;
}

    <!--注入不同数据类型 set-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
<property name="manSet">
      <set>
           <value>Set01</value>
           <value>Set02</value>
           <value>Set03</value>
           <value>Set04</value>
      </set>
</property>
    </bean>

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManSet().stream().forEach(item->{
            System.out.println(item);
        });

三.使用Map

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入 键值对 key值不能重复  value 可以
    Map manMap;
}

    <!--注入不同数据类型 map-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manMap">
            <map>
                <entry key="1" value="Map01" />
                <entry key="2" value="Map02" />
                <entry key="3" value="Map03" />
                <entry key="4" value="Map04" />
            </map>
        </property>
    </bean>

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManMap().forEach((k,v)->{
            System.out.println(v);
        });

四.使用prop

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    Properties manProp;
}

    <!--注入不同数据类型 Prop-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manProp">
            <props>
                <prop key="one">Prop01</prop>
                <prop key="one">Prop04</prop>
                <prop key="two">Prop05</prop>
                <prop key="three">Prop06</prop>
                <prop key="four">Prop07</prop>
            </props>
        </property>
    </bean>

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManProp().forEach((k,v)->{
            System.out.println(v);
        });

4.使用注解实现Spring Ioc

一.Ioc常用注解

二.实现

@Repository("userDao")// 与在XML配置文件中编写
//<bean id="userDao" class="dao.impl.UserDaoImpl" />等效
 
public class UserDaoImpl implements UserDao {
	…
}

使用@Autowired注解实现Bean的自动装配

默认按类型匹配，可使用@Qualifier指定Bean的名称 

@Service("userService")
public class UserServiceImpl implements UserService {
	@Autowired
	@Qualifier("userDao")
	private UserDao dao；//为dao属性注入名为userDao的Bean
	……
}

修改配置文件使注解生效，完成Bean的定义和组装 

<?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:context="http://www.springframework.org/schema/context"
	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">
	<!– 扫描包中注解标注的类>
    <!--指定需要被Spring扫描的基准包范围(多个包名之间用逗号隔开)-->
	<context:component-scan base-package="service,dao" />
</beans>

5.使用Java标准注解完成装配

使用@Resource注解实现组件装配

默认按名称匹配 

@Service("userService")
public class UserServiceImpl implements UserService {
	@Resource
	private UserDao dao；//查找名为dao的Bean，并注入给dao属性
	……
}

@Service("userService")
public class UserServiceImpl implements UserService {
	@Resource(name="userDao")
	private UserDao dao；// 为dao属性注入名为userDao的Bean
	……
}

@Service("userService")
public class UserServiceImpl implements UserService {
	@Resource(type = UserDaoImpl.class)//用于显示指定依赖的Bean的具体类型
	private UserDao dao；
	……
}

 对比@Autowired注解和@Resource注解

1.@Autowired是Spring提供的注解，@Resource是Java提供的

2.在不指定任何参数且不配合其他注解时，@Autowired注解会优先按Bean的类型进行装配，@Resource注解则是优先按Bean的名称进行装配

6.使用注解实现Spring Aop

1. AspectJ

面向切面的框架，它扩展了Java语言，定义了AOP语法，能够在编译期提供代码的织入

2.@AspectJ

AspectJ 5新增的功能，使用JDK 5.0注解技术和正规的AspectJ切点表达式语言描述切面

3.Spring通过集成AspectJ框架实现了以注解的方式定义切面，使得配置文件的代码大大减少

利用轻量级的字节码处理框架asm处理@AspectJ中所描述的方法参数名

注：使用@AspectJ，首先要保证所用的JDK是5.0或以上版本

  <bean id="myAcpect" class="com.cskt.aspect.MyAspect" />
  <aop:aspectj-autoproxy/>

// 给那个方法增强 。。。。。，
     @Before("execution( * com.cskt.service..*.*(..))")
     public void before(){
         System.out.println("前置通知.... 在方法之前要執行的公共代码放在这里");
     }

Spring在同一个功能上提供了注解和配置文件两种实现方式以供选择

通常情况下，优先选择注解来简化配置工作量

Aop中常用的注解

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class MyAspect {
    
    @Pointcut("execution(* com.example.MyService.myMethod(..))")
    public void myMethodPointcut() {
        // 定义切入点
    }
    
    @Before("myMethodPointcut()")
    public void beforeMethod(JoinPoint joinPoint) {
        // 在目标方法执行之前执行的通知逻辑
    }
    
    @AfterThrowing(pointcut = "myMethodPointcut()", throwing = "ex")
    public void afterThrowingMethod(JoinPoint joinPoint, Exception ex) {
        // 在目标方法抛出异常后执行的通知逻辑
    }
    
    @AfterReturning(pointcut = "myMethodPointcut()", returning = "result")
    public void afterReturningMethod(JoinPoint joinPoint, Object result) {
        // 在目标方法成功返回结果后执行的通知逻辑
    }
    
    @Around("myMethodPointcut()")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // 环绕通知：在目标方法前后执行一些操作，需要手动调用proceed()方法执行目标方法
        Object result;
        try {
            // 目标方法执行前的操作
            result = joinPoint.proceed();
            // 目标方法执行后的操作
        } catch (Exception ex) {
            // 异常处理操作
            throw ex;
        }
        return result;
    }
    
    @After("myMethodPointcut()")
    public void afterMethod(JoinPoint joinPoint) {
        // 在目标方法执行之后执行的通知逻辑
    }
}

在上述示例中，我们使用@Aspect将类标记为切面类，使用@Pointcut定义了切入点。然后，在不同的通知方法上使用相应的注解来实现不同类型的通知逻辑。

这些注解可以根据需要进行组合和配置，实现对目标方法的前置、后置、环绕、异常等各个时机的增强操作。通过AOP的方式，可以将横切关注点（如日志记录、事务管理等）从业务逻辑中解耦出来，提升代码的可维护性和复用性。