Spring framework core

Spring Framework
Core
2st WEEK
30 Jun
GEEKY ACADEMY 2013

2 | GEEK ACADEMY 2013
INSTRUCTOR TEAM
SALAHPIYA
Salah (Dean) Chalermthai
Siam Chamnan Kit
SChalermthai@sprint3r.com
Piya (Tae) Lumyong
-
piya.tae@gmail.com

Topic
• Introduction to Spring
• Basic bean
• IoC Container
• Bean Lifecycle
• Annotation

Introduction to Spring
GEEK ACADEMY 2013

Introduction to Spring
• What's Spring
• Dependency Injection
• Module of Spring
• Usage scenarios

What's Spring
• Goals
– make Enterprise Java easier to use
– promote good programming practice
– enabling a POJO-based programming model that is applicable in
a wide range of environments
• Some said Spring is just a “glue” for connecting all state of the art
technologies together (a.k.a Integration Framework) via it’s Application
Context.
• Heart and Soul of Spring is Dependency Injection and Aspect Oriented
Programming.

What is Spring Framework today?
• an open source application framework
• a lightweight solution for enterprise applications
• non-invasive (POJO based)
• is modular
• extendible for other frameworks
• de facto standard of Java Enterprise Application

Dependency Injection/Inversion of Control

Dependency Injection/Inversion of Control
• ทั่วไป • DI
Hollywood Principle: "Don't call me, I'll call you."

Module of Spring

Full-fledged Spring web application

Using a third-party web framework

Remoting usage

EJBs - Wrapping existing POJOs

LAB1 Setup/Basic DI

public interface MovieFinder {
public List<Movie> findMovie();
}
public class MovieLister {
private MovieFinder finder;
public MovieLister(MovieFinder finder) {
this.finder = finder;
}
public void listMovie() {
...
}
}
public class MovieFinderImpl2 implements MovieFinder {
private List<Movie> movies;
public MovieFinderImpl2(InputStream is) {
movies = new ArrayList<Movie>();
try {
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line;
while ((line=br.readLine())!=null) {
String[] csv = line.split("||");
movies.add(new Movie(csv[0], csv[1], Float.parseFloat(csv[2])));
}
} catch (IOException e) {}
}
@Override
public List<Movie> findMovie() {
return movies;
}
}
public class Assembler {
public static void main(String[] args) {
InputStream is = Assembler.class.getClass()
.getResourceAsStream("/movie.csv");
MovieFinder finder = new MovieFinderImpl2(is);
MovieLister lister = new MovieLister(finder);
lister.listMovie();
}
}
public class MovieListerTest {
@Test
public void testListMovie() {
//given
MovieFinder finder = mock(MovieFinder.class);
when(finder.findMovie()).thenReturn(new ArrayList<Movie>());
MovieLister lister = new MovieLister(finder);
//when
lister.listMovie();
//then
verify(finder).findMovie();
}
}
public class MovieFinderImpl2Test {
@Test
public void testFindMovie() {
//given
InputStream is = this.getClass().getResourceAsStream("/test-movie.csv");
MovieFinder finder = new MovieFinderImpl2(is);
//when
List<Movie> results = finder.findMovie();
//then
assertEquals(6, results.size());
}
}
LAB1 Setup/Basic DI

Basic bean
• What is bean?
• Creating bean
• Bean scope
• IoC Container
• Additional Features
• Bean Life cycle

What is bean?
• The objects that form the backbone of your application and that
are managed by the Spring IoC container are called beans.
• A bean is an object that is instantiated, assembled, and
otherwise managed by a Spring IoC container.
• These beans are created with the configuration metadata that
you supply to the container, for example, in the form of XML
<bean/> definitions which you have already seen in previous
chapters.

Creating bean
• Declaring a simple bean.
<bean id="hello" class="mypackage.HelloWorld" />
HelloWorld hello = new mypackage.HelloWorld();

Creating bean
• Injecting through constructors.
<bean id="hello" class="mypackage.HelloWorld">
<constructor-arg value="Hello World" />
</bean>
HelloWorld hello = new mypackage.HelloWorld(“Hello World”);

