Conectando ao banco de dados

3.1 Vinculando Hibernate e Bancos de Dados

Aprendemos como conectar o Hibernate ao nosso aplicativo usando Maven e como mapear tabelas para classes usando anotações. E agora surge a próxima pergunta - como lemos os objetos do banco de dados ou os salvamos lá?

Não tão rápido. Primeiro de tudo, você precisa lidar com mais três coisas:

• Configurando uma conexão de banco de dados
• Configurando o Hibernate
• Trabalhando com EntityManager

O Hibernate esconde completamente o trabalho com o banco de dados de sua aplicação, mas para evitar excessos, ele deve ser configurado corretamente. Você não pode pular esta etapa - caso contrário, como o Hibernate saberá em qual banco de dados salvar os objetos?

O Hibernate pode ser configurado e receber informações do banco de dados de três maneiras

• Usar arquivo de propriedades
• Usar o arquivo hibernate.cfg.xml
• Usar métodos de bean de configuração

E embora eu goste mais do último, você definitivamente encontrará todos os três, então analisaremos todos os três aqui.

3.2 Autorização no banco de dados

Vamos começar com as conexões de banco de dados mais importantes. Para fazer isso, você precisará fornecer dados para que o Hibernate possa fazer login no banco de dados desejado.

hibernate.dialect= org.hibernate.dialect.Oracle9Dialect
hibernate.connection.driver_class= oracle.jdbc.driver.OracleDriver
hibernate.connection.url= jdbc:oracle:thin:@localhost:1521:supershop
hibernate.connection.username=root
hibernate.connection.password=secret
hibernate.show_sql=true
hibernate.hbm2ddl=update

As mesmas configurações podem ser definidas na forma de um arquivo xml:

<hibernate-configuration>
	<session-factory>

    	<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
    	<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
    	<property name="connection.url">jdbc:oracle:thin:@localhost:1521:supershop</property>
    	<property name="connection.username">root</property>
    	<property name="connection.password">secret</property>
    	<property name="hibernate.show_sql ">true</property>
    	<property name="hbm2ddl.auto">update</property>

	</session-factory>
</hibernate-configuration>

Em ambos os exemplos, vemos as mesmas configurações com os mesmos valores. Só que o primeiro exemplo os representa como um arquivo de propriedades e o segundo como um arquivo xml .

Essas configurações são divididas em três grupos:

1. Especifique o tipo de DBMS
• Especifique o dialeto (tipo DBMS), por exemplo, Oracle 9.0
• Especifique o nome do driver JDBC para trabalhar com este DBMS
2. Especificar dados para autorização no banco de dados
• URL do banco de dados
• nome de usuário
• senha
3. Configurando o Hibernate Engine
• hibernate.show_sql- O Hibernate irá duplicar no console todas as requisições que ele executar
• hbm2ddl.auto- O Hibernate mudará a estrutura do banco de dados, se necessário

Existe uma terceira maneira de definir a configuração - por meio de caixas. Geralmente é usado em conjunto com o Spring, portanto, veremos isso quando aprendermos o SpringFramework.

3.3 Obtenha a SessionFactory

A próxima etapa é obter o objeto SessionFactory. Existem várias maneiras de fazer isso:

A primeira maneira é usar o arquivo hibernate.properties .

Para fazer isso, você só precisa escrever o seguinte código:

SessionFactory sessionFactory = new Configuration().buildSessionFactory();

Se o arquivo hibernate.properties não for encontrado no diretório do projeto atual, uma exceção será lançada.

A segunda maneira é a configuração usando hibernate.cfg.xml .

SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();

Se você escrever esse código, o arquivo hibernate.cfg.xml. Se nenhum arquivo for encontrado, o método buildSessionFactory()lançará uma exceção.

A terceira maneira é definir o arquivo de configuração manualmente .

As vezes durante o processo de desenvolvimento torna-se necessário mudar para uma base de teste ou alterar algumas outras configurações para trabalhar com a base, para isso você pode definir o arquivo de configuração manualmente:

SessionFactory sessionFactory = new Configuration().configure("hibernate-dev.cfg.xml").buildSessionFactory();

Método quatro - usamos um arquivo hibernate.properties personalizado:

ClassLoader classLoader = Thread.currentThread().getClassLoader();

Properties properties = new Properties();
properties.load(classLoader.getResourceAsStream("hibernate-dev.properties"));

SessionFactory sessionFactory = new Configuration()
            .addProperties(properties)
            .buildSessionFactory();

E, finalmente, você pode simplesmente costurar todos os parâmetros necessários diretamente no código:

Properties properties = new Properties();
properties.put(Environment.DRIVER, "com.mysql.jdbc.Driver");
properties.put(Environment.URL, "jdbc:mysql://localhost:3306/supershop");
properties.put(Environment.USER, "root");
properties.put(Environment.PASS, "password");

SessionFactory sessionFactory = new Configuration()
            .setProperties(properties)
            .buildSessionFactory();

3.4 Especifique onde procurar classes de Entidade

Mas isso não é tudo. Quando configuramos um objeto SessionFactory no Hibernate, este SessionFactory verifica se todas as tabelas necessárias com os tipos de coluna necessários existem no banco de dados.

E para que a SessionFactory seja capaz de fazer isso, ela precisa receber uma lista de classes de entidade que ela precisa mapear para o banco de dados.

Existem três maneiras de passar uma lista de classes de entidade:

Método um. Em hibernate.cfg.xmladicione uma linha como:

<mapping class="class-qualified-name" />

Exemplo:

<mapping class="com.codegym.data.User" />
<mapping class="com.codegym.data.Employee" />
<mapping class="com.codegym.data.Task" />

Método dois. Chame o método no objeto ConfigurationaddAnnotatedClass() . Exemplo:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addAnnotatedClass(com.codegym.data.User.class)
   	.buildSessionFactory();

Se houver muitas classes, você poderá adicioná-las em pacotes inteiros:

SessionFactory sessionFactory = new Configuration()
   	.configure()
   	.addPackage("com.codegym.data")
   	.buildSessionFactory();

3.5 Exemplo final

Agora que aprendemos como configurar o objeto SessionFactory, vamos escrever o código que irá utilizá-lo.

Será composto por três métodos:

1. Configurando o Hibernate
2. Método que obtém todos os funcionários do banco de dados
3. Método que salva um novo funcionário no banco de dados

Este modelo de código seria mais ou menos assim:

class EmployeeManager {
    private SessionFactory sessionFactory;

    public void class init() {
    	this.sessionFactory = new Configuration()
        	.configure()
        	.buildSessionFactory();
   }

   public List<Employee> getAllEmployes() {
         try (Session session = sessionFactory.openSession()) {
  	          Query<Employee> query = session.createQuery("from Employee", Employee.class);
    	        return query.list();
         }
   }

   public void addEmployee(Employee employee ) {
     	try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
       	    session.save(employee);
            transaction.commit();
     	}
   }
}

Antes de executar uma consulta ao banco de dados, você precisa criar uma sessão separada. Se as solicitações estiverem relacionadas, elas poderão ser executadas na mesma sessão. Se as solicitações não estiverem relacionadas (e vários minutos podem se passar entre elas), elas precisam fazer suas próprias sessões.

Se você deseja ler dados do banco de dados ou executar uma consulta complexa, deve primeiro criar um objeto Query e usá-lo para executar sua consulta.

Além disso, cada consulta ao banco de dados é executada em sua própria transação. Você precisa abri-lo, realizar as operações necessárias e, em seguida, fechar (confirmar).

Nas próximas palestras, analisaremos com mais detalhes como tudo isso funciona.