Spring Hello World

8/3/2019 Spring Hello World

1/57

1

Spring Framework:Spring Framework:RefactoringRefactoring

Helloworld ApplicationHelloworld Application

Sang ShinSang Shinwww.JavaPassion.comwww.JavaPassion.com

Learn with Passion!Learn with Passion!

1


2/57

2

Theme of this Presentation

How a simple HelloWorldapplication can berefactored in order to achieve the agility (andtestability)?

How can I change a certain part of an applicationwithout affecting other parts of the code?

How can I wire different parts of the applicationwithout writing a lot of glue code myself?

How can I test the business logic without being tied

up with a particular framework?


3/57

3

Refactoring HelloWorld Application

1.HelloWorld2.HelloWorld with command line arguments

3.HelloWorld with decoupling without using Interface

4.HelloWorld with decoupling using Interface

5.HelloWorld with decoupling through Factory

6.HelloWorld using Spring framework as a factory classbut not using DI (Dependency Injection)

7.HelloWorld using Spring framework's DI

8.HelloWorld using Spring framework's DI and XMLconfiguration file

9.HelloWorld using Spring framework's DI and XMLconfiguration file with constructor argument


4/574

1. HelloWorld Application1. HelloWorld Application


5/575

HelloWorld

// This is a good old HelloWorld application we all have written

// the first time we learn Java programming.

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello World!");

}}


6/576

HelloWorld: Outstanding Problems

This code is not extensible. You have changecode (and recompile) to handle a situationbelow.

What if I want to change the message?


7/57

7

HelloWorld: Areas for Refactoring

Support a simple and flexible mechanism forchanging the message


8/57

8

2. HelloWorld Application2. HelloWorld Applicationwith Command Linewith Command Line

ArgumentsArguments


9/57

9

HelloWorld With Command Line

argumentspublic class HelloWorldWithCommandLine {

public static void main(String[] args) { if(args.length > 0) {

System.out.println(args[0]);} else {

System.out.println("Hello World!");}

}

}


10/57

10


arguments: Areas Refactored This code externalize the message content and

read it in at runtime, from the command line

argument You can change the message without changing and

recompiling the code


11/57

11


arguments: Outstanding Problems The code responsible for the rendering

message (renderer the code that doesprintln)is also responsible for obtaining the message Changing how the message is obtained means

changing the code in the renderer

The renderer cannot be changed easily What if I want to output the message differently,

maybe to stderr instead of stdout, or enclosed inHTML tags rather than as plain text?


12/57

12

HelloWorld With Command Linearguments: Areas for Further Refactoring

Rendering logic should be in a logically separatecode from the rest of the code

Message provider logic should be in a logicallyseparate code from the rest of the code


13/57

13


with Decoupling (withoutwith Decoupling (withoutusing Interface)using Interface)


14/57

14

HelloWorld With Decoupling

De-couple message provider logicimplementation from the rest of the code bycreating a separate class

public class HelloWorldMessageProvider {

public String getMessage() {return "Hello World!";

}

}


15/57

15

HelloWorld With Decoupling De-couple message rendering logic implementation from

the rest of the code Message rendering logic is given

HelloWorldMessageProviderobject by someone (code is inthe next slide) this is Dependency Injection behavior

public class StandardOutMessageRenderer{

private HelloWorldMessageProvider messageProvider = null;

public void render() {

if (messageProvider== null) {throw new RuntimeException("You must set the property messageProvider of class:"

+ StandardOutMessageRenderer.class.getName());}

System.out.println(messageProvider.getMessage());

}// continued


16/57

16


// continued from previous page

public void setMessageProvider(HelloWorldMessageProviderprovider) {

this.messageProvider = provider;}

public HelloWorldMessageProvider getMessageProvider() {

return this.messageProvider;}

}


17/57

17


Launcher

public class HelloWorldDecoupled {

public static void main(String[] args) {StandardOutMessageRenderer mr =

new StandardOutMessageRenderer();HelloWorldMessageProvider mp =

new HelloWorldMessageProvider();

mr.setMessageProvider(mp);mr.render();

}}


18/57

18

HelloWorld With Decoupling: Areas

Refactored Message provider logic and message renderer

logic are separated from the rest of the code


19/57

19

HelloWorld With Decoupling:

OutstandingProblems A particular message provider

(HelloWorldMessageProvider) is hard-coded inthe message renderer Usage of different message provider in the message

renderer requires a change in the message renderer

