Meeting 5

Aus JSUG

Wechseln zu: Navigation, Suche

When: Monday, October 13th, 2008 - 19:00

Where: Freihaus HS4

In what follows we provide a simple formal model of this process. ,

Inhaltsverzeichnis

1 Guice
2 Springframework
3 Gallery

[Bearbeiten] Guice

Download the slides (pdf, 115KB).
You can also view the slides online.
Download the sourcecode (pdf, 13KB).

[Bearbeiten] Basic facts

Of course theory is nice, but it becomes useful when you start using a concret technology which enables dependency injection for you, such the Google Guice framework presented by Jan Zarnikov. It provides a pure Java style (no external XML configuration which makes it possible to misstype a name; refactorings also changes configuration!) with all Java5 features such as generics (type safety) and annotations (injecting is realized via Guice own annotations).

[Bearbeiten] Reductio ad absurdum

The following application is so simple, it actually does not require guice to work, but just for the sake for an introduction example:

public class MyApplication {
  public static void main(String[] args) {
    Injector injector = Guice.createInjector();
    Greeter greeter = injector.getInstance(Greeter.class);
    greeter.sayHello();
  }
}
 
public class Greeter {
  void sayHello() {
    System.out.println("Hello, world!");
  }
}

Taken from the presentation: http://www.youtube.com/watch?v=8RGhT-YySDY

[Bearbeiten] Simple example

The following chapter shows a simple application with a database connection and a mocked connection for its unit tests:

The UserController class is subject of the JUnit test and requires a database (in fact, just something that implements the DAO interface). Because unit tests should only test a certain unit (and not the database management system or anything else), the controller class will get another implementation of DAO injected if it is run by JUnit (namely TestDAO instead of JdbcDAO).

Injecting objects is just as easy as annotating the constructor with the @Inject annotation (you could also have used it at the field itself, or provided a setter method):

public class UserController {
 
  private final DAO dao;
 
  @Inject
  public UserController(DAO dao) {
    this.dao = dao;
  }
 
  public boolean login(String username, String password) {
    List<User> users = this.dao.getUsers();
    // ...
  }
}

Of course you also have to configure your dependencies somewhere:

public class AppModule extends AbstractModule {
  public void configure() {
    bind(DAO.class).to(JdbcDAO.class);
  }
}
 
public class TestModule extends AbstractModule {
  public void configure() {
    bind(DAO.class).to(TestDAO.class);
  }
}

To startup the Guice framework, you have to do following first:

public class MyApplication {
  public static void main(String[] args) {
    // configure Guice with AppModule
    Injector injector = Guice.createInjector(new AppModule());
 
    // userController already got its proper DAO instance injected
    UserController userController = injector.getInstance(UserController.class);
 
    boolean isLoggedIn = userController.login("Foo", "Bar");
  }
}

Or use your special configuration for unit test:

public class UserControllerTest {
 
  private UserController userController;
 
  @Before
  public void setup() {
    // configure Guice with TestModule, instead with AppModule
    Injector injector = Guice.createInjector(new TestModule());
    this.userController = injector.getInstance(UserController.class);
´ }
 
  // some tests...
 
}

[Bearbeiten] Links

http://code.google.com/p/google-guice/ ... Official Guice website
http://docs.google.com/View?docid=dd2fhx4z_5df5hw8 ... Official userguide
http://crazybob.org/2007/06/introduction-to-guice-video-redux.html ... Presentation about Guice
http://www.youtube.com/watch?v=FFXhXZnmEQM ... Other presentation about Guice

[Bearbeiten] Springframework

Download the slides (pdf, 0.6MB).
You can also view the slides online.

[Bearbeiten] Agenda

Short introduction to the Springframework
Basic declaration of beans
Medieval times (evolution of Spring)
Advanced features (just a preview)
Demo

[Bearbeiten] Content

Spring should be part of every Java application today; at least so says the lecturer Christoph Pickl. If it is not Spring, it should be any other framework which enables dependency injection. Spring ...

... is a leightweight inversion of control and aspect oriented container framework.
... makes developing JEE applications easier and more fun!

Spring's mission statements are:

JEE should be easier to use.
It is best to program to interfaces, rather than classes [...]
JavaBeans offer a great way of configuring applications.
OO is more important than any implementation technology [...]
Checked exceptions are overused in Java [...]
Testability is essential [...]

Each and every bean declarations got a beans root node declaring some namespaces:

<?xml version="1.0" encoding="UTF-8"?>
<!-- <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
     "http://www.springframework.org/dtd/spring-beans.dtd"> -->
<beans
  xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"
>
 
  <!-- define your beans here -->
 
</beans>

One could, for example, define a single dao-instance, and reuse that instance by injecting it into different controller classes:

<!-- this is our first (singleton) bean -->
<bean id="myDao" class="jsug.MyDao" />
 
<bean id="myCtrl1" class="jsug.MyController1">
  <!-- invokes MyController1.setDao(MyDao) -->
  <property name="dao">
    <ref bean="myDao" />
  </property>
</bean>
 
<!-- share same dao in second controller -->
<bean id="myCtrl2" class="jsug.MyController2">
  <property name="dao">
    <ref bean="myDao" />
  </property>
</bean>

Using the springframework today is very non-intrusive. Just load your application context and that's it:

// single code dependency to spring throughout our whole application
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class App {
  public static void main(String[] args) {
    String[] beanDefinitions = { "/beans.xml" };
    new ClassPathXmlApplicationContext(beanDefinitions);
  }
 
  public App() {
    // spring will invoke this constructor for us
  }
 
  public void init() {
    // and spring will also invoke this initialize method for us
  }
}

Sometimes, your beans have to be initialized via a certain method. To do this, declare your bean as follows:

<bean id="myBean" class="jsug.MyBean" init-method="init">
  <constructor-arg index="0" value="someStringValue" />
  <constructor-arg index="1" ref="someOtherBean" />
  <property name="firstName" value="Christoph" />
</bean>

The corresponding class:

public class MyBean {
 
  private final String someString;
  private String firstName;
 
  // #1 first of all, the bean will be created with proper constructor args
  public MyBean(String someString, Bean b) {
    this.someString = someString;
  }
 
  // #2 afterwards, all properties will be set via setter methods
  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }
 
  // #3 finally, the initialize method will get invoked
  public void init() {
    // initialize bean in here
  }
}