Configurando o Spring com JPA e Microsoft SQL Server
Tags: sqlserver, java, jpa, sql
Published: 2024-07-02 02:46:24

---
title: Configurando o Spring com JPA e Microsoft SQL Server
published: true
description: 
tags: sqlserver, java, jpa, sql
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nxkdd0e1lo4oeizo1rzd.png


# Use a ratio of 100:42 for best results.
# published_at: 2024-06-23 14:11 +0000
---

Configurar o banco de dados em um ambiente de desenvolvimento Java pode ser uma tarefa desafiadora, especialmente quando se trata de escolher o driver correto e configurar adequadamente as dependências. Aqui, vou compartilhar como configurar um ambiente Spring MVC utilizando JPA e o SQL Server.

## Passo 1: Adicionando Dependências

O primeiro passo é adicionar as dependências necessárias ao seu arquivo `pom.xml`.

```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>
```

## Passo 2: Configurando o JPA

Agora vamos criar a classe de configuração do JPA. Vou usar a nomenclatura `JPAConfiguration.java`.

```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);
    }
}
```

### Destaques da Configuração

1. **EntityManagerFactory Bean**: Configura o `EntityManagerFactory` com o adaptador do Hibernate e define o pacote onde as entidades JPA estão localizadas.
2. **Propriedades Adicionais**: Configurações específicas do Hibernate, como o dialeto SQL, exibição de SQL no console e geração de esquema de banco de dados.
3. **DataSource Bean**: Configura a conexão com o banco de dados, incluindo URL, usuário, senha e driver.
4. **TransactionManager Bean**: Gerencia as transações JPA.

## Considerações Finais

Ao configurar o banco de dados para um ambiente de desenvolvimento, é essencial garantir que as versões do driver e do SQL Server sejam compatíveis. No exemplo acima, a versão do driver `7.2.2.jre8` foi utilizada com sucesso com as versões mais recentes do SQL Server Developer e Express.

Essa configuração deve proporcionar uma base sólida para iniciar o desenvolvimento de aplicações Spring MVC com JPA utilizando o SQL Server. Experimente e adapte conforme necessário para atender às suas necessidades específicas.