spring什么叫面向切面

fiy 1年前其他 34

共3条回复我来回复

worktile
Worktile官方账号
评论

面向切面（Aspect-Oriented Programming，简称AOP）是一种编程范式，它可以帮助我们更好地模块化和管理我们的代码。在传统的面向对象编程中，我们将功能逻辑分散在不同的类中，当一个功能需要被多个类共享时，我们需要在每个类中重复编写相同的代码。这样不仅会产生代码冗余，而且在后期维护和修改代码时也会变得困难。

而AOP的目标就是通过将这些横切逻辑进行分离，使得我们可以在不改变原有代码的情况下，将这些横切逻辑应用到目标代码中。横切逻辑包括日志记录、异常处理、事务管理等。通过AOP，我们可以将这些横切逻辑独立出来，形成切面（Aspect），然后再通过切点（Pointcut）指定目标代码的具体位置，将切面应用到目标代码中。

Spring是一个开源的Java框架，它提供了强大的AOP支持。在Spring中，我们可以使用AspectJ注解或XML配置来定义切面以及切点。Spring AOP在运行时使用动态代理实现了AOP功能，它可以将切面织入到目标代码中，从而实现横切逻辑的功能。

总结来说，面向切面是一种用来将横切逻辑与目标代码进行解耦的编程范式。通过AOP，我们可以将通用的横切逻辑独立出来，然后通过切点指定具体的目标代码位置，将切面织入到目标代码中。Spring框架提供了强大的AOP支持，使得我们可以更加方便地实现面向切面的编程。

1年前 0条评论
fiy
Worktile&PingCode市场小伙伴
评论
面向切面编程（AOP）是一种软件设计思想，用于解决应用程序中的横切关注点（cross-cutting concerns）问题。横切关注点是指存在于应用程序多个模块或组件中的功能需求，它们无法集中在一个模块或组件中实现。举例来说，日志记录和事务管理是常见的横切关注点。

AOP通过将横切关注点从核心业务逻辑中分离出来，使得核心业务逻辑更加纯粹和模块化。这样可以提高代码的可维护性、可测试性和可扩展性。

下面是关于面向切面编程的五个重要点：
1. 切面（Aspect）：切面是一个用于描述某个横切关注点的类。它包含了一些横切关注点的逻辑，在特定的切入点（Joinpoint）上被执行。比如，一个日志切面可以在方法执行之前和之后记录日志信息。
2. 连接点（Joinpoint）：连接点是程序执行过程中的一个特定位置，比如方法的调用或异常的抛出。连接点是切面逻辑可以插入的地方。切入点（Pointcut）是切面中定义的一个或多个连接点的集合。
3. 通知（Advice）：通知是切面中定义的具体逻辑，它决定了在何时和如何插入切入点。常见的通知类型包括“前置通知”（在连接点调用之前执行），“后置通知”（在连接点调用之后执行），“异常通知”（在连接点抛出异常后执行），和“环绕通知”（在连接点前后执行）。
4. 切入点（Pointcut）：切入点是一个表达式，它定义了哪些连接点应该被切面逻辑所影响。切入点使用确定的规则匹配连接点。通常，切入点使用方法签名、注解、类的类型等来定义。
5. 织入（Weaving）：织入是将切面逻辑与业务逻辑结合起来的过程。它可以在编译时（编译期织入）、类加载时（类加载期织入）或运行时（运行期织入）进行。在织入过程中，切面将被插入到目标对象的指定连接点上。
总结来说，面向切面编程是一种用于解决横切关注点问题的设计思想，通过将横切关注点的逻辑与业务逻辑分离，提高了代码的模块化和可维护性。它由切面、连接点、通知、切入点和织入等概念组成。
1年前 0条评论
不及物动词
这个人很懒，什么都没有留下～
评论
面向切面编程（AOP）是一种编程范式，它的核心思想是将程序逻辑划分为核心业务逻辑和横切逻辑（与业务逻辑无关的非功能性需求，如日志记录、性能监控等），通过将横切逻辑与核心业务逻辑分离，使得系统设计更加模块化、可复用和易于维护。

在传统的面向对象编程中，某个类的功能主要通过方法来实现，每个方法处理某个具体功能的同时也要处理一些额外的需求，如安全性、事务控制等。如果将这些额外的需求散落在各个方法中，会导致代码重复，不易维护。而面向切面编程就是将这些横切逻辑从核心业务逻辑中剥离出来，以一种集中的方式实现它们。

Spring是一个支持AOP的框架，它提供了一种将横切逻辑模块化的解决方案。Spring的AOP功能基于代理机制实现，它通过维护一个目标对象的代理对象，在代理对象中添加横切逻辑，从而实现AOP的功能。

