Introdução ao Maven, Spring, MySQL, Hibernate e a primeira aplicação CRUD (parte 3)

Boa tarde. Neste artigo gostaria de compartilhar meu primeiro encontro com coisas como Maven, Spring, Hibernate, MySQL e Tomcat no processo de criação de uma aplicação CRUD simples. Esta é a terceira parte de 4. O artigo é destinado principalmente àqueles que já completaram 30-40 níveis aqui, mas ainda não se aventuraram além do Java puro e estão apenas começando (ou prestes a começar) a entrar no mundo aberto com todas essas tecnologias, frameworks e outras palavras desconhecidas. Esta é a terceira parte do artigo “Introdução ao Maven, Spring, MySQL, Hibernate e a primeira aplicação CRUD”. As partes anteriores podem ser vistas seguindo os links:

• Introdução ao Maven, Spring, MySQL, Hibernate e a primeira aplicação CRUD (parte 1)
• Introdução ao Maven, Spring, MySQL, Hibernate e a primeira aplicação CRUD (parte 2)

Contente:

• Criando e conectando um banco de dados
• ORM e JPA
• Entidade
• Propriedades de hibernação
• Configuração de hibernação
• Camada de acesso a dados

Criando e conectando um banco de dados

Bem, é hora de começar a trabalhar no banco de dados. Antes de conectar o Hibernate e pensar em como tudo deveria funcionar lá, primeiro vamos dar uma olhada no banco de dados em si, ou seja, Vamos criar, conectar, fazer e preencher a placa. Usaremos o SGBD (Sistema de Gerenciamento de Banco de Dados) MySQL (claro, você deve primeiro baixar e instalar). SQL (Structured Query Language) é uma linguagem de programação declarativa usada para criar, modificar e manipular dados em um banco de dados relacional. Nesses bancos de dados, os dados são armazenados na forma de tabelas. Como a aplicação se comunica com o banco de dados (transmitindo consultas SQL ao banco de dados e retornando resultados). Para isso, Java possui algo como JDBC (Java DataBase Connectivity) , que, simplesmente, é um conjunto de interfaces e classes para trabalhar com bancos de dados. Para interagir com o banco de dados é necessário criar uma conexão, para isso o pacote java.sqlpossui uma classe Connection. Existem várias maneiras de estabelecer uma conexão, por exemplo você pode usar o método getConnectionde classe DriverManager. Porém, a interação com o banco de dados não é feita diretamente, pois existem muitos bancos de dados e são diferentes. Portanto, para cada um deles existe seu próprio driver JDBC. Através deste driver é estabelecida uma conexão com o banco de dados. Portanto, antes de mais nada, para não nos distrairmos com isso depois, vamos instalar o driver MySQL . Vamos adicionar a pom.xmlseguinte dependência:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

Agora vamos criar o banco de dados. Exibir -> Janelas de ferramentas -> Banco de dados - o painel do banco de dados será aberto. Novo (verde +) -> Fonte de dados -> MySQL - será aberta uma janela na qual você precisa especificar o nome de usuário e a senha, nós os configuramos ao instalar o MySQL (por exemplo, usei root e root). Porta (padrão para MySQL 3306), nome, etc. deixe como está. Você pode testar a conexão usando o botão " Testar conexão ". Clique em OK e agora estamos conectados ao servidor MySQL. A seguir, vamos criar um banco de dados. Para fazer isso, você pode escrever um script no console que é aberto:

CREATE DATABASE test

Clique em Executar e o banco de dados está pronto, agora você pode conectá-lo, para isso volte em Propriedades da fonte de dados e digite o nome do banco de dados (teste) no campo Banco de dados, em seguida digite novamente o nome de usuário e senha e clique em OK. Agora precisamos fazer uma mesa. Você pode usar ferramentas gráficas, mas pela primeira vez, provavelmente vale a pena escrever um script à mão para ver como fica:

USE test;

CREATE TABLE films
(
  id int(10) PRIMARY KEY AUTO_INCREMENT,
  title VARCHAR(100) NOT NULL,
  year int(4),
  genre VARCHAR(20),
  watched BIT DEFAULT false  NOT NULL
)
COLLATE='utf8_general_ci';
CREATE UNIQUE INDEX films_title_uindex ON films (title);

INSERT INTO `films` (`title`,`year`,`genre`, watched)
VALUES
  ("Inception", 2010, "sci-fi", 1),
  ("The Lord of the Rings: The Fellowship of the Ring", 2001, "fantasy", 1),
  ("Tag", 2018, "comedy", 0),
  ("Gunfight at the O.K. Corral", 1957, "western", 0),
  ("Die Hard", 1988, "action", 1);

