mirror of
https://github.com/tiennm99/java-design-patterns.git
synced 2026-05-14 08:58:26 +00:00
docs: improvements to the Context Object docs
This commit is contained in:
Ilkka Seppälä
+61
-75
@@ -1,74 +1,49 @@
|
||||
---
|
||||
title: Context object
|
||||
category: Creational
|
||||
title: Context Object
|
||||
category: Behavioral
|
||||
language: en
|
||||
tags:
|
||||
- Data access
|
||||
- Context
|
||||
- Decoupling
|
||||
- Encapsulation
|
||||
---
|
||||
|
||||
## Name / classification
|
||||
|
||||
Context Object
|
||||
|
||||
## Also known as
|
||||
|
||||
Context, Encapsulate Context
|
||||
* Context
|
||||
* Context Encapsulation
|
||||
* Context Holder
|
||||
|
||||
## Intent
|
||||
|
||||
Decouple data from protocol-specific classes and store the scoped data in an object independent
|
||||
of the underlying protocol technology.
|
||||
Encapsulate the context (state and behaviors) relevant to the user or the request being processed in order to decouple application components from the complexities of the environment.
|
||||
|
||||
## Explanation
|
||||
|
||||
Real-world example
|
||||
|
||||
> This application has different layers labelled A, B and C with each extracting specific information
|
||||
> from a similar context for further use in the software. Passing down each pieces of information
|
||||
> individually would be inefficient, a method to efficiently store and pass information is needed.
|
||||
> This application has different layers labelled A, B and C with each extracting specific information from a similar context for further use in the software. Passing down each pieces of information individually would be inefficient, a method to efficiently store and pass information is needed.
|
||||
|
||||
In plain words
|
||||
|
||||
> Create an object and store the data there and pass this object to where it is needed.
|
||||
> Create an object to store the context data and pass it where needed.
|
||||
|
||||
[Core J2EE Patterns](http://corej2eepatterns.com/ContextObject.htm) says
|
||||
|
||||
> Use a Context Object to encapsulate state in a protocol-independent way to be shared throughout your application.
|
||||
> Use a Context Object to encapsulate state in a protocol-independent way to be shared throughout your application.
|
||||
|
||||
**Programmatic Example**
|
||||
|
||||
We define what data a service context object contains.
|
||||
Define the data that the service context object contains.
|
||||
|
||||
```Java
|
||||
@Getter
|
||||
@Setter
|
||||
public class ServiceContext {
|
||||
|
||||
String ACCOUNT_SERVICE, SESSION_SERVICE, SEARCH_SERVICE;
|
||||
|
||||
public void setACCOUNT_SERVICE(String ACCOUNT_SERVICE) {
|
||||
this.ACCOUNT_SERVICE = ACCOUNT_SERVICE;
|
||||
}
|
||||
|
||||
public void setSESSION_SERVICE(String SESSION_SERVICE) {
|
||||
this.SESSION_SERVICE = SESSION_SERVICE;
|
||||
}
|
||||
|
||||
public void setSEARCH_SERVICE(String SEARCH_SERVICE) {
|
||||
this.SEARCH_SERVICE = SEARCH_SERVICE;
|
||||
}
|
||||
|
||||
public String getACCOUNT_SERVICE() {
|
||||
return ACCOUNT_SERVICE;
|
||||
}
|
||||
|
||||
public String getSESSION_SERVICE() {
|
||||
return SESSION_SERVICE;
|
||||
}
|
||||
|
||||
public String getSEARCH_SERVICE() {
|
||||
return SEARCH_SERVICE;
|
||||
}
|
||||
|
||||
public String toString() { return ACCOUNT_SERVICE + " " + SESSION_SERVICE + " " + SEARCH_SERVICE;}
|
||||
String accountService;
|
||||
String sessionService;
|
||||
String searchService;
|
||||
}
|
||||
```
|
||||
|
||||
@@ -83,10 +58,10 @@ public class ServiceContextFactory {
|
||||
}
|
||||
```
|
||||
|
||||
Instantiate the context object in the first layer and the adjoining layer upcalls the context in the current layer, which
|
||||
then further structures the object.
|
||||
Instantiate the context object in the first layer. The adjoining layer calls the context in the current layer, which then further structures the object.
|
||||
|
||||
```Java
|
||||
@Getter
|
||||
public class LayerA {
|
||||
|
||||
private static ServiceContext context;
|
||||
@@ -95,15 +70,12 @@ public class LayerA {
|
||||
context = ServiceContextFactory.createContext();
|
||||
}
|
||||
|
||||
public static ServiceContext getContext() {
|
||||
return context;
|
||||
}
|
||||
|
||||
public void addAccountInfo(String accountService) {
|
||||
context.setACCOUNT_SERVICE(accountService);
|
||||
}
|
||||
}
|
||||
|
||||
@Getter
|
||||
public class LayerB {
|
||||
|
||||
private static ServiceContext context;
|
||||
@@ -112,15 +84,12 @@ public class LayerB {
|
||||
this.context = layerA.getContext();
|
||||
}
|
||||
|
||||
public static ServiceContext getContext() {
|
||||
return context;
|
||||
}
|
||||
|
||||
public void addSessionInfo(String sessionService) {
|
||||
context.setSESSION_SERVICE(sessionService);
|
||||
}
|
||||
}
|
||||
|
||||
@Getter
|
||||
public class LayerC {
|
||||
|
||||
public static ServiceContext context;
|
||||
@@ -129,54 +98,71 @@ public class LayerC {
|
||||
this.context = layerB.getContext();
|
||||
}
|
||||
|
||||
public static ServiceContext getContext() {
|
||||
return context;
|
||||
}
|
||||
|
||||
public void addSearchInfo(String searchService) {
|
||||
context.setSEARCH_SERVICE(searchService);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Here is the context object and layers in action.
|
||||
|
||||
```Java
|
||||
var layerA = new LayerA();
|
||||
layerA.addAccountInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerA.getContext());
|
||||
var layerB = new LayerB(layerA);
|
||||
layerB.addSessionInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerB.getContext());
|
||||
var layerC = new LayerC(layerB);
|
||||
layerC.addSearchInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerC.getContext());
|
||||
var layerA=new LayerA();
|
||||
layerA.addAccountInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerA.getContext());
|
||||
var layerB=new LayerB(layerA);
|
||||
layerB.addSessionInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerB.getContext());
|
||||
var layerC=new LayerC(layerB);
|
||||
layerC.addSearchInfo(SERVICE);
|
||||
LOGGER.info("Context = {}",layerC.getContext());
|
||||
```
|
||||
|
||||
Program output:
|
||||
|
||||
```Java
|
||||
Context = SERVICE null null
|
||||
Context = SERVICE SERVICE null
|
||||
Context = SERVICE SERVICE SERVICE
|
||||
Context=SERVICE null null
|
||||
Context=SERVICE SERVICE null
|
||||
Context=SERVICE SERVICE SERVICE
|
||||
```
|
||||
|
||||
## Class diagram
|
||||
|
||||
|
||||
|
||||
## Application
|
||||
## Applicability
|
||||
|
||||
Use the Context Object pattern for:
|
||||
|
||||
* Sharing information across different system layers.
|
||||
* Decoupling software data from protocol-specific contexts.
|
||||
* Exposing only the relevant API's within the context.
|
||||
* When there is a need to abstract and encapsulate context information from different parts of an application to avoid cluttering the business logic with environment-specific code.
|
||||
* In web applications, to encapsulate request-specific information and make it easily accessible throughout the application without passing it explicitly between functions or components.
|
||||
* In distributed systems, to encapsulate contextual information about the task being performed, user preferences, or security credentials, facilitating their propagation across different components and services.
|
||||
|
||||
## Known uses
|
||||
|
||||
* Web application frameworks often implement a Context Object to encapsulate HTTP request and response objects, session information, and other request-specific data.
|
||||
* Enterprise applications use Context Objects to manage and propagate transactional information, security credentials, and user-specific settings across different layers and services.
|
||||
* [Spring: ApplicationContext](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/ApplicationContext.html)
|
||||
* [Oracle: SecurityContext](https://docs.oracle.com/javaee/7/api/javax/ws/rs/core/SecurityContext.html)
|
||||
* [Oracle: ServletContext](https://docs.oracle.com/javaee/6/api/javax/servlet/ServletContext.html)
|
||||
|
||||
## Consequences
|
||||
|
||||
Benefits:
|
||||
|
||||
* Decoupling: Components and services are decoupled from the specificities of the execution environment, enhancing modularity and maintainability.
|
||||
* Centralization: Contextual information is centralized in one place, making it easier to manage, access, and debug.
|
||||
* Flexibility: The pattern allows for flexible and dynamic context management, which can adapt to changes in the environment or requirements.
|
||||
|
||||
Trade-offs:
|
||||
|
||||
* Overhead: Introducing a Context Object can add overhead in terms of performance, especially if not implemented efficiently.
|
||||
* Complexity: If the Context Object is not well-designed, it can become a bloated and complex monolith, difficult to manage and understand.
|
||||
|
||||
## Related Patterns
|
||||
|
||||
* [Singleton](https://java-design-patterns.com/patterns/singleton/): The Context Object is often implemented as a Singleton to ensure a global point of access.
|
||||
* [Strategy](https://java-design-patterns.com/patterns/strategy/): Context Objects can use Strategies to adapt their behavior based on the context they encapsulate.
|
||||
* [Decorator](https://java-design-patterns.com/patterns/decorator/): Can be used to dynamically add responsibilities to the Context Object.
|
||||
|
||||
## Credits
|
||||
|
||||
* [Core J2EE Design Patterns](https://amzn.to/3IhcY9w)
|
||||
|
||||
@@ -26,7 +26,6 @@ package com.iluwatar.context.object;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import lombok.ToString;
|
||||
|
||||
/**
|
||||
* Where context objects are defined.
|
||||
|
||||
Reference in New Issue
Block a user