A temporal collection is a simple way to implement a Temporal Property or a Temporal Object.
A temporal instance (either a Temporal Property or Temporal Object), when going through a series of amendments, the property itself or the properties the object references change over time. Each version of the temporal instance captures the state of the instance that will last for some period of time until the instance changes again with another amendment.
The basic representation and interface for a temporal collection provides get and put operations that use a date as an index:
Data Transfer Object (DTO) is an object used to pass data with multiple items in one shot between client and server, to avoid client from issuing multiple calls to a remote server to get each item in separate calls.
Optionally, we can make use of a DTO Assembler class as some sort of a mapper in between DomainObject and DataTransferObject to map from one side to another in either direction. That is, to create a serializable DTO object given a Domain Object, or to update a Domain Object given a DTO object.
People who just started to learn Spring framework is often confused by the term "Inversion of Control" (IoC) which can be achieved through "Dependency Injection" (DI).
DI is a way of providing the dependencies (e.g. creating objects and its dependencies), wiring components into application. In Spring, those objects defined and instantiated by Spring containers then inject into application are called Spring Beans.
IoC is a concept, it means to create instances of dependencies first, the concept is usually achieved by using metadata-driven approach to assemble instances at runtime. IoC is the end result of DI. However, DI is not the only way to achieve IoC. For example, Workday's XpressO is a great example of metadata-driven development to achieve IoC.
Here are some more good explanations:
Inversion of Control (IoC) means to create instances of dependencies first and latter instance of a class (optionally injecting them through constructor), instead of creating an instance of the class first and then the class instance creating instances of dependencies. Thus, inversion of control inverts the flow of control of the program. Instead of the callee controlling the flow of control (while creating dependencies), the caller controls the flow of control of the program.
IoC is a programming technique, expressed here in terms of object-oriented programming, in which object coupling is bound at run time by an assembler object and is typically not known at compile time using static analysis.
IoC is a common pattern in the Java community that helps wire lightweight containers or assemble components from different projects into a cohesive application.
Spring helps in the creation of loosely coupled applications because of Dependency Injection.
Flyweight Design Pattern Principle
Flyweight pattern is a structural pattern in GoF as it supports large numbers of fine-grained objects efficiently. Since each fine-grained object (e.g. a character in an editor application) may incur overhead that adds up. This pattern shares objects in a pool (Flyweight Factory) to minimize memory use.
In a Composite (or Decorator) structure, Prototype uses a prototypical instance to create new Composite Component. Composite is a structural pattern where as Prototype is creational pattern. They are related to each other in a sense that Prototype only make sense in the context of a structural pattern like Composite or Decorator.
Command Design Pattern Example
Command pattern is a behavioral pattern in GoF as it allows us to decouple between the Invoker (a.k.a. sender, an object that invokes an operation) and the Receiver (an object that receives the request to execute a certain operation).
Also known as an action or transaction pattern.
Memento Design Pattern Example
The word 'memento' refers to an object that is kept as a reminder or souvenir of a person or event. Memento pattern is a behavioral pattern in GoF, as it captures and externalizes an object's internal state. This allows the object to be restored to its previous state at a later time.
State Design Pattern Example
State pattern is a behavioral pattern in GoF because it allows to alter its behavior when a context's internal state changes. The pattern handles each state using a separate state object and the transition from one state to another that does not call for if-then statements.
Chain of Responsibility pattern is a behavioral pattern that sends data (a request, a Command) to an concrete handler object and if that handler object can't use/handle it, it passes the data/request to other objects along the chain until an handler object handles it.
Mediator Design Pattern Example
Mediator pattern is a behavioral pattern that coordinates and encapsulates many-to-many communication/interaction among related objects (Colleagues) so that Colleagues interact not directly with other independent Colleagues, but indirectly with other Colleagues through a centralized Mediator.