Introducing Spring Framework

Chapter 3 ■ Applying Different Configurations
In Listing 3-14, you are now using the GenericGroovyApplicationContext class that will load your Groovy script,
by passing the groovy file's classpath where it is located (META-INF/spring/mydocuments.groovy); it will start up
your Spring Container by creating all the necessary instances, wiring up your classes and having them ready when you
need them. Remember that you are now using Groovy! to configure your Spring container.
And now run your unit test with the following command:
gradle test
Which Configuration to Choose?
Every type of configuration has some differences and some applicable usage (see Table 3-3).
Table 3-3. Differences and Usage
Type of Configuration
XML
Annotations
Java Bean Configuration
Groovy Bean Configuration
Usage
This can be used with third party libraries and/or different development
environments. It’s easy to read and follow but it can grow, and even though it can be
split into different files, you need to keep track of them.
It is another way to do configurations, but here you are attaching the Spring
context to your application. This can be avoided by using your own domain-based
annotations and just these can be annotated.
This is now one of the preferred methods for developers who hate to struggle with
the XML, and it can be used for beans or components that don’t change too much.
This is a new complete feature that can be used with the power of the Groovy
programming language; it’s simple and there’s less to type.
So it will depend on your needs and how you want to manage your development cycle. Or you may have a team
that prefers some configuration because it is easy to manage and doesn’t affect your development goals.
Summary
In this chapter, you saw ways to accomplish the same behavior using different styles or conventions to create
beans. You saw the different classes that load up your beans, such as ClassPathXmlApplicationContext,
AnnotationConfigApplicationContext, and the new GenericGroovyApplicationContext.
You saw how you can annotate classes so the Spring container knows about the beans to use, its dependencies,
and relationship with other classes. You saw how the @Repository marks your class as a Spring-managed component
that act as a data access object.
Also, you saw how to use the Java configuration class and its @Configuration and @Bean annotations to create
the beans and their relationship. And you saw how to use Groovy to expose the beans using the Groovy programming
language.
In the next chapter, you are going to start adding more features to your Spring application, My Documents.
You’ll learn how the Spring container initiates your classes and the different approaches you can take in order to get
different instances of the same class.
43