Spring AOP – Advice

Spring AOP – Advice

Spring AOP Advice is the action taken by an aspect at a particular join point. Different types of advice include 

• Around advice
• Before advice
• After advice

Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors around the join point.

Types of advice:

• Before advice: Advice that executes before a join point, but which does not have the ability to prevent execution flow proceeding to the join point.
  
  
• After returning advice: Advice to be executed after a join point completes normally.
  
  
• After throwing advice: Advice to be executed if a method exits by throwing an exception.
  
  
• After (finally) advice: Advice to be executed regardless of the means by which a join point exits, normal or exceptional return.
  
  
• Around advice: Advice that surrounds a join point such as a method invocation. This is the most powerful kind of advice. Around advice can perform custom behavior before and after the method invocation. It is also responsible for choosing whether to proceed to the join point or to shortcut the advised method execution by returning its own return value or throwing an exception.

Aspect Oriented Programming with Spring

Aspect Oriented Programming with Spring

Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. One of the key components of Spring is the AOP framework. While the Spring IoC container does not depend on AOP, meaning you do not need to use AOP if you don't want to, AOP complements Spring IoC to provide a very capable middleware solution. Aspect-Oriented Programming requires breaking down program logic into distinct parts called concerns. 

The functions that span multiple points of an application are called cross-cutting concerns and these cross-cutting concerns are conceptually separate from the application's business logic. Examples of aspects are logging, auditing, declarative transactions, security, caching, etc. Spring AOP module provides interceptors to intercept an application. For example, when a method is executed, you can add extra functionality before or after the method execution.

AOP is used in the Spring Framework to

• Provide declarative enterprise services, especially as a replacement for EJB declarative services. 

• Allow users to implement custom aspects, complementing their use of OOP with AOP.

AOP Terminologies

Before we start working with AOP, let us become familiar with the AOP concepts and terminology. These terms are not specific to Spring, rather they are related to AOP.

• Aspect: a modularization of a concern that cuts across multiple classes. Transaction management is a good example of a crosscutting concern in Java EE applications. In Spring AOP, aspects are implemented using regular classes  or regular classes annotated with the @Aspect annotation.

• Join point: a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution.

• Advice: action taken by an aspect at a particular join point. Different types of advice include "around," "before" and "after" advice

• Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut.

• Introduction: declaring additional methods or fields on behalf of a type. Spring AOP allows you to introduce new interfaces to any advised object. 

• Target object: object being advised by one or more aspects. Also referred to as the advised object. 

• AOP proxy: an object created by the AOP framework in order to implement the aspect contracts. In the Spring Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy.

• Weaving: linking aspects with other application types or objects to create an advised object. This can be done at compile time, load time, or at runtime. Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime.

Spring Dependencies

Spring Dependencies

An application will have certain objects that work together to present what the end-user sees as a coherent application. We can define a number of bean definitions that are stand-alone, each to themselves, to a fully realized application where objects work (or collaborate) together to achieve some goal.

Injecting Dependencies

It becomes evident upon usage that code gets much cleaner when the DI principle is applied, and reaching a higher grade of decoupling is much easier when beans do not look up their dependencies, but are provided with them.

Setter Injection

Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