Creating bean
• Creating bean form factory.
<bean id="md5Digest"
class="java.security.MessageDigest"
factory-method="getInstance">
<constructor-arg value="MD5"/>
</bean>
MessageDigest md5Digest = new java.security.MessageDigest
.getInstance(“MD5”);

Injecting into bean properties
• Injecting simple values.
<bean id="hello" class="mypackage.HelloWorld">
<property name=”message” value="Hello World" />
</bean>
HelloWorld hello = new mypackage.HelloWorld();
hello.setMessage(“Hello World”);

• References to other beans (collaborators).
<bean id="msgService" class="mypackage.MessageService">
<property name=”messageProvider” ref="hello" />
</bean>
HelloWorld hello = …
MessageService msgService = new
mypackage.MessageService();
msgService.setMessageProvider(hello);

• Inner beans
<bean id="outer" class="...">

<property name="target">

<bean class="com.mycompany.Person">
<property name="name" value="Fiona Apple"/>
<property name="age" value="25"/>
</bean>
</property>
</bean>

• Collections
– java Collection type (List, Set, Map, and Properties)
– <list/>, <set/>, <map/>, <props/>
<list>
<value>
<bean … />
</value>
<ref bean="somebean" />
</list>
<props>
<prop key="admin">admin@company.org</prop>
<prop key="support">support@company.org</prop>
<prop key="develop">develop@company.org</prop>
</props>

• Nulls
<property name=“target”>
<null />
</property>

• p-namespace
– Using xml schema "http://www.springframework.org/schema/p"
<bean name="john-classic" class="com.mycompany.Person">
<property name="name" value="John Doe"/>
<property name="spouse" ref="jane"/>
</bean>
<bean name="john-modern"
class="com.mycompany.Person“
p:name="John Doe"
p:spouse-ref="jane"/>

• Spring Expression Language – SpEL (v3.0)
<bean id="numberGuess" class="org.spring.samples.NumberGuess">
<property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }" />

</bean>
<bean id="shapeGuess" class="org.spring.samples.ShapeGuess">

<property name="initialShapeSeed" value="#{ numberGuess.randomNumber }" />

</bean>

Bean Scope
• Control bean creation in spring context.
• Default scope is singleton.

Bean Scope
• Singleton scope

Bean Scope
• Prototype scope

Bean Scope
• Other scopes
– request, session, and global session are only used in
web-based applications.
• Custom scopes – Spring Framework Reference

IoC Container
GEEK ACADEMY 2013

IoC Container
• Lightweight Container
• Application lifecycle
• Container Overview
• Configuration metadata
• Instantiating a container

Lightweight Container
• Lifecycle management
• Lookup
• Configuration
• Dependency resolution

Lightweight Container(Feature Added)
• Transaction
• Thread management
• Object pooling
• Clustering
• Management
• Remoting
• Exposing remote services
• Consuming remote services
• Customization and extensibility
• AOP

Application lifecycle

Container Overview
• Essence of IoC container

Configuration metadata
• XML-based configuration metadata
• Annotation-based configuration metadata (v2.5)
– Java-based configuration (3.0) provided by Spring
JavaConfig project

• XML-based configuration
<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd">
<bean id="..." class="...">

</bean>
<bean id="..." class="...">

</bean>

</beans>

• Java-based configuration (v3.0)
@Configuration
public class AppConfig {
@Bean
public MyService myService() {
return new MyServiceImpl();
}
}
<beans>
<bean id="myService" class="com.acme.services.MyServiceImpl"/>
</beans>

Instantiating a container
• ApplicationContext represents the Spring IoC container
ApplicationContext context =
new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});
ApplicationContext ctx =
new AnnotationConfigApplicationContext(MyService.class, Dependency1.class, Dependency2.class);
GenericXmlApplicationContext context = new GenericXmlApplicationContext();
context.getEnvironment().setActiveProfiles("production", "no-jms");
context.load("spring-master.xml");
context.refresh();

Using the container
// retrieve configured instance
PetStoreService service = context.getBean("petStore", PetStoreService.class);
// use configured instance
List userList = service.getUsernameList();

