[JAVA] Développement d'applications Web Spring5 MVC avec connexion Visual Studio Code SQL Server
introduction
Nous étendrons le projet créé dans Hello World Creation. SQLServer utilise la base de données et la table créées dans ici.
environnement
OS:Windows 10 Pro 64bit DB:SQL Server 2019(Cent OS 8 on Hyper-V) Editor:Visual Studio Code 1.42.1 JDK:AdoptOpenJDK 11.0.6+10 x64 Apache Maven:v3.6.3 Apache Tomcat:v9.0.31
Création de projet
J'ai copié le projet créé dans Hello World dans "D: \ JAVA \ Project \ sqlSample" et je l'ai créé.
pom.xml Ajoutez le référentiel requis pour accéder à SQL Server.
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>8.2.1.jre11</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>3.4.2</version>
<scope>compile</scope>
</dependency>
L'ensemble du fichier pom.xml.
pom.xml
<?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>
<groupId>com.example</groupId>
<artifactId>sqlSample1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>11</java.version>
<spring.version>5.2.4.RELEASE</spring.version>
<!-- web.Exécutez la compilation même sans xml-->
<failOnMissingWebXml>false</failOnMissingWebXml>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.microsoft.sqlserver</groupId>
<artifactId>mssql-jdbc</artifactId>
<version>8.2.1.jre11</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>3.4.2</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.thymeleaf</groupId>
<artifactId>thymeleaf-spring5</artifactId>
<version>3.0.11.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.thymeleaf.extras</groupId>
<artifactId>thymeleaf-extras-java8time</artifactId>
<version>3.0.4.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>
Création de modèle
Créez la partie service qui décrit la logique métier, la partie persistence qui se connecte à la base de données (émet une instruction SQL) et le fichier de configuration.
création de service après-vente
Créez un dossier "service" dans "D: \ JAVA \ Project \ sqlSample \ src \ main \ java \ com \ example". Créez un dossier de configuration directement en dessous. Créez ServiceConfig.java dans le dossier config.
D:\JAVA\Project\sqlSample\src\main\java\com\example
└─service
└─config
└ServiceConfig.java
ServiceConfig.java
package com.example.service.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@ComponentScan(basePackages = "com.example.service")
@EnableTransactionManagement
public class ServiceConfig {
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager transactionManager =
new DataSourceTransactionManager(dataSource);
return transactionManager;
}
}
Création d'un service de persistance
Créez un dossier "persistence" dans "D: \ JAVA \ Project \ sqlSample \ src \ main \ java \ com \ example". Créez un dossier de configuration, un dossier d'entité et un dossier de référentiel directement en dessous. Créez PersistenceConfig.java dans le dossier config.
D:\JAVA\Project\sqlSample\src\main\java\com\example
└─persistence
├─config
│ └─PersistenceConfig.java
├─entity
└─repository
PersistenceConfig.java décrit les paramètres de connexion à SQL Server.
PersistenceConfig.java
package com.example.persistence.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import com.zaxxer.hikari.HikariDataSource;
@Configuration
@ComponentScan(basePackages = "com.example.persistence.repository")
@PropertySource("classpath:jdbc.properties")
public class PersistenceConfig {
@Bean
public DataSource dataSource(@Value("${jdbc.driverClassName}") String driverClassName,
@Value("${jdbc.url}") String url,
@Value("${jdbc.username}") String username,
@Value("${jdbc.password}") String password) {
HikariDataSource dataSource = new HikariDataSource();
dataSource.setDriverClassName(driverClassName);
dataSource.setJdbcUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
dataSource.setMinimumIdle(10);
dataSource.setMaximumPoolSize(300);
dataSource.setConnectionInitSql("SELECT 0");
return dataSource;
}
@Bean
public NamedParameterJdbcTemplate jdbcTemplate(DataSource dataSource) {
NamedParameterJdbcTemplate jdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
return jdbcTemplate;
}
}
Création du service des ressources
Créez un dossier "resources" dans "D: \ JAVA \ Project \ sqlSample \ src \ main". Créez jdbc.properties dans le dossier des ressources.
D:\JAVA\Project\sqlSample\src\main
└─resources
└─jdbc.properties
Décrit les informations de connexion pour se connecter à SQL Server.
jdbc.properties
jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.url=jdbc:sqlserver://xxx:1433;databaseName=Training01;QuotedID=NO //Spécifiez le nom d'hôte ou l'adresse IP de SQL Server.
jdbc.username=xxx //Spécifiez le nom d'utilisateur de la connexion.
jdbc.password=xxx //Spécifiez le mot de passe de l'utilisateur qui se connecte.
WebAppInitializer.java modifié
Ajoutez PersistenceConfig.class et ServiceConfig.class à getRootConfigClasses afin que les modèles pour la connexion DB et la logique métier puissent être utilisés.
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class<?>[] {PersistenceConfig.class, ServiceConfig.class};
}
L'ensemble de WebAppInitializer.java.
WebAppInitializer.java
package com.example.web.config;
import java.nio.charset.StandardCharsets;
import javax.servlet.Filter;
import com.example.persistence.config.PersistenceConfig;
import com.example.service.config.ServiceConfig;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
/**
*Spécifie les classes Java Config pour MVC non Spring, telles que la logique métier.
*/
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class<?>[] {PersistenceConfig.class, ServiceConfig.class};
}
/**
*Spécifie la classe Java Config pour Spring MVC.
*/
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class<?>[] {MvcConfig.class};
}
/**
*Spécifiez le modèle d'URL pour DispatcherServlet.
* "/"En spécifiant, DispatcherServlet reçoit toutes les demandes.
*/
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
/**
*Spécifiez le filtre de servlet.
*S'il y a plusieurs filtres, ils seront exécutés dans l'ordre spécifié dans le tableau.
*/
@Override
protected Filter[] getServletFilters() {
return new Filter[]{
new CharacterEncodingFilter(StandardCharsets.UTF_8.name(), true)};
}
}
C'est la préparation.
Création d'entité
Créez une entité qui reçoit des données de la base de données.
D:\JAVA\Project\sqlSample\src\main\java\com\example\persistence
└─entity
└─ProductsMaster.java
ProductsMaster.java
package com.example.persistence.entity;
import lombok.Data;
@Data
public class ProductsMaster {
private String ProductsCode;
private String ProductsName;
private Integer UnitPrice;
public ProductsMaster() {}
public ProductsMaster(
String ProductsCode,
String ProductsName,
Integer UnitPrice
) {
this.ProductsCode = ProductsCode;
this.ProductsName = ProductsName;
this.UnitPrice = UnitPrice;
}
}
créer un référentiel
Créez un référentiel qui se connecte à la base de données et émet des instructions SQL.
D:\JAVA\Project\sqlSample\src\main\java\com\example\persistence
└─repository
├─ProductsMasterRepository.java
└─ProductsMasterRepositoryImpl.java
ProductsMasterRepository.java
package com.example.persistence.repository;
import java.util.List;
import com.example.persistence.entity.ProductsMaster;
public interface ProductsMasterRepository {
List<ProductsMaster> productsMasterList();
}
ProductsMasterRepositoryImpl.java
package com.example.persistence.repository;
import java.util.List;
import com.example.persistence.entity.ProductsMaster;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class ProductsMasterRepositoryImpl implements ProductsMasterRepository {
@Autowired
NamedParameterJdbcTemplate jdbcTemplate;
@Override
public List<ProductsMaster> productsMasterList() {
String strSQL = "SELECT * FROM TB_TestTable ORDER BY ID";
List<ProductsMaster> pMList = jdbcTemplate.query(strSQL,
(rs, rowNum) -> new ProductsMaster(
rs.getString("ProductsName"),
rs.getString("ProductsCode"),
rs.getInt("UnitPrice")
)
);
return pMList;
}
}
création de service
Créez un service qui sera la logique métier. Il n'est pas nécessaire de le créer dans ce contenu, mais je le créerai à titre d'exemple.
D:\JAVA\Project\sqlSample\src\main\java\com\example
└─service
├─ProductsMasterService.java
└─ProductsMasterServiceImpl.java
ProductsMasterService.java
package com.example.service;
import java.util.List;
import com.example.persistence.entity.ProductsMaster;
public interface ProductsMasterService {
List<ProductsMaster> productsMasterList();
}
ProductsMasterServiceImpl.java
package com.example.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.persistence.entity.ProductsMaster;
import com.example.persistence.repository.ProductsMasterRepository;
@Service
public class ProductsMasterServiceImpl implements ProductsMasterService {
@Autowired
ProductsMasterRepository productsMasterRepository;
@Override
public List<ProductsMaster> productsMasterList() {
List<ProductsMaster> pMList = productsMasterRepository.productsMasterList();
return pMList;
}
}
création de formulaire
Créez un dossier "form" dans "D: \ JAVA \ Project \ sqlSample \ src \ main \ java \ com \ example \ web". Créez ProductsMasterForm.jave dans le dossier du formulaire.
D:\JAVA\Project\sqlSample\src\main\java\com\example\web
└─form
└─ProductsMasterForm.java
ProductsMasterForm.java
package com.example.web.form;
import java.util.List;
import com.example.persistence.entity.ProductsMaster;
import lombok.Data;
@Data
public class ProductsMasterForm {
private List<ProductsMaster> helloList;
}
Créer un contrôleur
Créez ProductsMasterController.java dans "D: \ JAVA \ Project \ sqlSample \ src \ main \ java \ com \ example \ web \ controller".
D:\JAVA\Project\sqlSample\src\main\java\com\example\web
└─controller
└─ProductsMasterController.java
ProductsMasterController.java
package com.example.web.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.example.service.ProductsMasterService;
import com.example.web.form.ProductsMasterForm;
@Controller
@RequestMapping("/hello")
public class ProductsMasterController {
@Autowired
ProductsMasterService productsMasterService;
@GetMapping("/index")
public String indexGet(Model model) {
ProductsMasterForm productsMasterForm = new ProductsMasterForm();
productsMasterForm.setHelloList(productsMasterService.productsMasterList());
model.addAttribute("productsMasterForm", productsMasterForm);
return "productsMasterForm/index";
}
}
création de vue
Créez un dossier "productsMaster" dans "D: \ JAVA \ Project \ sqlSample \ src \ main \ webapp \ WEB-INF \ templates". Créez index.html dans le dossier productsMaster.
D:\JAVA\Project\sqlSample\src\main\webapp\WEB-INF\templates
└─productsMaster
└─index.html
index.html
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Spring5 MVC sqlSample01</title>
</head>
<body>
<h1>Hello Spring Products List</h1>
<table border="1">
<thead>
<tr>
<th>Code produit</th>
<th>nom du produit</th>
<th>Prix unitaire</th>
</tr>
</thead>
<tbody>
<tr th:each="pm : ${productsMasterForm.pmList}" th:object="${pm}">
<td th:text="*{ProductsCode}"></td>
<td th:text="*{ProductsName}"></td>
<td th:text="*{UnitPrice}"></td>
</tr>
</tbody>
</table>
</body>
</html>
Compiler / Package
Vous pouvez compiler et créer un fichier war avec la commande suivante.
mvn package
Contrôle de fonctionnement
Palette de commandes
Tomcat: Add Tomcat Server
La boîte de dialogue de sélection du dossier Tomcat s'affiche. Sélectionnez le dossier Tomcat (D: \ JAVA \ Tomcat \ apache-tomcat-9.0.31).
Palette de commandes
Tomcat: Run on Tomcat Server
La boîte de dialogue de sélection de fichier war s'affiche. Sélectionnez le fichier war (D: \ JAVA \ Project \ SpringSample01 \ target \ sqlSample1-1.0-SNAPSHOT.war) créé par "mvn package".
Veuillez accéder à "[http: // localhost: 8080 /](http: // localhost: 8080 /)".
Cliquez sur sqlSample-1.0-SNAPSHOT.
Lors de la modification du code → vérification de l'opération, le fichier war placé dans Tomact n'était pas correctement reflété sauf s'il était supprimé à chaque fois. J'aimerais pouvoir faire un déploiement à chaud, je ne l'ai pas trouvé.
Cette source d'échantillon
Téléchargé sur GitHub. https://github.com/t-skri1/SpringSample02
Résumé
C'est simple, mais c'est maintenant une application Web. La prochaine fois, nous intégrerons Spring Security.
Recommended Posts