Uma tabela é criada com o nome filmscom colunas id, titleetc. Para cada coluna, o tipo é indicado (tamanho máximo de saída entre parênteses).

• PRIMARY KEY- esta é a chave primária, usada para identificar exclusivamente um registro na tabela (o que implica exclusividade)
• AUTO_INCREMENT— o valor será gerado automaticamente (é claro que será diferente de zero, então você não precisa especificar isso)
• NOT NULL- aqui tudo também é óbvio, não pode ficar vazio
• DEFAULT- defina o valor padrão
• COLLATE- codificação
• CREATE UNIQUE INDEX- torne o campo único
• INSERT INTO- adicione um registro à tabela

O resultado é um sinal como este: Talvez valha a pena tentar conectar-se a ele, por enquanto, separadamente de nossa aplicação web. E se surgirem alguns problemas com isso, resolveremos isso imediatamente. Caso contrário, mais tarde vamos conectar o Hibernate , fazer alguma coisa, configurar, mexer, e se errarmos em algum lugar, pelo menos saberemos que o problema não está aqui. Bom, para verificar a conexão, vamos criar um método main, temporariamente. A princípio você pode colocá-lo em qualquer lugar, até na classe do controlador, até no modelo ou configuração, não importa, basta utilizá-lo para ter certeza de que está tudo bem com a conexão e você pode excluí-lo. Mas para ter mais cuidado, vamos criar uma classe separada para isso Main:

package testgroup.filmography;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "root";
        System.out.println("Connecting...");

        try (Connection connection = DriverManager.getConnection(url, username, password)) {
            System.out.println("Connection successful!");
        } catch (SQLException e) {
            System.out.println("Connection failed!");
            e.printStackTrace();
        }
    }
}

Tudo é simples aqui, definimos os parâmetros de conexão ao nosso banco de dados e tentamos criar uma conexão. Vamos lançar este maine dar uma olhada. Então, recebi uma exceção, alguns problemas de fuso horário e alguns outros avisos sobre SSL. Depois de navegar na Internet, você descobrirá que esse é um problema bastante comum e, ao usar versões diferentes do driver (mysql-connector-java), ele pode xingar de maneira diferente. Por exemplo, descobri experimentalmente que ao usar a versão 5.1.47 não há exceções devido ao fuso horário, a conexão é criada normalmente, mas o aviso SSL ainda aparece. Com algumas outras versões parecia haver uma exceção em relação ao SSL, e não apenas um aviso. Ok, esse não é o ponto. Você pode tentar lidar com esse problema separadamente, mas não entraremos nisso agora. A solução para tudo isso é bastante simples, você precisa especificar parâmetros adicionais na url , ou seja serverTimezone, se o problema for de fuso horário e useSSLse o problema for de SSL:

String url = "jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false";

Agora definimos o fuso horário e desabilitamos o SSL. Lançamos novamente maine pronto - Conexão bem-sucedida! Bem, ótimo, descobrimos como criar uma conexão. A classe Mainbasicamente completou sua tarefa, você pode excluí-la.

ORM e JPA

No bom sentido, para um melhor entendimento, é melhor começar a conhecer os bancos de dados em ordem, desde o início, sem hibernações e outras coisas. Portanto, seria uma boa ideia encontrar alguns guias e primeiro tentar trabalhar com classes JDBC, escrever consultas SQL manualmente e assim por diante. Bem, vamos passar imediatamente para o modelo ORM . O que isto significa? Claro, é novamente aconselhável ler sobre isso separadamente, mas tentarei descrevê-lo brevemente. ORM (Mapeamento Objeto-Relacional ou mapeamento objeto-relacional) é uma tecnologia para mapear objetos em estruturas de banco de dados relacionais, ou seja, para representar nosso objeto Java como uma linha da tabela. Graças ao ORM, você não precisa se preocupar em escrever scripts SQL e se concentrar em trabalhar com objetos. Como usá-lo. Java tem outra grande novidade, JPA (Java Persistence API), que implementa o conceito ORM. JPA é uma dessas especificações; descreve os requisitos para objetos, define várias interfaces e anotações para trabalhar com o banco de dados. JPA é essencialmente uma descrição, um padrão. Portanto, existem muitas implementações específicas, uma das quais (e uma das mais populares) é o Hibernate, que é a essência deste framework. Hibernate é uma implementação da especificação JPA projetada para resolver problemas de mapeamento objeto-relacional (ORM). Precisamos conectar tudo isso ao nosso projeto. Além disso, para que nosso Spring não fique à margem e também participe de toda essa movimentação com bancos de dados, precisamos conectar mais alguns módulos, pois tudo o que obtivemos da dependência spring-webmvc não é mais suficiente para isso. Também precisaremos do spring-jdbc para trabalhar com o banco de dados, do spring-tx para suportar transações e do spring-orm para trabalhar com o Hibernate. Vamos adicionar dependências a pom.xml:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.1.1.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.3.7.Final</version>
</dependency>

