Spring ORM Support

Object-relational mapping (ORM) frameworks map low-level database operations onto a high-level programming API that can be accessed from within object-oriented source code. ORM frameworks often provide configuration options to optimize the performance of such database operations. However, determining the set of optimal configuration options is a challenging task. Through an exploratory study on two open source applications (Spring PetClinic and ZK), we find that the difference in execution time between two configurations can be large. In addition, both applications are not shipped with an ORM configuration that is related to performance: instead, they use the default values provided by the ORM framework. We show that in 89% of the 9 analyzed test cases for PetClinic and in 96% of the 54 analyzed test cases for ZK, the default configuration values supplied by the ORM framework performed significantly slower than the optimal configuration for that test case. Based on these observations, this paper proposes an approach for automatically finding an optimal ORM configuration using a multi-objective genetic algorithm. We evaluate our approach by conducting a case study of Spring PetClinic and ZK. We find that our approach finds near-optimal configurations in 360-450 seconds for PetClinic and in 9-12 hours for ZK. These execution times allow our approach to be executed to find an optimal configuration before each new release of an application.

The self-description data configuration model

Persistence is an important set of techniques and technologies for accessing and transacting data, and ensuring that data is mobile regardless of specific applications and contexts. In Java development, persistence is a key factor in enterprise, e-commerce, and other transaction-oriented applications. Today, the Spring Framework is the leading out-of-the-box solution for enterprise Java developers; in it, you can find a number of Java Persistence solutions. This book gets you rolling with fundamental Spring Framework 3 concepts and integrating persistence functionality into enterprise Java applications using Hibernate, the Java Persistence API (JPA) 2, and the Grails Object Relational Mapping tool, GORM. Covers core Hibernate fundamentals, demonstrating how the framework can be best utilized within a Spring application context Covers how to use and integrate JPA 2, found in the new Java EE 6 platform Covers how to integrate and use the new Grails persistence engine, GORM What youll learn How to use Spring Persistence, including using persistence tools in Spring as well as choosing the best Java Persistence frameworks/tools outside of Spring How to work with Spring Framework features such as Inversion of Control (IoC), aspect-oriented programming (AOP), and more How to work with Spring JDBC, use declarative transactions with Spring, and reap the benefits of a lightweight persistence strategy How to work with Hibernate and integrate it into your Spring-based enterprise Java applications for transactions, data processing, and more How to integrate with legacy databases, as well as use best practices for developing web services and handling Hibernate proxies and lazy collections How to the integrate the Spring/Hibernate persistence tier with RIA technologies like Ajax and Flash How to integrate JPA for architecting a well-layered persistence tier in your enterprise Java application How to move a persistence tier into JPA How to use and integrate the Grails persistence framework, GORM, and how to leverage it within a standard Java Spring MVC application Who is this book for? This book is ideal for developers interested in learning more about persistence framework options on the Java platform, as well as fundamental Spring concepts. Because the book covers several persistence frameworks, it is suitable for anyone interested in learning more about Spring or any of the frameworks covered. Lastly, this book covers advanced topics related to persistence architecture and design patterns, and is ideal for beginning developers looking to learn more in these areas.

Object-relational mapping is a technology that connects relationships with object-oriented entities, which aims to eliminate duplicate layers together with costs of maintenance and any errors arising from their existence. A lot of tools and technologies were designed in order to support and implement idea of object-relational mapping. In this paper we present the performance comparison of two most common object-relational mapping interfaces for .NET framework: Entity Framework and NHibernate. In the .NET developers community, there is a lot of discussion today about the similarities and differences of the both technologies. To address this issue, we compared the features and performance of both tools. We analysed the performance of Entity Framework and NHibernate for two different databases (MS SQL Server and PostgreSQL), different query languages (lambda expressions and LINQ for Entity Framework and HQL and Critera API for NHibernate) and compared the results with the standard SqlClient queries. The results show that there is no significant difference between these both tools and we proved that common opinion that NHibernate performs better than Entity Framework is incorrect.

This paper describes AnnaBot, one of the first tools to verify correct use of Annotation-based metadata in the Java programming language. These Annotations are a standard Java 5 mechanism used to attach metadata to types, methods, or fields without using an external configuration file. A binary representation of the Annotation becomes part of the compiled “.class” file, for inspection by another component or library at runtime. Java Annotations were introduced into the Java language in 2004 and have become widely used in recent years due to their introduction in the Java Enterprise Edition 5, the Hibernate object-relational mapping API, the Spring Framework, and elsewhere. Despite that, mainstream development tools have not yet produced a widely-used verification tool to confirm correct configuration and placement of annotations external to the particular runtime component. While most of the examples in this paper use the Java Persistence API, AnnaBot is capable of verifying anyannotation-based API for which “claims”—description of annotation usage—are available. These claims can be written in Java or using a proposed Domain-Specific Language, which has been designed and a parser (but not the code generator) have been written.

