Você está aqui: Java ::: Java Persistence Architecture API (JPA) - Arquitetura de Persistência Java ::: Entidades (Entity, Entities)

O que são entidades no JPA?

Quantidade de visualizações: 13315 vezes
Uma entidade em JPA é um objeto de domínio leve e de persistência. Por objeto de domínio entendemos os objetos de classes que pertencem ao domínio da aplicação (por exempo, as regras de negócios). Por leve entendemos que o custo de construir instâncias e manipular tais objetos é muito baixo, se comparado com algumas características de EJB e JEE. Finalmente entendemos que um objeto de persistência é um objeto que tem seus valores recuperados e/ou enviados (persistidos) a um banco de dados.

Geralmente uma entidade JPA representa uma tabela em um banco de dados relacional e cada instância desta entidade representa uma linha (registro ou tupla) na tabela. A base de uma entidade é a classe de entidade, embora entidades podem usar classes auxiliares (helper classes).

Uma classe de entidade JPA é tão simples quanto um POJO (Plain Old Java Objects). Isso quer dizer que qualquer classe Java pode ser uma entidade JPA. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import javax.persistence.*;

@Entity
@Table(name="usuarios")
public class Usuario{
  @Id
  @GeneratedValue(strategy=GenerationType.IDENTITY)
  private int id;
  private String nome;
  
  public Usuario(){}

  public Usuario(int id){ 
    this.id = id; 
  }

  public int getId(){ 
    return id; 
  }

  public void setId(int id){
    this.id = id;
  }

  public String getNome(){
    return nome; 
  }

  public void setNome(String nome){ 
    this.nome = nome; 
  }
}

Note que antes da definição do nome desta classe nós temos duas anotações (annotation): a primeira usa javax.persistence.Entity para informar que esta classe é uma entidade. A segunda usa javax.persistence.Table para informar o nome da tabela para a qual a entidade será mapeada. Se não usássemos esta última anotação, a entidade seria mapeada para uma tabela chamada USUARIO.

Note que esta classe possui duas variáveis persistentes: id e nome. Consequentemente a tabela no banco de dados terá duas colunas como estes mesmos nomes.

O restante da classe se parece com um JavaBean, com seus métodos get e set. Há ainda as anotações que definem a propriedade a ser usada como chave primária da entidade e como os valores de tal chave serão gerados. Nas dicas sobre JPA você obtém mais detalhes sobre isso.

Para que uma classe Java possa ser usada como uma entidade JPA, ela deve obedecer a algumas regras:

a) - A classe deve ser anotada com a anotação javax.persistence.Entity;

b) - A classe deve ter um construtor sem argumento public ou protected. Outros construtores podem ser adicionados, contanto que um sem argumento seja fornecido.

c) - A classe não deve ser declarada como final. Nenhum dos métodos ou variáveis (persistentes) de instâncias devem ser declarados como final.

d) - Se uma instância de uma entidade for passada por valor como um objeto isolado, por exemplo, através da interface remota de um bean de sessão, a classe deverá implementar a interface Serializable.

e) - Entidades podem extender classes entidades e não-entidades. E classes não-entidades podem extender classes entidades.

e) - Variáveis persistentes de instâncias devem ser declaradas private, protected ou de pacote e devem ser acessadas somente pelos métodos da classe de entidade. Clientes de uma classe entidade devem acessar seu estado somente por meio de métodos get e set.

Link para compartilhar na Internet ou com seus amigos:

Java ::: Dicas & Truques ::: Imagens e Processamento de Imagens

Manipulação de imagens em Java - Como carregar imagens JPG (JPEG), GIF ou PNG usando o método getImage() da classe Toolkit

Quantidade de visualizações: 23675 vezes
O método getImage() da classe Toolkit retorna um objeto da classe Image que obtém informações de imagem (pixels) a partir do caminho informado. Veja que este método não verifica se a imagem informada para o método existe ou se foi carregada com sucesso. Veja mais dicas nesta seção para aprender a realizar tais tarefas.

O código abaixo mostra como chamar o método getImage() para carregar uma imagem ao clicar em um botão:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package arquivodecodigos;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
public class Estudos extends JFrame{
  private Image imagem = null;  
 