public class SimpleMovieLister { // the SimpleMovieLister has a dependency on the MovieFinder     private MovieFinder movieFinder; // a setter method so that the Spring container can 'inject' a MovieFinder     public void setMovieFinder         (MovieFinder movieFinder) {       this.movieFinder = movieFinder;     } }

Constructor Injection

Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator. Additionally, calling a static factory method can be considered almost equivalent.

public class SimpleMovieLister {     // the SimpleMovieLister has a dependency on the MovieFinder     private MovieFinder movieFinder;     // a constructor so that the Spring container can 'inject' a MovieFinder     public SimpleMovieLister        (MovieFinder movieFinder) {         this.movieFinder = movieFinder;     }     }

Constructor or Setter DI?

·         Setter based DI makes objects of that class responsive to being re-configured (or re-injected) at some later time.

·         Constructor-injection supplying all of an object's dependencies means that that object is never returned to client (calling) code in a less than totally initialized state.

Spring Expression Language (SpEL)

Spring Expression Language (SpEL)

The Spring Expression Language (SpEL) is a powerful expression language that supports querying and manipulating an object graph at runtime. The language syntax is similar to Unified EL but offers additional features, most notably method invocation and basic string templating functionality.

The Spring Expression Language was created to provide the Spring community with a single well supported expression language that can be used across all the products in the Spring portfolio. SpEL is based on an technology agnostic API allowing other expression language implementations to be integrated should the need arise.

While SpEL serves as the foundation for expression evaluation within the Spring portfolio, it is not directly tied to Spring and can be used independently.

The expression language supports the following functionality

• Literal expressions
• Boolean and relational operators
• Regular expressions
• Class expressions
• Accessing properties, arrays, lists, maps
• Method invocation
• Relational operators
• Assignment
• Calling constructors
• Ternary operator
• Variables
• User defined functions
• Collection projection
• Collection selection
• Templated expressions

The EvaluationContext interface

The interface EvaluationContext is used when evaluating an expression to resolve properties, methods, fields, and to help perform type conversion. The StandardEvaluationContext is where you specify the root object to evaluate against via the method setRootObject or passing the root object into the constructor. . You can also specify variables and functions that will be used in the expression using the methods setVariable and registerFunction. The StandardEvaluationContext is also where you can register custom ConstructorResolvers, MethodResolvers, and PropertyAccessors to extend how SpEL evaluates expressions.

Type Conversion

By default SpEL uses the conversion service available in Spring core (org.springframework.core.convert.ConversionService). This conversion service comes with many converters built in for common conversions but is also fully extensible so custom conversions between types can be added. Additionally it has the capability that it is generics aware. This means that when working with generic types in expressions, SpEL will attempt conversions to maintain type correctness for any objects it encounters.

Advantage of Hibernate over JDBC

Advantage of Hibernate over JDBC

JDBC	Hibernate
With JDBC, developer has to write code to map an object model's data to a relational data model and its corresponding database schema.	Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate takes care of this mapping using XML files so developer need not write code for this.
The mapping of Java objects with database tables and vice versa conversion is to be taken care of by the developer, the developer needs to write code for this.	Hibernate provides transparent persistence, to map database tables rows to application objects during interaction with RDBMS.
JDBC supports Structured Query Language (SQL). Developer has to find out the efficient way to access database, i.e. to select effective query from a number of queries to perform same task.	Hibernate provides a powerful query language Hibernate Query Language. Hibernate also supports native SQL statements. It also selects an effective way to perform a database manipulation task for an application.
Application using JDBC to handle persistent data having database specific code. The code is written to map table fields to object properties. As table changes or database changes then it is essential to change object structure as well to map table-to-object/object-to-table.	Hibernate provides this mapping. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.
With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application.	Hibernate reduces lines of code by maintaining object-table mapping and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.
With JDBC, to enable caching the developer needs to write the code for caching of Objects	Hibernate, has its own caching facility, instead of coding for the caching feature, the developer just configures caching through configuration files.
In JDBC there is no check that always every user has updated data. This check has to be added by the developer.	Hibernate enables developer to define version type field which updates database table every time a row is updated in form of Java object to that table.If two users retrieve same row and modify it and one user save this modified row   to database, version is automatically updated for this row by Hibernate. When other user tries to save updated row to database then it does not allow saving it because this user does not have updated data.

Spring Modules

Spring Modules

The Spring Framework contains a lot of features, which are well-organized in about twenty modules. These modules can be grouped together based on their primary features into 

Ø  Core Container 

Ø  Data Access/Integration 

Ø  Web 

Ø  AOP (Aspect Oriented Programming) 

Ø  Instrumentation 

Ø  Test

Core Container Module

The Core Container consists of the Core, Beans, Context and Expression modules.

The Core and Beans modules provide the most fundamental parts of the framework and provides the IoC and Dependency Injection features.

The Context module build on top of the Core and Beans modules. The Context module inherits its features from the Beans module and adds support for internationalization (I18N), event-propagation, resource-loading, and the transparent creation of contexts. The ApplicationContext interface is the focal point of the Context module that provides these features.

The Expression Language module provides a powerful expression language for querying and manipulating an object graph at runtime. The language supports setting and getting of property values, property assignment, method invocation, accessing the context of arrays, collections and indexers, logical and arithmetic operators, named variables, and retrieval of objects by name from Spring's IoC container.

Data Access/Integration Module

The Data Access/Integration layer consists of the JDBC, ORM, OXM, JMS and Transaction modules.

The JDBC module provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes.

The ORM module provides integration layers for popular object-relational mapping APIs, including JPA, JDO, Hibernate, and iBatis.

The OXM module provides an abstraction layer for using a number of Object/XML mapping implementations for JAXB, Castor, XMLBeans, JiBX and XStream.

The JMS module provides Spring's support for the Java Messaging Service. It contains features for both producing and consuming messages.

The Transaction module provides a way to do programmatic as well as declarative transaction management, not only for classes implementing special interfaces, but for all your POJOs.

Web Module

The Web layer consists of the Web, Web-Servlet and Web-Portlet modules.

Spring's Web module provides basic web-oriented integration features, such as multipart file-upload functionality, the initialization of the IoC container using servlet listeners and a web-oriented application context.

The Web-Servlet module provides Spring's Model-View-Controller (MVC) implementation for web-applications

The Web-Portlet module provides the MVC implementation to be used in a portlet environment and mirrors what is provided in the Web-Servlet module.

AOP and Instrumentation Module

Spring's AOP module provides an aspect-oriented programming implementation allowing you to define, method-interceptors and pointcuts to cleanly decouple code implementing functionality that should logically be separated.

The Instrumentation module provides class instrumentation support and classloader implementations to be used in certain application servers.

Test Module

The Test module contains the Test Framework that supports testing Spring components using JUnit or TestNG. 

Spring Framework

Spring Framework

The Spring Framework is an open source application framework for the Java platform which aims to make J2EE development easier. Spring framework offers a lot of freedom to Java developers yet provides well-documented and easy to use solutions for common practices in the industry.

Spring is a glue framework that gives an easy way of configuring and resolving dependencies throughout the J2EE stack. The core features of the Spring Framework can be used in developing any Java application, but there are extensions for building web applications on top of the Java EE platform. Spring framework targets to make J2EE development easier to use and promote good programming practice by enabling a POJO-based programming model.

Goals of Spring Framework

•          Reduce glue code/plumbing work

–        Spring Framework takes lot of load off the programmer by providing dependencies when required and by using AOP.

•          Externalize dependencies

–        Dependencies are described in a separate file (xml) rather than mixing it with the business logic code itself. This gives a better control over the application.

•          Manage dependencies at a single place

–        Dependencies can be managed better due to this.

•          Improve testability

–        Actual code can easily be replaced by a stub for testing purposes.

•          Foster good application design

–        Since the actual implementation sits behind the interfaces, it fosters good application design.

•          Flexibility

–        Spring offers integration points with several other frameworks. So, you do not have to write them yourself.

–        Programmers are free to choose the modules that suit their application. Spring has a well layered architecture of 7 modules:

•          Spring Core

•          Spring Context

•          Spring AOP

•          Spring DAO

•          Spring ORM

•          Spring WebFlow

•          Spring Web MVC

Features of Spring Framework

•          Lightweight

–        Objects in a Spring-enabled application often have no dependencies on Spring specific classes. It’s jar file is just over 2.5 MB.

–        Provides support to not only J2EE applications but also to stand alone applications

•          Inversion of Control (IoC) and Dependency Injection

–        The core of the Spring Framework is based on the principle of IoC. Applications that follow the IoC principle use configuration that describes the dependencies between its components.

–        Ioc or to be more descriptive, Dependency Injection aims to offer a simpler mechanism for providing components dependencies.

•          AOP

–        Aspect Oriented Programming can be used to separate cross-cutting concerns from business logic. These concerns, then can be applied to many parts of the application. Logging and security are typical examples of such concerns.

•          Pojo based programming

–        Spring based applications need not extend/implement any spring specific classes. It leads to a simpler yet extensible programming model.

Continuous Integration

Continuous Integration

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly. 

The basic idea behind the continuous integration is to ensure that there are no compilation issues at the end of the day by numerous check ins made by the developers in a team. Also, this would enable to identify any compilation issues at the early stages of the development process.

In this process, all the developers’ activities are collaborated and merged at the central system.  The main aim in this process is to eliminate the “integration problems”. Each and every integration is automatically built, deployed and tested thoroughly.

The main aim of CI is to prevent integration problems.

Continuous integration is the practice of frequently integrating one's new or changed code with the existing code repository which should occur frequently enough that no intervening window remains between commit and build, and such that no errors can arise without developers noticing them and correcting them immediately. 

Rather than a periodically scheduled build, in CI the normal practice is to trigger these builds by every commit to a repository.

Best Practices of CI

1.      Maintain a proper code repository.

2.      Automate the build process.

3.      Ensure every developer commits the files to the main stream every day.

4.      Every commits made should be built.

5.      Results of the build should be made transparent, so that all the developers will be aware of the quality of the build every day.

6.      Test the build in a production look-like environment.

7.      Broken builds should be fixed immediately.

8.      Everyone should be able to get the latest build from the main stream.

9.      Automate the deployment process.

