Comment configurer l'intégration AOP de SpringBoot avec le Web

Configuration d'AOP

Introduction à AOP

Pour introduire la programmation orientée aspect (AOP), vous devez d'abord envisager un scénario comme celui-ci : l'entreprise dispose d'un système de gestion des ressources humaines qui est actuellement en ligne, mais le système fonctionne de manière instable et parfois, il s'exécute très lentement. Afin de détecter quel lien pose problème, le développeur souhaite surveiller le temps d'exécution de chaque méthode, puis déterminer le problème en fonction de ces temps d'exécution. Une fois le problème résolu, supprimez ces moniteurs. Le système est actuellement en cours d'exécution. Si vous modifiez manuellement des milliers de méthodes dans le système, la charge de travail sera trop importante et ces méthodes de surveillance devront être supprimées à l'avenir. Si vous pouvez ajouter du code de manière dynamique pendant que le système est en cours d'exécution, le système est en cours d'exécution. le problème peut être très bien résolu. La programmation orientée aspect (AOP) est un moyen d'ajouter dynamiquement du code au runtime du système. Spring Boot offre un bon support pour AOP. En AOP, il y a quelques concepts courants à comprendre :

• Les points de jointure font référence à des méthodes d'une classe qui peuvent être améliorées. Par exemple, si vous souhaitez modifier la fonction de cette méthode, alors la méthode est un point de connexion. Pointcut fait référence à la définition de l'opération d'interception du point de jointure. Cette définition fait référence à l'interception de toutes les méthodes commençant par insert comme point d'entrée

• Après avoir intercepté le Joinpoint, l'opération à effectuer est d'envoyer une notification. Par exemple, la surveillance du journal d’impression mentionnée précédemment. Les notifications sont divisées en pré-notifications, post-notifications, notifications d'exception, notifications finales et notifications environnantes

• Aspect (aspect) : la combinaison de Pointcut et Advice

• Target (objet cible) : la classe à amélioré devient Target

• Support Spring Boot

Spring Boot fournit une solution de configuration automatisée spring-boot-starter-aop pour la configuration AOP basée sur Spring. Introduisez d'abord les dépendances, comme suit :

<!--    AOP 依赖    -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

Puis dans com.sang.aop. . Créez la classe UserService sous le package de service, comme suit :

@Service
public class UserService {
    public String getUserById(Integer id){
        System.out.println("get...");
        return "user";
    }
    public void deleteUserById(Integer id){
        System.out.println("delete...");
    }
}

Ensuite, créez l'aspect, comme suit :

@Component
@Aspect
public class LogAspect {
    @Pointcut("execution(* com.sang.aop.service.*.*(..))")
    public void pc1() {
    }
    @Before(value = "pc1()")
    public void before(JoinPoint jp) {
        String name = jp.getSignature().getName();
        System.out.println(name + "方法开始执行...");
    }
    @After(value = "pc1()")
    public void after(JoinPoint jp) {
        String name = jp.getSignature().getName();
        System.out.println(name + "方法执行结束...");
    }
    @AfterReturning(value = "pc1()", returning = "result")
    public void afterReturning(JoinPoint jp, Object result) {
        String name = jp.getSignature().getName();
        System.out.println(name + "方法返回值为：" + result);
    }
    @AfterThrowing(value = "pc1()",throwing = "e")
    public void afterThrowing(JoinPoint jp, Exception e) {
        String name = jp.getSignature().getName();
        System.out.println(name+"方法抛异常了，异常是："+e.getMessage());
    }
    @Around("pc1()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        return pjp.proceed();
    }
}

Explication du code :

@L'annotation Aspect indique qu'il s'agit d'une classe d'aspect

• @Pointcut. () l'annotation est utilisée dans la méthode pc1() pour définir un point de coupe. Le premier * en exécution indique que la méthode renvoie n'importe quelle valeur, le deuxième * indique n'importe quelle classe du package de services, le troisième * indique n'importe quelle méthode de la classe et les deux points entre parenthèses indiquent que les paramètres de la méthode sont arbitraires, comme décrit. ici Le point d'entrée est toutes les méthodes de toutes les classes du package de services

• before() utilise l'annotation @Before, indiquant qu'il s'agit d'une pré-notification et que la méthode est exécutée avant que la méthode cible ne soit exécutée. Le paramètre JoinPoint peut fournir le nom, les modificateurs et d'autres informations sur la méthode cible

• la méthode after() utilise l'annotation @After, indiquant qu'il s'agit d'une post-notification, qui est exécutée après l'exécution de la méthode cible

