【Spring篇】AOP案例

已于 2023-05-26 12:52:27 修改
阅读量2.9k 收藏 36
点赞数 28
分类专栏： SSM 文章标签： spring java mybatis spring boot spring cloud
于 2023-05-20 13:28:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Javascript_tsj/article/details/130254152
版权

🍓系列专栏:Spring系列专栏

🍉个人主页:个人主页

一、案例：业务层接口执行效率

1.需求分析

这个需求也比较简单，前面我们在介绍 AOP 的时候已经演示过 :
需求 : 任意业务层接口执行均可显示其执行效率（执行时长）
这个案例的目的是查看每个业务层执行的时间，这样就可以监控出哪个业务比较耗时，将其查找出来方便优化。
具体实现的思路 :
(1) 开始执行方法之前记录一个时间
(2) 执行方法
(3) 执行完方法之后记录一个时间
(4) 用后一个时间减去前一个时间的差值，就是我们需要的结果。
所以要在方法执行的前后添加业务，经过分析我们将采用 环绕通知 。
说明 : 原始方法如果只执行一次，时间太快，两个时间差可能为 0 ，所以我们要执行万次来计算时间
差

2.环境准备

  • 创建一个Maven项目
  • pom.xml添加Spring依赖
<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.itheima</groupId>
  <artifactId>spring_21_case_interface_run_speed</artifactId>
  <version>1.0-SNAPSHOT</version>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.16</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>
添加 AccountService 、 AccountServiceImpl 、 AccountDao 与 Account 类 
public interface AccountService {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    List<Account> findAll();

    Account findById(Integer id);

}
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    public void save(Account account) {
        accountDao.save(account);
    }

    public void update(Account account){
        accountDao.update(account);
    }

    public void delete(Integer id) {
        accountDao.delete(id);
    }

    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

public interface AccountDao {

    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account);

    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id);

    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account);

    @Select("select * from tbl_account")
    List<Account> findAll();

    @Select("select * from tbl_account where id = #{id} ")
    Account findById(Integer id);
}
import java.io.Serializable;

public class Account implements Serializable {

    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
resources 下提供一个 jdbc.properties 
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
创建相关配置类 
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})

public class SpringConfig {
}

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}
public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}
编写Spring整合Junit的测试类 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    @Autowired
    private AccountService accountService;

    @Test
    public void testFindById(){
        Account ac = accountService.findById(2);
    }

    @Test
    public void testFindAll(){
        List<Account> all = accountService.findAll();
    }

}
最终创建好的项目结构如下 :

3.功能开发

步骤 1: 开启 SpringAOP 的注解功能
在 Spring 的主配置文件 SpringConfig 类中添加注解 
@EnableAspectJAutoProxy
步骤 2: 创建 AOP 的通知类
该类要被 Spring 管理，需要添加 @Component
要标识该类是一个 AOP 的切面类，需要添加 @Aspect
配置切入点表达式，需要添加一个方法，并添加 @Pointcut 
@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}


}
步骤 3: 添加环绕通知
在 runSpeed() 方法上添加 @Around, 完成核心业务，记录万次执行的时间 
@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }

}
步骤4 : 运行单元测试类

 

补充说明
当前测试的接口执行效率仅仅是一个理论值，并不是一次完整的执行过程。
这块只是通过该案例把 AOP 的使用进行了学习，具体的实际值是有很多因素共同决定的。

二、AOP通知获取数据

目前我们写 AOP 仅仅是在原始方法前后追加一些操作，接下来我们要说说 AOP 中数据相关的内容，我们将从获取参数 、 获取返回值 和 获取异常 三个方面来研究切入点的相关信息。
前面我们介绍通知类型的时候总共讲了五种，那么对于这五种类型都会有参数，返回值和异常吗 ?
我们先来一个个分析下 :
获取切入点方法的参数，所有的通知类型都可以获取参数
  • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
  • ProceedingJoinPoint：适用于环绕通知
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
  • 返回后通知
  • 环绕通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
  • 抛出异常后通知
  • 环绕通知

