Introduction

For over 17 years, J-Framework has been incrementally developed and evolved by Dr. Jalal Kiswani to be mature, reliable, and consistent. It is currently utilized and implemented in many organizations and systems in different domains such as banking, education, government, and technology; Also, it has been applied on different scales from single-user systems, and startups, to large-scale enterprise applications.

In addition to being practically proven, its components are also scientifically discussed in a master’s thesis, PhD dissertation, and scientific research publications.

J-Framework is owned, developed, and maintained by Dr. Jalal Kiswani, for licensing and support, please Contact the author.

J Framework

Key Benefits

J-Framework provides many direct benefits for Development, Operations, and DevOps engineers. Below are some of the many benefits:

  1. Elegant and easy-to-use Configuration API that covers the needs of applications of all scales, from standalone, monolithic, to microservices-based systems; In addition to a large set of APIs, tools, and wrappers that enable faster and efficient software development, such as Exception Handing API, Caching, Logging, and many others, which all part of J-Framework-Core project.

  2. Elegant and easy-to-use Data API that utilizes a unified configuration, connection pool, and components of JDBC, JPA, and NoSQL along with intensive logging, audit-trail, timing, and many others using J-Framework-Data projects.

  3. Efficient development of Java Web Applications by enabling Faces-4, CDI-4, and Persistence-3.1 on Tomcat-10.1 with zero configurations; in addition to providing a set of defaults, listeners, filters,APIs, and tools using J-Framework-Web project.

  4. Efficient web development approach by providing Embedded Web Server which is mainly a tuned wrapper for Tomcat-10.1 web server, using J-Framework-Standalone project.

  5. Efficient development of both: traditional and mature Microservices development using J-Framework-Service project.

  6. Elegant and easy-to-use Microservices Client using J-Framework-ServiceClient project.

  7. Fast and easy End-to-End Java Database Driven Web Application development with zero-configurations, including security, reusable web controllers, and data-access components using J-Framework-WebStack project.

Basic Usage

All that you need to be able to utilize most of the components in the framework, is to Create a Maven Project and replace your pom.xml with the following contents:

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.jalalkiswani</groupId>
		<artifactId>j-app-webstack</artifactId>
		<version>7.0.0-SNAPSHOT</version>
	</parent>
	<artifactId>j-framework-webstack-example</artifactId>
	<packaging>war</packaging>
</project>

If you are using an Eclipse-based IDE, be sure to refresh your project (select your project→ right click→ Maven→ Update Project)

Create a main class with the following contents:

package com.app;

import com.jk.web.embedded.JKWebApplication;

public class App {
	public static void main(String[] args) {
		JKWebApplication.run();
	}
}

If you are using an Eclipse-based IDE, just copy the code above, and paste it into the source folder, and eclipse will create the package structure and the java file for you with the contents you pasted.

That’s it. Now, run your App class, and your browser will open to localhost:8080 with the following user interface.

webapp

You need to enable snapshot versions to be able to use the UNLICENSED version of the framework. To enable the snapshot version, add the following code to your settings.xml file available at USER-HOME/.m2

<profiles>
  <profile>
     <id>allow-snapshots</id>
        <activation><activeByDefault>true</activeByDefault></activation>
     <repositories>
       <repository>
         <id>snapshots-repo</id>
         <url>https://oss.sonatype.org/content/repositories/snapshots</url>
         <releases><enabled>false</enabled></releases>
         <snapshots><enabled>true</enabled></snapshots>
       </repository>
     </repositories>
   </profile>
</profiles>

Instant Benefits

With this, you gain the following benefits instantly:

Maven Benefits:

  1. The compiler plugin is set to use JDK 17+.

  2. War plugin set to run without complaining about web.xml.

  3. All the dependencies are aligned to work together smoothly without conflicts.

  4. Ability to load Maven properties from the maven.properties file.

  5. Proper exclusions of dependencies such as Tomcat Embedded libraries and other runtime libraries, to save developers and deployers time thinking about run-time dependencies issues.

  6. Enable snapshots by default, which could be useful for the internal development of components such as libraries and microservices (you can disable them if of course needed).

Web Server Benefits:

  1. Embedded Tomcat server configured and launched for you on port 8080 (you can change the port number).

  2. The browser is opened for you on the app root.

Generated Code:

  1. Facelet template created in src/main/webapp/WEB-INF/templates/default.xhtml.

  2. Beans file located in src/main/webapp/WEB-INF/beans.xml, which is required to enable CDI (while beans.xml has become optional in the latest JEE versions, Weld still looks for it)

  3. Default faces pages are located at src/main/webapp/index.xhtml, which you can use as the template for your faces views/pages.

Data Benefits:

The following configured and ready to run with zero-config:

  1. H2 database.

  2. C3P0 Connection pool.

  3. JPA (Java/Jakarta Persistence API 3.1) based on Hibernate implementation.

  4. Unified Configurations for all your data components such as JDBC, JPA, Connection-Pool, and NoSQL.

Web Benefits:

The following is ready and configured to run on TOMCAT 10.1+:

  1. JSF (Java/Jakarta Server Faces 4, CDI-4, JSP-3.1, Omnifaces-4, PrimeFaces 12).

  2. Set of configurations, listeners, and filters that make your life easier.

Microservices Benefits:

  1. REST Microservices support.

  2. Set of configurations, filters, listeners, and APIs that can save you a lot of headaches.

Main Projects

J-Framework is an end-end Java development framework that enables faster and more efficient software development. It consists of many subprojects; the following are some of them:

  • J-Framework-Core is a set of libraries and APIs that includes Configuration Management, Exception Handling, Context API, Logging, and many other utilities such as I/O , reflection, String, Collections…​etc.

  • J-Framework-Data is a zero-config Data Access API that enables the best of JDBC and JPA, with a unified configuration, and elegant API, with intensive features around these APIs including ease of development, logging, auditing, timing, and monitoring.

  • J-Framework-Web is a project that enables zero-config setup for Java/JakartaEE-10 Web Apps on Tomcat, it consists of all the needed dependencies and configurations of Faces 4 (JSF), PrimeFaces 12, CDI 4 (Weld), and Omnifaces-4, in addition of a set of Listeners and Filters that enables many features such as automatic configuration detections, logging initializations, and proper bootstrapping and shutting-down to enable clean approach of hot deployment.

  • J-Framework-Standalone is a zero-config wrapper of Tomcat Embedded web server that contains some utilities and enhancements, it enables faster software development by eliminating the need to configure and run external web server to develop Java Web Applications (JSF, JSP or, Servlets) and Microservice.

  • J-Framework-Service is a zero-config project that enables a faster approach toward Jakarta EE 10 microservices development, it consists of all the needed dependencies, configurations, and proper listeners and filters to have reliable software development such as exception handlers and context synchronization.

  • J-Framework-ServiceClient is a project that helps Java developers call microservice in an efficient approach that includes proper configuration, timing, exception handling, unified logging, and others.

  • J-Framework-WebStack is a zero-config project that enables Java software developers to build end-end Java web applications that communicates with databases or microservices with zero-config including out-of-the-box features such as security and data-management components.