--Versuchen Sie Beispielcode, der mit Spring Boot + Spring JDBC funktioniert --Verwenden Sie die H2-Datenbank für die Datenbank
Die Standardeinstellungen werden wie folgt in application.properties geschrieben.
applicatin.properties
spring.datasource.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=false
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.initialization-mode=embedded
Diese Einstellung wird automatisch angewendet, sodass sie nicht in application.properties beschrieben werden muss. Wenn Sie einen anderen Wert als diesen Einstellungswert verwenden möchten, müssen Sie ihn in application.properties beschreiben.
Die Standardeinstellungsinformationen werden im folgenden Spring JDBC-Quellcode beschrieben.
ClassUtils.forName("org.h2.Driver", H2EmbeddedDatabaseConfigurer.class.getClassLoader()));
@Override
public void configureConnectionProperties(ConnectionProperties properties, String databaseName) {
properties.setDriverClass(this.driverClass);
properties.setUrl(String.format("jdbc:h2:mem:%s;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=false", databaseName));
properties.setUsername("sa");
properties.setPassword("");
}
public static final String DEFAULT_DATABASE_NAME = "testdb";
Die Einstellungselemente von application.properties sind [Spring Boot-Referenzdokumentation - Anhänge - Anhang A: Allgemeine Anwendungseigenschaften](https://docs.spring.io/spring-boot/docs/2.2.0.M5/reference/html/appendix .html # Anhang).
schema.sql und data.sql sind Dateien, die die SQL-Anweisungen beschreiben, die beim Start von Spring Boot ausgeführt werden.
--Schreiben Sie SQL-Anweisungen wie die Erstellung von DDL-Tabellen (Data Definition Language) in schema.sql --Schreiben Sie SQL-Anweisungen wie DML (Data Manipulation Language), um Datensätze in data.sql hinzuzufügen
Es ist auch möglich, die ausgeführte SQL-Anweisung abhängig vom Datenbanktyp zu ändern, z. B. schema-h2.sql und data-h2.sql.
“How-to” Guides - 10. Database Initialization
Spring Boot can automatically create the schema (DDL scripts) of your DataSource and initialize it (DML scripts). It loads SQL from the standard root classpath locations: schema.sql and data.sql, respectively. In addition, Spring Boot processes the schema-${platform}.sql and data-${platform}.sql files (if present), where platform is the value of spring.datasource.platform. This allows you to switch to database-specific scripts if necessary. For example, you might choose to set it to the vendor name of the database (hsqldb, h2, oracle, mysql, postgresql, and so on).
Es ist auch möglich, die zu lesende SQL-Datei zu ändern, indem Sie sie in applyatin.properties beschreiben.
applicatin.properties
spring.datasource.schema=classpath:foo-schema.sql
spring.datasource.data=classpath:bar-data.sql
--pom.xml: Maven-Build-Konfigurationsdatei --.java: Java-Quellcodedatei -. sql: Datei, die die SQL-Anweisung beschreibt, die beim Start ausgeführt werden soll
├── pom.xml
└── src
└── main
├── java
│ └── com
│ └── example
│ ├── Person.java
│ ├── SampleController.java
│ └── SampleService.java
└── resources
├── data.sql
└── schema.sql
pom.xml
Maven Build Konfigurationsdatei.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.0.M5</version>
<relativePath/>
</parent>
<groupId>com.example</groupId>
<artifactId>spring-jdbc-sample</artifactId>
<version>0.0.1</version>
<name>spring-jdbc-sample</name>
<description>Spring JDBC sample</description>
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--Verwenden Sie Spring JDBC-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--Verwenden Sie die H2-Datenbank-->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>
SampleController.java
Eine Klasse zum Empfangen von HTTP-Anforderungen.
package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@SpringBootApplication
@RestController
public class SampleController {
public static void main(String[] args) {
SpringApplication.run(SampleController.class, args);
}
@Autowired
private SampleService service;
//Fügt Daten mit dem angegebenen Namen hinzu
@RequestMapping("/add/{name}")
public List<Person> index(@ModelAttribute Person person) {
service.save(person);
return service.findAll();
}
}
SampleService.java
Eine Klasse, die die Datenbank mithilfe der Spring JDBC JdbcTemplate-Klasse bearbeitet.
package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class SampleService {
@Autowired
private JdbcTemplate jdbcTemplate;
//Gibt eine Liste von Daten zurück
public List<Person> findAll() {
//Assembler zusammenstellen und ausführen, um ausgeführt zu werden
String query = "SELECT * from person";
List<Person> persons = jdbcTemplate.query(query, new BeanPropertyRowMapper<>(Person.class));
return persons;
}
//Daten hinzufügen
public Person save(Person person) {
//Stellen Sie die auszuführende SQL zusammen
SqlParameterSource param = new BeanPropertySqlParameterSource(person);
SimpleJdbcInsert insert =
new SimpleJdbcInsert(jdbcTemplate)
.withTableName("person")
.usingGeneratedKeyColumns("id");
//Führen Sie SQL und AUTO aus_Holen Sie sich den Wert von INCREMENT
Number key = insert.executeAndReturnKey(param);
person.setId(key.longValue());
System.out.println("Add: " + person);
return person;
}
}
Person.java
Eine Klasse, die einen Datensatz in der Datenbank darstellt.
package com.example;
public class Person {
private Long id; // AUTO_ID mit INCREMENT angeben
private String 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;
}
@Override
public String toString() {
return "Person(id=" + id + ", name=" + name + ")";
}
}
schema.sql
Eine Datei, die die SQL-Anweisungen beschreibt, die beim Start ausgeführt werden.
CREATE TABLE IF NOT EXISTS person (
id INTEGER NOT NULL AUTO_INCREMENT,
name VARCHAR(256) NOT NULL,
PRIMARY KEY (id)
);
data.sql
Eine Datei, die die SQL-Anweisungen beschreibt, die beim Start ausgeführt werden.
INSERT INTO person (name) VALUES('Alice');
Erstellen Sie mit dem Befehl mvn, um eine JAR-Datei zu generieren.
$ mvn package
Starten Sie Spring Boot mit dem Befehl java.
$ java -jar target/spring-jdbc-sample-0.0.1.jar
Sie können sehen, wie Daten zur Datenbank hinzugefügt werden.
$ curl http://localhost:8080/add/Bob
[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]
$ curl http://localhost:8080/add/Cindy
[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"},{"id":3,"name":"Cindy"}]
Recommended Posts