Essas duas dependências são suficientes. javax.persistence-apichegará junto com hibernate-core e spring-jdbc e spring-tx junto com spring-orm .

Entidade

Portanto, queremos que os objetos de classe Filmpossam ser armazenados no banco de dados. Para fazer isso, a classe deve satisfazer uma série de condições. No JPA existe uma Entidade para isso . Uma classe de entidade é uma classe POJO comum , com campos privados e getters e setters para eles. Deve ter um construtor não privado sem parâmetros (ou um construtor padrão) e deve ter uma chave primária, ou seja, algo que identificará exclusivamente cada registro desta classe no banco de dados. Você também pode ler sobre todos os requisitos para essa classe separadamente. Vamos transformar nossa classe Filmem uma entidade usando anotações JPA:

package testgroup.filmography.model;

import javax.persistence.*;

@Entity
@Table(name = "films")
public class Film {

    @Id
    @Column(name = "id")
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "title")
    private String title;

    @Column(name = "year")
    private int year;

    @Column(name = "genre")
    private String genre;

    @Column(name = "watched")
    private boolean watched;

    // + getters and setters
}

• @Entity- indica que esta classe é uma entidade.
• @Table- aponta para uma tabela específica para exibir esta entidade.
• @Id— indica que este campo é uma chave primária, ou seja, esta propriedade será usada para identificar cada entrada exclusiva.
• @Column— conecta um campo a uma coluna da tabela. Se os nomes dos campos e das colunas da tabela forem iguais, você poderá omiti-los.
• @GeneratedValue— a propriedade será gerada automaticamente; você pode especificar como entre parênteses. Não entenderemos agora como funcionam exatamente as diferentes estratégias. Basta saber que neste caso cada novo valor aumentará 1 em relação ao anterior.

Para cada propriedade, você também pode especificar muitas outras coisas, por exemplo, o que deve ser diferente de zero ou único, especificar o valor padrão, tamanho máximo, etc. Isto será útil se você precisar gerar uma tabela baseada nesta classe; o Hibernate tem esta opção. Mas nós mesmos já criamos a tabela e configuramos todas as propriedades, então podemos passar sem ela. Uma pequena nota.A documentação do Hibernate recomenda o uso de anotações não em campos, mas em getters. No entanto, a diferença entre estas abordagens é bastante subtil e na nossa aplicação simples isto não terá qualquer impacto. Além disso, a maioria das pessoas coloca anotações acima dos campos. Portanto, vamos deixar assim, fica mais arrumado.

Propriedades de hibernação

Bem, vamos começar a configurar nosso Hibernate. E antes de mais nada, vamos colocar algumas informações, como nome de usuário e senha, url e mais alguma coisa em um arquivo separado. Você pode, é claro, especificá-los como uma linha normal diretamente na classe, como fizemos quando verificamos a conexão ( String username = "root";e depois passamos para o método de criação da conexão). Mas é ainda mais correto armazenar esses dados estáticos em algum propertyarquivo. E se, por exemplo, você precisar alterar o banco de dados, não precisará percorrer todas as classes e procurar onde ele é usado; bastará alterar o valor neste arquivo uma vez. Vamos criar um arquivo db.properties no diretório de recursos :

jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?serverTimezone=Europe/Minsk&useSSL=false
jdbc.username=root
jdbc.password=root

hibernate.dialect=org.hibernate.dialect.MySQL8Dialect
hibernate.show_sql=true

Bem, tudo está claro acima, parâmetros para conexão ao banco de dados, ou seja, nome da classe do driver, URL, nome de usuário e senha. hibernate.dialect- esta propriedade é necessária para indicar ao Hibernate qual versão específica da linguagem SQL é usada. O fato é que em todo SGBD, para ampliar capacidades, adicionar alguma funcionalidade ou otimizar algo, costumam modernizar um pouco a linguagem. Como resultado, cada SGBD possui seu próprio dialeto SQL. É como acontece com o inglês, parece que o idioma é o mesmo, mas na Austrália, nos EUA ou na Grã-Bretanha será um pouco diferente e algumas palavras podem ter significados diferentes. E para evitar problemas de compreensão, você precisa informar diretamente ao Hibernate com o que exatamente ele deve lidar. hibernate.show_sql— graças a esta propriedade, as consultas ao banco de dados serão exibidas no console. Isso não é necessário, mas com isso você pode pelo menos ver o que está acontecendo, caso contrário pode parecer que o Hibernate está fazendo algum tipo de mágica. Bem, claro, não ficará totalmente claro para exibir; é melhor usar algum tipo de logger para isso, mas isso é algo para outro momento, por enquanto servirá.

