Spring Framework, Hibernate & Java: Oracle, Database & MySQL

Let us first take a little survey of what JDK is. The Java Development Kit (JDK0 is an implementation of either one of the Java platform, standard edition, Java platform, enterprise edition, Micro edition platforms and this software was released by the Oracle Corporation in the form of binary product aimed at Java developers on Solaris, Linu, MacOS or windows. The JDK includes a private JVM and a few other resources to finish the development of a java application. Since its introduction, the Java Development Kits have been the far most widely used Software Development Kit. 

Let us first take a little survey of what JDK is. The Java Development Kit (JDK0 is an implementation of either one of the Java platform, standard edition, Java platform, enterprise edition, Micro edition platforms and this software was released by the Oracle Corporation in the form of binary product aimed at Java developers on Solaris, Linu, MacOS or windows. The JDK includes a private JVM and a few other resources to finish the development of a java application. Since its introduction, the Java Development Kits have been the far most widely used Software Development Kit. 

The Apache Commons Logging (JCL) provides a Log interface that is intended to be both light-weight and an independent abstraction of other logging toolkits. It provides the middleware/tooling developer with a simple logging abstraction, that allows the user (application developer) to plug in a specific logging implementation.

Eclipse is an open-source Integrated Development Environment (IDE) supported by IBM. Eclipse is popular for Java application development (Java SE and Java EE) and Android apps. It also supports C/C++, PHP, Python, Perl, and other web project developments via extensible plug-ins. Eclipse is cross-platform and runs under Windows, Linux and Mac OS.

Spring BeanFactory Container

This is the simplest container providing the basic support for DI and is defined by the org.springframework.beans.factory.BeanFactoryinterface. The BeanFactory and related interfaces, such as BeanFactoryAware, InitializingBean, DisposableBean, are still present in Spring for the purpose of backward compatibility with a large number of third-party frameworks that integrate with Spring.

The Spring container is at the core of the Spring Framework. The container will create the objects, wire them together, configure them, and manage their complete life cycle from creation till destruction. The Spring container uses DI to manage the components that make up an application. These objects are called Spring Beans, which we will discuss in the next chapter.

The Application Context is Spring's advanced container. Similar to BeanFactory, it can load bean definitions, wire beans together, and dispense beans upon request. Additionally, it 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. This container is defined by the org.springframework.context.ApplicationContext interface.

The Singleton Scope

If a scope is set to singleton, the Spring IoC container creates exactly one instance of the object defined by that bean definition. This single instance is stored in a cache of such singleton beans, and all subsequent requests and references for that named bean return the cached object.

The life cycle of a spring bean is easy to understand. When a bean is instantiated, it may be required to perform some initialization to get it into a usable state. Similarly, when the bean is no longer required and is removed from the container, some cleanup may be required. Though, there are lists of the activities that take place behind the scene between the time of bean Instantiation and its destruction, this chapter will discuss only two important bean life cycle callback methods, which are required at the time of bean initialization and its destruction.

Initialization callbacks

Implementing the org.springframework.beans.factory.InitializingBean interface allows a bean to perform initialization work after all necessary properties on the bean are set by the container. The InitializingBean interface specifies exactly one method:

org.springframework.beans.factory.InitializingBean interface  provide Initialization callbacks method as given below:

"void afterPropertiesSet() throws Exception"

The org.springframework.beans.factory.DisposableBean interface specifies a single

method:

void destroy() throws Exception;

Thus, you can simply implement the above interface and finalization work can be done

inside destroy() method as follows:

public class ExampleBean implements DisposableBean {

public void destroy() {

// do some destruction work

If you have too many beans having initialization and/or destroy methods with the same name, you don't need to declare init-method and destroy-method on each individual bean. Instead, the framework provides the flexibility to configure such situation using default-init-method and default-destroy-method attributes on the <beans> element as follows:

Quite often you will find yourself in a situation where you would need to perform some processing pre and post instantiationof the bean by Spring framework. Spring has provided BeanPostProcessor interface which defines a callback methods to achieve this functionality.

Classes that implements BeanPostProcessor interface needs to be defined in an ApplicationContext(spring bean configuration file) and will be applied on all the beans defined in an application context.

Dependency injection is a technique whereby one object supplies the dependencies of another object. A dependency is an object that can be used (a service). An injection is the passing of a dependency to a dependent object (a client) that would use it. The service is made part of the client's state.[1] Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.

Constructor-based DI is accomplished when the container invokes a class constructor with a number of arguments, each representing a dependency on the other class.

Constructor Based Dependency Injection is the one in which the wiring between beans is achieved using constructors. When such a dependency injection is performed, the container invokes a constructor with one or more arguments, each representing a dependency. In our example of OrderClient we need to inject a CSVDataStore. Let us create a constructor in OrderClient which accepts an argument of type DataStore.

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

The Spring IoC container also supports setter injection, which is the preferred method of dependency injection in Spring. Setter injection uses the set* methods in a class file to garner property names that are configurable in the spring XML config.

Inner beans are the beans which are defined in the scope of another bean. Spring provides a way to inject inner beans also. Inner beans are defined in a scope of another beans which means inner beans are not shared by another beans.

Inner beans are defined like below:

In Spring if one Bean depends on another Bean class for some business logic, then this type of dependency is called object dependency.In case of Object dependency in Spring, the spring IOC container is responsible for creating that required object and injecting into the dependent classes.

In Spring we need to use <ref> element to inform spring container about the object dependency.

Autowiring feature of spring framework enables you to inject the object dependency implicitly. It internally uses setter or constructor injection. Autowiring can't be used to inject primitive and string values. It works with reference only.

It is very important for us to know that all Spring beans are managed - they "live" inside a container, called "application context".

Spring supports four modes for autowiring: byName, byType, constructor, default, and no (which is the default). When using byName autowiring, Spring attempts to wire each property to a bean of the same name. So, if the target bean has a property named foo and a foo bean is defined in the ApplicationContext, the foo bean is assigned to the foo property of the target. When using byType autowiring, 

In Spring, “Autowiring by Name” means, if the name of a bean is same as the name of other bean property, auto wire it. This mode specifies autowiring by property name. Spring container looks at the beans on which auto-wire attribute is set to byName in the XML configuration file. It then tries to match and wire its properties with the beans defined by the same names in the configuration file. If matches are found, it will inject those beans. Otherwise, bean(s) will not be wired. For example, if a “customer” bean exposes an “address” property, Spring will find the “address” bean in current container and wire it automatically. 

In Spring, “Autowiring by Constructor” is actually autowiring by Type in constructor argument. It means, if data type of a bean is same as the data type of other bean constructor argument, auto wire it. When the autowire by constructor is enabled -which is actually analogous to autowire by type, but applies to constructor arguments- spring will autowire a property if exactly one bean of the property type exists in the container. 

Configuring ODBC Data Sources

An Open Database Connectivity (ODBC) application uses an ODBC data source to connect to an instance of Microsoft SQL Server. An ODBC data source is a stored definition that records:

The ODBC driver to use for connections specifying the data source.

The information used by the ODBC driver to connect to a source of data.

a data access object (DAO ) is an object that provides an abstract interface to some type of database or other persistence mechanism. By mapping application calls to the persistence layer, the DAO provides some specific data operations without exposing details of the database. This isolation supports the Single responsibility principle. It separates what data access the application needs, in terms of domain-specific objects and data types (the public interface of the DAO), from how these needs can be satisfied with a specific DBMS , database schema, etc. (the implementation of the DAO).

The most common plain old SQL tasks are those that involve executing DDL statements (such as CREATE TABLE) or DML statements (such as INSERT INTO). Using Fluent JDBC, you can easily invoke single SQL statements, as well as SQL scripts.

Executing a Single SQL Statement

Executing an SQL Script

Using Auto-Commit During Script Execution

Some of the transaction managers are-

DataSource Transaction manager -  We can use DataSourceTransactionManager for simple JDBC persistence mechanism. Sample configuration of DataSourceTransactionManager looks like below

     <bean id=”transactionManager”

           class=”org.springframework.jdbc.datasource.DataSourceTransactionManager>

          <property name=”dataSource” ref= “datasource” />

     </bean>

Applications use resources, such as Java Database Connectivity (JDBC) data sources or connection factories, that are configured through the Resources view of the administrative console. How these resources participate in a global transaction depends on the underlying transaction support of the resource provider.

You can approach coding transactions in two basic ways: programmatically or declaratively. When possible, declarative transactions are a better choice since they allow the container to manage the transaction for you, and this saves you from having to put JTA transaction management calls into your application code. But as we’ll see, not every scenario can be adapted to use declarative transactions. We’ll start by examining programmatic transaction management, then discuss how declarative transaction management can supplant some programmatic calls.

Most of the time developers give the least importance to transaction management and as a result lots of code has to be reworked later or developer implements transaction management without knowing how it actually works or what aspect needs to be used in their scenario.

An important aspect of transaction management is defining the right transaction boundary for e.g when should a transaction start,when should it end,when data should be committed in DB and when it should be rolled back (in the case of exception).

There is likewise an understood "unconfigured" or "default" arrangement of Log4j, that of a Log4j-instrumented Java application which does not have any Log4j design. This prints to stdout a notice that the program is unconfigured, and the URL to the Log4j site where subtle elements on the notice and setup might be found. And in addition printing this notice, an unconfigured Log4j application will just print ERROR or FATAL log passages to standard out.

When composing a library it is extremely valuable to log information. However there are many logging executions out there, and a library can't force the utilization of a specific one on the general application that the library is a piece of.

The Logging bundle is a ultra-thin extension between various logging executions. A library that uses the house logging API can be utilized with any logging usage at runtime. Center logging accompanies support for various famous logging usage, and composing connectors for others is a sensibly straightforward assignment.