 Advantages of CI

1.      Integration bugs are detected early and are easy to track down due to small change sets. 

2.      Avoids last-minute chaos at release dates

3.      Constant availability of a "current" build for testing, demo, or release purposes.

4.      Frequent code check-in pushes developers to create modular, less complex code

5.      Enforces discipline of frequent automated testing.

6.      Immediate feedback on system-wide impact of local changes

Constructors in Java

Constructors in Java

A constructor in Java is a block of code similar to a method that’s called when an instance of an object is created. A constructor is a special method that is used to initialize an object. Every class has a constructor, if we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class. A constructor does not have any return type.

A constructor has same name as the class in which it resides. Constructor in Java cannot be abstract, static, final or synchronized. These modifiers are not allowed for constructor.

public class Student { int rollNumber; String name; public Student() {             rollNumber=0;             name="";             System.out.println("Inside Default Constructor"); } }

There are two types of Constructor

·         Default Constructor – is the one which does not have any parameters

·         Parameterized constructor – may contain 1 or more parameter list.

If we don't explicitly declare a constructor for any java class the compiler builds a default constructor for that class

public class Student { int rollNumber; String name; // Default Constructor public Student() {             rollNumber=0;             name="";             System.out.println("Inside Default Constructor"); } // parameterized constructor Student(int rno,String sname){             rollNumber=rno;             name=sname; System.out.println("Inside Parametrized Constructor"); } }

Constructor Overloading

Like methods, constructors can also be overloaded. Overloaded constructors are different on the basis of their type of parameters or number of parameters. Constructor overloading is not much different than method overloading. In case of method overloading you have multiple methods with same name but different signature, whereas in Constructor overloading you have multiple constructor with different signature.

Let’s create a class with the main method to class the Student Class

public class MainClass { public static void main(String[] args) {             // Default Constructor will be called             Student s1=new Student();                         // Calling Parametrized Constructor             Student s2=new Student(1,"Bond"); } }

Once we execute the above class, we get the following output

Inside Default Constructor Inside Parametrized Constructor

Some of the key points to remember regarding Constructors

·         A constructor doesn’t have a return type.

·         The name of the constructor must be the same as the name of the class.

·         Unlike methods, constructors are not considered members of a class.

·         A constructor is called automatically when a new instance of an object is created.

·         Constructors can be overloaded just like normal methods.

·         Constructors can be private. This facilitates Singleton Design Pattern.