Spring By Example One Day Workshop

Spring By ExampleOleksiy RezchykovEugene Scripnik

SpringByExample.com.ua @ua_spring

2

About us Software Engineers

Working with Spring since 2006

Pragmatic programmers

SpringByExample.com.ua founders


3

Contents Intro

IoC using Spring

Persistence with Spring

Web applications with Spring MVC


4

Intro What we will do today?

Meet some new faces

Learn some new stuff

Code some new stuff


5

SpringFramework history

In October 2002 Rod Johnson wrote his famous book

The first milestone release 1.0 - June 2004

Company renamed from Interface21 to SpringSource in 2007

SpringSource acquired by VMWare in 2009


6

Spring in 2012


7

IoC using Spring Buiding xml contexts

Bean scopes & lifecycles

Constructor vs Setter injection

Property placeholders

p & c and util name spaces

Annotation context

Using component scan

AOP usage

Spring AOP vs AspectJ


8

Inversion of Control Inversion of regular approach where object

was responsible for satisfying it’s own dependencies

Implementation of Dependency Injection

Container instantiates and wires dependencies


9

IoC Pros vs Cons (to discuss)


10

Injection types Setter injection– when you are using setter to

fulfill bean dependency

Constructor injection – when constructor is called to set-up a bean with dependencies


11

CI vs SI Pro vs Cons (to discuss)


12

Context An object which contains beans declarations

with their dependencies

BeanFactory interface implementation


13

XML namespaces


14

Context


15

Context usage


16

Bean lifecycle Depends on scope and lazy initialization

Main bean scopes:

Singleton and Prototype

(Also there are multiple web scopes)


17

Bean instantiation order


18

Bean Post-processingBea

n instantiation

• Bean instantiated for singletons with eager initialization

Dependency

injection

• Dependencies are injected into beans

Bean

post-

processing

• Bean post-processing actions• You can put your custom logic

in here


19

Property Editors


20

Multiple config files


21

Bean definition inheritance


22

Inner Beans


23

Factory Method


24

Map, List, Set, Prop, Null


25

Map, List, Set, Prop, Null


26

Util namespace


27

Component model


28

@Autowired Spring proprietary annotation for property

injection

Supports @Qualifier to select implementation by name if more than one exists in context

Has required parameter to enforce dependency loading


29

@Autowired


30

@Inject Context and Dependency Injection (CDI)

standard JSR-299


31

@Resource JSR 250 (Common annotations)

Supports @PostConstruct and @PreDestroy as well


32

AutowiringAn appropriate bean for dependency is found through:

Type

Name

Type and Name combination


33

Resource loading and i18n


34

Resource loading and i18n


35

SpEl Stands for Spring Expression Language

Can be used in the xml context

Can be used in bean classes


36

SpEl


37

Java Spring Config @Configuration

@Bean

Support for Environment and Profiles


38

Java Spring Config


39

Environment abstraction & context

profiles Environment abstraction introduced in Spring 3.1

Can be declaratively and programmatically configured

Affects property resolution

Affects bean profiles


40


profiles


41


profiles


42

AOPA programming paradigm which allows to separate cross-cutting concerns

Cross-cutting logic:

Logging

Tracing

Security


43

AOP Aspect

Advice

Join point

Pointcut


44

AOP


45

Spring AOP Spring AOP defaults to using standard J2SE

dynamic proxies for AOP proxies. This enables any interface (or set of interfaces) to be proxied.

Spring AOP can also use CGLIB proxies. This is necessary to proxy classes, rather than interfaces

It is good practice to program to interfaces rather than classes, business classes normally will implement one or more business interfaces.


46

AspectJ Spring AOP is often uses the AspectJ

declaration style

AspectJ itself uses Load Time Weaving (LTW) to modify the bean code according to Aspect logic

LTW could do much more than dynamic proxies but it is more time-consuming operation. This means that LTW has a performance drawback.