1.环境准备

  • 创建一个Maven项目
  • pom.xml添加Spring依赖
  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>
  </dependencies>
添加 BookDao 和 BookDaoImpl 类 
public interface BookDao {
 public String findName(int id);
 }
 @Repository
 public class BookDaoImpl implements BookDao {

 public String findName(int id) {
 System.out.println("id:"+id);
 return "itcast";
 }
 }
创建 Spring 的配置类 
@Configuration
@ComponentScan("com.itheima")

public class SpringConfig {
}
编写通知类 
@Component
 @Aspect
 public class MyAdvice {
 @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
 private void pt(){}

 @Before("pt()")
 public void before() {
 System.out.println("before advice ..." );
 }

 @After("pt()")
 public void after() {
 System.out.println("after advice ...");
 }

 @Around("pt()")
 public Object around() throws Throwable{
 Object ret = pjp.proceed();
 return ret;
 }
 @AfterReturning("pt()")
 public void afterReturning() {
 System.out.println("afterReturning advice ...");
 }


 @AfterThrowing("pt()")
 public void afterThrowing() {
 System.out.println("afterThrowing advice ...");
 }
 }
编写 App 运行类 
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        String name = bookDao.findName(100);
        System.out.println(name);
    }
}
最终创建好的项目结构如下 :

2.获取参数 

非环绕通知获取方式
在方法上添加 JoinPoint, 通过 JoinPoint 来获取参数 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Before("pt()")
public void before(JoinPoint jp)
Object[] args = jp.getArgs();
System.out.println(Arrays.toString(args));
System.out.println("before advice ..." );
}
//...其他的略
}
运行 App 类，可以获取如下内容，说明参数 100 已经被获取

思考 : 方法的参数只有一个，为什么获取的是一个数组 ?
因为参数的个数是不固定的，所以使用数组更通配些。
如果将参数改成两个会是什么效果呢 ?
(1) 修改 BookDao 接口和 BookDaoImpl 实现类 
public interface BookDao {
public String findName(int id,String password);
}
@Repository
public class BookDaoImpl implements BookDao {
public String findName(int id,String password) {
System.out.println("id:"+id);
return "itcast";
}
}
(2) 修改 App 类，调用方法传入多个参数 
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new
AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = ctx.getBean(BookDao.class);
String name = bookDao.findName(100,"itheima");
System.out.println(name);
}
}
(3) 运行 App ，查看结果 , 说明两个参数都已经被获取到

说明 :
使用 JoinPoint 的方式获取参数适用于 前置 、 后置 、 返回后 、 抛出异常后通知。
环绕通知获取方式
环绕通知使用的是 ProceedingJoinPoint ，因为 ProceedingJoinPoint 是 JoinPoint 类的子
类，所以对于 ProceedingJoinPoint 类中应该也会有对应的 getArgs() 方法，我们去验证下 : 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp)throws Throwable {
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
}
//其他的略
}
运行 App 后查看运行结果，说明 ProceedingJoinPoint 也是可以通过 getArgs() 获取参数

 

注意 :
pjp.proceed() 方法是有两个构造方法，分别是 :

  •  调用无参数的proceed，当原始方法有参数，会在调用的过程中自动传入参数
  • 所以调用这两个方法的任意一个都可以完成功能
  • 但是当需要修改原始方法的参数时，就只能采用带有参数的方法,如下:
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = pjp.proceed(args);
return ret;
}
//其他的略
}
有了这个特性后，我们就可以在环绕通知中对原始方法的参数进行拦截过滤，避免由于参数的
问题导致程序无法正确运行，保证代码的健壮性。

3.获取返回值

对于返回值，只有返回后 AfterReturing 和环绕 Around 这两个通知类型可以获取，具体如何获取 ?
环绕通知获取返回值 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable{
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = pjp.proceed(args);
return ret;
}
//其他的略
}
上述代码中， ret 就是方法的返回值，我们是可以直接获取，不但可以获取，如果需要还可以进行修改。
返回后通知获取返回值 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(Object ret) {
System.out.println("afterReturning advice ..."+ret);
}
//其他的略
}
注意 :
(1) 参数名的问题

