Chapter 1, Getting Started with Guice, introduces Guice as an alternative to writing dependency injection code using constructors or factories. The focus is on simplicity and separation of concerns, which Guice brings in with dependency injection. Along with this, Maven is introduced to build and run the sample applications.

Chapter 2, Exploring Google Guice, lays down a sound footing in various areas of the dependency injection. We start our discussion with Injector, which prepares the object graph and injects the dependencies. Discussion continues with various types of bindings, Guice provides to bind a reference to its implementation. At the end of the chapter, we visit a case for injecting static dependencies.

Chapter 3, Diving Deeper in Guice, focuses on advanced concepts in Guice. Beyond explicit bindings we investigate the application of Providers, Scoping, Binding collections, and Configuration Management. Various Guice extensions such as guice-throwingproviders, guice-assistedinject, and guice-multibindings are discussed. A solution to handle installation of modules is discussed in later part.

Chapter 4, Guice in Web Development, helps us to learn about developing a web application in java using Servlets and JSPs using Guice. We discuss the programmatic approach to configure routing to servlets and JSPs and avoiding declarative approach altogether in web.xml. We discuss guice-servlet an important extension, which provides important artifacts like GuiceServletContextListener, ServletModule, and GuiceFilter. We learn how to scope various instances to Request, Session, and Singleton.

Chapter 5, Integrating Guice with Struts 2, demonstrates integration of Guice with Struts 2. We discuss guice-struts the extension, which provides various artifacts such as Struts2GuicePluginModule and Struts2Factory for easy integration. The web application developed is redeveloped with Guice and Struts2.

Chapter 6, Integrating Guice with JPA 2, illustrates integration of Guice with JPA 2 and Hibernate 3 in a web and standalone application. We continue with our Struts 2 based application from the previous chapter and make it driven by a JPA, Hibernate-backed database. In this process we discuss the extension guice-persist and various artifacts it provides such as, JpaPersistModule and PersistFilter. Transaction handling is discussed using JpaTxnInterceptor.

Chapter 7, Developing Plugins and Extensions using Guice, focuses on SPI, Service Provider Interface. Important classes and interfaces, which are useful for developing extensions and plugins around Guice, are discussed. A custom LoggingInterceptor is developed to understand various functionalities of SPI. guice-multibinder, an extension for binding collections is analyzed.

Chapter 8, AOP with Guice, provides a brief overview of what AOP is, and how Guice adds to its own style of AOP with method interceptors by providing an implementation of aopalliance. Various artifacts such as Matchers and MethodInterceptor are discussed. A lot of examples are covered detailing both the artifacts.

Appendix, Prerequisites, provides tips regarding essential tools involved in running and building the samples. Installation of Maven, Eclipse, Tomcat, and MySQL server is illustrated. Importing MySQL data dump for running the samples of chapter 6, 7, and 8 is also detailed.

You need to have JDK 1.5 installed on your machine. For running the samples from the various chapters Maven, the ubiquitous build and project management tool is required. Readers are advised to refer to the Appendix for prerequisites while running the samples.

This book is for anyone hands on with Java (JDK 5 and above) and curious to implement Guice for dependency injection. Being hands on book, programmers struggling with Guice would also find it as a handy reference.

In this book, you will find a number of styles of text that distinguish between different kinds of information. Here are some examples of these styles, and an explanation of their meaning.

Code words in text are shown as follows: "We can include other contexts through the use of the include directive."

A block of code is set as follows:

new ServletModule(){
      @Override
      protected void configureServlets() {
        install(new MainModule());
        serve("/response").with(FlightServlet.class);
        serve("/").with(IndexServlet.class);
      }
}

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

SearchRQ create(
@Assisted("depLoc") String depLoc,
@Assisted("arrivLoc") String arrivLoc,
Date flightDate);

Any command-line input or output is written as follows:

# mvn exec:java -Dexec.mainClass="org.packt.client.Client"

New terms and important words are shown in bold. Words that you see on the screen, in menus or dialog boxes for example, appear in the text like this: "clicking the Next button moves you to the next screen".

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or may have disliked. Reader feedback is important for us to develop titles that you really get the most out of.

To send us general feedback, simply send an e-mail to <[email protected]>, and mention the book title through the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide on www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.