  public Estudos() {
    super("Estudos Java");
     
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
     
    JButton btn = new JButton("Carregar Imagem");
    btn.addActionListener(
      new ActionListener(){
        @Override
        public void actionPerformed(ActionEvent e){
          // imagem a ser carregada
          String minhaImagem = "C:\\estudos_java\\lago.jpg";          
 
          // Obtém o Toolkit padrão
          Toolkit toolkit = 
            Toolkit.getDefaultToolkit();
          imagem = toolkit.getImage(minhaImagem);
 
          JOptionPane.showMessageDialog(null, 
            "A imagem  foi carregada. Agora é só manipulá-la.");
        }
      }
    );
 
    c.add(btn);
         
    setSize(400, 300);
    setVisible(true);
  }
   
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Ao executar este código nós teremos o seguinte resultado:

A imagem foi carregada. Agora é só manipulá-la.


Java ::: Classes e Componentes ::: JTable

Apostila Java Swing - Como alterar o valor de uma célula da JTable em tempo de execução

Quantidade de visualizações: 190 vezes
Em algumas situações nós precisamos alterar ou definir o valor de uma determinada célula de uma tabela JTable em tempo de execução, ou seja, enquanto o programa Java Swing estiver sendo executado.

Para isso nós podemos usar o método setValueAt() da classe JTable. Tudo que precisamos fazer é fornecer o novo valor para a célula, assim como os índice da linha e da coluna na qual ela está localizada.

Veja o código Java completo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
 
public class Estudos extends JFrame{
  public Estudos(){
    super("Exemplo de uma tabela simples");
         
    // colunas da tabela
    String[] colunas = {"Cidade", 
           "Estado", "Habitantes"};
         
    // conteúdo da tabela
         
    Object[][] conteudo = {
        {"Goiânia", "GO", "43.023.432"},
        {"São Paulo", "SP", "5.343.234"},
        {"Rio de Janeiro", "RJ", "6.434.212"},
        {"Jussara", "GO", "87.454"},
        {"Barra do Garças", "MT", "64.344"}
    };
         
    // constrói a tabela
    final JTable tabela = new JTable(conteudo, colunas);
    tabela.setPreferredScrollableViewportSize(new 
        Dimension(350, 50));
     
    Container c = getContentPane();
    c.setLayout(new FlowLayout());
         
    JButton btn = new JButton("Alterar valor 
            da 2ª célula - 1ª linha");
    btn.addActionListener(
      new ActionListener(){
        public void actionPerformed(ActionEvent e){
          tabela.setValueAt("Teste", 0, 1);
        }
      }
    );
         
    JScrollPane scrollPane = new JScrollPane(tabela);
        c.add(scrollPane);
    c.add(btn);
         
    setSize(400, 300);
    setVisible(true);
  }
     
  public static void main(String args[]){
    Estudos app = new Estudos();
    app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}



Java ::: Fundamentos da Linguagem ::: Tipos de Dados

Java para iniciantes - Como usar o tipo de dados boolean em seus códigos Java

Quantidade de visualizações: 22610 vezes
O tipo de dados boolean representa dois valores lógicos representados pelos literais true ou false. Valores boolean são produzidos pelos operadores relacionais (<, <=, > e >=), condicionais (&& e ||), lógicos (& e |) e de igualdade (== e !=) e são usados para gerenciar o fluxo de controle durante a execução do programa.

Veja um trecho de código exemplificando o uso deste tipo de dados:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

public class Estudos{
  public static void main(String args[]){
    boolean continuar = true;
    
    if(continuar == true){
      System.out.println("Podemos continuar.");
    }
    else{
      System.out.println("Vamos parar.");
    }    
    
    System.exit(0);
  }
}

Quando quisermos testar se o valor de uma variável ou constante do tipo boolean é true, podemos omitir o operador e o literal. Veja:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

if(continuar){
  System.out.println("Podemos continuar.");
}

O mesmo vale para a negação:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

if(!continuar){
  System.out.println("Podemos parar.");
}



Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 39 usuários muito felizes estudando em nosso site.