• afterReturning La méthode () utilise l'annotation @AfterReturning, indiquant qu'il s'agit d'une notification de retour, et la valeur de retour de la méthode cible peut être obtenue dans cette méthode. Le paramètre de retour dans l'annotation @AfterReturning représente le nom de variable de la valeur de retour correspondant au paramètre de méthode. Notez que le type de résultat est défini dans les paramètres de la méthode comme Objet, ce qui signifie que la valeur de retour de la méthode cible peut être de n'importe quel type. Si le type du paramètre de résultat est Long, alors cette méthode ne peut gérer que la situation dans laquelle. la valeur de retour de la méthode cible est Long

• La méthode afterThrowing() utilise l'annotation @AfterThrowing, indiquant qu'il s'agit d'une notification d'exception, c'est-à-dire que lorsqu'une exception se produit dans la méthode cible, la méthode sera appelée. Le type d'exception est Exception, ce qui signifie que toutes les exceptions seront exécutées dans cette méthode. Si le type d'exception est ArithmeticException, ce qui signifie que ce n'est que lorsque la méthode cible lève une exception ArithmeticException que la méthode sera entrée pour traitement

• A. version réécrite de ce paragraphe : La méthode around() annotée avec @Around est appelée un conseil surround. La notification Surround a la fonction la plus puissante de toutes les notifications. Elle peut implémenter une pré-notification, une post-notification, une notification d'exception et une notification de retour. Une fois que la méthode cible est entrée dans la notification surround, la méthode cible continue l'exécution en appelant la méthode procéd de l'objet ProceedingJoinPoint. Les développeurs peuvent modifier ici les paramètres d'exécution, les valeurs de retour, etc. de la méthode cible et gérer les exceptions de la méthode cible.

• configuration Une fois terminé, créez une interface dans le contrôleur et appelez respectivement les deux méthodes dans le service utilisateur. Vous pouvez voir que le code dans LogAspect est intégré dynamiquement dans la méthode cible et exécuté, comme suit :

get...

l'exécution de la méthode getUserById se termine...

la méthodedeleteUserById commence l'exécution...
delete...
la valeur de retour de la méthodedeleteUserById est : null
L'exécution de la méthode deleteUserById se termine...


Autres

Page d'accueil personnalisée

Après le démarrage du projet Spring Boot, il recherchera d'abord index.html comme fichier de page d'accueil dans le chemin de ressource statique. S'il ne peut pas être trouvé, il recherchera le fichier index.html dynamique comme fichier de page d'accueil.

例如，如果想使用静态的 index.html 页面作为项目的首页，只需在 resources/static 目录下创建 index.html 文件疾苦。若想使用动态页面作为项目首页，则需在 resources/templages 目录下创建 index.html （使用Thymeleaf 模板） 或者 index.ftl（使用 FreeMarker 模板），然后在 Controller 中返回逻辑视图名，如下：

@Controller
public class IndexController {
    @RequestMapping("/index")
    public String index(){
        return "index";
    }
}

运行项目，输入"http://localhost:8081"，查看结果

自定义 favicon

favicon.ico 是浏览器选项卡左上角的图标，可以放在静态资源路径下或者类路径下，静态资源路径下的 favicon.ico 优先级高于类路径下的 favicon.ico

可以使用在线转换网站：https://www.bitbug.net/ 将一张普通图片转为 .ico 图片，转换成功后，将文件重命名为 favicon.ico ，然后复制到 resources/static 目录下，如图

启动项目，查看效果

注意：清缓存，然后 Ctrl+F5 强制刷新

除去某个自动配置

Spring Boot 中提供了大量的自动化配置类，在 Spring Boot 的入口类上有一个 @SpringBootApplication 注解。该注解是一个组合注解，由 @SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan 组成，其中 @EnableAutoConfiguration 注解开启自动化配置，相关的自动化配置就会被使用。要移除某个自动化配置，开发者可以按照以下方法进行相应的配置更改

@SpringBootApplication
@EnableAutoConfiguration(exclude = {ErrorMvcAutoConfiguration.class})
public class Chapter04Application {
    public static void main(String[] args) {
        SpringApplication.run(Chapter04Application.class, args);
    }
}

在 @EnableAutoConfiguration 注解中使用 exclude 属性去除 Error 的自动化配置类，这时如果在 resources/static/error 目录下创建 4xx.htnl、5xx.html ，访问出错时就不会自动跳转了。由于 @EnableAutoConfiguration 注解的 exclude 属性值是一个数组，因此有多个要排除的自动化配置文件只需要继续添加即可。另外一种配置方法是在 application.properties 文件中进行配置，示例如下：

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration

添加前

添加后

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!