L'année dernière, je comptais un peu de compréhension de la façon dont le Springboot pratique et rapide a été développé dans divers canaux. Mais je n'ai pas étudié dur à ce moment-là. Après tout, je sentais que je n'étais pas très compétent dans Struts et SpringMVC. Cependant, après avoir lu beaucoup de présentations sur Springboot, ce n'était pas aussi difficile que je le pensais, alors j'ai commencé à me préparer à apprendre Springboot. Dans mon temps libre, après avoir lu Springboot Real Combat et certains blogs de Masters sur Springboot, j'ai commencé à écrire mon premier projet Springboot. Après avoir pu implémenter des fonctions CRUD à Springboot avec un développement simple d'interfaces de style repos, ce billet de blog a été créé.
Introduction à Springboot
Spring Boot est un nouveau cadre fourni par l'équipe pivot. Il est conçu pour simplifier le processus initial de construction et de développement des nouvelles applications de printemps. Le framework utilise un moyen spécifique de le configurer, afin que les développeurs n'aient plus besoin de définir des configurations de chaudières.
Autrement dit, vous pouvez rapidement développer un projet avec seulement quelques pots et quelques configurations simples.
Si je veux simplement développer une interface externe, je n'ai besoin que du code suivant.
Un programme principal démarre le Springboot
@SpringBootApplicationPublic class Application {public static void main (String [] args) {springApplication.run (application.class, args); }}Couche de contrôle
@RestControllerPublic class helloworldController {@RequestMapping ("/ Hello") public String Index () {return "Hello World"; }}Après avoir réussi le programme principal, écrivez la couche de contrôle, puis entrez http: // localhost: 8080 // Bonjour dans le navigateur pour afficher les informations.
Je pense que l'utilisation de Springboot pour développer des programmes est très simple!
Dans les mots pratiques de Springboot:
Il n'y a pas de configuration ici, pas de web.xml, pas d'instructions de construction, et même pas de serveur d'applications, mais c'est toute l'application. Springboot fera toute la logistique requise pour exécuter l'application, et il vous suffit d'obtenir le code de l'application.
Développer un service RESTFul basé sur Springboot
Avant de développer un programme, vous devriez faire quelques préparatifs
Créer une base de données `Springboot`; Utilisez` Springboot`; Drop Table If Exist `T_User`; Créer la table` T_USER` (`ID` INT (11) Non Null Auto_increment Commentaire 'ID',` Name` Varchar (10) COMMENTAU NULL 'NULL' NAME ', `` Age' Int (2) COMMANDE NULL 'VAR', COME PRIMATIVE (`id`)) Auto_increment = 12 charset par défaut = utf8;
Le pot le plus central de Springboot
Spring-boot-starter: module de base, y compris la prise en charge automatique de la configuration, la journalisation et le YAML;
<parent> <proupId> org.springframework.boot </proupId> <Ertifactid> printemps-boot-starter-Parent </ artifactid> <version> 1.5.9.release </ version> <loutpath /> </parent> <projeties> <project.build.sourceencoding> utf-8 </project.build.sourceencoding> utf-8 </project.build.sourceencoding> <Java.version> 1.7 </java.version> <mybatis-spring-boot> 1.2.0 </ mybatis-spring-boot> <mysql-connector> 5.1.39 </ mysql-connector> </preperties> <dedences> <dependency> <proupId> org.springFramework. <ArtefactId> printemps-boot-starter-web </ artifactid> </dependency> <dependency> <proupId> org.springframework.boot </proupId> <Artifactid> Spring-boot-starter-thymeleaf </lefactive> </pedency> <fedency> <proprid> org.springframeworkwork.boot </ groupid> <ArtefactId> printemps-boot-starter-data-jpa </retifactid> </dpendance> <dependency> <proupId> org.springframework.boot </proupId> <Artefactid> printemps-boot-devtools </ artifactive> <pochotional> truefrawewwork. <ArtefactId> Spring-Boot-Starter-Test </ ArtifactId> <POPE> Test </cope> </Dependance> <! - Spring Boot Mybatis Dependency -> <Dedency> <ProupId> org.mybatis.spring.boot </proupId> <Artifactid> Mybatis-Spring-boot-starter </rtifid> <version> $ {mybatis-spring-boot} </ version> </ dépendance> <! - MySQL Connection Driver Dependency -> <Dependency> <ProupId> MySQL </proncID> <RetefactId> MySQL-Connector-Java </RitifActid> <version> $ {MySQL-Connector} </Degel> <Dependance> <! - Utilisez le plug-in Springboot pour utiliser l'application Spring-Boot-Devtools. Lorsque le fichier du ClassPath change, il redémarre automatiquement! -> <harin> <proupId> org.springframework.boot </proupId> <ArtifactId> Spring-Boot-Maven-Plugin </ ArfactId> <FIGIGURATION> <FORK> true </fork> </Fonfiguration> </Glugin> </Glugins> </ build> com.pancm.web - couche de contrôleur
com.pancm.dao - couche de fonctionnement des données dao
com.pancm.bean - Classe d'entité
com.pancm.bean.service - couche de logique commerciale
Application - Classe de démarrage de l'application
Application.Properties - Fichier de configuration de l'application, la configuration sera automatiquement lue par le démarrage de l'application
Généralement, nous avons besoin de quelques configurations personnalisées, telles que la configuration de la configuration de connexion de JDBC, où nous pouvons utiliser Application.Properties pour la configurer. La configuration réelle de la source de données doit être soumise à celle de chacun.
## Configuration de la source de données printemps.datasource.url = jdbc: mysql: // localhost: 3306 / springboot? useunicode = true & worseencoding = utf8spring.datasource.username = rootspring.datasource.password = 123456spring.datasource ##-class-name = co. MyBatis Configuration # Configure comme com.pancm.bean pointez le chemin du package de classe d'entité. MyBatis.TypeaSespackage = com.pancm.bean # Configurez le package de mappeur sous le chemin de classe de classe, * signifie que tous les fichiers XML seront analysés. mybatis.mapperLocations = classpath /: mapper / *. xml
Il est presque temps de venir au code clé.
Nous commençons par écrire la classe POJO, correspondant à la table T_User dans la base de données.
Le code est le suivant
classe publique User {/ ** numéro * / private int id; / ** nom * / nom de chaîne privée; / ** Âge * / Int privé; public user () {} public class user {/ ** numéro * / private int id; / ** nom * / nom de chaîne privée; / ** Âge * / Int privé; Utilisateur public () {} // Getter et Setter omis}Dans la couche DAO précédente, Hibernate et MyBatis pourraient utiliser des annotations ou des fichiers de configuration de mappeur. Ici, nous utilisons le JPA de Spring pour terminer Crud.
illustrer:
Il existe généralement deux façons d'implémenter la mise en œuvre de Crud et de la base de données:
Le premier est la configuration du mappeur de XML.
Le deuxième type consiste à utiliser des annotations, @insert, @Select, @upDate, @delete et d'autres annotations. Cet article utilise le deuxième type
import org.apache.ibatis.annotations.delete; import org.apache.ibatis.annotations.insert; import org.apache.ibatis.annotations.mapper; import org.apache.ibatis.annotations.result; import org.apache.ibatis.select; importe; import org.apache.ibatis.anotations.select; org.apache.ibatis.annotations.update; import org.springframework.data.repository.query.param; import com.pancm.bean.user; @mapperpublic interface userdao {/ ** * data ajout * / @insert ("insert dans t_user (id, nom, âge) (# {id}, # {name}, # {age}) ") void addUser (utilisateur utilisateur); / ** * Modification des données utilisateur * / @upDate ("Update t_user set name = # {name}, age = # {age} où id = # {id}") void UpdateUser (utilisateur utilisateur); / ** * Suppression des données utilisateur * / @delete ("Supprimer de T_User où id = # {id}") void DeleteUser (int id); / ** * Informations utilisateur de requête en fonction du nom d'utilisateur * * / @Select ("SELECT ID, nom, âge de T_User") // RETOUR MAP Résultat Set @Results (@ @Result (propriété = "name"), @Result (propriété = "Agel", Column = "Age"),}) Userbyn (@Param (Column = "Age"),}) utilisateur nom d'utilisateur); / ** * Informations utilisateur de requête en fonction de l'ID utilisateur * * / @Select ("SELECT ID, Nom, Age From T_User") utilisateur findbyid (@param ("id") int userId); / ** * Informations utilisateur de requête en fonction de l'âge de l'utilisateur * / @Select ("SELECT ID, nom, âge de T_User où âge = # {utilisateur}") utilisateur findByage (int userage);}Compréhension personnelle des annotations utilisées par cette interface:
Mappeur: a ajouté cette annotation à l'interface pour indiquer que cette interface est une CRUD implémentée en fonction de l'annotation.
Résultats: L'ensemble de résultats de la carte retournée, la propriété représente les champs de la classe utilisateur et la colonne représente les champs de la base de données correspondante.
Param: champ pour la condition SQL.
Insérer, sélectionner, mettre à jour, supprimer: recruter, modifier et supprimer les bases de données correspondantes.
C'est fondamentalement la même chose que Hibernate et Mybatis.
Le code est le suivant:
interface
Importer com.pancm.bean.user; / ** * * Title: UserService * Description: Interface utilisateur * Version: 1.0.0 * @Author Pancm * @Date 9 janvier 2018 * / Interface publique UserService {/ ** * Ajouter l'utilisateur * @param user * @return * / boolean addUser (utilisateur utilisateur); / ** * Modifier l'utilisateur * @param utilisateur * @return * / booléen updateUser (utilisateur utilisateur); / ** * Supprimer l'utilisateur * @param id * @return * / booléen DeleteUser (int id); / ** * Informations utilisateur de requête en fonction du nom d'utilisateur * @param nom d'utilisateur * / utilisateur finseserByName (String Username); / ** * Informations utilisateur de requête en fonction de l'ID utilisateur * @param userId * / utilisateur findUserById (int userId); / ** * Interroger les informations utilisateur basées sur l'ID utilisateur * @param utilisateur * / utilisateur findUserByage (int userage);}Classe d'implémentation
import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.service; import com.pancm.bean.user; import com.pancm.dao.userdao; Import com.pancm.service.UserService; / ** * @Author Pancm * @Date 9 janvier 2018 * / @ ServicePublic Class UseserServiceIMPL implémente UserService {@Autowired Private UserDao UserDao; @Override public boolean addUser (utilisateur utilisateur) {booléen flag = false; essayez {userdao.adDuser (utilisateur); Flag = true; } catch (exception e) {e.printStackTrace (); } drapeau de retour; } @Override public boolean updateUser (utilisateur utilisateur) {booléen flag = false; essayez {userdao.updateUser (utilisateur); Flag = true; } catch (exception e) {e.printStackTrace (); } drapeau de retour; } @Override public boolean DeleteUser (int id) {boolean flag = false; essayez {userdao.deleteUser (id); Flag = true; } catch (exception e) {e.printStackTrace (); } drapeau de retour; } @Override public utilisateur finseserByName (String username) {return userdao.findByName (nom d'utilisateur); } @Override public utilisateur finseserById (int userId) {return userdao.findById (userId); } @Override public utilisateur finseserByage (int userage) {return userdao.findByage (userage); }}La couche de contrôle est très similaire à SpringMVC, mais elle est beaucoup plus simple que cela.
Ma compréhension personnelle de l'annotation sur la couche de contrôle est la suivante:
RestController: les méthodes de la classe par défaut seront renvoyées au format JSON.
Requestmapping: configuration du chemin d'interface.
Méthode: Format de demande.
RequestParam: paramètres de demande.
La mise en œuvre spécifique est la suivante:
import org.springframework.beans.factory.annotation.autowired; import org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.requestMethod; import org.springframework.web.bind.annotation.restController; import com.pancm.bean.user; import com.pancm.service.userservice; / ** * * Titre: userrestController * Description: * User data opération Interface * version: 1.0.0 * @Autor Pancm * @Date 9 janvier "/ api / user") classe publique USERRESTController {@Autowired Private UserService UserService; @RequestMapping (value = "/ addUser", méthode = requestMethod.post) public boolean addUser (utilisateur utilisateur) {System.out.println ("Démarrer à ajouter ..."); return userservice.adduser (utilisateur); } @Requestmapping (value = "/ updateUser", méthode = requestMethod.put) public boolean updateUser (utilisateur utilisateur) {System.out.println ("Démarrer à mettre à jour ..."); return userService.updateUser (utilisateur); } @RequestMapping (value = "/ deleteUser", méthode = requestMethod.delete) public boolean delete (@RequestParam (value = "username", requis = true) int userId) {System.out.println ("start Delete ..."); return userservice.deleteUser (userId); } @RequestMapping (value = "/ username", méthode = requestMethod.get) utilisateur public findByUsername (@RequestParam (value = "username", required = true) string username) {System.out.println ("start Query ..."); return userService.FindUserByName (nom d'utilisateur); } @RequestMapping (value = "/ userId", méthode = requestMethod.get) public utilisateur findByUserId (@RequestParam (value = "userId", requis = true) int userId) {System.out.println ("start query ..."); return userService.FindUserById (userId); } @RequestMapping (value = "/ userage", méthode = requestMethod.get) utilisateur public findByUserage (@RequestParam (value = "userAge", requis = true) int userage) {System.out.println ("start query ..."); return userService.FindUserById (utilisateur); }}SpringApplication est une classe utilisée pour démarrer les applications Spring à partir de la méthode principale.
Par défaut, il effectue les étapes suivantes:
1. Créez une instance ApplicationContext appropriée (selon ClassPath).
2. Enregistrez une commande de commandePropertySource pour utiliser les paramètres de ligne de commande comme propriétés de ressort.
3. Actualisez le contexte d'application et chargez tous les haricots singleton.
4. Activez tous les haricots CommandLinerUnner.
Démarrez cette classe directement à l'aide de Main, et Springboot le configure automatiquement.
PS: Même maintenant, je pense toujours que c'est vraiment incroyable.
Certaines annotations pour cette classe sont expliquées. :
SpringbootApplication: activer la numérisation des composants et la configuration automatique.
MAPPERSCAN: Configuration du package de scan de classe d'interface de mappeur
Le code est le suivant:
import org.mybatis.spring.annotation.mapperscan; import org.springframework.boot.springApplication; import org.springframework.boot.autoconfigure.springbootapplication; / ** * * Titre: Application * Description: * Springboot Program * Version Jerraire: 1.0.0 * 2018 * / @ SpringbootApplication @ Mapperscan ("com.pancm.dao") Application de classe publique {public static void main (String [] args) {// Démarrer le tomcat intégré et initialiser l'environnement de ressort et ses composants de printemps SpringApplication.run (application.class, args); System.out.println ("Le programme est en cours d'exécution ..."); }}Une fois le code écrit, nous effectuons le test de code.
Après avoir démarré l'application, utilisez l'outil Postman pour tester l'interface.
Les résultats des tests sont les suivants:
Un seul objet et un test sont utilisés ici. Les méthodes réelles ont été testées, mais je pense qu'il n'est pas nécessaire de coller la carte.
J'ai mis le projet sur Github:
https://github.com/xuwujing/springboot
Résumer
Ce qui précède est l'introduction de l'éditeur pour développer un service Restful basé sur Springboot pour implémenter la fonction d'ajout, de supprimer, de modifier et de vérifier. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!