Spring Basics

Spring Basics
annotation based
application development
https://github.com
/Innominds-jee
/spring-java-training.git

Index
 Introduction
 Spring Containers
 Spring Bean Lifecycle
 Spring Annotations
 Spring Bean Scopes
 Profiles & Conditional Beans
 Spring AOP
 Spring Expression Language (SpEL)

Introduction
 Spring started as a lightweight alternative to Java
Enterprise Edition. (Using EJBs)
 Spring offered a simpler approach to enterprise
Java development, utilizing dependency injection
and aspect-oriented programming to achieve the
capabilities of EJB with plain old Java objects
(POJOs).
 Spring 2.5 introduced annotation-based
component-scanning, which eliminated a great
deal of explicit XML configuration for an
application’s own components. And Spring 3.0
introduced a Java-based configuration as a type-
safe and refactorable option to XML.

Spring as an integration framework
Spring has support in different areas
Web Layer: we can integrate with HTML,JSP,
thymeleaf, velocity, freemarker, tiles etc.
Scripting : groovy, JRuby, BeanShell
Messaging: supports ActiveMQ, RabbitMQ
Security Method level and Http URLs
ORM : hibernate, eclipselink with JPA
NoSQL: supports MongoDB, elastic search
Popular frameworks are also dependent on
spring. Ex: Hybris, Mule ESB, Liferay, Magnolia

IoC Introduction (from spring docs)
 IoC is also known as dependency injection (DI).
 It is a process whereby objects define their
dependencies, that is, the other objects they work
with, only through constructor arguments, arguments
to a factory method, or properties that are set on the
object instance after it is constructed or returned from
a factory method.
 The container then injects those dependencies when
it creates the bean.
 This process is fundamentally the inverse, hence the
name Inversion of Control (IoC)

Types of Containers
There are two types of containers
 BeanFactory Container: This is the simplest
container providing basic support for DI.
It creates beans on demand.
 ApplicationContext Container: This container
adds more enterprise-specific functionality such
as the ability to resolve textual messages from a
properties file and the ability to publish application
events to interested event listeners. It creates
beans upon starting the application.

Spring web application containers hierarchy

Java based configuration
Java based spring container can be created
using below class
final AnnotationConfigApplicationContext aCtx
= new AnnotationConfigApplicationContext();
aCtx.register(MySpringConfig.class); //pass the configuration
aCtx.refresh();// it will creates the registered beans

Spring Annotation
 @Configuration: Configuration file
 @Bean: to declare a bean in Java configuration
 @Import : import another Java Configuration
 @ImportResource : import XML configuration
 @ComponentScan: scans the beans starting with given base
package
 @Scope: to define Scope of a bean
 @Conditional: this works with Condition interface
 @EnableAspectJAutoProxy: enabling auto proxy, @Aspect
 @Primary: works with @Component
 @Qualifier: works with @Autowired and @Inject
 @Value: annotation spring express Language
 @ActiveProfiles: choose profiles in Test cases
 @ContextConfiguration: To load with configuration test cases
 @Runwith: Runwith(SpringJUnit4ClassRunner)

Basic Annotations in Spring
 @Configuration: Indicates that a class declares
one or more @Bean methods and may be processed
by the Spring container to generate bean definitions
and service requests for those beans at runtime
 @Bean: Creates Spring bean from java object
 @Import: Used to import configuration file
 @ImportResource: Used to import XML
Based Configuration file
 ComponentScan: scans the spring beans on
the given base package. It looks for
@Service, @Component, @Controller,
@Repository .

Spring Bean Scopes
 Singleton: Single bean per IOC container (default)
 Prototype: creates new bean each time
WEB APPLICATION SCOPES
 Request: each request new bean created
 Session: for each user session new bean created
 Global Session: Typically only valid when used in a
portlet context.
NOTE: you can also create your own scope if these are not fit to
your requirement
There are two types of scope available in spring core
container
@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

Enabling profile
 Spring Profiles were introduced in spring 3.1.
It allows us to define beans by deployment regions such as
“dev” , “qa”, “prod” etc.
 Spring profiles are enabled using the case insensitive tokens