Configuração de hibernação

Vamos prosseguir para definir a configuração. configVamos criar uma classe no pacote HibernateConfig:

package testgroup.filmography.config;

import org.springframework.beans.factory.annotation.Autowired;
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.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

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

@Configuration
@ComponentScan(basePackages = " testgroup.filmography")
@EnableTransactionManagement
@PropertySource(value = "classpath:db.properties")
public class HibernateConfig {
    private Environment environment;

    @Autowired
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }

    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", environment.getRequiredProperty("hibernate.dialect"));
        properties.put("hibernate.show_sql", environment.getRequiredProperty("hibernate.show_sql"));
        return properties;
    }

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(environment.getRequiredProperty("jdbc.driverClassName"));
        dataSource.setUrl(environment.getRequiredProperty("jdbc.url"));
        dataSource.setUsername(environment.getRequiredProperty("jdbc.username"));
        dataSource.setPassword(environment.getRequiredProperty("jdbc.password"));
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan("testgroup.filmography.model");
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager() {
        HibernateTransactionManager transactionManager = new HibernateTransactionManager();
        transactionManager.setSessionFactory(sessionFactory().getObject());
        return transactionManager;
    }
}

Há muitas coisas novas aqui, por isso é melhor procurar informações adicionais sobre cada item em fontes diferentes. Vamos repassar isso brevemente aqui.

• @ConfigurationJá descobrimos @ComponentScanquando fizemos a aula WebConfig.
• @EnableTransactionManagement— permite que você o use TransactionManagerpara gerenciar transações. O Hibernate trabalha com o banco de dados usando transações; elas são necessárias para que um determinado conjunto de operações seja executado como um todo, ou seja, se o método apresentar problemas com alguma operação, todas as outras não serão executadas, para que não aconteça como no exemplo clássico da transferência de dinheiro, quando foi concluída a operação de retirada de dinheiro de uma conta, mas o a operação de escrever para outro não funcionou e, como resultado, o dinheiro desapareceu.
• @PropertySource— conectando o arquivo de propriedades que criamos recentemente.
• Environment- para obter propriedades de propertyum arquivo.
• hibernateProperties- este método é necessário para representar as propriedades do Hibernate como um objeto Properties
• DataSource— usado para criar uma conexão com o banco de dados. Esta é uma alternativa ao DriverManager , que usamos anteriormente quando criamos o arquivo main. A documentação diz que DataSourceé preferível usar. É isso que faremos, claro, não esquecendo de ler na Internet quais são as diferenças e vantagens. Um benefício em particular é a capacidade de criar um Database Connection Pool (DBCP).
• sessionFactory— para criar sessões com a ajuda das quais são realizadas operações com objetos de entidade. Aqui definimos a fonte de dados, as propriedades do Hibernate e em qual pacote precisamos procurar pelas classes de entidade.
• transactionManager— para configurar o gerenciador de transações.

Uma pequena nota sobre DataSource. A documentação diz que o uso da implementação padrão, ou seja DriverManagerDataSource, , não é recomendado, porque é apenas um substituto para o pool de conexões normal e geralmente é adequado apenas para testes e similares. Para uma aplicação normal, é preferível usar algum tipo de biblioteca DBCP. Bem, para a nossa aplicação, claro, o que temos é suficiente, mas para completar o quadro, talvez ainda utilizemos outra implementação conforme recomendado. Vamos adicionar a pom.xmlseguinte dependência:

<dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-dbcp</artifactId>
            <version>9.0.10</version>
</dependency>

E no método dataSourcede classe HibernateConfignós o substituímos DriverManagerDataSourcepor BasicDataSourceum do pacote org.apache.tomcat.dbcp.dbcp2:

BasicDataSource dataSource = new BasicDataSource();

Bom, parece que tudo está pronto, a configuração está pronta, só falta adicioná-la ao nosso AppInitializer :

protected Class<?>[] getRootConfigClasses() {
        return new Class[]{HibernateConfig.class};
    }

Camada de acesso a dados

É hora de finalmente começar com nosso DAO. Vamos para a aula FilmDAOImple primeiro apagamos a lista de testes de lá, não precisamos mais dela. Vamos adicionar uma fábrica de sessões e trabalhar nela.

private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

