Você é gay, programadora de java e acha super chata a maneira como heterossexuais espertalhões dão voltas e mais voltas para ensinar persistencia em JPA com Hibernate? Sem falar dos exemplos complexos com códigos complicados , só para você dizer:
–Nossa, como esse cara é foda!
Chega! Agora você vai aprender!

Vou supor aqui que você saiba mexer no netbeans e no Mysql ou MariaDB, ok? Crie um database dentro dele chamado gays, dentro dele iremos criar a tabela Machos.

Lembre-se Hibernate é uma forma mapear classes para banco de dados e vice versa, o povo do java ama transformar tudo em classe. Pense nas classes como structs do C para abrir soquete, é tipo isso.
A classe irá virar uma tabela no MySQL com nome em maiúsculo por padrão.

No Netbeans o seu projeto se chamará HibernanteLuz (aquele que hiberna na luz) e ficará num pacote chamado com.javanunes.hibernanteluz , depois você muda do seu jeito. No seu banco de dados MySQL ou MariaDB o usuário será o root e a senha dele será BUCETILDES.

Entre no seu mysql e crie esse tabela abaixo, se não quiser criar, dane-se! O hibernate criará mesmo assim!

create table MACHOS (
  id bigint not null auto_increment,
  nome varchar(60) not null,
  conjuge varchar(60),
  endereco varchar(100),
  whatsapp varchar(18),
  redesocial varchar(160),
  idade int (3),
  primary key (id)
);

No seu Netbeans (mil vezes melhor que o Eclipse) você escolherá menu file>New project>Java with Maven (…Eu disse Marven… kkkk!) > Java Application e dê o nome, no meu caso eu dei HibernanteLuz

Você colocará no arquivo pom.xml do Maven as instruções para o seu projeto baixar todas dependências na hora de compilar, tipo um apt-get do Ubuntu ou um ports do BSD. Você deverá colocar o código ensinado aqui dentro das tags <dependencies> </dependencies> , não tem problema se já existirem outros, você irá acrescentar mais esses aqui abaixo:

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

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
</dependency>

Depois, clique com o botão direito na árvore do projeto e escolha New> Entity Class (será a sua tabela), dê todas informações possíveis que ele pedir, o Netbeans pode pedir para você usar o plugin de conectividade para se conectar ao mysql, o meu o maven já havia baixado em /home/javanunes/.m2/mysql-connector-java/8.0.16/mysql-connector-java-8.0.16.jar , o seu você que procure ou baixe do site deles! Usar esse conector fará o netbeans sugar toda a tabela e criar uma classe entidade prontinha para você, melhor do que fazer na unha!

Ele irá criar uma classe com várias anotações como @Id , @Table , @Entity , @Column , elas servem para o JPA sinalizar ao Hibernate o que será tabela, campo e chave primária. Crie ou exporte do banco uma classe com nome de Machos, os atributos delas serão privados e serão os campos da tabela do banco de dados, os gets e sets serão os métodos para guardar e pegar dados nela. A sua classe Machos ficará assim:

/*
 package com.javanunes.hibernanteluz;

import java.io.Serializable;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 *
 * @author javanunes
 */

@Table(name = "MACHOS")
@Entity
public class Machos implements Serializable {

    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "id")
    private Long id;
    @Basic(optional = false)
    @Column(name = "nome")
    private String nome;
    @Column(name = "conjuge")
    private String conjuge;
    @Column(name = "endereco")
    private String endereco;
    @Column(name = "whatsapp")
    private String whatsapp;
    @Column(name = "redesocial")
    private String redesocial;
    @Column(name = "idade")
    private Integer idade;

    public Machos() {
    }

    public Machos(Long id) {
        this.id = id;
    }

    public Machos(Long id, String nome) {
        this.id = id;
        this.nome = nome;
    }

    public Long getId() {
        return id;
    }

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

    public String getNome() {
        return nome;
    }

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

    public String getConjuge() {
        return conjuge;
    }

    public void setConjuge(String conjuge) {
        this.conjuge = conjuge;
    }

    public String getEndereco() {
        return endereco;
    }

    public void setEndereco(String endereco) {
        this.endereco = endereco;
    }

    public String getWhatsapp() {
        return whatsapp;
    }

    public void setWhatsapp(String whatsapp) {
        this.whatsapp = whatsapp;
    }

    public String getRedesocial() {
        return redesocial;
    }

    public void setRedesocial(String redesocial) {
        this.redesocial = redesocial;
    }

    public Integer getIdade() {
        return idade;
    }

    public void setIdade(Integer idade) {
        this.idade = idade;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Machos)) {
            return false;
        }
        Machos other = (Machos) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "com.javanunes.hibernanteluz.Machos[ id=" + id + " ]";
    }
    
}

Agora você deverá criar em HibernanteLuz/src/main/resources/ o famigerado arquivo hibernate.cfg.xml
Ele será lido pelo Hibernate para saber qual senha o sue banco usa, qual usuário ele irá usar, caminho do banco e outros parâmetros complexos, geralmente as pessoas têm muitos problemas com esse arquivo por ele estar em lugar errado e preenchido com coisas usadas antigamente, o seu ficará assim:

<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost/gays</property>
<property name="dialect">org.hibernate.dialect.MySQL8Dialect</property>
<property name="connection.username">root</property>
<property name="connection.password">BUCETILDES</property>
<property name="connection.pool_size">3</property>
<property name="current_session_context_class">thread</property>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping class="com.javanunes.hibernanteluz.Machos" />
<mapping resource="Machos.hbm.xml"/>
</session-factory>
</hibernate-configuration>
   