spring.profiles.active or spring_profiles_active.
 Profile can be activated with below mentioned ways
1. an Environment Variable
2. a JVM Property
3. Web Parameter
4. Programmatic
@Profile Annotation used to create bean for specific environment

Conditional Beans
Conditional Beans were introduced in spring 4.0
It works together with @Conditional annotation and Condition
interface
It allows developer to define strategy to create bean. These are not
limited to environment
Spring boot framework extensively uses this feature to create bean
based on properties file information
@Bean
@Conditional(LinuxMailConditon.class)
MailService mailService() {
return new LinuxMailServiceImpl();
}
@Bean
@Conditional(WindowsMailConditon.class)
MailService mailService() {
return new WindowsMailServiceImpl();
}

JDBC Template condition
public class JdbcTemplateCondition implements Condition {
@Override
public boolean matches(ConditionContext context,
AnnotatedTypeMetadata metadata) {
try {
context.getClassLoader().loadClass("org.springframework.jdbc
. core.JdbcTemplate");
return true;
} catch (Exception e) {
return false;
}
}
}

Aspect Oriented Programming
 Cross-cutting Concerns impact the application
in many points. Ex: Logging, Security, Caching
and Transaction Management are called cross-
cutting concerns.
 Using AOP we can define common functionality in
one place and we can declaratively define how
and where this functionality can be applied.
 Cross cutting concerns are modularized into
special classes are called aspects.

AOP Terminology
 Aspect: modularization of cross-cutting concern
ex: security Aspect will check whether calling person has privileges to
access checkBalance() method
 Advice: Job of an Aspect called advice.
 Joinpoints: In an application there are many places
where we can apply aspect. These points are called
join points.
 Pointcuts: point cuts are the join points where we can
woven advice.
 Introductions: inject new methods and attributes into
existing classes are called introductions.
 Weaving: process of applying aspects to target
classes to create new proxies.

Types of Weaving
 Compile time Weaving: Aspects are woven when
the target class is compiled. It requires special
kind of compiler. (works only on AspectJ
programming model).
 Classloading time: Aspects are weaving when
the class loaded by the class loader. This kind of
weaving requires special kind of classLoader.
(works only with AspectJ )
 Runtime weaving: Aspects are woven during the
runtime of the program execution. AOP container
dynamically generates proxy objects that delegate
the requests to target objects. (Spring AOP
supports only this)

Types of Advice
 @Before
 @After
 @AfterReturning
 @AfterThrowing
 @Around

Configuring AOP in spring project
 It is just adding below annotations to configuration file
@Aspect
@EnableAspectJAutoProxy(proxyTargetClass = true)
 And Writing some pointcuts and advice annotations
@Before("execution(** com.innominds.aop.service.*.*())")
public void beforeMethod() {
//write JOB of aspect
}
NOTE: Spring doesn’t provide its own annotations instead
it depends on AspectJ annotations.

 In Spring, aspects are woven into spring-
managed beans at runtime by wrapping them
with a proxy class.
There are two types of proxy creation possible
 JDK Dynamic proxy: If the services are invokes
based on interfaces it creates proxy by
implementing that interface.
 CGLIB Proxy: it extends the existing target class
and calls super class methods.
 Proxy class poses as the target bean intercepting
advised method calls and forwarding those calls
to the target bean.

Spring Expression Language with @Value
annotation
 A powerful expression language that supports
querying and manipulating an object graph at
runtime.
 syntax to define the expression is of the form
#{ <expression string> }.
 @Value annotation used to bound the value
from the spring expression language.

@Primary and @Qualifier
 @Primary: used to select one default
implementation when multiple concrete classes
available for single interface.
 @Qualifier: Used to select one of the
implementation at the time of @Autowiring

Spring Testing
 @Runwith : Used to select spring test runner with
Junit Test cases
 @ContextConfiguration: take spring
configuration and creates container with test
beans
 @ActiveProfiles: enables profiles form test
cases
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PaymentConfig.class })
@ActiveProfiles(profiles = { "dev" })
public class PaymentServiceTest {}

Spring Basics

Recommended

More Related Content

What's hot (20)

Similar to Spring Basics (20)

Recently uploaded (20)

Spring Basics