Springboot est un produit qui est né pour simplifier la création, l'exploitation, le débogage et le déploiement des applications de printemps. La fonction d'assemblage automatique nous permet de mieux nous concentrer sur l'entreprise elle-même plutôt que sur la configuration XML externe. Nous devons seulement suivre les spécifications et introduire des dépendances pertinentes pour créer facilement un projet Web.
Les opérations de base de données de Spring Framework sont profondément encapsulées dans JDBC. Grâce à la fonction d'injection de dépendance, DataSource peut être enregistré dans JDBCTemplate, ce qui nous permet de compléter facilement le mappage relationnel d'objet et de contribuer à éviter les erreurs courantes. À Springboot, nous pouvons facilement l'utiliser.
Caractéristiques
Dépendances d'importation
Ajouter une dépendance à JdbCTemplate dans pom.xml
<! - Spring JDBC Dependency Package, en utilisant Spring-Boot-Starter-JDBC ou Spring-Boot-Starter-Data-JPA obtiendra automatiquement HikaricP Dependency -> <Dendency> <ProupID> org.springframework.boot </ GroupId> Package -> <Dedency> <GroupId> MySQL </rom grouped> <Ertifactive> MySQL-Connector-Java </Retifactid> </Dependency> <! - Tomcat est incorporé par défaut, si vous devez remplacer le conteneur, il est également très simple -> <Dedency> <ProupId> Org.SpringFramework. <ArtefactId> printemps-boot-starter-web </ artifactid> </dependency>
Connectez-vous à la base de données
Ajoutez la configuration suivante dans Application.Properties. Il convient de noter que Springboot configurera automatiquement DataSource par défaut, ce qui privilégiera l'utilisation du pool de connexion HikaricP. S'il n'y a pas de dépendance, sélectionnez Tomcat-JDBC. Si aucun des deux premiers n'est disponible, sélectionnez Commons DBCP2. La propriété Spring.Datasource.Type peut spécifier d'autres types de pools de connexion
printemps.datasource.url = jdbc: mysql: // localhost: 3306 / Chapter4? useunicode = true & caractérisation = utf-8 & zerodatetimebehavior = convertto Null & allowerMultiqueries = true & usessl = falsespring.datasource.password = rootspring.datasource.username = root # spring.datasource.type # Les configurations subtiles peuvent être ajustées par le préfixe suivant # printemps.datasource.hikari # printemps.datasource.tomcat # printemps.datasource.dbcp2
Démarrez le projet, via le journal, vous pouvez voir que par défaut, le hikaridatasource est injecté.
2018-05-07 10: 33: 54.021 info 9640 --- [Main] OsjeaannotationMbeanExporter: Bean avec nom 'DataSource' a été automatiquement Le serveur JMX en tant que mbean [com.zaxxer.hikari: name = dataSource, type = HikaridataSource] 2018-05-07 10: 33: 54.071 info 9640 --- [Main] Osbwembedded.tomcat.TomcatWerver: Tomcat a commencé à port (s): 8080 (HTTP) avec le contexte de Tomcat (s): 8080 (HTTP) avec le contes '' 2018-05-07 10: 33: 54.075 Info 9640 --- [Main] com.battcn.chapter4Application: Démarré Chapitre4 Application en 3,402 secondes (JVM en cours d'exécution) pour 3,93)
Code spécifique
Après avoir terminé la configuration de base, effectuez des opérations de codage spécifiques. Afin de réduire la quantité de code, je n'écrirai pas d'interfaces telles que UserDao et UserService. J'utiliserai JDBCTemplate directement dans le contrôleur pour accéder à la base de données. Ce n'est pas standardisé. N'apprends pas de moi ...
Structure de table
Créez une table avec T_User
Créer un tableau `t_user` (` id` int (8) non null auto_increment commentaire `` incrément de clé primaire '', `nom d'utilisateur` varchar (50) non null commentaire` `nom d'utilisateur '',` mot de passe` varchar (50) non nul commentaire `` mot de passe '', touche principale (`id`)) moteur = innodb Charset = utf8 comment = 'user table';
Classe d'entité
package com.battcn.entity; / ** * @author levin * @Since 2018/5/7 0007 * / public class utilisateur {private long id; Nom d'utilisateur de chaîne privée; mot de passe de chaîne privé; // todo omettre get set}Interface de style repos
package com.battcn.Controller; import com.battcn.entity.user; import org.springframework.beans.factory.annotation.autowired; import org.springframework.jdbc.core.BeanProperTyRowMapper; import org.springframework.jdbc.Core.jdbcTemplate; SpringFramework.web.bind.annotation. *; Importer java.util.list; / ** * @Author Levin * @Since 2018/4/23 0023 * / @ restController @ requestmapping ("/ use") public class SpringjdbcTroller {Private Final JDBCTETTLEM JDBCTemplate; @Autowired public SpringJDBCController (JDBCTemplate JDBCTemplate) {this.jdbCTemplate = JDBCTemplate; } @Getmapping public list <ser utilisateur> queryUsers () {// requête tous les utilisateurs SQL SQL = "SELECT * FROM T_USER"; return jdbctemplate.query (sql, nouvel objet [] {}, nouveau beanpropertyrowmapper <> (user.class)); } @GetMapping ("/ {id}") Utilisateur public GetUser (@pathvariable long id) {// Query String Sql = "select * from t_user où id =?"; return jdbCTemplate.QueryForObject (SQL, nouvel objet [] {id}, nouveau beanpropertyrowmapper <> (user.class)); } @Deletemapping ("/ {id}") public int Deuser (@pathvariable long id) {// supprimer les informations utilisateur en fonction de la chaîne de clé primaire ID SQL = "delete from t_user où id =?"; return jdbCTemplate.update (sql, id); } @Postmapping public int AddUser (@Requestbody User utilisateur) {// Ajouter une chaîne d'utilisateur sql = "INSERT INTO T_USER (nom d'utilisateur, mot de passe) (?,?)"; return jdbctemplate.update (sql, user.getUserName (), user.getPassword ()); } @Putmapping ("/ {id}") public int editUser (@pathvariable long id, @Requestbody User utilisateur) {// Modifier les informations de l'utilisateur en fonction de la clé de clé principale SQL = "Update T_User set username =?, Password =? WHERE ID =?"; return jdbctemplate.update (sql, user.getUserName (), user.getPassword (), id); }}test
Étant donné que l'interface ci-dessus est une interface de style restful, l'addition et la modification ne peuvent pas être terminées via le navigateur, nous devons écrire Junit nous-mêmes ou utiliser des outils tels que Postman.
Créer un test unitaire Chapitre4Applicationtests et simuler des opérations de demande telles que GET, POST, PUT, DELETE, etc. via TestRestTemplate
package com.battcn; import com.battcn.entity.user; import org.junit.test; import org.junit.runner.runwith; import org.slf4j.logger; import org.slf4j.loggerfactory; import org.springframework.Beans.factory.annotation.Autowired; import; org.springframework.boot.test.context.springboottest; import org.springframework.boot.test.web.client.testremplate; import org.springframework.boot.web.server.localserverport; import org.springframework.Core.Cara org.springframework.http.httpMethod; import org.springframework.http.Responseentity; import org.springframework.test.context.junit4 Chapter4Application.Class, WebenIironment = Springboottest.webenvironment.random_port) Classe publique Chapter4ApplicationTests {private static final logger log = loggerFactory.getLogger (Chapter4ApplicationTestS.Class); @Autowired Private TestRestTemplate Template; @LocalServerport Private int port; @Test public void test1 () lève une exception {template.postForEntity ("http: // localhost:" + port + "/ utilisateurs", nouvel utilisateur ("user1", "pass1"), Integer.class); log.info ("[Ajouter un succès de l'utilisateur] / n"); // TODO Si c'est la collection renvoyée, utilisez Exchange au lieu de GetForENTITY, qui doit forcer le type de réponse <list <utilisateur >> Response2 = template.exchange ("http: // localhost:" + port + "/ users", httpMethod.get, null, new paramètreTypereference <list <user> () {}); Final List <User> Body = Response2.GetBody (); log.info ("[requête all] - [{}] / n", corps); Long userId = body.get (0) .getId (); ResponseNtity <User> réponse3 = template.getForEntity ("http: // localhost:" + port + "/ users / {id}", user.class, userid); Log.info ("[Clé primaire Query] - [{}] / n", réponse3.getBody ()); template.put ("http: // localhost:" + port + "/ utilisateurs / {id}", nouvel utilisateur ("user11", "pass11"), userId); log.info ("[modifier l'utilisateur avec succès] / n"); template.delete ("http: // localhost:" + port + "/ users / {id}", userId); log.info ("[Supprimer l'utilisateur avec succès]"); }}Résumer
Ce chapitre présente plusieurs opérations couramment utilisées de JDBCTemplate. Pour plus de détails, veuillez consulter la documentation de l'API JDBCTemplate.
De nombreux bigwigs ont écrit des tutoriels sur Springboot. S'il y a des similitudes, pardonnez-moi. Ce tutoriel est basé sur le dernier Spring-Boot-Starter-Parent: 2.0.1.release, et les fonctionnalités de la nouvelle version seront introduites ensemble ...