Object-relational mapping plays an important role especially when we deal with large enterprise applications that have to be open and easy to maintain. In this paper, an enterprise flexible object-relational mapping strategy which involves metadata is raised according to the characteristics of data items. Then, the hierarchy of the framework is detailed, and the realization of framework modules is given using the mapping strategy. The framework would greatly facilitate the rapid development of enterprise application in modeling and data operation. The reference framework has features of self-adaptivity, flexibility, scalability, reusability. Using this framework can meet the diversity of user demands without modify the constructure of application.

The paper introduces an extension to the NeeK language [2, 5]. In the current shape NeeK allows for selection of fragments of a given ontology. The selected part is automatically mapped to a database schema by data views implementation [7]. Experience with a real system using data views has shown that the resulting database schema does not necessarily reflect the needs of the business logic of an application that uses a specific data view. As a work around database views were used on top of data views to modify the schema. Analogous experience with object views, an ontology-object mapping similar to object-relational mappings like Java Persistence API [1], has shown that straight forward mapping of a given ontology is not always sufficient. The modification of NeeK language proposed in the paper allows for minimizing the need of using database views for data views and additional code for of object views. This extension can be seen as a special case of ontology mapping, but focuses on solving particular problems of NeeK rather than being a complete ontology mapping language.

Data indexing is common in data mining when working with high-dimensional, large-scale data sets. Hadoop, a cloud computing project using the MapReduce framework in Java, has become of significant interest in distributed data mining. To resolve problems of globalization, random-write and duration in Hadoop, a data indexing approach on Hadoop using the Java Persistence API (JPA) is elaborated in the implementation of a KD-tree algorithm on Hadoop. An improved intersection algorithm for distributed data indexing on Hadoop is proposed, it performs O(M+logN), and is suitable for occasions of multiple intersections. We compare the data indexing algorithm on open dataset and synthetic dataset in a modest cloud environment. The results show the algorithms are feasible in large-scale data mining.

Large software systems are typically composed of multiple layers, written in different languages and loosely coupled using a string-based interface. For example, in modern web-applications, a server written in Java communicates with a database back-end by passing in query strings. This widely prevalent approach is unsafe as the analyses developed for the individual layers are oblivious to the semantics of the dynamically constructed strings, making it impossible to statically reason about the correctness of the interaction. Further, even simple refactoring in such systems is daunting and error prone as the changes must also be applied to isolated string fragments scattered across the code base.

With the introduction of Liberty JVM within CICS (Customer Information Control System), IBM has enabled the deployment and execution of modern computing or APIs straight in CICS and executed them next to legacy applications written in COBOL, HLASM, and other languages. Using Java EE features brings enterprise-level capabilities like scalability, transactionality, security, and manageability. This integration of Java EE features also enhances the performance of Java applications deployed in CICS environments. This paper explores different Java EE features, such as Context and Dependency Injection (CDI), Enterprise Java Beans (EJB), Java Persistence API (JPA), Java Transaction API (JTA), Java Message Service (JMS), and more, available to Java applications deployed into the CICS Liberty JVM environment. It also explores how the Liberty JVM supports each feature and how the integration with CICS works in each case.

This article presents the comparative analysis of time efficiency while executing queries by object-relational mapping framework Entity Framework for the following database engines: Microsoft SQL Server, MySQL and PostgreSQL. Time measurements of obtaining object results from database queries were made by app created in C#. Queries referred to single or multiple tables linked by relationships (1:1, 1:n, m:n) and performed operations of reading, creating, updating and deleting data. Obtained results have been cleaned from outliers and trimmed means were given as final results. Different database engines obtained the shortest query execution times depending on record number and table structures.

During the last decade, there has been a major paradigm shift in the way the software services are being provided to the enterprise and corporate sector. Instead of using on-premises LOB (Line of Business) applications, corporations and enterprises are switching to off-premises host applications that are now being offered as a service by several software companies. This new concept of providing software service is generally known as SaaS (i.e., Software as a Service). However, the adaptation of such a model necessitates that the applications - that are required to be provided as a service should be generalized for users or groups of users. The users or user groups ordinarily correspond to a company or group of companies/businesses and are termed as tenants. In this regard, the architecture of SaaS applications needs to be customized to support certain characteristics – e.g., configurability, maintainability and scalability – to support a diverse numbers of users. This paper, firstly, analyzes new trends in the present day business environment alongside the hardware and software industry that led to the development of SaaS model; and then looks into the characteristics and features that a multi-tenant system needs to possess in order to put this concept into practice.