Additional features

Additional features
• Bean definition inheritance
• Importing configuration files
• Using depends-on
• Lazy-initialized beans
• Property Placeholder

Bean definition inheritance
• Declaring parent and child beans

Bean definition inheritance
<bean id="inheritedTestBeanWithoutClass" abstract="true">
<property name="name" value="parent"/>
<property name="age" value="1"/>
</bean>
<bean id="inheritsWithClass" class="org.springframework.beans.DerivedTestBean"
parent="inheritedTestBeanWithoutClass" init-method="initialize">
<property name="name" value="override"/>

</bean>
<bean id="inheritsWithClass2" class="org.springframework.beans.DerivedTestBean"
...
</bean>
<bean id="inheritsWithClass3" class="org.springframework.beans.DerivedTestBean"
...
</bean>
• Declaring parent and child beans

Importing configuration files
• xml-context-config.xml
• xml-service-config.xml
• xml-repository-config.xml
<beans>
<import resource="classpath:xml-repository-config.xml"/>
<import resource="classpath:xml-service-config.xml"/>
</beans>
<beans>
<bean id="finder" class="mypackage.MovieFinder"/>
</beans>
<beans>
<bean id="lister" class="mypackage.MovieLister">
<constructor-arg ref="finder"/>
</bean>
</beans>

Using depends-on
• Bean dependency
– one bean is set as a property of another
– accomplish this with the <ref/> element in XML-based
configuration metadata
– sometimes dependencies between beans are less direct
• For example, a static initializer in a class needs to be
triggered, such as database driver registration.

Using depends-on
<bean id="beanOne" class="ExampleBean" >
<property name="manager" ref="manager" />
</bean>
<bean id="manager" class="ManagerBean" />
<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
<property name="manager" ref="manager" />
</bean>
<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />
• Direct Dependency
• Indirect Dependency

Lazy-initialized beans
• IoC container create a bean instance when it is first requested
<bean id="lazy" class="ExpensiveToCreateBean" lazy-init="true"/>

Property Placeholder
<context:property-placeholder location="classpath:com/foo/jdbc.properties"/>
<bean id="dataSource" destroy-method="close"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:hsql://production:9002
jdbc.username=sa
jdbc.password=root

LAB2 Wiring Bean

LAB2 Wiring Bean
MovieFinder
MovieFinderImpl2
MovieLister
CheckSum
Spring Container
Assembler

Bean Lifecycle
GEEK ACADEMY 2013

Bean Lifecycle
• Bean Lifecycle
• Lifecycle Callback
• Bean Aware
• FactoryBean
• Extension Points

Bean Life cycle

Lifecycle Callback
• Implement Interface
– InitializingBean.afterPropertiesSet()
– DisposableBean.destroy()
• <bean/> element
– Init-method attribute
– destroy-method attribute
<bean id="exampleInitBean" class="examples.ExampleBean" init-method="init"/>
<bean id="exampleInitBean" class="examples.ExampleBean" destroy-method="cleanup"/>
@PostConstruct
@PreDestroy
Internally, the Spring Framework uses BeanPostProcessor implementations
to process any callback interfaces it can find and call the appropriate methods.

Bean Aware
• Spring offers a range of Aware interfaces that
allow beans to indicate to the container that they
require a certain infrastructure dependency.
– ApplicationContextAware - Declaring ApplicationContext
– BeanFactoryAware - Declaring BeanFactory
– BeanNameAware - Name of the declaring bean
– ResourceLoaderAware - Configured loader for low-level access to resources
– ServletConfigAware - Current ServletConfig the container runs in. Valid only in a
web-aware Spring ApplicationContext
– ServletContextAware - Current ServletContext the container runs in. Valid only
in a web-aware Spring ApplicationContext
– Etc.

Customizing instantiation logic with a FactoryBean
• FactoryBean interface is a point of pluggability into the Spring
IoC container's instantiation logic for complex initialization
bean.
public interface FactoryBean<T> {
/** Return an instance of the object managed by this factory. */
T getObject() throws Exception;
/** Return the type of object that this FactoryBean creates. */
Class<?> getObjectType();
/** Is the object managed by this factory a singleton? */
boolean isSingleton();
}
<bean id="bean" class="MyFactoryBean"/>

