Les paramètres par défaut sont écrits dans application.properties comme suit.
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
Ce paramètre est appliqué automatiquement, il n'est donc pas nécessaire de le décrire dans application.properties. Si vous souhaitez utiliser une valeur autre que cette valeur de paramètre, vous devez la décrire dans application.properties.
Les informations de configuration par défaut sont décrites dans le code source Spring JDBC suivant.
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";
L'élément de réglage de application.properties est [Documentation de référence Spring Boot - Annexes - Annexe A: Propriétés d'application communes](https://docs.spring.io/spring-boot/docs/2.2.0.M5/reference/html/appendix .html # annexe).
schema.sql et data.sql sont des fichiers qui décrivent les instructions SQL exécutées au démarrage de Spring Boot.
Il est également possible de modifier l'instruction SQL exécutée en fonction du type de base de données, tel que schema-h2.sql et 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).
Il est également possible de modifier le fichier SQL à lire en le décrivant dans applicatin.properties.
applicatin.properties
spring.datasource.schema=classpath:foo-schema.sql
spring.datasource.data=classpath:bar-data.sql
--pom.xml: fichier de configuration de construction Maven --.java: fichier de code source Java -. sql: fichier qui décrit l'instruction SQL à exécuter au démarrage
├── pom.xml
└── src
└── main
├── java
│ └── com
│ └── example
│ ├── Person.java
│ ├── SampleController.java
│ └── SampleService.java
└── resources
├── data.sql
└── schema.sql
pom.xml
Fichier de configuration de construction Maven.
<?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>
<!--Utiliser Spring JDBC-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--Utiliser la base de données H2-->
<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
Une classe pour recevoir des requêtes HTTP.
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;
//Ajoute des données avec le nom spécifié
@RequestMapping("/add/{name}")
public List<Person> index(@ModelAttribute Person person) {
service.save(person);
return service.findAll();
}
}
SampleService.java
Une classe qui manipule la base de données à l'aide de la classe Spring JDBC JdbcTemplate.
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;
//Renvoie une liste de données
public List<Person> findAll() {
//Assemblez et exécutez SQL à exécuter
String query = "SELECT * from person";
List<Person> persons = jdbcTemplate.query(query, new BeanPropertyRowMapper<>(Person.class));
return persons;
}
//Ajouter des données
public Person save(Person person) {
//Assemblez le SQL pour exécuter
SqlParameterSource param = new BeanPropertySqlParameterSource(person);
SimpleJdbcInsert insert =
new SimpleJdbcInsert(jdbcTemplate)
.withTableName("person")
.usingGeneratedKeyColumns("id");
//Exécuter SQL et AUTO_Obtenez la valeur de INCREMENT
Number key = insert.executeAndReturnKey(param);
person.setId(key.longValue());
System.out.println("Add: " + person);
return person;
}
}
Person.java
Une classe qui représente un enregistrement dans la base de données.
package com.example;
public class Person {
private Long id; // AUTO_Donner une pièce d'identité avec INCREMENT
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
Un fichier qui décrit les instructions SQL exécutées au démarrage.
CREATE TABLE IF NOT EXISTS person (
id INTEGER NOT NULL AUTO_INCREMENT,
name VARCHAR(256) NOT NULL,
PRIMARY KEY (id)
);
data.sql
Un fichier qui décrit les instructions SQL exécutées au démarrage.
INSERT INTO person (name) VALUES('Alice');
Construisez avec la commande mvn pour générer un fichier JAR.
$ mvn package
Démarrez Spring Boot avec la commande java.
$ java -jar target/spring-jdbc-sample-0.0.1.jar
Vous pouvez voir comment les données sont ajoutées à la base de données.
$ 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