Beruflich Dokumente
Kultur Dokumente
James Brundege
www.synaptocode.com
What is Spring?
2 Things: An Inversion of Control (IoC) Container
Utilities that provide a consistent (and simple!) API to many other technologies (JDBC, ORM, AOP, Declarative Transactions, etc)
Traditional "Pull" approach: Direct instantiation Asking a Factory for an implementation Looking up a service via JNDI
"Push" approach: Something outside of the Object "pushes" its dependencies into it. The Object has no knowledge of how it gets its dependencies, it just assumes they are there.
Domai n Model
Service Layer
DB
Pull Example
public class BookDemoServicePullImpl implements BookDemoService { public void addPublisherToBook(Book book) { BookDemoFactory factory = BookDemoFactory.getFactory(); BookDemoDao dao = factory.getBookDemoDao();
String isbn = book.getIsbn(); if (book.getPublisher() == null && isbn != null) { Publisher publisher = dao.findPublisherByIsbn(isbn); book.setPublisher(publisher); } }
}
Push Example
(Dependency Injection)
public class BookDemoServiceImpl implements BookDemoService { private BookDemoDao dao; public void addPublisherToBook(Book book) { String isbn = book.getIsbn(); if (book.getPublisher() == null && isbn != null) { Publisher publisher = dao.findPublisherByIsbn(isbn); book.setPublisher(publisher); } } public void setBookDemoDao(BookDemoDao dao) { this.dao = dao; } }
Definitions
Dependency Injection is the act of injecting dependencies into an Object.
Inversion of Control is the general style of using Dependency Injection to wire together application layers. Hence Spring is an Inversion of Control container. That is, it is a container that handles Dependency Injection for you.
Loose Coupling is improved because you don't hard-code dependencies between layers and modules. Instead you configure them outside of the code. This makes it easy to swap in a new implementation of a service, or break off a module and reuse it elsewhere.
Testability is improved because your Objects don't know or care what environment they're in as long as someone injects their dependencies. Hence you can deploy Objects into a test environment and inject Mock Objects for their dependencies with ease.
This just has to be done once on startup, and can be done in the main() method or whatever code bootstraps the application.
But don't! That is a "Pull" technique that treats the ApplicationContext like a Factory. Instead, make sure that applicationContext.xml connects every bean to every other bean that needs it. None of the beans thus have a dependency on spring.jar
JDBC and DAOs ORM: Hibernate, iBatis, TopLink and others Declarative Transaction Support (without a full J2EE
app server) Aspect-Oriented Programming Remote calls and Web Services (Axis) EJBs
Resources
Spring Website: http://www.springframework.org/
Download Spring with sample applications:
http://prdownloads.sourceforge.net/springframework/spring-framework-1.2.8-withdependencies.zip?download
Wikipedia:
http://en.wikipedia.org/wiki/Spring_Framework_%28Java%29 EasyMock: http://www.easymock.org/ Echo2 (Rich Web Inteface framework) http://www.nextapp.com/platform/echo2/echo/