Para começar, criaremos um método de exibição de uma página com uma lista de filmes, nela receberemos uma sessão e faremos uma solicitação ao banco de dados (retirando todos os registros e formando uma lista):

public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

Existem 2 pontos aqui. Primeiro, um aviso foi exibido. Isso se deve ao fato de que queremos receber um parametrizado List<Film>, mas o método retorna simplesmente Listporque em tempo de compilação não se sabe qual tipo a requisição irá retornar. Então a ideia nos avisa que estamos fazendo uma conversão insegura, que pode resultar em problemas. Existem várias maneiras mais corretas de fazer isso, para que tal dúvida não surja. Você pode pesquisar informações na Internet. Mas não vamos nos preocupar com isso agora. O fato é que sabemos exatamente que tipo será retornado, então não haverá problemas aqui, você pode simplesmente ignorar o aviso. Mas, para que seus olhos não sejam desagradáveis, você pode pendurar uma anotação acima do método @SupressWarning("unchecked"). Fazendo isso, meio que dizemos ao compilador, obrigado, amigo, pela sua preocupação, mas eu sei o que estou fazendo e tenho tudo sob controle, então você pode relaxar e não se preocupar com esse método. Em segundo lugar, a ideia está sublinhada em vermelho " from Film". É apenas uma consulta HQL (Hibernate Query Language) e a ideia não entende se está tudo correto ou se há algum erro. Você pode ir até as configurações da ideia e ajustar tudo manualmente (procure na Internet se estiver interessado). Ou você pode simplesmente adicionar suporte para o framework Hibernate, para fazer isso, clique com o botão direito no projeto, selecione Add Framework Support , marque a caixa Hibernate e clique em OK. Depois disso, muito provavelmente na classe de entidade ( Film) muitas coisas também estarão sublinhadas em vermelho, por exemplo, onde a anotação @Table(name = "films")emitirá o aviso Cannot resolve table 'films' . Novamente, não há nada de errado aqui, isso não é um erro de design, tudo irá compilar e funcionar. A ideia é enfatizada porque nada sabe sobre a nossa base. Para corrigir isso, vamos integrar a ideia ao banco de dados. View -> Tool Windows -> Persistense (uma aba será aberta) -> botão direito do mouse, selecione Assign Data Sources -> em Data Source, especifique a conexão com o banco de dados e clique em OK . Quando tudo isso foi consertado, ainda restava alguma coisa. Vamos para um nível superior, para o serviço. Na classe, FilmServiceImplmarcamos o allFilmsmétodo spring com uma anotação @Transactional, que indicará que o método deve ser executado em uma transação (sem isso, o Hibernate se recusará a funcionar):

@Transactional
public List<Film> allFilms() {
    return filmDAO.allFilms();
}

Então, está tudo pronto aqui, você não precisa mexer em nada no controle. Bem, parece que chegou a hora da verdade, clique em Executar e veja o que acontece. E aqui está, o nosso sinal, e desta vez não foi obtido de uma lista que nós mesmos fizemos na aula, mas de um banco de dados. Ótimo, tudo parece estar funcionando. Agora fazemos todas as outras operações CRUD da mesma maneira usando métodos de sessão. A classe resultante fica assim:

package testgroup.filmography.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import testgroup.filmography.model.Film;

import java.util.List;

@Repository
public class FilmDAOImpl implements FilmDAO {
    private SessionFactory sessionFactory;

    @Autowired
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    @SuppressWarnings("unchecked")
    public List<Film> allFilms() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Film").list();
    }

    @Override
    public void add(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.persist(film);
    }

    @Override
    public void delete(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.delete(film);
    }

    @Override
    public void edit(Film film) {
        Session session = sessionFactory.getCurrentSession();
        session.update(film);
    }

    @Override
    public Film getById(int id) {
        Session session = sessionFactory.getCurrentSession();
        return session.get(Film.class, id);
    }
}

Agora só falta lembrar de ir ao serviço e adicionar uma anotação aos métodos @Transactional. É isso, pronto. Agora você pode executar e verificar. Clique em links e botões, tente adicionar/excluir/editar entradas. Se tudo for feito corretamente, deverá funcionar. Agora, este é um aplicativo CRUD completo usando Hibernate, Spring, MySQL. Continua... Apresentando Maven, Spring, MySQL, Hibernate e o primeiro aplicativo CRUD (parte 1) Apresentando Maven, Spring, MySQL, Hibernate e o primeiro aplicativo CRUD (parte 2) Apresentando Maven, Spring, MySQL, Hibernate e o primeira aplicação CRUD (parte 3) Introdução ao Maven, Spring, MySQL, Hibernate e a primeira aplicação CRUD (parte 4)