(2)afterReturning 方法参数类型的问题
参数类型可以写成 String ，但是为了能匹配更多的参数类型，建议写成 Object 类型
(3)afterReturning 方法参数的顺序问题

运行App后查看运行结果，说明返回值已经被获取到

4.获取异常 

对于获取抛出的异常，只有抛出异常后 AfterThrowing 和环绕 Around 这两个通知类型可以获取，具
体如何获取 ?
环绕通知获取异常
这块比较简单，以前我们是抛出异常，现在只需要将异常捕获，就可以获取到原始方法的异常信息了 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp){
Object[] args = pjp.getArgs();
System.out.println(Arrays.toString(args));
args[0] = 666;
Object ret = null;
try{
ret = pjp.proceed(args);
}catch(Throwable throwable){
t.printStackTrace();
}
return ret;
}
//其他的略
}
在 catch 方法中就可以获取到异常，至于获取到异常以后该如何处理，这个就和你的业务需求有关
了。
抛出异常后通知获取异常 
@Component
@Aspect
public class MyAdvice {
@Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
private void pt(){}
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {
System.out.println("afterThrowing advice ..."+t);
}
//其他的略
}
如何让原始方法抛出异常，方式有很多， 
@Repository
public class BookDaoImpl implements BookDao {
public String findName(int id,String password) {
System.out.println("id:"+id);
if(true){
throw new NullPointerException();
}
return "itcast";
}
}
注意 :

运行App后，查看控制台，就能看的异常信息被打印到控制台 

至此，AOP通知如何获取数据就已经讲解完了，数据中包含参数、返回值、异常(了解)。  

三、百度网盘密码数据兼容处理

1.需求分析

需求: 对百度网盘分享链接输入密码时尾部多输入的空格做兼容处理。

问题描述 :
点击链接，会提示，请输入提取码，如下图所示

  • 当我们从别人发给我们的内容中复制提取码的时候，有时候会多复制到一些空格，直接粘贴到百度的提取码输入框
  • 但是百度那边记录的提取码是没有空格的
  • 这个时候如果不做处理，直接对比的话，就会引发提取码不一致，导致无法访问百度盘上的内容
  • 所以多输入一个空格可能会导致项目的功能无法正常使用。
此时我们就想能不能将输入的参数先帮用户去掉空格再操作呢 ?
  • 答案是可以的，我们只需要在业务方法执行之前对所有的输入参数进行格式处理——trim() 是对所有的参数都需要去除空格么?
  • 也没有必要，一般只需要针对字符串处理即可。

  • 以后涉及到需要去除前后空格的业务可能会有很多，这个去空格的代码是每个业务都写么?
  • 可以考虑使用AOP来统一处理。
AOP 有五种通知类型，该使用哪种呢 ?
我们的需求是将原始方法的参数处理后在参与原始方法的调用，能做这件事的就只有环绕通知。
综上所述，我们需要考虑两件事 :
①：在业务方法执行之前对所有的输入参数进行格式处理 —— trim()

②：使用处理后的参数调用原始方法——环绕通知中存在对原始方法的调用

2.具体实现

添加 ResourcesService ， ResourcesServiceImpl,ResourcesDao 和 ResourcesDaoImpl
类 
public interface ResourcesService {
    public boolean openURL(String url ,String password);

}

@Service
public class ResourcesServiceImpl implements ResourcesService {
    @Autowired
    private ResourcesDao resourcesDao;

    public boolean openURL(String url, String password) {
        return resourcesDao.readResources(url,password);
    }
}
public interface ResourcesDao {

    boolean readResources(String url, String password);
}

@Repository
public class ResourcesDaoImpl implements ResourcesDao {
    public boolean readResources(String url, String password) {
        System.out.println(password.length());
        //模拟校验
        return password.equals("root");
    }
}
创建 Spring 的配置类 
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
AOP 
@Component
@Aspect
public class DataAdvice {
    @Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
    private void servicePt(){}