下面我们来详细讲解Spring AOP的使用方法和操作流程。

一、导入依赖
首先需要将Spring AOP的相关依赖添加到项目中。在Maven项目中，可以通过在pom.xml文件中添加以下依赖来引入Spring AOP：
```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
```
二、定义切面
在Spring AOP中，切面由切点和通知组成。切点用来定义在哪些加入点（程序执行过程中的某些特定位置）上应用通知，通知则具体描述了在切点上应该执行的操作。

1、定义切点
切点是一个匹配连接点的表达式，它定义了哪些方法是适用的加入点。Spring AOP支持使用AspectJ切点表达式来定义切点，可以根据方法的访问修饰符、方法名、参数类型等来匹配方法。

2、定义通知
通知是在切点上执行的操作，它可以在方法执行前、执行后或抛出异常时执行。Spring AOP提供了以下几种通知类型：
- @Before：在方法执行前执行的通知
- @After：在方法执行后执行的通知
- @AfterReturning：在方法执行后返回结果时执行的通知
- @AfterThrowing：在方法抛出异常时执行的通知
- @Around：在方法执行前后都执行的通知
通知需要定义一个方法，方法的命名可以任意，但该方法应加上对应的通知类型的注解。

3、组装切面
将切点和通知组装成一个切面，可以通过使用@Aspect注解来标记一个类为切面，然后在切面类中定义切点和通知。

三、声明切面和目标对象
在Spring AOP中，切面是一个普通的Java类，并不会自动成为Spring Bean。要将切面声明为Spring Bean，需要在配置类或XML配置文件中进行声明。

1、使用@Configuration和@EnableAspectJAutoProxy注解声明配置类，并将切面类作为Bean进行声明。
```
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public MyAspect myAspect() {
        return new MyAspect();
    }
}
```
2、在XML配置文件中进行声明：
```

<bean id="myAspect" class="com.example.MyAspect"/>
```
四、使用切面
在Spring AOP中，可以通过以下两种方式使用切面：
1、使用@Aspect注解标记的切面：
```
@Aspect
@Component
public class MyAspect {
    
    @Pointcut("execution(public * com.example.Service.*(..))")
    public void myPointcut() {}
    
    @Before("myPointcut()")
    public void beforeAdvice() {
        System.out.println("Before Advice");
    }
    
    // 其他通知方法...
}
```
在上述代码中，切面类MyAspect使用@Aspect注解进行标记，并且使用@Component注解将该切面声明为Spring Bean。在切面类中使用@Pointcut注解定义切点，使用@Before注解定义前置通知。

2、通过XML配置使用切面：
```

<bean id="myAspect" class="com.example.MyAspect"/>


<aop:config>
    
    <aop:pointcut id="myPointcut" expression="execution(public * com.example.Service.*(..))"/>
    
    
    <aop:before method="beforeAdvice" pointcut-ref="myPointcut"/>
</aop:config>
```
在上述代码中，切面类MyAspect在XML配置文件中进行了声明，并且通过aop:before标签配置了前置通知。

五、测试切面
使用切面对目标对象进行增强的过程是由Spring AOP框架自动完成的，在目标对象上添加切面的行为并不需要手动调用。
```
@Service
public class MyService {
  
  public void doSomething() {
    System.out.println("doSomething");
  }
}
```
```
@Aspect
@Component
public class MyAspect {
    
    @Pointcut("execution(public * com.example.MyService.doSomething(..))")
    public void myPointcut() {}
    
    @Before("myPointcut()")
    public void beforeAdvice() {
        System.out.println("Before Advice!");
    }
}
```
```
@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "com.example")
public class AppConfig {

    @Bean
    public MyAspect myAspect() {
        return new MyAspect();
    }

    @Bean
    public MyService myService() {
        return new MyService();
    }
}
```
```
public class Main {
  
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    MyService myService = context.getBean(MyService.class);
    myService.doSomething();
    context.close();
  }
}
```
输出结果：
```
Before Advice!
doSomething
```
在上述示例中，通过@Configuration和@EnableAspectJAutoProxy注解声明了配置类，并将切面类和目标对象声明为Bean。在Main类中通过ApplicationContext获取目标对象，并调用其方法，此时会自动执行切面的通知（Before Advice）。

通过上述步骤，我们就可以在Spring AOP中使用切面来对目标对象进行增强了。通过将横切逻辑从核心业务逻辑中解耦出来，我们可以更加灵活地实现各种非功能性需求，并且可以提高代码的可重用性和可维护性。
1年前 0条评论