Hibernate Core

<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>7.1.1</version>
</dependency>

implementation 'org.hibernate.orm:hibernate-core:7.1.1'

// Core session management
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

// Configuration and bootstrapping
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.SessionFactoryBuilder;

// Query APIs
import org.hibernate.query.Query;
import org.hibernate.query.SelectionQuery;
import org.hibernate.query.NativeQuery;

// Core annotations
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.NaturalId;
import org.hibernate.annotations.Fetch;

import org.hibernate.*;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

// Configure and build SessionFactory
StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
    .configure() // configures settings from hibernate.cfg.xml
    .build();

SessionFactory sessionFactory = new MetadataSources(registry)
    .buildMetadata()
    .buildSessionFactory();

// Use Session for persistence operations
try (Session session = sessionFactory.openSession()) {
    Transaction tx = session.beginTransaction();

    // Create and persist an entity
    MyEntity entity = new MyEntity("example");
    session.persist(entity);

    // Query entities
    List<MyEntity> entities = session.createQuery(
        "FROM MyEntity WHERE name = :name", MyEntity.class)
        .setParameter("name", "example")
        .getResultList();

    tx.commit();
}

public interface Session extends SharedSessionContract, EntityManager {
    // Core persistence operations
    <T> T find(Class<T> entityClass, Object primaryKey);
    void persist(Object entity);
    <T> T merge(T entity);
    void remove(Object entity);
    void refresh(Object entity);

    // Transaction management
    Transaction beginTransaction();
    Transaction getTransaction();

    // Query creation
    <R> Query<R> createQuery(String queryString, Class<R> resultClass);
    <R> NativeQuery<R> createNativeQuery(String sqlString, Class<R> resultClass);
}

public interface SessionFactory extends EntityManagerFactory {
    Session openSession();
    Session getCurrentSession();
    <R> R inSession(Function<Session, R> work);
    <R> R inTransaction(Function<Session, R> work);
}

public class MetadataSources {
    public MetadataSources(ServiceRegistry serviceRegistry);
    public MetadataSources addAnnotatedClass(Class<?> annotatedClass);
    public MetadataSources addResource(String name);
    public Metadata buildMetadata();
}

public interface Metadata {
    SessionFactoryBuilder getSessionFactoryBuilder();
    Database getDatabase();
    Collection<EntityBinding> getEntityBindings();
}

public interface Query<R> extends CommonQueryContract {
    List<R> getResultList();
    R getSingleResult();
    R getSingleResultOrNull();

    // Parameter binding
    <P> Query<R> setParameter(String name, P value);
    <P> Query<R> setParameter(int position, P value);

    // Pagination
    Query<R> setFirstResult(int startPosition);
    Query<R> setMaxResults(int maxResult);
}

public interface SelectionQuery<R> extends Query<R> {
    // Selection-specific operations
    SelectionQuery<R> setOrder(List<Order> orderList);
    SelectionQuery<R> setOrder(Order... orders);
}

// Type-safe Criteria API
public interface CriteriaBuilder {
    <T> CriteriaQuery<T> createQuery(Class<T> resultClass);
    Predicate and(Predicate... restrictions);
    Predicate equal(Expression<?> x, Object y);
    <Y extends Comparable<? super Y>> Predicate greaterThan(Expression<? extends Y> x, Y y);
}

// Caching annotations
@Target({TYPE, METHOD, FIELD})
@Retention(RUNTIME)
public @interface Cache {
    CacheConcurrencyStrategy usage() default CacheConcurrencyStrategy.READ_WRITE;
    String region() default "";
}

// Fetching strategy annotations
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface Fetch {
    FetchMode value();
}

// Natural identifier annotation
@Target({METHOD, FIELD})
@Retention(RUNTIME)
public @interface NaturalId {
    boolean mutable() default false;
}

public interface Transaction {
    void begin();
    void commit();
    void rollback();
    boolean isActive();

    // Timeout configuration
    void setTimeout(int seconds);
    int getTimeout();
}

public interface UserType<J> {
    int getSqlType();
    Class<J> returnedClass();
    boolean equals(J x, J y);
    int hashCode(J x);
    J nullSafeGet(ResultSet rs, int position, SharedSessionContractImplementor session, Object owner);
    void nullSafeSet(PreparedStatement st, J value, int index, SharedSessionContractImplementor session);
}

// Core enums
public enum FlushMode {
    /** Never flush unless explicitly requested */
    MANUAL,
    /** Flush when transaction commits */
    COMMIT,
    /** Automatically flush when needed */
    AUTO,
    /** Always flush before query execution */
    ALWAYS
}

public enum CacheMode {
    /** Normal cache interaction */
    NORMAL,
    /** Ignore second-level cache completely */
    IGNORE,
    /** Only read from cache, never write */
    GET,
    /** Only write to cache, never read */
    PUT,
    /** Refresh cache entries */
    REFRESH
}

public enum LockMode {
    /** No locking */
    NONE,
    /** Read lock */
    READ,
    /** Optimistic locking */
    OPTIMISTIC,
    /** Pessimistic read lock */
    PESSIMISTIC_READ,
    /** Pessimistic write lock */
    PESSIMISTIC_WRITE
}

// Core interfaces
public interface SharedSessionContract extends AutoCloseable {
    Transaction beginTransaction();
    Query createQuery(String queryString);
    Criteria createCriteria(Class persistentClass);
    void flush();
    void clear();
    boolean isOpen();
}