SPRING 1. overview
0 likes•621 views
Spring is a dependency injection container that manages the lifecycle and dependencies of components in an application. It supports loading configuration from XML files located in the classpath or file system using application contexts like ClassPathXmlApplicationContext or FileSystemXmlApplicationContext. Spring provides modules for aspects, data access, messaging, and testing that add functionality beyond the core container. Dependency injection allows objects to have their dependencies provided at creation rather than creating them directly, which makes the code loosely coupled, readable, and easy to test.
SPRING 1. overview
- 2. Spring Overview Container is at the core of the Spring Framework. Spring’s container uses dependency injection (DI) to manage the components that make up an application. This includes creating associations between collaborating components. As such, these objects are cleaner and easier to understand, support reuse, and are easy to unit test. There’s no single Spring container : Bean factories (defined by the org.springframework.beans.factory.BeanFactory interface) are the simplest of containers, providing basic support for DI
- 3. Application contexts (defined by the org.springframework.context.ApplicationContext interface) build on the notion of a bean factory by providing application framework services, such as the ability to resolve textual messages from a properties file and the ability to publish application events to interested event listeners. ClassPathXmlApplicationContext —Loads a context definition from an XML file located in the classpath, treating context definition files as classpath resources.
- 4. FileSystemXmlApplicationContext —Loads a context definition from an XML file in the file system
- 5. XmlWebApplicationContext — from an XML file con-tained within a web application. FileSystemXmlApplicationContext(1) vs ClassPathXmlApplicationContext(2) (1) will look for foo.xml in a specific location within the file system, whereas (2) will look for foo.xml anywhere in the classpath (including JAR files).
- 6. Code Application Context Loading an application context from the file system or from the classpath is similar to how you load beans into a bean factory. For example, here’s how you’d load a File - SystemXmlApplicationContext: ApplicationContext context = new FileSystemXmlApplicationContext("c:/foo.xml"); Similarly, you can load an application context from within the application’s classpath using ClassPathXmlApplicationContext :
- 7. ApplicationContext context = new ClassPathXmlApplicationContext("foo.xml");
- 9. Spring Modules Overview Spring Framework is a container that manages how the beans in a Spring-enabled application are created, configured, and managed. Within this module you’ll find the bean factory, which is the portion of Spring that provides DI
- 10. AOP Modules : Provides rich support for aspect-oriented programming in its AOP module
- 11. DATA ACCESS AND INTEGRATION : data access objects (DAO) module abstracts away the boilerplate code so that you can keep your database code clean and simple, and prevents problems that result from a failure to close database ressources Spring’s ORM support builds on the DAO sup-port , providing a convenient way to build DAOs for several ORM solutions
- 12. Java Message Service (JMS) for asynchronous integration with other applications through messaging TESTING : pring provides a module ded-icated to testing Spring applications
- 13. DI DEF : With DI, on the other hand, objects are given their dependencies at creation time by some third party that coordinates each object in the system. Objects aren’t expected to create or obtain their dependencies—dependencies are injected into the objects that need them
- 14. Advantages : tightly coupled
- 15. Class doesn’t create his own quest
- 16. the dependency can be swapped out with a different implementation without the depending object knowing the difference
- 17. Code is easy to read.
- 18. Code with DI
- 19. How DI works? The Spring application context is fully responsible for the creation of and wiring of the objects that make up the application. loads the Spring context from one or more XML files located in the application’s classpath as ClassPathXmlApplicationContext -> Note that this class knows nothing about which type of Quest our hero has
- 20. Bean Life with Spring
- 21. AOP Overview AOP : makes it possible to modularize these services and then apply them declaratively to the components that they should affect. This results in components that are more cohesive and that focus on their own specific concerns, completely ignorant of any sys-tem services that may be involved. In short, aspects ensure that POJOs remain plain.