Dentro dele teremos referencia a um arquivo muito importante chamado do tipo HBM.XML, a maioria das pessoas não criam esse arquivo e acabam tendo problemas com a entidade, pois bem, esse arquivo se chamará Machos.hbm.xml e deverá ficar também dentro de HibernanteLuz/src/main/resources/
o conteúdo dele, baseado em nossa tabela, deverá ser exatamente assim:

<hibernate-mapping package="com.ajavanunes.hibernanteluz">
   <class name = "com.javanunes.hibernanteluz.Machos" table = "MACHOS">
      <meta attribute = "class-description">
          Esse arquivo é citado pelo src/main/resources/hibernate.cfg.xml e reflete os campos que a entidade/class/tabela tem
      </meta>
      <id name = "id" type = "long" column = "id">
         <generator class="native"/>
      </id>
      <property name = "nome" column = "nome" type = "string"/>
      <property name = "conjuge" column = "conjuge" type = "string"/>
      <property name = "redesocial" column = "redesocial" type = "string"/>
      <property name = "whatsapp" column = "whatsapp" type = "string"/>
      <property name = "endereco" column = "endereco" type = "string"/>
      <property name = "idade" column = "idade" type = "int"/>
   </class>
</hibernate-mapping>

Você agora deverá criar uma classe para deixar o nosso projeto mais organizadinho , ela irá chamar Banco, mas é claro, se você quiser misturar tudo numa classe só, pode fazer, mas ficará feio, a classe Banco será usada em nossa classe principal que criarei daqui a pouco, Banco será assim:

package com.javanunes.hibernanteluz;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

public class Banco {
    
     public static Session hibernate() { 
        try {
            // Cria uma sessão espírita com as informaçoes de hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory().getCurrentSession();
        }
        catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Erro ao processar SQL pois teve falha num arquivo *.hbm.xml da entidade ou coisa pior --------->" + ex);
            throw new ExceptionInInitializerError(ex);
        }
     }
    
}

Agora iremos criar a classe principal, onde o nosso entry point ficará e onde as coisas realmente acontecerão para o usuário ver, ouvir e cheirar… A classe principal eu irei chamar de Main e deverá conter esse código onde eu já implemento o método insert para você usá-lo e também para lembrar um pouco SQL, mas esse método poderia ter qualquer nome, até mesmo bozo se quisesse:

package com.javanunes.hibernanteluz;
import org.hibernate.Session;


public class Main {

    public static void main(String... args){
         System.out.println("BANCO DE DADOS DAS TRAVESTI");
         try{
            insert("André Schurrle","Anna Sharipova","https://twitter.com/Andre_Schuerrle");
         }
         catch(Exception ex){
            System.err.println("Erro no cadastro:"+ex);
         }
    }
    
    // Metodo bobinho insert para você inserir dados lá no main, fazendo uma alusao ao SQL 
    private static void insert(String nome, String conjuge, String redesocial) {
        Session session = Banco.hibernate();
        session.beginTransaction();
        
        Machos macho = new Machos();
        macho.setNome(nome);
        macho.setConjuge(conjuge);
        macho.setRedesocial(redesocial);
        
        session.save(macho);
        session.getTransaction().commit();
        System.out.println("Bicha! Salvo no banco o "+macho.getNome());
    }
    
}

No main eu já usei o método insert para inserir um macho chamado André com uma esposa, amante ou concubina chamada Anna, você poderia se quisesse nem usar método nenhum e deixar todo o código do método jogado dentro do main, mas ficaria feio.

Depois de rodar isso, é bem provável que você tenha algum erro, afinal, Java com xml, frameworks, maven e goals sem erros, não é Java, em java é tudo tem que dar voltas e ser complexo para parecer profissional, então faz de conta que ta tudo bem. Python e PHP nos dão muita inveja, mas deixa pra lá!

O seu banquinho ficará mais ou menos assim:

Eu particularmente prefiro jdbc pra mexer com bancos, mas na filosofia Java, nada pode ser simples, quanto mais enrolado, dando voltas, melhor é e mais bem-visto pelo mercado é. Tipo as empresas que você trabalha: se podemos dificultar, vamos dificultar! O mundo é dos sociopatas!
A desculpa dos javeiros para o Hibernate é que com ele você pode mudar o banco de dados que o código java continuará o mesmo, bastando apenas fazer algumas modificações de dialeto no seu arquivo persistence.xml

Fazendo consultas com Hibernate e HQL

Eu criei um método baseado nas classes e códigos criados mais acima, ele funciona mais ou menos igual ao mysql_query do PHP e retorna uma lista que depois você transformará em objeto da classe para ler seus atributos.

public static List hql(String minhaQuery) {
        Session session = Banco.hibernate();
        session.beginTransaction();
        // Esse List é o java.util.List mesmo
        List result = session.createQuery(minhaQuery).list();
        return result;
}

Com esse método hql você poderá consultar qual o macho número um cadastrado jogando isso em algum lugar do seu código:

 List macho = hql("from Machos"); 
 // Converte o primeiro item achado da lista em um objeto da classe Machos
 Machos machos = (Machos) macho.get(1);
 // Imprime o nome do primeiro macho encontrado:
 System.out.println(machos.getNome());