Container Extension Points
• Container Extension Points – Spring Framework Reference
– BeanPostProcessor
• InitDestroyAnnotationBeanPostProcessor
• RequiredAnnotationBeanPostProcessor
– BeanFactoryPostProcessor
• PropertyPlaceholderConfigurer
• PropertyOverrideConfigurer

Container Extension Points
• Becareful
– Note also that BeanPostProcessors registered programmatically are always processed before
those registered through auto-detection, regardless of any explicit ordering.
– Note that if you have beans wired into your BeanPostProcessor using autowiring or @Resource
(which may fall back to autowiring), Spring might access unexpected beans when searching for
type-matching dependency candidates, and therefore make them ineligible for auto-proxying or other
kinds of bean post-processing. For example, if you have a dependency annotated with @Resource where
the field/setter name does not directly correspond to the declared name of a bean and no name attribute
is used, then Spring will access other beans for matching them by type.
• This means that if you have @Transactional in a bean that is loaded in reference to a
BeanPostProcessor, that annotation is effectively ignored.
• The solution generally would be that if you need transactional behavior in a bean that has to
be loaded in reference to a BeanPostProcessor, you would need to use non-AOP transaction
definitions - i.e. use TransactionTemplate.
• Container Extension Points – Spring Framework Reference

Forget It !!!

Annotation
• Annotation-based container configuration
• Classpath scanning and managed components
• Java-based container configuration

Annotation-based container configuration
• Stereotypical
@Component
@Repository @Service @Controller @Configuration
Any Component
Data access Service classes Spring MVC Java Config

• Basic annotations (1)
– Spring Annotations
• @Autowired
• @Qualifier
• @Required
• @Value
– JSR 250 (Common Annotations for the
Java)
• @Resource
• @PostConstruct
• @PreDestroy
– JSR 330 (Dependency Injection for
Java)
• @Inject
• @Named
• @Scope
• @Singleton
• @Named

• Basic annotations (2)
– Spring Context
• @Scope
• @Bean
• @DependsOn
• @Lazy
– Transactional
• @Transactional

@Value
@Component("ejbAccessService")
public class EjbAccessService {
/** The provider api connection url. */
@Value("${provider.api.url}")
private String apiUrl;
/** The provider api connection username. */
@Value("${provider.api.username}")
private String apiUsername;
/** The provider api connection password. */
@Value("${provider.api.password}")
private String apiPassword;
...
}
provider.api.url=corbaloc:iiop:localhost:2809
provider.api.username=Administrator
provider.api.password=password
<context:property-placeholder
location="classpath:META-INF/provider.properties"
properties-ref="providerProps" />
<util:properties id="providerProps">
<prop key="provider.api.url">t3://127.0.0.1:7001</prop>
<prop key="provider.api.username">weblogic</prop>
<prop key="provider.api.password">weblogic</prop>
</util:properties>
Properties
placeholders

@Autowired (1)
@Service("accountService")
public class AccountServiceImpl {
@Autowired
private AccountRepository repository;
@Autowired
public AccountServiceImpl(AccountRepository repository) {}
@Autowired(required = false)
public void setRepository(AccountRepository repository) {}
@Autowired
public void populate(Repository r, OrderService s) {}
...
}
Matches by Type → Restricts by Qualifiers → Matches by Name

@Autowired (2)
@Service
@Autowired
private AccountRepository[] repositories;
@Autowired
public AccountServiceImpl(Set<AccountRepository> set) {}
@Autowired(required = false)
public void setRepositories(Map<String,AccountRepository> map){}
...
}

@Required
@Required
public void setRepository(AccountRepository repository) {}
...
}
<bean name="accountService" class="AccountServiceImpl">
<property name="repository" ref="accountRepository"/>
</bean>

