Configuration de Spring avec JPA et Microsoft SQL Server

La configuration de la base de données dans un environnement de développement Java peut être une tâche difficile, surtout lorsqu'il s'agit de choisir le bon pilote et de configurer correctement les dépendances. Ici, je vais partager comment configurer un environnement Spring MVC à l'aide de JPA et SQL Server.

Étape 1 : ajout de dépendances

La première étape consiste à ajouter les dépendances nécessaires à votre fichier pom.xml.

<dependencies>
    <!-- Dependência do MSSQL -->
    <dependency>
        <groupId>com.microsoft.sqlserver</groupId>
        <artifactId>mssql-jdbc</artifactId>
        <version>7.2.2.jre8</version>
    </dependency>

    <!-- Dependência do Spring Data JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- Dependência do Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

Étape 2 : configuration de JPA

Créons maintenant la classe de configuration JPA. J'utiliserai la nomenclature JPAConfiguration.java.

package br.com.meuprojeto.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Properties;

@Configuration
@EnableTransactionManagement
public class JPAConfiguration {

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource, Properties additionalProperties) {
        LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        factoryBean.setJpaVendorAdapter(vendorAdapter);
        factoryBean.setPackagesToScan("br.com.meuprojeto.loja.models");
        factoryBean.setDataSource(dataSource);
        factoryBean.setJpaProperties(additionalProperties);
        return factoryBean;
    }

    @Bean
    @Profile("dev")
    public Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.SQLServerDialect");
        properties.setProperty("hibernate.show_sql", "true");
        properties.setProperty("hibernate.hbm2ddl.auto", "create");
        properties.setProperty("javax.persistence.schema-generation.scripts.create-target", "db-schema.jpa.ddl");
        return properties;
    }

    @Bean
    @Profile("dev")
    public DriverManagerDataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setUsername("sa");
        dataSource.setPassword(""); // Adicione sua senha aqui
        dataSource.setUrl("jdbc:sqlserver://127.0.0.1;databaseName=MeuProjeto;");
        dataSource.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        return dataSource;
    }

    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

Points forts de la configuration

1. EntityManagerFactory Bean : configure EntityManagerFactory avec l'adaptateur Hibernate et définit le package où se trouvent les entités JPA.
2. Propriétés supplémentaires : paramètres spécifiques à Hibernate tels que le dialecte SQL, l'affichage SQL dans la console et la génération de schéma de base de données.
3. DataSource Bean : configure la connexion à la base de données, y compris l'URL, l'utilisateur, le mot de passe et le pilote.
4. TransactionManager Bean : gère les transactions JPA.

Considérations finales

Lors de la configuration de la base de données pour un environnement de développement, il est essentiel de s'assurer que les versions du pilote et de SQL Server sont compatibles. Dans l'exemple ci-dessus, la version 7.2.2.jre8 du pilote a été utilisée avec succès avec les dernières versions de SQL Server Developer et Express.

Cette configuration devrait fournir une base solide pour commencer à développer des applications Spring MVC avec JPA à l'aide de SQL Server. Expérimentez et adaptez-vous si nécessaire pour répondre à vos besoins spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!