Entity
An entity is a distinct, identifiable object, concept, participant, or record represented in a system's model or data.
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 business concepts as independently identifiable objects that can be stored and retrieved.
- How deep it goes
- Explains class design, identity, mapping, managed updates, and detached-instance merging, including provider behavior.
- Examples
- Uses Message and Item mappings and an auction account-and-address model to illustrate entities.
- What you can do after
- Apply it via JPA and Hibernate to map domain classes, persist instances, and handle detached state.
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 →
Clean Applications with Hexagonal Architecture
A domain object with an identity whose state and invariants are governed by domain rules.
- How it is used
- Places entities in the framework-free domain core to own business invariants during migration to hexagonal architecture.
- How deep it goes
- Defines identity and invariants, then details factory-based validation, boundary mapping risks, and testing responsibilities.
- Examples
- Uses Article and ArticleId to illustrate persistent identity, Title validation, and an aggregate referencing Author.
- What you can do after
- Build domain entities from scratch with factory-enforced invariants and keep their rules independent of adapters.
Read how Clean Applications with Hexagonal Architecture 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
- Uses entities to represent identity relationships and connect authorization policies to principals and resources.
- How deep it goes
- Defines entities and explains their preprocessing, schema design, and use in policy evaluation.
- Examples
- Illustrates inconsistent employment-status and ownership attributes across systems, and a new Folder entity introduced through schema updates.
- What you can do after
- Evaluate entity models for consistent attributes and appropriately narrow action types.
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.
High Performance Unity Game Development
In this section's ECS representation, an entity is an index in data arrays that identifies an individual record.
- How it is used
- Maps an individual record to an array index within an ECS representation of data and logic.
- How deep it goes
- Defines entities as array indices and illustrates their use in enemy movement.
- Examples
- Uses index i to access and update enemy positions in an array.
- What you can do after
- Understand how an entity index selects a record during array-based movement.
Read how High Performance Unity Game Development explains entity →
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.
Also covered in
- Essential GraphRAG
- BDD in Action, Second Edition
- Machine Learning Platform Engineering
- Build Python Web Apps with Streamlit
- Kafka Streams in Action, Second Edition
- Outlier Detection in Python
- Software Security for Developers
- Spring in Action, Sixth Edition
- Knowledge Graphs and LLMs in Action
- AI Agents in Action, Second Edition
- gRPC Microservices in Go
- Python Concurrency with asyncio
What to know first
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- SQLSQL is a standardized declarative language for defining, querying, and manipulating data in relational database systems.
- foreign keyA foreign key is a column or set of columns whose values reference a key in the same or another relational table, linking records and supporting referential integrity.
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 or piece of information associated with an entity, object, or structured data item.
- @Entityconfigured by · @Entity is a Jakarta Persistence annotation that marks a Java class as a persistent entity managed by a persistence provider.
- Entity Framework Coreused by · Entity Framework Core is a cross-platform object-relational mapper for .NET that enables applications to work with databases through .NET objects and queries.
- JPAuses · JPA, now Jakarta Persistence, is a Java standard API for mapping objects to relational data and managing their persistence.
Questions about entity
What is entity?
An entity is a distinct, identifiable object, concept, participant, or record represented in a system's model or data.
Which Manning books explain entity?
Java Persistence with Spring Data and Hibernate epub, Building Web APIs with ASP.NET Core, Clean Applications with Hexagonal Architecture, ASP.NET Core in Action, 3e, Authorization in Action, Grokking Relational Database Design, Quarkus in Action, 100 SQL Server Mistakes and How to Avoid Them and 6 more.
What should I know before learning entity?
Manning books that teach entity usually introduce JSON, SQL, foreign key and Java first.
What kinds of entity are there?
Kinds of entity include subject and cart item.
What are the parts of entity?
Entity includes attribute.
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.













