Hibernate Architecture Overview

Hibernate Architecture Overview

Hibernate, is an ORM solution, which sits between the Java application data access layer and the Relational Database. The Java application makes use of the Hibernate APIs to load, store, query, etc its domain data. Hibernate implements the Java Persistence API (JPA) specifications. 

SessionFactory (org.hibernate.SessionFactory)

SessionFactory  is a thread-safe representation of the mapping of the application domain model to a database. SessionFactory acts as a factory for org.hibernate.Session instances. The EntityManagerFactory is the JPA equivalent of a SessionFactory.

A SessionFactory is very expensive to create, so, for any given database, the application should have only one associated SessionFactory. The SessionFactory maintains services that Hibernate uses across all Sessions such as second level caches, connection pools, transaction system integrations, etc.

Session (org.hibernate.Session)

A single-threaded, short-lived object conceptually modeling a "Unit of Work". In JPA nomenclature, the Session is represented by an EntityManager.

The Hibernate Session wraps a JDBC java.sql.Connection and acts as a factory for org.hibernate.Transaction instances. 

Transaction (org.hibernate.Transaction)

A single-threaded, short-lived object used by the application to demarcate individual physical transaction boundaries. 

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.