It was first introduced in Design Patterns: elements of reusable Object-Oriented Software. The decorator pattern allow functionality to be added to objects during runtime. Another way of solving this problem is to create interfaces and use the Decorator Pattern. Or even understand how they are being used in case they are in different packages. However, it can be tricky to navigate through a long chain of wrapping functions. Wrapping functions are very useful and straightforward. This is useful when we need to dependencies added to the function but we still need to return the http.Handler type (usually combined with http.HanlderFunc)Īn alternative way of dealing with dependency injection can be found in this article I wrote some time ago. In the most basic form, you can just wrap the functions you use to handle the requests for additional behaviour. A great example of this pattern can be found in how people create middlewares for HTTP servers. In cases where we need to receive an extra dependency we can wrap the function we want to execute in another function that receives the dependency as a parameter, returning a function with the exact signature we need.
Very often we need to use functions with a fixed signature as a parameter or a field. package main import ( "fmt" ) func main() Dependency injectionĪnother great use case for this technique is for dependency injection. The most basic form of function wrapping is passing the function you want to wrap to another function as parameter. Wrapping functions is a very easy and quick way of maintaining single responsibility and decoupling for programs.
0 kommentar(er)
