Vorwort
Das JDBC -Templet von Spring ist eine grundlegende Kapselung, die Spring für JDBC verwendet. Es hilft den Programmierern hauptsächlich, Datenbankverbindungen zu verwalten, und die restlichen Nutzungsmethoden sind kein großer Unterschied von der direkten Verwendung von JDBC.
Geschäftsanforderungen
Jeder ist mit der Verwendung von JDBC vertraut. Dies soll hauptsächlich die Schritte zur Verwendung des Frühlings -JDBC -Templet im Springboot demonstrieren, sodass wir eine einfache Anforderung entwickelt haben. Ein Quarksatz eines Benutzerobjekts. Ein Objekt hat zwei Eigenschaften, eine ID und der andere ist Name. Gespeichert in der Auth_User -Tabelle in MySQL.
Erstellen Sie neue Projekte und fügen Sie Abhängigkeiten hinzu
Erstellen Sie ein leeres Springboot -Projekt in der Intellij -Idee. Spezifische Schritte Referenz
Grafisches Tutorial von Intellij IDEA zum Erstellen von Spring-Boot-Projekten. Nach den Anforderungen dieses Beispiels müssen wir die folgenden drei Abhängigkeiten hinzufügen
<Depopenty> <gruppe> org.springFramework.boot </GroupId> <artifactId> Spring-Boot-Starter-Web </artifactId> </abhängig> <Depopentcy> <GroupID> org.springFramework.boot </Groupid> <artifactid> Spring-Boot-Starr-JDBC </artifactid> </artifactid> <gruppe> MySQL </GroupID> <artifactId> mysql-connector-java </artifactid> <version> 6.0.6 </Version> </abhängig>
Da wir den HTTP-REST-Service veröffentlichen möchten, fügen wir die Abhängigkeit von Spring-Boot-Starter-Web hinzu. Hier möchten wir die JDBC Tempet-Methode verwenden, um auf die Datenbank zuzugreifen. Daher fügen wir die Abhängigkeit von Spring-Boot-Starter-JDBC hinzu, um auf die MySQL-Datenbank zuzugreifen. Daher fügen wir die neueste Version des JDBC-Treibers von MySQL hinzu.
Bereiten Sie die Datenbankumgebung vor
Angenommen, MySQL 5.7 ist bereits auf dem Linux -Betriebssystem installiert. Die folgenden Vorgänge werden in der Befehlszeile des Betriebssystems ausgeführt und über den Root -Benutzer im Befehlszeilenclient von MySQL angemeldet.
Datenbank und Tabelle erstellen
Datenbank erstellen Springboot_jdbc; table auth_user (uUid bigint nicht null, Name varchar (32), Primärschlüssel (UUID)) Standard charSet = utf8mb4;
Setzen Sie Benutzerberechtigungen
Gewähren Sie alle Privilegien für Springboot_Jdbc.* An 'Springboot'@'%' identifiziert von 'Springboot';
Datenquelle konfigurieren (Verbindungspool)
Die Datenquelle von Springboot ist automatisch konfiguriert. In Springboot 2.0 sind mehrere Datenquellenkonfigurationen verfügbar und wählen aus, welche Datenquelle in der letzten Reihenfolge von Hikaricp -> Tomcat Pooling -> Commons DBCP2 verwendet werden soll.
Wenn das Projekt Spring-Boot-Starter-JDBC-Abhängigkeit hinzufügt, ist die Abhängigkeit von Hikaricp-Datenquellen bereits enthalten, sodass hier automatisch die HikarICP-Verbindungspool-Datenquelle konfiguriert ist.
Fügen Sie die folgende Konfiguration in Applications.Properties hinzu
#Genalische Datenquellenkonfiguration spring.datasource.driver-class-name = com.mysql.cj.jdbc.driverspring.datasource.url = jdbc: mysql: //10.110.2.5: 3306/spri ng-boot-jdbc? charset = utf8mb4 & uSessl = falsspring.datasource.username = Springbootspring.DataSource.Password = Springboot# Hikari Datenquelle Spezifische Konfiguration Spring.DataSource.hikari.maximum-pool-Größe = 20Spring.DataSource.hikari.Minimum-idle = 5
Unter ihnen sind die meisten Konfigurationen der Hikari -Datenquelle in der folgenden Abbildung dargestellt. Sie können die Bedeutung jeder Konfiguration überprüfen
Programmentwicklung
Benutzerdatenbankentität
Nach den Anforderungen hat die entsprechende Benutzerdatenentität zwei Attribute, eine ID und der andere ist Name. Dies ist ein reines Pojo -Objekt.
Paket com.yanggaochao.springboot.learn.springbootjdbClearn.domain.dao;/*** Benutzerentität Objekt** @author yang gaochao* @Since 2018-03-09*/öffentliche Klasse Userdo {private long id; privater Zeichenfolge Name; public long getid () {return id; } public void setId (Long id) {this.id = id; } public String getName () {return name; } public void setName (String -Name) {this.name = name; }} Allgemeines HTTP -REST -Rückgabeobjekt
Normalerweise möchten wir in der HTTP -REST -Schnittstelle nicht nur den Inhalt des Geschäftsobjekts direkt zurückgeben, sondern auch einige gemeinsame Informationen wie das Ergebnis des Schnittstellenaufrufs, die benutzerdefinierte Textnachricht zurückgegeben, wenn der Anruf fehlschlägt. Usw. Dann müssen wir zwei gemeinsame REST -Return -Objekte einrichten. Zusätzlich zur Rückgabe gemeinsamer Schnittanrufergebnisse und -meldungen enthält man einen separaten Geschäftsbereich und eine Sammlung, die mehrere Unternehmensinhalte enthält. Die spezifische Definition ist wie folgt
Rückgabe von Objekt für separate Geschäftsinhalte
paket com.yanggaochao.springboot.learn.springbootjdbClearn.domain.bo;/*** einzelnes Objekt Rückgabeergebnis** @author yang gaochao* @Since 2018-03-09*/public class restItemresult <t> privates String-Ergebnis; private String -Nachricht; privates T -Artikel; public String getResult () {Rückgabeergebnis; } public void setResult (String -Ergebnis) {this.result = result; } public String getMessage () {Rückgabenachricht; } public void setMessage (String -Nachricht) {this.message = message; } public t getItem () {return item; } public void setItem (t item) {this.Item = item; }} Sammlung von Geschäftsinhalten gibt Objekt zurück
Paket com.yanggaochao.springboot.learn.springbootjdbclearn.domain.bo; Import Java.util.collection;/*** Collection-Objekt Rückgabe von Ergebnis** @author yang gaochao* @Since 2018-03-09*/public class restcollectionResult <T> {t> {privat String Ergebnis; private String -Nachricht; private Sammlung <t> Artikel; public String getResult () {Rückgabeergebnis; } public void setResult (String -Ergebnis) {this.result = result; } public String getMessage () {Rückgabenachricht; } public void setMessage (String -Nachricht) {this.message = message; } public collection <t> getItems () {Return items; } public void setItems (Sammlung <T> Elemente) {this.Items = items; }} Entwicklung der Datenpersistenzschichtentwicklung
Benutzerdaten -Persistenzschicht -Schnittstelle Definition
package com.yanggaochao.springboot.learn.springbootjdbclearn.dao;import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;import java.util.List;/** * User data layer interface* * @author Yang Gaochao* @since 2018-03-09*/public interface userDao {/*** Speichern Sie einen neuen Benutzer in der Datenbank** @param Benutzerobjekt, um zu speichern* @return, ob Muskelverstärkung erfolgreich ist*/boolean add (Benutzerdo-Benutzer); / *** Aktualisieren Sie einen Benutzer in der Datenbank*** @param Benutzerbenutzerbenutzer zu aktualisieren* @return, ob das Update erfolgreich ist*/ boolean Update (Benutzerdo -Benutzer); / *** Löschen Sie einen angegebenen Benutzer*** @param id Die Identität des Benutzers zu löschen* @return, ob der Löschen erfolgreich ist*/ boolean löschen (Long ID); / *** Genaue Abfrage eines bestimmten Benutzers** @Param ID Die Identität des Benutzers zum Abfragen* @return Wenn er abgefragt werden kann, Benutzerinformationen zurückgeben, ansonsten null*/ userdo location (Long ID) zurückgeben; / *** Abfragen Sie den Benutzer mit dem Namen*** @param Name den Namen, der fuzzy* @return Liste der Benutzer abfragen*/ list <UserDo> MatchName (String -Name);} Implementierung von Benutzerdaten Persistenzschicht
Paket com.yanggaochao.springboot.learn.springbootjdbClearn.dao.impl; Import Com.yanggaochao.springboot.learn.springbootjdbclearn.dao.userdao; Import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.userdo; import org.springframework.bean.factory.annotation.autowired; org.springframework.jdbc.support.rowset.SqlRowSet;import org.springframework.stereotype.Repository;import java.util.ArrayList;import java.util.List;/** * User object database access implementation class* * @author Yang Gaochao* @since 2018-03-09 */@RepositoryPublic class userDaOJDBCtemPletImpl implementiert userDao {private endgültige jdbctemplate jdbCtemplate; @Autowired public userDaOJDBCTEMPLETIMPL (JDBCTEMPLET JDBCTEMPLATE) {this.jdbctemplate = jdbctemplate; } @Override public boolean add (userdo user) {string sql = "In Auth_User (uUid, Name) Werte (?,?)" Einfügen; return jdbctemplate.update (SQL, user.getId (), user.getName ())> 0; } @Override public boolean update (userdo user) {string sql = "achte auth_user set name =? Wo uUid =?"; return jdbctemplate.update (SQL, user.getName (), user.getId ())> 0; } @Override public boolean delete (long id) {string sql = "löschen von auth_user wo uUid =?"; return jdbctemplate.update (SQL, ID)> 0; } @Override public userdo socate (long id) {string sql = "select * von auth_user wo uUid =?"; Sqlrowset rs = jdbctemplate.QueryForrowset (SQL, ID); if (rs.Next ()) {return generateEnateEntity (rs); } return null; } @Override publiclist <userDo> MatchName (String -Name) {String sql = "Select * From Auth_User, wo Name wie?"; Sqlrowset rs = jdbctemplate.QueryForrowset (SQL, "%" + name + "%"); Liste <Bedo> user = new ArrayList <> (); while (rs.Next ()) {users.add (generateEntity (rs)); } Rückgabebenutzer; } private userDo generateEntity (SQLROWSet RS) {UserDo Wechatpay = new UserDo (); WeChatpay.setID (rs.getLong ("uUid")); WeChatpay.SetName (rs.getString ("Name")); Wechatpay zurückgeben; }} Hier verwenden wir zunächst Annotation @Repository, um anzuzeigen, dass dies eine Klasse der Datenpersistenzschicht ist, und Springboot wird diese Klasse automatisch instanziiert. Fügen Sie dann dem Konstruktor einen @autowired hinzu. Wenn Springboot in dieser Klasse instanziiert, wird die JDBCTEMPLET -Instanz automatisch in diese Klasse injiziert. Hier wird die JDBCTEMPLET-Instanz durch Springboot automatisch basierend auf der Datenquellenkonfiguration in Anwendungen konfiguriert. Gemäß dem Algorithmus von Springboot zur automatischen Konfiguration von Datenquellen ist die hier konfigurierte Datenquelle Hikaricp.
Der Rest ist genau wie die gewöhnliche Entwicklung des Frühlings -JDBCTEMPLET. Durch manuelles Konvertieren zwischen Objekten und Datenbank -SQL durch Programmierer können Benutzer hinzugefügt, geändert, geändert, gelöscht, Fuzzy -Matching, präzise Abfragen und andere Funktionen geändert werden.
Daten für Datenschichten
Data Service Layer -Schnittstelle Definition
package com.yanggaochao.springboot.learn.springbootjdbclearn.service;import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.UserDO;import java.util.List;/** * User service layer interface* * @author Yang Gaochao* @since 2018-03-09 */public interface userservice {userDo add (userDo user); Userdo -Update (Benutzerdo -Benutzer); boolean delete (Long ID); UserDo Locate (Long ID); LIST <UserDo> MatchName (String -Name);} Implementierung von Datendienstschichten
Paket com.yanggaochao.springboot.learn.springbootjdbClearn.service.impl; Import Com.yanggaochao.springboot.learn.springbootjdbclearn.dao.userdao; Import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.userdo; import com.yanggaochao.springboot.learn.springbootjdbClearn.Service.Userservice; org. @Autowired public userServiceImpl (userDao userDao) {this.userdao = userDao; } @Override public userdo add (userDo user) {user.setId (neues Datum (). GetTime ()); if (userDao.add (user)) {zurücksender Benutzer; } return null; } @Override public userDo update (userDo user) {if (userDao.update (user)) {return locum (user.getId ()); } return null; } @Override public boolean delete (long id) {return userDao.delete (id); } @Override public userdo location (long id) {return userDao.locate (id); } @Override publiclist <userDo> MatchName (String -Name) {return userDao.matchName (Name); }} Hier wird diese Implementierungsklasse über eine @Service-Annotation als Geschäftsklasse auf Unternehmensebene deklariert. Mit userDao der Persistenzschicht kann Springboot diese Geschäftsschichtklasse über @Autowired instanziieren und die entsprechende Persistenzschichtklasse automatisch in diese Business -Klasse einbringen.
Wenn Sie hier Benutzerobjekte hinzufügen und die Identifizierung für den Benutzer festlegen, wird eine Millisekundenzahl der aktuellen Zeit einfach als Identifikation verwendet. Während des tatsächlichen Entwicklungsprozesses muss dieser Ort einen global einzigartigen Mechanismus verwenden, um sicherzustellen, dass dieses Logo nicht wiederholt werden kann.
Externe Service -Schichtentwicklung
Paket com.yanggaochao.springboot.learn.springbootjdbClearn.web; Import Com.yanggaochao.springboot.learn.springbootjdbClearn.domain.bo.restcollectionResult; Import com.yanggaochao.springboot.learn.springbootjdbclearn.domain.dao.userdo; import com.yanggaochao.springboot.learn.springbootjdbClearn.Service.Userservice; org.springFramework.web.bind.annotation. @RequestMapping (value = "/add", method = requestMethod.post) public restItemresult <userDo> add (@RequestBody userDo user) {restItemresult <userDo> result = new RestItemresult <> (); user = userService.add (Benutzer); if (user! = null) {result.setItem (user); result.setResult ("Erfolg"); } else {result.setMessage ("neuer Benutzer fehlgeschlagen"); result.setResult ("Misserfolg"); } Rückgabeergebnis; } @RequestMapping (value = "/update", method = requestMethod.post) public restItemresult <userDo> update (@RequestBody userDo user) {restItemresult <userDo> result = new restItemresult <> (); user = userService.update (Benutzer); if (user! = null) {result.setItem (user); result.setResult ("Erfolg"); } else {result.setMessage ("UserDo hat den Benutzer nicht geändert"); result.setResult ("Misserfolg"); } Rückgabeergebnis; } @RequestMapping (value = "/delete/{uUid}", method = requestMethod.get) public restItemresult <UserDo> delete (@PathVariable long uUid) {restItemresult <userDo> result = new restItemresult <> (); if (UserService.delete (uUid)) {result.setResult ("Erfolg"); } else {result.setMessage ("Benutzer delete fehlgeschlagen"); result.setResult ("Misserfolg"); } Rückgabeergebnis; } @RequestMapping (value = "/socate/{uUid}", method = requestMethod.get) public restItemresult <userDo> socate (@PathVariable long uUid) {restItemresult <userDo> result = new restItemresult <> (); Userdo user = userService.locate (uUid); if (user! = null) {result.setItem (user); result.setResult ("Erfolg"); } else {result.setMessage ("Abfragebrenner fehlgeschlagen"); result.setResult ("Misserfolg"); } Rückgabeergebnis; } @RequestMapping (value = "/match/{name}", method = requestMethod.get) public rastCollectionResult <UserDo> Match (@PathVariable String name) {restCollectionResult <BenerDo> result = new tastcollectionResult <> (); LIST <BENEDO> Users = UserService.MatchName (Name); result.setItems (Benutzer); result.setResult ("Erfolg"); Rückgabeergebnis; }} Hier wird @restController verwendet, um zu erklären, dass dies eine HTTP -REST -Schnittstelle ist. Die Anrufroute für jede Schnittstelle wird gebildet, indem @RequestMapping in der Klasse und @RequestMapping auf der Methode kombiniert wird. Die Methode Eigenschaft in @RequestMapping auf der Methode deklariert die von HTTP aufgerufene Methode. @RequestBody Annotation konvertiert das JSON -Objekt automatisch in die Postdaten in ein Pojo -Objekt. @PathVariable konvertiert automatisch Daten im HTTP -URL -Pfad in Parameter der Servicemethode.
HTTP -REST -Schnittstellentest
Testen Sie, dass der HTTP -REST -Service über den HTTPClient von Apache Commons aufgerufen wird.
HTTP RESST ruft Hilfsklassen auf
Paket com.yanggaochao.springboot.learn.springbootjdbClearn; org.apache.commons.httpclient.defaulttttpMethodryHandler; importieren org.apache.commons.httpclient.httpclient; org.apache.commons.httpclient.methods.getMethod; import org.apache.commons.httpclient.methods.getmethod; java.io.buffenedReader; import Java.io.inputStreamReader; Import Java.io.inputStreamReader; Import Java.io.reader; http request * * @param url Die URL von http zu greifen * @return access http Der nach */ public String httpGetRequest (String url, map <string> header) {try {httpclient httppclient = new httpclient () erhalten; GetMethod method = new getMethod (URL); method.setRequestheader ("Content-Typ", "Application/JSON; CharSet = UTF-8"); method.getParams (). setParameter (httpMethodParams.retry_handler, neuer DefaulthttpMethodryHandler (3, False)); if (Header! }} int statusCode = httpclient.executemethod (Methode); if (statusCode == 200) {return ParzeinputStream (method.getResponseBoundAtReam ()); } else {System.out.println (url + "status =" + statusCode); }} catch (Ausnahme e) {e.printstacktrace (); } return null; } / *** Verwenden Sie die Post -Methode, um eine HTTP -Anforderung zu initiieren Httpclient (); Postmethod method = new postmethod (URL); method.setRequestheader ("Content-Typ", "Application/JSON; CharSet = UTF-8"); method.setRequestheader ("user-Agent", "Mozilla/5.0 (Windows NT 6.1; Wow64) Applewebkit/537.36 (khtml, wie Gecko) Chrome/34.0.1847.131 Safari/537.36"); if (Header! }} method.setRequestentity (neue StringRequestentity (Daten, "JSON", "UTF-8"); int statuscode = httpclient.executemethod (Methode); if (statusCode == 200) {return ParzeinputStream (method.getResponseBoundAtReam ()); } else {system.out.println (url + "status =" + statuscode + pareeinputStream (methode.getResponseBodyAssTream ())); }} catch (Ausnahme e) {e.printstacktrace (); } return null; } / *** Textdaten von java.io.Reader** @param rd java.io.Reader -Objekt* @throws Exception löst einen Fehler aus, wenn ein Fehler auftritt Stringlinie; StringBuilder reActeContext = new StringBuilder (); while ((line = brd.readline ())! } //rd.close (); if (responcteContext.length ()> 0) {ResponseContext.DeletEcharat (responseContext.length () - 1); } return responseContext.toString (); } / *** Textdaten aus dem Eingabestream analysieren** @Param Is Eingabestream* @Throws Ausnahme löst eine Ausnahme aus, wenn ein Fehler auftritt }} Hier implementieren wir hauptsächlich die Methode zum Aufrufen des HTTP -REST -Dienstes mit GET und Post -Methoden.
Testfälle
Verwenden Sie JUNIT, um Testfälle auszuführen. Um den Test zu implementieren, haben wir die folgende Maven -Abhängigkeit hinzugefügt
<dependency> <groupId>commons-httpclient</groupId> <artifactId>commons-httpclient</artifactId> <version>3.1</version> <scope>test</scope></dependency><dependency> <groupId>org.codehaus.jettison</groupId> <artifactId>jettison</artifactId> <version>1.3.3</version> <Scope> test </scope> </abhängig>
paket com.yanggaochao.springboot.learn.springbootjdbClearn; import org.codeehaus.jettison.json.jsonObject; java.util.list;/** * Beschreibung: * * @author yang gaochao * @Since 2018-03-09 */public class UseraPitest {private String userAddurl = "http: // localhost: 3030/Sicherheit/api/v1/user/adding"; private String userLocateurl = "http: // localhost: 3030/security/api/v1/user/socate/"; private String userDeleteurl = "http: // localhost: 3030/security/api/v1/user/delete/"; private String userUpdateurl = "http: // localhost: 3030/security/api/v1/user/update"; private String usermatchurl = "http: // localhost: 3030/security/api/v1/user/match/"; JsonObject adduser = new JsonObject (); Langes adduserId = null; List <Long> userIDS = new ArrayList <> (); @Before public void vor () löst Ausnahme aus (adduser.put ("Name", "schöne Schafe"); JsonObject adDResultjson = new JSONObject (new HttpclientHelper (). Assert ("Erfolg" .Eequals (addResultjson.getString ("Ergebnis")); addUserid = addResultjson.getJsonObject ("item"). getlong ("id"); JsonObject user = new JsonObject (); user.put ("Name", "Pleasant Goat"); addResultjson = new JsonObject (new httpclientHelper (). Assert ("Erfolg" .Eequals (addResultjson.getString ("Ergebnis")); userIds.add (addResultjson.getJsonObject ("item"). getlong ("id")); user.put ("name", "grauer Wolf"); addResultjson = new JsonObject (new httpclientHelper (). Assert ("Erfolg" .Eequals (addResultjson.getString ("Ergebnis")); userIds.add (addResultjson.getJsonObject ("item"). getlong ("id")); } @Test public void testupdateuser () löst Ausnahme aus {jsonObject user = new JsonObject (); user.put ("Name", "Smad Sheep"); user.put ("id", addUerId); new httpclientHelper (). JsonObject Locateresultjson = new JSONObject (new HttpclientHelper (). Assert (user.getString ("Name"). Equals (Locateresultjson.getJsonObject ("Element"). getString ("Name")); } @Test public void testMatchUser () löst Ausnahme aus {jsonObject matchResultjson = new JsonObject (new httpclientHelper (). assert (matchResultjson.has ("items") && matchResultjson.getJsonArray ("items"). Länge () == 2); matchResultjson = new JsonObject (new httpclientHelper (). assert (matchResultjson.has ("items") && matchResultjson.getJsonArray ("items"). Länge () == 1); } @After public void After () löst Ausnahme aus {if (addUSerId! Assert ("Erfolg" .Eequals (DELETERSULTJSON.getString ("Ergebnis")); } für (long userId: userIds) {jsonObject deleteresultjson = new JsonObject (new httpclientHelper (). Assert ("Erfolg" .Eequals (DELETERSULTJSON.getString ("Ergebnis")); }}} Hier werden zwei Testfälle in @Test deklariert, man testet die Funktion des Benutzeränderungen und die andere testet die Fuzzy -Abfragefunktion der Benutzer. @Before deklariert die Vorbereitungen, bevor jeder Testfall ausgeführt wird. Hier fügen wir zuerst drei Datenstücke in die Datenbank ein und testen gleichzeitig auch die Funktion des Hinzufügens von Daten und präzisen Abfragen. @Nach der Ausführung jedes Testfalles erklärt die Reinigung. Hier löschen wir die zuvor eingefügten Daten hauptsächlich. Die Funktion der Benutzerdeletion wird hier synchron getestet.
PostScript
Hier ist ein komplettes Beispiel für Springboot mit JDBC Templet. Wenn Sie Erfahrung mit JDBC -Templet im Frühjahr haben, dann der Hauptzweck, eine Menge Konfigurationsarbeiten im Frühjahr zu reduzieren.
Der in diesem Artikel beteiligte Code wurde auf GitHub hochgeladen, und Sie können ihn auch lokal herunterladen
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Referenzwert für das Studium oder die Arbeit eines jeden hat. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.