Entity
An entity is a distinct, identifiable person, object, event, or concept represented as a unit in a data, software, or semantic model.
Java Persistence with Spring Data and Hibernate epub
A business entity is an object representing a significant concept or state in an application's business domain.
- How it is used
- Models independently retrievable business objects as persistent Java classes mapped to database rows.
- How deep it goes
- Defines identity and lifecycle, then explains basic JPA mapping, field access, and detached-instance merging.
- Examples
- Uses a mapped Message class and User accounts whose Address is either shared or owned.
- What you can do after
- Build it from scratch by identifying independent domain objects and mapping Java classes with @Entity and @Id.
Read how Java Persistence with Spring Data and Hibernate epub explains entity →
Building Web APIs with ASP.NET Core
An entity class is a C# class whose instances represent persistent data entities and their mapped attributes.
- How it is used
- Represents database records as C# objects used for CRUD operations and code-first schema creation.
- How deep it goes
- Works through annotated classes, relationship properties, composite keys, and DbSet exposure, without descending into EF Core internals.
- Examples
- Uses board-game, domain, mechanic, and link classes, plus HTTP requests that read or change entities.
- What you can do after
- Build it from scratch: define mapped C# entity classes and expose them through an EF Core DbContext.
Read how Building Web APIs with ASP.NET Core explains entity →
ASP.NET Core in Action, 3e
An entity is an application object whose structure and identity are mapped by an object-relational mapper to a database record.
- How it is used
- Uses application objects as the working representation of database data in a recipe-management API.
- How deep it goes
- Explains class mapping, conventions, relationships, model discovery, and insertion, while deferring many convention details and customizations.
- Examples
- Demonstrates Recipe and Ingredient classes, a many-to-one relationship, and creating linked rows through a recipe service.
- What you can do after
- Build it from scratch by defining entity classes, exposing them through DbContext, tracking objects, and saving mapped rows.
Authorization in Action
An entity is a person, organization, service, thing, or AI agent that can participate in relationships with a digital identity system.
- How it is used
- Structures principals and resources so authorization policies can evaluate actions using attributes and relationships.
- How deep it goes
- Defines entities and details attributes, relationships, schemas, normalization, namespaces, and Cedar evaluation integration.
- Examples
- Uses employees, customers, service accounts, documents, projects, cost centers, pipelines, and normalized employment-status data.
- What you can do after
- Apply it via Cedar by modeling typed principals and resources, supplying trustworthy attributes, and evaluating structured access requests.
Grokking Relational Database Design
A distinct real-world object or concept that can be described by attributes and represented by data.
- How it is used
- Frames relational database design by turning requirement subjects into tables with records and attributes.
- How deep it goes
- Walks through entity identification, attributes, primary keys, data types, naming, and later relationship design.
- Examples
- Uses online-store products and a spaceship database containing brands, models, spaceships, dealers, and customers.
- What you can do after
- Build it from scratch by identifying entities, selecting attributes and keys, and assigning suitable data types.
Read how Grokking Relational Database Design explains entity →
Quarkus in Action
A persistence entity is a Java object whose state is mapped to and managed as records in a database through object-relational mapping.
- How it is used
- Represents reservation and inventory data as database-backed Java objects accessed through Panache or JPA.
- How deep it goes
- Works through entity annotations, ID choices, and access patterns, but does not develop a pure-JPA service.
- Examples
- Shows a reservation with an overlap method, a car with a generated ID, and an EntityManager persist call.
- What you can do after
- Build it from scratch as a Panache or plain JPA entity, then access it through a repository or EntityManager.
100 SQL Server Mistakes and How to Avoid Them
An entity is a distinct type of thing represented in a data model and typically implemented as a table or related set of data.
- How it is used
- Organizes database data into objects, attributes, and relationships during schema design.
- How deep it goes
- Defines entities through ERDs and relationships, then connects them to keys and normalization without detailing implementation commands.
- Examples
- Uses sales orders, products, employees, and offices to demonstrate entity separation, relationships, keys, and duplication avoidance.
- What you can do after
- Evaluate schema structure by identifying entities, attributes, relationships, keys, and opportunities for normalization.
Read how 100 SQL Server Mistakes and How to Avoid Them explains entity →
Microsoft Azure in Action
An entity is a record-like item in Azure Table Storage containing properties and identifying keys.
- How it is used
- Stores flexible, fast-access records inside Azure Table Storage.
- How deep it goes
- Explains properties, JSON-defined schemas, composite identity, and partition placement, while deferring deeper partition planning.
- Examples
- Uses a book catalog entity with title and bookid properties and a GUID row key.
- What you can do after
- Builds and inserts an entity with PowerShell using Add-AzTableRow and a CloudTable reference.
Natural Language Processing in Action, Second Edition
An entity is a recognized semantic item in an utterance, such as a location, time expression, person, drug, or crop type.
- How it is used
- Uses entities to represent factual nodes in knowledge graphs and parameterize actions in conversational interfaces.
- How deep it goes
- Explains naming, normalization, triples, extraction, and slot distinctions, but stops short of general entity-linking methods.
- Examples
- Uses NELL triples, normalized names, weather locations and times, drug and crop types, and extracted proper names.
- What you can do after
- Apply entity representations to inspect knowledge-graph records and extract actionable parameters from chatbot utterances.
Read how Natural Language Processing in Action, Second Edition explains entity →
.NET in Action, Second Edition
A database entity is an application object or distinct unit of data whose state is represented and persisted in a database.
- How it is used
- Maps application objects to relational data sources and supports persistence, querying, and CRUD operations.
- How deep it goes
- Explains properties, relationships, conventions, generated tables, persistence, and eager loading, but defers detailed explicit configuration.
- Examples
- Uses Book, Rating, and Tag classes plus CatalogContext code that saves ratings and loads them with Include.
- What you can do after
- Apply it via EF Core by defining entity classes, modeling relationships, persisting objects, and loading related data.
Simple Object-Oriented Design: Create clean, maintainable applications
An entity is a domain object that represents a business concept through identifying attributes and behavior that maintains those attributes consistently.
- How it is used
- Models business concepts in the domain Model and maintains their attributes through entity behavior.
- How deep it goes
- Defines attributes, behavior, and layer-boundary risks, but stops short of implementation mechanics or detailed coding patterns.
- Examples
- Uses an Invoice class and the transformation of a repository-retrieved entity into a client-specific data structure.
- What you can do after
- Apply it by keeping business behavior with domain attributes and translating entities into client-specific structures.
Read how Simple Object-Oriented Design: Create clean, maintainable applications explains entity →
Go in Action, Second Edition
An entity is a domain object representing a distinct business concept with identity and associated data or behavior.
- How it is used
- Centers a shared domain model that API and worker modules can use independently of infrastructure.
- How deep it goes
- Defines Article and Feed fields and relates them to interfaces, stopping short of detailed entity behavior or persistence.
- Examples
- Uses Article for news articles and Feed for RSS/Atom feeds, with Fetcher, ArticleReader, and Storage interfaces.
- What you can do after
- Build it from scratch by defining portable domain structs and interfaces before implementing API, worker, or infrastructure details.
Related concepts
- subjectincludes · A subject is an entity designated as the focus of representation, data modeling, or an authorization policy.
- attributehas part · An attribute is a named property, value, or piece of information associated with an entity, object, or program element.
- @Entityconfigured by · The @Entity annotation is a Jakarta Persistence annotation that declares a Java class as a persistent entity mapped to stored data.
- Entity Framework Coreused by · Entity Framework Core is a cross-platform object-relational mapping framework for .NET that enables applications to query and persist data through .NET objects and APIs.
- JPAuses · JPA, now Jakarta Persistence, is a Java standard for mapping objects to relational data and managing their persistence.
- mergeproduced by · merge is a JPA EntityManager operation that copies the state of a detached or new entity instance into a managed instance in a persistence context.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.