    @Around("DataAdvice.servicePt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            //判断参数是不是字符串
            if(args[i].getClass().equals(String.class)){
                args[i] = args[i].toString().trim();
            }
        }
        Object ret = pjp.proceed(args);
        return ret;
    }


}
编写 App 运行类 
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
        boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
        System.out.println(flag);
    }
}

四、AOP总结

AOP的知识就已经讲解完了，接下来对于AOP的知识进行一个总结:

1.AOP的核心概念

概念： AOP(Aspect Oriented Programming) 面向切面编程，一种编程范式
作用：在不惊动原始设计的基础上为方法进行功能 增强
核心概念
  • 代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
  • 连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
  • 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
  • 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
  • 切面（Aspect）：描述通知与切入点的对应关系
  • 目标对象（Target）：被代理的原始对象成为目标对象

2.切入点表达式

切入点表达式标准格式：动作关键字 ( 访问修饰符 返回值 包名 . 类 / 接口名 . 方法名（参数）异常
名 ) 
 execution(* com.itheima.service.*Service.*(..))
切入点表达式描述通配符：
  • 作用：用于快速描述，范围描述
  • *：匹配任意符号（常用）
  • .. ：匹配多个连续的任意符号（常用）
  • +：匹配子类类型

切入点表达式书写技巧

1. 按 标准规范 开发
2. 查询操作的返回值建议使用 * 匹配
3. 减少使用 .. 的形式描述包
4. 对接口 进行描述 ，使用 * 表示模块名，例如 UserService 的匹配描述为 *Service
5. 方法名书写保留动词，例如get ，使用 * 表示名词，例如 getById 匹配描述为 getBy*
6. 参数根据实际情况灵活调整

3.五种通知类型

  • 前置通知
  • 后置通知
  • 环绕通知（重点）
  1. 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
  2. 环绕通知可以隔离原始方法的调用执行
  3. 环绕通知返回值设置为Object类型
  4. 环绕通知中可以对原始方法调用过程中出现的异常进行处理
  • 返回后通知
  • 抛出异常后通知

4.通知中获取参数

获取切入点方法的参数，所有的通知类型都可以获取参数
  • JoinPoint：适用于前置、后置、返回后、抛出异常后通知
  • ProceedingJoinPoint：适用于环绕通知
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
  • 返回后通知
  • 环绕通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
  • 抛出异常后通知
  • 环绕通知

笔记来自： 黑马程序员SSM框架教程