@Qualifier
public class ReportServiceImpl {
@Autowired
@Qualifier("main")
private DataSource mainDataSource;
@Autowired
@Qualifier("freeDS")
private DataSource freeDataSource;
...
}
<beans>
<bean class="org.apache.commons.dbcp.BasicDataSource">
<qualifier value="main"/>
</bean>
<bean id="freeDS" class="org.apache.commons.dbcp.BasicDataSource"/>
...
</beans>

@Scope
@Service
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class AccountServiceImpl implements AccountService {
...
}

@Lazy & @DependsOn
@Lazy
@Service
@DependsOn({"orderService", "currencyService"})
...
}

Factory method component
@Component
public class CurrencyRepositoryFactory {
@Bean
@Lazy
@Scope("prototype")
@Qualifier("public")
public CurrencyRepository getCurrencyRepository() {
return new CurrencyMapRepository();
}
}

JSR 250 @Resource
@Resource(name = "orderService")
private OrderService orderService;
@Resource(name = "orderService")
public void setOrderService(OrderService orderService) {}
@Resource
private AuditService auditService;
@Resource
public void setAuditService(AuditService auditService) {}
...
}
If no name is specified explicitly, the default name is derived from the field name or setter method.
If no explicit name specified, and similar to @Autowired, @Resource finds a primary type match instead of a specific named bean.
Matches by Name → Matches by Type → Restricts by Qualifiers (ignored if match is found by name)

Spring Annotation vs JSR-330
Spring JSR-330
@Autowired @Inject Has no 'required' attribute
@Component @Named
@Scope @Scope Only for meta-annotations and injection points
@Scope @Singleton Default scope is line 'prototype'
@Qualifier @Named
@Value X
@Required X
@Lazy X

JSR 330
@Named
@Singleton
@Inject
@Inject
public AccountServiceImpl(@Named("default") AccountRepository r) {}
@Inject
public void setAccountRepository(AccountRepository repository) {}
...
}
@Inject Matches by Type → Restricts by Qualifiers → Matches by Name

Classpath scanning and managed components
• Basic Configuration

<context:annotation-config/>

<context:component-scan
base-package="org.bank.service,org.bank.repository">

LAB3 Annotation-based

Java-based container configuration
• Annotation-based configuration metadata
@Configuration
public class BankConfg {
@Bean
public TransferService createTransferService() {
return new TransferServiceImpl();
}
@Bean(name = "exchangeService", initMethod = "init")
public Exchange createExchangeService() {
return new ExchangeServiceImpl();
}
}

Java-based container configuration
ApplicationContext context
= new AnnotationConfigApplicationContext(BankConfig.class);
• Instantiating a container
– Scanning
ApplicationContext context = new AnnotationConfigApplicationContext();
context.scan("org.bank.config");
context.refresh();

@Import
@Configuration
@Import({RepositoryConfig.class, ServiceConfig.class})
public class BankConfig {
...
}
@Configuration
public class RepositoryConfg {
...
}
@Configuration
public class ServiceConfig {
...
}

@ImportResources
@Configuration
@ImportResource("classpath:spring-master.xml")
public class BankConfig {
@Value("${jdbc.url}")
private String jdbcUrl;
@Bean
public DataSourse dataSource() {
return new SimpleDataSource(jdbcUrl);
}
}
jdbc.url=jdbc:derby://localhost:1527/test
jdbc.user=admin
jdbc.password=password
<context:property-placeholder
location="classpath:META-INF/jdbc.properties" />
Properties
placeholders

Dependency injection
@Configuration
public class BankServiceConfig {
@Autowired
private CurrencyRepository currencyRepository;
@Bean
public CurrencyService currencyService() {
return new CurrencyServiceImpl(currencyRepository);
}
@Bean(name = {"orderBuilder", "builder"})
public OrderBuilder orderBuilder() {
return new OrderBuilder(currencyService());
}
}

Approach to configuration
• XML
– infrastructure beans
• Annotations
– working beans
• Java
– an alternative to the FactoryBean

LAB4 Java-based

Links
• SpringSource
• Spring Reference 3.2
• Thank for
– Dmitry Noskov

THANK YOU FOR
YOUR TIME
GEEK ACADEMY 2013

Spring framework core

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Spring framework core

Ähnlich wie Spring framework core (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Spring framework core