Search for a command to run...
Android Developer With the experience of 9 plus years | Expert in Kotlin, Java, And KMM | Expert Android Jetpack, Coroutine, and MVVM | 30 plus Applications developed | 10 plus on Play stores.
Every positive action, no matter how small, contributes to the greater good of humanity.
No comments yet. Be the first to comment.
Discover our Design Patterns series: Unlock the secrets of effective software design with insightful posts exploring various design patterns!
The Composite design pattern facilitates the composition of objects into tree structures, enabling the manipulation of these structures as if the
A structural design pattern that optimizes memory usage by sharing common parts of the state among multiple objects
The Composite design pattern facilitates the composition of objects into tree structures, enabling the manipulation of these structures as if the
The Bridge design pattern helps break down a big class or a group of closely linked classes into two parts: abstraction and implementation. These part
ProblemImagine you're developing a fitness tracking application that gathers workout data from various fitness devices in XML format and generates detailed performance summaries for users.As you strive to enhance the app's capabilities, you contempla...
The Proxy pattern is a structural design pattern that provides a surrogate or placeholder for another object to control access to it. It allows you to add a layer of indirection to control access, manage complexity, and enhance functionality.
Remote Access: Use the Proxy pattern when you need to represent an object that is located remotely or in a different address space.
Lazy Initialization: Use it when you want to delay the creation of a resource-intensive object until it is needed.
Access Control: Use it to add additional checks or controls over access to an object, such as logging, authentication, or authorization.
Caching: Use it to implement caching mechanisms to improve performance by storing frequently accessed or expensive-to-create objects.
Identify the Subject: Identify the object for which you want to create a proxy.
Design the Proxy Class: Create a proxy class that implements the same interface as the subject. This class acts as a surrogate for the subject, controlling access and performing additional tasks as needed.
Implement Proxy Logic: Implement the proxy logic within the proxy class to control access to the subject. This may include lazy initialization, access control, caching, or remote communication.
Use the Proxy Object: Replace direct access to the subject with access through the proxy object. Clients interact with the proxy object as if it were the subject, unaware of the underlying complexity.
Let's demonstrate the Proxy pattern with an example of a simple image viewer application. We'll create a proxy to load and display images, with lazy initialization and logging capabilities.
kotlinCopy code// Step 1: Identify the Subject
interface Image {
fun display()
}
// Step 2 & 3: Design and Implement the Proxy Class
class ProxyImage(private val filename: String) : Image {
private var realImage: RealImage? = null
override fun display() {
if (realImage == null) {
realImage = RealImage(filename)
}
realImage!!.display()
}
}
// Real Subject
class RealImage(private val filename: String) : Image {
init {
loadFromDisk()
}
override fun display() {
println("Displaying image: $filename")
}
private fun loadFromDisk() {
println("Loading image: $filename")
}
}
// Client Code
fun main() {
val image1: Image = ProxyImage("image1.jpg")
val image2: Image = ProxyImage("image2.jpg")
// Image 1 will be loaded from disk
image1.display()
// Image 2 will be loaded from disk
image2.display()
// Image 1 will not be loaded again (lazy initialization)
image1.display()
}
Controlled Access: Allows for controlled access to the subject, enabling additional functionalities such as lazy initialization, access control, and logging.
Enhanced Security: Provides an additional layer of security by adding access controls and restrictions.
Improved Performance: Can improve performance by implementing caching and other optimizations.
Complexity: Introduces additional complexity with the need to implement the proxy class and manage the interaction between the proxy and the subject.
Overhead: This may introduce overhead due to the additional layer of indirection and the execution of proxy logic.
Transparent Proxy: Implement the proxy to be transparent to the client, providing the same interface as the subject.
Efficient Proxy Logic: Ensure that proxy logic is efficient and does not introduce unnecessary overhead.
Thorough Testing: Test the proxy thoroughly to ensure that it behaves correctly and does not impact the performance of the system.