热爱编程的小白白
关注
  • 28
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
Spring的aop小案例
09-07
在本小案例中，我们将深入探讨Spring框架中的一个重要特性——面向切面编程（Aspect-Oriented Programming，简称AOP）。AOP是Spring框架的核心组成部分，它允许开发者将关注点分离，比如日志记录、事务管理、性能...
Java框架技术 Spring 学习案例 Spring AOP案例和Spring事务处理案例
03-20
本教程主要聚焦于Spring框架的两大核心特性：Spring AOP（面向切面编程）和Spring事务处理，通过具体的应用案例来深入理解这两个概念。 首先，让我们详细探讨Spring AOP。AOP是面向切面编程的缩写，它允许程序员...
Aop小案例
weixin_56177676的博客
10-18 1927
demo_aop
Spring3：AOP
weixin_30757793的博客
10-29 130
AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对...
SpringAOP 常见应用场景
最新发布
Zyw907155124的博客
06-08 1322
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
Spring AOP 代码加案例详解
持续学习，持续更新
04-27 2392
学习AOP就要先学习代理模式，这样AOP的学习就简单了。代理模式是Java常见的设计模式之一，包含：静态代理和动态代理。通过案例感受静态代理：租房子问题。房东需要将房子出租，如果都亲力亲为太麻烦了：房东要自己出去贴广告，带租客看房，讨价还价，签合同，收租金，定期检查房子，定期保洁。这时候就需要中介代理了，房东就是要租房拿钱，额外的功能：签合同，讨价还价，定期检查房子 ，定期保洁都由中介代理去做，所以 代理 简化了 业主的功能,同时对房东的功能做了一个扩展。找中介的好处：（1）保护真实对象 （房东） （2
Spring AOP示例
Markix的博客
08-18 359
AOP基本概念： 切面（Aspect）：切面是通知和切点的结合。 通知（Advice）：定义了切面是什么以及何时使用。 切点（Pointcut）：定义了切面作用在何处。 … 不多bb，直接开干。 示例： 基本思路：启用Aspect自动代理；编写切面逻辑。 目标类 package com.markix.aop.service; import org.springframework.stereoty...
spring之AOP的概念及简单案例
weixin_53701598的博客
05-20 145
AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。
SpringAOP案例代码笔记
04-26
Spring的AOP开发（XML）Spring的AOP的注解开发 代码案例
Spring 入门案例——AOP
08-19
本入门案例将帮助你理解并掌握Spring AOP的基本概念和使用方法。 在Spring AOP中，我们首先需要了解的是"切面"（Aspect）的概念。切面是封装了横切关注点的代码模块，它可以包含通知（Advice）、切点（Pointcut）和...
Spring AOP注解案例及基本原理详解
08-19
Spring AOP注解案例及基本原理详解 Spring AOP是基于AspectJ实现的，提供了强大的面向切面编程功能。通过使用注解，可以将横切逻辑与业务逻辑分离，从而提高代码的可维护性和可读性。 Aspect: 切面是一个类，负责...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行之前和/或之后添加额外的功能。 在Spring AOP中，可以审核4个“时刻”： 事件之前（在方法执行之前执行“某些操作”） 返回之后（在某种方法的结果返回之后执行一些操作） 引发异常之后（在方法异常之后执行一些操作） 事件周围（合并以上三个事件。） 以下示例将向您展示其工作原理
Spring AOP 实例
12-19
1.简单的AOP日志实现-某方法之前的前后记录日志； 2.简单的AOP日志实现-需要记录方法的运行时间； 3.简单的AOP日志实现-增加检查订单功能；
AOP的例子 记录日志
07-04
切面编程的例子，采用spring，可以在方法执行的前中后进行跟踪
spring-aop和注解的实例
01-13
代码中有注解实例，spring框架实例，aop切片实例
Spring：入门AOP案例分析
黑马程序员官方博客
06-06 1509
🍭SSM框架01：Spring的IoC和DI，以及手把手带你创建Spring核心配置文件 🍭SSM框架02：从0-1学习Spring配置文件 🍭为什么要学Spring？学什么？怎么学？ 🍭Spring到底是如何来实现IOC和DI？案例解析入门篇 🍭万字详解Spring之IOC全部知识点 🍭详解DI相关内容，一文掌握DI配置与使用 🍭Spring掌握IOC/DI配置管理第三方bean 🍭Spring核心容器环境配置、创建、依赖注入等 🍭Spring掌握IOC/DI注解管理第三方bean 🍭...
3.3 AOP之AOP概念及相关术语
qq_44774198的博客
08-02 320
AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。...
springAOP示例
小志的博客
12-04 399
1、创建一个maven项目（创建maven项目过程省略），pom.xml文件引入如下依赖： <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.2.0.RELEASE&...
Spring中的Aop简单实例讲解
BookSea的博客
07-02 3468
注重版权，转载请注明原作者和原文链接 作者：码农BookSea 原文链接：https://editor.csdn.net/md?articleId=107092569 Aop，即面向切面编程，面向切面编程的目标就是分离关注点 比如：一个骑士只需要关注守护安全，或者远征，而骑士辉煌一生的事迹由谁来记录和歌颂呢，当然不会是自己了，这个完全可以由诗人去歌颂，比如当骑士出征的时候诗人可以去欢送，当骑士英勇牺牲的时候，诗人可以写诗歌颂骑士的一生。那么骑士只需要关注怎么打仗就好了。而诗人也只需要关注写诗歌颂和欢送.
springaop around案例
05-19
下面是一个使用Spring AOP around通知的示例： 假设我们有一个服务类 `UserService`，其中有一个方法 `getUserById`，通过用户ID从数据库中获取用户信息。我们想要在方法执行前后添加日志记录，可以使用Spring AOP...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

热爱编程的小白白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值