public class StandardOutMessageRenderer {

private HelloWorldMessageProvidermessageProvider = null;...


20/57

20

HelloWorld With Decoupling: Areas

for Further Refactoring Let these components implement interfaces User of a component uses interface as a

reference type


21/57

21


with Decoupling Usingwith Decoupling UsingInterfaceInterface


22/57

22

HelloWorld With Decoupling (Using

Interface) Message provider logic now uses Java

interface

public interface MessageProvider {public String getMessage();}

public class HelloWorldMessageProviderimplements MessageProvider {

public String getMessage() {return "Hello World!";

}

}


23/57

23

HelloWorld With Decoupling (usingInterface)

Message rendering logic is given MessageProviderobject instance by someone this is DependencyInjection behavior

public interface MessageRenderer {

public void render();

public void setMessageProvider(MessageProviderprovider);

public MessageProvidergetMessageProvider();}


24/57

24


public class StandardOutMessageRendererimplements MessageRenderer {

// MessageProvider is Java Interface private MessageProvidermessageProvider = null;

public void render() {if (messageProvider == null) {

throw new RuntimeException(

"You must set the property messageProvider of class:"+ StandardOutMessageRenderer.class.getName());}System.out.println(messageProvider.getMessage());

}

// Continued to the next page


25/57

25


// MessageProvider is Java Interfacepublic void setMessageProvider(MessageProviderprovider) {

this.messageProvider = provider;}

// MessageProvider is Java Interfacepublic MessageProvidergetMessageProvider() {

return this.messageProvider;}

}


26/57

26


Launcher

public class HelloWorldDecoupled {

public static void main(String[] args) { MessageRenderermr = new StandardOutMessageRenderer(); MessageProvidermp = new HelloWorldMessageProvider();


}}


27/57

27

HelloWorld With Decoupling (usingInterface): Areas Refactored

Message rendering logic does not get affectedby the change in message providerimplementation


28/57

28

HelloWorld With Decoupling:OutstandingProblems

Using different implementation of either theMessageRendererorMessageProviderinterfaces means a change to the business logic

code (launcher in this example)


29/57

29

HelloWorld With Decoupling: Areasfor Further Refactoring

Create a simple factory class that reads theimplementation class names from a propertiesfile and instantiate them during runtime on

behalf of the application


30/57

30


with Decoupling throughwith Decoupling throughFactory classFactory class


31/57

31

HelloWorld With Factory Classpublic class MessageSupportFactory {

private static MessageSupportFactory instance = null;private Properties props = null;private MessageRenderer renderer = null;private MessageProvider provider = null;

private MessageSupportFactory() {props = new Properties();try {

props.load(new FileInputStream("msf.properties"));

// get the implementation classesString rendererClass = props.getProperty("renderer.class");String providerClass = props.getProperty("provider.class");

renderer = (MessageRenderer) Class.forName(rendererClass).newInstance();provider = (MessageProvider) Class.forName(providerClass).newInstance();

} catch (Exception ex) {ex.printStackTrace();

}}


32/57

32

HelloWorld With Factory Class

static {instance = new MessageSupportFactory();

}

public static MessageSupportFactory getInstance() {return instance;

}

public MessageRenderer getMessageRenderer() {return renderer;

}

public MessageProvider getMessageProvider() {return provider;

}

}


33/57

33

HelloWorld With Factory Class

public class HelloWorldDecoupledWithFactory {

public static void main(String[] args) { MessageRenderer mr =

MessageSupportFactory.getInstance().getMessageRenderer();

MessageProvider mp =MessageSupportFactory.getInstance().getMessageProvider();mr.setMessageProvider(mp);mr.render();

}}


34/57

34

HelloWorld With Factory Class:Properties file

# msf.propertiesrenderer.class=StandardOutMessageRendererprovider.class=HelloWorldMessageProvider


35/57

35

HelloWorld With Decoupling: AreasRefactored

Message provider implementation and Messagerenderer implementation can be replaced simplyby changing the properties file No change is required in the business logic code

(launcher)


36/57

36

HelloWorld With Factory:Outstanding Problems

You still have to write a lot of glue code yourselfto assemble the application together You have to write MessageSupportFactoryclass

You still have to inject an instance ofMessageProviderinto the implementation ofMessageRendereryourself

The above is called wiring


37/57

37

HelloWorld With Factory: Areas forFurther Refactoring

We can use Spring framework to handle thewiring

Replace MessageSupportFactoryclass with

Spring framework's DefaultListableBeanFactoryclass You can think ofDefaultListableBeanFactoryclass

as a more generic version of

MessageSupportFactoryclass


38/57

38


with Spring Frameworkwith Spring Framework(but not using DI feature(but not using DI featureyet)yet)


39/57

39

HelloWorld With Spring Framework

public class HelloWorldSpring {

public static void main(String[] args) throws Exception {

// Get the bean factory - the code of getBeanFactory() is in the next slideBeanFactory factory = getBeanFactory();

MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");MessageProvider mp = (MessageProvider) factory.getBean("provider");


}

// Continued in the next page


40/57

40

HelloWorld With Spring Framework(No need to understand this code)

// You write your own getBeanFactory() method using Spring framework's// DefaultListableBeanFactoryclass.

private static BeanFactory getBeanFactory() throws Exception {// get the bean factoryDefaultListableBeanFactory factory = new DefaultListableBeanFactory();

// create a definition readerPropertiesBeanDefinitionReader rdr = new PropertiesBeanDefinitionReader(

factory);

// load the configuration options

Properties props = new Properties();props.load(new FileInputStream("beans.properties"));

rdr.registerBeanDefinitions(props);

return factory;

}


