Component library
0 likes886 views
The document discusses a component library for managing the lifecycle of software components using immutable data structures in a Clojure framework. It covers the advantages and disadvantages of the component model, including improved state management and simplified testing, as well as challenges like the difficulty of retrofitting the model to existing applications. Additionally, it provides sample code illustrating the implementation and use of components within a system.
![(defrecord Database [host port connection]
;; Implement the Lifecycle protocol
component/Lifecycle
(start [component]
(println ";; Starting database")
;; In the 'start' method, initialize this component
;; and start it running. For example, connect to a
;; database, create thread pools, or initialize shared
;; state.
(let [conn (connect-to-database host port)]
;; Return an updated version of the component with
;; the run-time state assoc'd in.
(assoc component :connection conn)))
(stop [component]
(println ";; Stopping database")
;; In the 'stop' method, shut down the running
;; component and release any external resources it has
;; acquired.
(.close connection)
;; Return the component, optionally modified. Remember that if you
;; dissoc one of a record's base fields, you get a plain map.
(assoc component :connection nil)))
(defn new-database [host port]
(map->Database {:host host :port port}))](https://image.slidesharecdn.com/componentlibrary-150710071024-lva1-app6891/85/Component-library-31-320.jpg)
![(defrecord ExampleComponent [options cache database scheduler]
component/Lifecycle
(start [this]
(println ";; Starting ExampleComponent")
;; In the 'start' method, a component may assume that its
;; dependencies are available and have already been started.
(assoc this :admin (get-user database "admin")))
(stop [this]
(println ";; Stopping ExampleComponent")
;; Likewise, in the 'stop' method, a component may assume that its
;; dependencies will not be stopped until AFTER it is stopped.
this))
(defn example-component [config-options]
(map->ExampleComponent {:options config-options
:cache (atom {})}))](https://image.slidesharecdn.com/componentlibrary-150710071024-lva1-app6891/85/Component-library-32-320.jpg)
![(defn example-system [config-options]
(let [{:keys [host port]} config-options]
(component/system-map
:database (new-database host port)
:scheduler (new-scheduler)
:app (component/using
(example-component config-options)
[:database :scheduler]))))](https://image.slidesharecdn.com/componentlibrary-150710071024-lva1-app6891/85/Component-library-33-320.jpg)
![(defn my-system []
(component/system-map
:context-math-engine (new-context-math-engine-system)
:application-api (component/using (new-application-api)
[:context-math-engine])))](https://image.slidesharecdn.com/componentlibrary-150710071024-lva1-app6891/85/Component-library-40-320.jpg)
Component library
- 2. Agenda • component library introduction • example
- 3. Introduction
- 4. Tiny Clojure framework for managing the lifecycle of software components which have runtime state
- 5. Real-world applications need to manage state
- 6. It can be seen as a style of dependency injection using immutable data structures
- 8. Components
- 9. A component is a collection of functions which share some runtime state
- 10. A component is similar in spirit to the definition of an object in Object-Oriented Programming
- 11. A component knows how to start and stop the application pieces that have to manage state
- 12. Some examples • Database access: database connection • External API service: HTTP connection pool • Web server: a session store • In-memory cache: a Clojure Atom or Ref
- 13. Systems
- 14. Components are composed into systems
- 15. A system is a component which knows how to start and stop other components
- 16. It is also responsible for injecting dependencies into the components which need them
- 17. Advantages of the Component Model
- 18. Large applications often consist of many stateful processes which must be started and stopped in a particular order. The component model makes those relationships explicit and declarative
- 19. Each component receives references only to the things it needs, avoiding unnecessary shared state
- 20. Easy to swap in "stub" or "mock" implementations of a component for testing purposes, without relying on time-dependent constructs, such as with-redefs or binding, which are often subject to race conditions in multi-threaded code
- 21. Having all state reachable via a single "system" object makes it easy to reach in and inspect any part of the application from the REPL
- 22. Having a coherent way to set up and tear down all the state associated with an application enables rapid development cycles without restarting the JVM
- 23. It can also make unit tests faster and more independent, since the cost of creating and starting a system is low enough that every test can create a new instance of the system
- 24. Disadvantages of the Component Model
- 25. It is not easy to retrofit the component model to an existing application without major refactoring
- 26. For small applications, declaring the dependency relationships among components may actually be more work than manually starting all the components in the correct order
- 27. The system map is too large to inspect visually
- 28. The code cannot discover relationships automatically
- 29. Cyclic dependencies are forbidden among components
- 30. Some code
- 31. (defrecord Database [host port connection] ;; Implement the Lifecycle protocol component/Lifecycle (start [component] (println ";; Starting database") ;; In the 'start' method, initialize this component ;; and start it running. For example, connect to a ;; database, create thread pools, or initialize shared ;; state. (let [conn (connect-to-database host port)] ;; Return an updated version of the component with ;; the run-time state assoc'd in. (assoc component :connection conn))) (stop [component] (println ";; Stopping database") ;; In the 'stop' method, shut down the running ;; component and release any external resources it has ;; acquired. (.close connection) ;; Return the component, optionally modified. Remember that if you ;; dissoc one of a record's base fields, you get a plain map. (assoc component :connection nil))) (defn new-database [host port] (map->Database {:host host :port port}))
- 32. (defrecord ExampleComponent [options cache database scheduler] component/Lifecycle (start [this] (println ";; Starting ExampleComponent") ;; In the 'start' method, a component may assume that its ;; dependencies are available and have already been started. (assoc this :admin (get-user database "admin"))) (stop [this] (println ";; Stopping ExampleComponent") ;; Likewise, in the 'stop' method, a component may assume that its ;; dependencies will not be stopped until AFTER it is stopped. this)) (defn example-component [config-options] (map->ExampleComponent {:options config-options :cache (atom {})}))
- 33. (defn example-system [config-options] (let [{:keys [host port]} config-options] (component/system-map :database (new-database host port) :scheduler (new-scheduler) :app (component/using (example-component config-options) [:database :scheduler]))))
- 37. Shows how component library works and how use a workflow that let you change code and avoid the JVM restarting
- 38. The example is just an API that exposes one endpoint to do additions curl http://localhost:8080/math/sum -v --data "value1=1;value2=2"
- 40. (defn my-system [] (component/system-map :context-math-engine (new-context-math-engine-system) :application-api (component/using (new-application-api) [:context-math-engine])))
- 41. Demo time :)
- 43. Thanks