47

Persistence with Spring

Building DAO

Embedded Datasources

JDBC vs ORM DAO’s

Integration testing with Spring

@Transactional & transactions with Spring


48

Spring supports JDBC

JPA

JDO

Concrete ORM

NoSQL templates (Mongo/Redis)

Graph DB abstractions - Spring Data Graph project


49

Persistence layer

Service

• Persistence service which has domain specific logic

Repository (DAO)

• Spring JDBCTemplate• SessionFactory, EntityManagerFactory• Redis/Mongo template

DB

• RDBMS (or NoSQL)


50

JDBCTemplate Useful interface

No boilerplate code

Exception handling


51

JDBCTemplate


52

JDBC namespace


53

Intro to HibernateObject Relational Mapping - is a programming technique for converting data between incompatible type systems in object-oriented programming languages. This creates, in effect, a "virtual object database" that can be used from within the programming language.


54

ORM main challenges Object inheritance

Object relations


55

Hibernate main parts SessionFactory

Session

Entity


56

Transactions in Spring

Support for ACID transactions

Declarative and programmatic


57

Transaction managers

Spring support both container managed and framework managed transactions

Managers:

DataSourceTransactionManager

HibernateTransactionManager

JPATransactionManager

JTATransactionManager


58

@Transactional Isolation levels

Transaction propagation

Read-only transactions


59

Read-only transactions

A read-only transaction can be used when your code reads but does not modify data. Read-only transactions can be a useful optimization in some cases, such as when you are using Hibernate.


60

Isolation levels DEFAULT - The default isolation level for the

underlying resource (usually this is the READ_COMMITTED isolation level)


61

Isolation levels READ_UNCOMMITTED - Least restrictive

isolation level. A transaction can read data updates even if they haven't yet been committed. (The updates might subsequently be rolled-back).


62

Isolation levels READ_COMMITTED - A transaction can only

read data that has already been committed. The transaction doesn't see uncommitted updates.


63

Isolation levels REPEATABLE_READ - A transaction always

reads the same value after it has read some data. Other transactions can update the data in parallel with the original transaction.


64

Isolation levels SERIALIZABLE - This is the most restrictive

isolation level. Transactions are completely isolated from each other. Resource managers frequently implement this isolation level by locking large amounts of data


65

Propagation NOT_SUPPORTED

Suspends client's transaction until bean method is complete


66

Propagation SUPPORTS

If client has transaction, bean method is included in it

If client doesn't have transaction, bean method doesn't create one


67

Propagation REQUIRED

If client has a transaction, bean method is included in it

If client doesn't have a transaction, bean method creates one


68

Propagation REQUIRES_NEW

If client has a transaction, bean method creates new one anyway

If client doesn't have a transaction, bean method creates one


69

Propagation MANDATORY

If client has a transaction, bean method uses it

If client doesn't have a transaction, exception!


70

Propagation NEVER

If client has a transaction, exception!

If client doesn't have transaction, bean method doesn't create one


71

Persistence layer testing

Context loading in test

Environment abstraction and profiles usage

Transactional methods

Embedded data source could be used


72

Persistence layer testing


73

Spring MVC Application context

Dispatcher Servlet and it’s context

Controllers and mappings

Implementing CRUD logic

Using Spring for UI tests


74

Application & Dispatcher servlet

context


75

Front controller and MVC


76

URL mappings @RequestMapping


77

View resolvers AbstractCachingViewResolver

XmlViewResolver

ResourceBundleViewResolver

UrlBasedViewResolver

InternalResourceViewResolver

VelocityViewResolver / FreeMarkerViewResolver

ContentNegotiatingViewResolver


78

View resolvers


79

CRUD in one place


80

Using Spring for UI tests

Integration testing of Controllers

Spring as a framework for Selenium UI tests

Spring By Example One Day Workshop

Technology

Transcript of Spring By Example One Day Workshop