41/57

41

HelloWorld With SpringFramework: Areas Refactored

Removed the need of your own glue code(MessageSupportFactory)

Gained a much more robust factory

implementation with better error handling andfully de-coupled configuration mechanism


42/57

42

HelloWorld With SpringFramework: Outstanding Problems

The startup code must have knowledge of theMessageRenderer's dependencies and mustobtain dependencies and pass them to the

MessageRenderer Spring acts as no more than a sophisticated factory

class creating and supplying instances of classes asneeded in this case

You are providing your own getBeanFactory()method using low-level API's of Spring framework


43/57

43

HelloWorld With Spring Framework:Areas for Further Refactoring

Use Dependency Injection (DI) of the SpringFramework Glue the application together externally using the

BeanFactory configuration


44/57

44


using Spring Framework &using Spring Framework &Dependency Injection (DI)Dependency Injection (DI)

S


45/57

45

HelloWorld using SpringFramework's DI#Message rendererrenderer.class=StandardOutMessageRenderer# Ask Spring to assign provider bean to the MessageProvider property# of the Message renderer bean (instead of you doing it manually)renderer.messageProvider(ref)=provider

#Message providerprovider.class=HelloWorldMessageProvider

H ll W ld i S i


46/57

46

HelloWorld using SpringFramework's DIpublic class HelloWorldSpringWithDI {

public static void main(String[] args) throws Exception {

// get the bean factory

BeanFactory factory = getBeanFactory();

MessageRenderer mr = (MessageRenderer) factory.getBean("renderer");

// Note that you don't have to manually inject message provider to// message renderer anymore.

mr.render();

}

// Continued in the next page

H ll W ld i S i


47/57

47

HelloWorld using SpringFramework's DI

private static BeanFactory getBeanFactory() throws Exception {// get the bean factoryDefaultListableBeanFactory factory = new DefaultListableBeanFactory();

// create a definition reader

PropertiesBeanDefinitionReader rdr = new PropertiesBeanDefinitionReader(factory);

// load the configuration optionsProperties props = new Properties();props.load(new FileInputStream("beans.properties"));

rdr.registerBeanDefinitions(props);

return factory;}

}

H ll W ld i S i


48/57

48

HelloWorld using SpringFramework's DI: Areas Refactored

The main() method now just obtains theMessageRendererbean and calls render() It does not have to obtain MessageProvider bean

and set the MessageProvider property of theMessageRenderer bean itself.

This wiring is performed through Springframework's Dependency Injection.


49/57

49

A Few Things to Observe

Note that we did not have to make any changesto the classes (components) that are beingwired together

These classes have no reference to Springframework whatsoever and completely obliviousto Spring framework's existence No need to implement Spring framework's interfaces

No need to extend Spring framework's classes These classes are genuine POJO's which can

be tested without dependent on Springframework


50/57

50

8. HelloWorld Application8. HelloWorld Applicationwith Spring Framework &with Spring Framework &

Dependency Injection (DI)Dependency Injection (DI)using XML Configuration Fileusing XML Configuration File


51/57

51

Spring DI with XML file

Dependencies of beans are specified in an XMLfile XML based bean configuration is more popular than

properties file based configuration


52/57

52

Spring DI with XML Configuration File


53/57

53

Spring DI with XML Configuration Filepublicclass HelloWorldSpringWithDIXMLFile {

publicstaticvoidmain(String[] args) throws Exception {


BeanFactory factory = getBeanFactory();

MessageRenderer mr =

(MessageRenderer) factory.getBean("renderer");mr.render();

}

privatestatic BeanFactory getBeanFactory() throws Exception {


BeanFactory factory =new ClassPathXmlApplicationContext("/beans.xml");

return factory;

}

}


54/57

54

9. HelloWorld Application9. HelloWorld Applicationwith Spring Framework &with Spring Framework &

Dependency Injection (DI)Dependency Injection (DI)using XML Configuration Fileusing XML Configuration Filewith Constructor argumentwith Constructor argument

Spring DI with XML Configuration File:


55/57

55

Spring DI with XML Configuration File:via Constructor

This is a configurable message

Spring DI with XML Configuration File:


56/57

56

Spring DI with XML Configuration File:via Constructor

public class ConfigurableMessageProvider implements

MessageProvider {

private String message;

public ConfigurableMessageProvider(String message) {

this.message = message;

}

public String getMessage() {

return message;

}

}


57/57

57

Thank you!Thank you!

Check JavaPassion.com Codecamps!Check JavaPassion.com Codecamps!

http://www.javapassion.com/codecampshttp://www.javapassion.com/codecamps

Learn with Passion!Learn with Passion!

57
http://www.javapassion.com/codecampshttp://www.javapassion.com/codecampshttp://www.javapassion.com/codecamps

Documents

Spring Hello World