Introduction au framework Aifei : Une approche épurée pour le développement web en Java

Avec l’évolution rapide des technologies d’intelligence artificielle, les frameworks traditionnels comme Spring Boot montrent leurs limites en termes de complexité et de poids. En 2026, Aifei (signifiant "Amour du Vol") se positionne comme une alternative légère, performante et conçue dès le départ pour s’adapter aux exigences du développement assisté par IA.

Pourquoi choisir Aifei ?

Résumé : Aifei permet aux développeurs Java d’écrire des applications web propres, rapides et faciles à maintenir dans l’ère de l’intelligence artificielle.

Prérequis techniques

Avant de commencer, assurez-vous d’avoir installé :

• JDK 1.8 ou supérieur (JDK 21 recommandé pour les meilleures performances)
• Maven 3.x+ pour la gestion des dépendances
• Un IDE (IntelliJ IDEA ou Eclipse)

Création d’un projet Aifei

Voici la structure typique d’une application Aifei :

aifei-app/
├── src/main/java/com/example/
│   ├── MainApp.java           # Point d'entrée
│   ├── AppConfig.java         # Configuration globale
│   └── UserService.java       # Exemple de service
├── src/main/resources/
│   ├── app-config.txt         # Fichier de configuration principal
│   ├── app-config-dev.txt     # Profil de développement
│   ├── undertow-dev.txt       # Paramètres du serveur
│   └── log4j2.xml             # Gestion des logs
├── pom.xml                    # Dépendances Maven
└── package.xml                # Options de packaging

Dépendances Maven (pom.xml)

Incluez ces bilbiothèques essentielles :

<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
    <!-- Cœur du framework Aifei -->
    <dependency>
        <groupId>cn.aifei</groupId>
        <artifactId>aifei-all</artifactId>
        <version>1.0.1</version>
    </dependency>

    <!-- Serveur Undertow intégré -->
    <dependency>
        <groupId>io.undertow</groupId>
        <artifactId>undertow-core</artifactId>
        <version>2.2.39.Final</version>
    </dependency>

    <!-- Journalisation avec Log4j2 -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.26.0</version>
    </dependency>
</dependencies>

Point d’entrée de l’application

Le lancement ne nécessite qu’une seule ligne de code :

package com.example;

import cn.aifei.core.Aifei;

public class MainApp {
    public static void main(String[] args) {
        Aifei.start(new AppConfig(), args);
    }
}

Configuration principale (AppConfig.java)

Cette classe configure les composants fondamentaux :

package com.example;

import cn.aifei.config.*;
import cn.aifei.log.log4j.Log4jLogFactory;
import cn.aifei.server.undertow.UndertowServer;
import cn.aifei.util.PropKit;

public class AppConfig implements AifeiConfig {

    public void config(Settings settings) {
        settings.setLogFactory(new Log4jLogFactory());
        settings.setServer(new UndertowServer());
    }

    public void config(Routes routes) {
        routes.scan("com.example");
    }

    public void config(Plugins plugins) {
        // Ajout futur de plugins (base de données, cache, etc.)
    }
}

Fichiers de configuration

app-config.txt :

aifei.profiles.active = dev

app-config-dev.txt :

debugMode = true

undertow-dev.txt :

undertow.port = 8080
undertow.host = 0.0.0.0

Exemple de service REST

Utilisez le paradigme Just Service pour exposer rapidement des API :

package com.example;

import cn.aifei.core.Path;
import cn.aifei.vip.arch.core.Out;

@Path("/user")
public class UserService {

    public Out index() {
        return Out.of("info", "Bienvenue sur l'API utilisateur");
    }

    public Out greet(String name) {
        if (name == null || name.isBlank()) {
            return Out.fail("Le nom est requis");
        }
        return Out.of("salutation", "Bonjour, " + name.trim());
    }

    public Out status() {
        return Out.ok("Système opérationnel");
    }
}

Construction de réponses avec Out

La classe Out simplifie la création de réponses JSON structurées :

• Out.of("key", value) → réponse réussie avec données
• Out.ok("message") → succès standard
• Out.fail("erreur") → réponse d’échec

Lancement de l’application

Depuis votre IDE, exécutez simplement MainApp.main(). Vous verrez :

INFO: Démarrage du framework Aifei...
INFO: Serveur Undertow actif sur le port 8080
INFO: 3 endpoints détectés via @Path
INFO: Application démarrée avec succès !

Test des endpoints

Utilisez un client HTTP ou un navigateur :

GET http://localhost:8080/user
→ {"code":0,"data":{"info":"Bienvenue sur l'API utilisateur"}}

GET http://localhost:8080/user/greet?name=Marie
→ {"code":0,"data":{"salutation":"Bonjour, Marie"}}

GET http://localhost:8080/user/status
→ {"code":0,"msg":"Système opérationnel"}

Connexion à une base de données

Ajoutez les dépendances suivantes dans pom.xml :

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.23</version>
</dependency>

Configurez la source de données dans app-config-dev.txt :

db.url = jdbc:mysql://localhost:3306/demo?useSSL=false&serverTimezone=UTC
db.user = admin
db.password = secret
db.pool.max = 20

Activez le plugin dans AppConfig :

public void config(Plugins plugins) {
    Prop p = PropKit.use("app-config-dev.txt");
    DruidPlugin dp = new DruidPlugin(p.get("db.url"), p.get("db.user"), p.get("db.password"));
    dp.setInitialSize(5).setMinIdle(5).setMaxActive(p.getInt("db.pool.max"));
    plugins.add(dp);
}

Tests unitaires simples

Grâce à la nature indépendante des services, vous pouvez les tester directement :

@Test
public void testGreetUser() {
    UserService service = new UserService();
    Out response = service.greet("Alice");
    assertTrue(response.getData().toString().contains("Alice"));
}

Plus besoin de contexte Spring ou de conteneur web — les tests sont rapides et isolés.

Conclusion

Vous avez maintenant créé une application web fonctionnelle avec Aifei, en quelques minutes seulement. Ce framework repense le développement Java en mettant l’accent sur la simplicité, la rapidité et la compatibilité avec les outils modernes d’assistance par IA. Si vous cherchez une alternative agile à Spring Boot, Aifei mérite une place dans votre boîte à outils.