[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 /)". tomcat4.jpg

Cliquez sur sqlSample-1.0-SNAPSHOT.

sqlSample1.jpg

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

Développement d'applications Web Spring5 MVC avec connexion Visual Studio Code SQL Server
Développement d'applications Web Spring Boot2 avec connexion Visual Studio Code SQL Server
Développement d'applications Web Spring 5 MVC avec Visual Studio Code Utilisation de Spring Security 1/3 [Préparation]
Développement d'applications Web Spring5 MVC avec création de modèles Visual Studio Code Maven
Développement d'applications Web Spring 5 MVC avec Visual Studio Code Utilisation de Spring Security 2/3 [Création de page 1/2]
Développement d'applications Web Spring 5 MVC avec Visual Studio Code Utilisation de Spring Security 3/3 [Création de page 2/2]
Développement d'applications Web Spring5 MVC avec Visual Studio Code Hello World Creation
Développement d'applications Web Spring Boot2 avec création de Visual Studio Code Hello World
Développement d'applications Web Spring5 MVC avec construction de l'environnement de code Visual Studio (installation de JDK11 / Maven / Tomcat / Visual Studio Code)
Créer un environnement de développement Web APP avec Java + Spring avec Visual Studio Code
Démarrez le développement d'applications Web avec Spring Boot
Créer un environnement de développement de programme Java avec Visual Studio Code
Construction d'environnement de développement d'applications Web Java avec VS Code (struts2)
Utiliser PlantUML avec Visual Studio Code
Exécutez l'application WEB avec Spring Boot + Thymeleaf
Un enregistrement de la configuration d'un environnement de développement Java avec Visual Studio Code
Découvrez .NET 5 avec Docker et Visual Studio Code
Créer un serveur API Web avec Spring Boot
Prise en main des programmes Java à l'aide de Visual Studio Code
Pourquoi pouvez-vous développer Java avec Visual Studio Code?
À peu près le flux de développement d'applications Web avec Rails.
Mémo de développement d'applications Web avec MVN, Tomcat, JSP / Servlet avec VScode
La première application WEB avec Spring Boot-Making a Pomodoro timer-
Pour recevoir une demande vide avec Spring Web MVC @RequestBody
Application Spring Boot qui spécifie les paramètres de connexion à la base de données avec des paramètres
Configuration Java avec Spring MVC
[Spring Boot] Création d'applications Web
Résumé de l'article sur le développement d'applications Web
Java avec Visual Studio Code
Application Web construite avec docker (1)
Serveur Web et serveur d'applications Rails
Comparaison du développement d'applications WEB avec Rails et Java Servlet + JSP
Comment utiliser PlantUML avec Visual Studio Code (créé le 30 octobre 2020)
Créons une application Web de gestion de livres avec Spring Boot part1
Créons une application Web de gestion de livres avec Spring Boot part3
Créons une application Web de gestion de livres avec Spring Boot part2
[Probablement le plus simple] Développement d'applications WEB avec Apache Tomcat + Java Servlet
Ce que j'ai appris en travaillant Java avec Visual Studio Code
Coexistence de Flyway dans la base de données embarquée (h2) de l'environnement de développement et la base de données des versions (SQL Server) avec Spring Boot
[Spring Boot] Précautions lors du développement d'une application Web avec Spring Boot et du placement d'une guerre sur un serveur Tomcat indépendant