Software Programming: Spring Boot

How to Implement Design Patterns in Spring Boots Application

In a Spring Boot web project, design patterns are essential to create a maintainable, scalable, and testable application. Below are some common design patterns and how you can implement them in a Spring Boot project:
Singleton PatternThe Singleton pattern ensures a class has only one instance and provides a global point of access to it. In Spring, beans are singleton by default.
For Example :

Factory Pattern
The Factory pattern is used to create objects without specifying the exact class of object that will be created.

For Example :
Usage in a Controller

Prototype Pattern
The Prototype pattern is used to create a new instance of a class by copying or cloning an existing instance.

For Example :

Adapter Pattern
The Adapter pattern allows incompatible interfaces to work together. In a Spring Boot project, it can be used to integrate third-party libraries.

For Example :Suppose you have an external logging service that doesn't fit directly into your logging system.
Usage:
Decorator Pattern
The Decorator pattern is used to add behavior to individual objects without affecting the behavior of other objects from the same class.
Example:

Observer Pattern
The Observer pattern allows an object to notify other objects when its state changes.
Example:

Usage in a Service:

Template Method Pattern
The Template Method pattern defines the skeleton of an al algorithm in a method, deferring some steps to subclasses.
Example:

Usage:

Conclusion: Design patterns are critical in developing well-structured, maintainable, and flexible Spring Boot applications. They help in decoupling components, reusing code, and making the application easier to understand and extend. By leveraging these patterns in your Spring Boot project, you can achieve better code organization and more effective application design.

Inversion of Control (IoC) in Spring Frameworks

IOC , java , Spring Boot 1 comment :

IoC stands for "Inversion of Control", a principle in software engineering where the control of objects or portions of a program is transferred to a framework or container. This concept is fundamental to achieving loose coupling in object-oriented design, which makes applications more modular, flexible, and easier to maintain.
Key Concepts of Inversion of Control :

Dependency Injection (DI)

The most common implementation of IoC.
Dependencies (objects that a class requires to function) are injected into the class rather than the class creating them itself.
Can be implemented in three main ways: constructor injection, setter injection, and interface injection.

Service Locator

An alternative to dependency injection.
A central registry (the service locator) provides dependencies upon request.
Can lead to less transparency in dependency management compared to DI.

How IoC Works:

Without IoC.

With IoC (Dependency Injection).

In the example above, with IoC, the `Car` class does not create the `Engine` instance itself. Instead, it receives it from an external source (typically an IoC container).
Benefits of IoC:

Decoupling: Reduces the dependency between components, making the system more modular. Testability: Easier to test components in isolation since dependencies can be easily mocked or stubbed. Flexibility: Easier to swap out implementations of dependencies without modifying the dependent class.

Maintainability: Simplifies code management and maintenance by following the single responsibility principle.

IoC Containers: IoC containers are frameworks that manage the creation and injection of dependencies. Some popular IoC containers are:
Spring (Java): Provides comprehensive support for dependency injection and IoC.

PicoContainer (Java): Lightweight and simple to use.

Unity (C#): A dependency injection container from Microsoft.

Autofac (C#): A popular IoC container for .NET applications.

Example in Spring Framework:

Spring Framework is a well-known example of an IoC container. Here’s how dependency injection is typically configured in a Spring application:

XML Configuration:

Java Configuration:

Annotation-Based Configuration:

In these examples, the Spring container manages the lifecycle and injection of the `Engine` dependency into the `Car` class. In summary, IoC is a design principle that helps to create flexible, maintainable, and testable software systems by inverting the control of dependency management. Dependency injection is the most common pattern used to implement IoC, and it is supported by various frameworks and containers across different programming languages.

Multiples DATABASE Connection and Data shifting Using Spring Boots API

Data shifting , java 8 , Microservices , Multiples DATABASE Connection , Spring Boot No comments :

Multiple DataBase Connection and Data shifting using Spring boot API configuration Example.

Step-by-step Write Java files.
1. application.properties File for Add multiple DataBase Connection.

2. DBConfigDBNAME.JAVA Files for multiple DataBase Connection.

3. Job Scheduler.java file for Auto shift programm.

4. Entity Beans, Repository, Services Implementations for Binding and shifting Data.

Create Spring Boot Java (Microservices)

Create Spring Boot Java (Microservices).

Project Name: DataShiftingConfigSpringBoots
Group: DataShifting-a143mk
Artifactid: DataShifting-a143mk
Description: DataBase Connection and Data shifting using Spring boot API.
Package: DataShiftinga143mk

Select the technologies and library(Maven Dependency ) to be.

spring-boot-configuration-processor
ojdbc8

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

pom.xml

<groupId>DataShiftinga143mk</groupId>
	<artifactId>DataShifting-a143mk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<version>0.0.1-SNAPSHOT</version>
	<name>DataShiftingConfigSpringBoots</name>
	<description>DataBase Connection and Data shifting using Spring boot API</description>

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.3.RELEASE</version>
		<relativePath/> 
	</parent>

<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

<dependency>
 <groupId>com.oracle.database.jdbc</groupId>
 <artifactId>ojdbc8</artifactId>
 <version>12.2.0.1</version>
 </dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>
	</dependencies>

<build>
		<plugins>
			
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>

<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				
				<configuration>
					<useFile>false</useFile>
					<includes>
						<include>**/*Spec.java</include>
					</includes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

1. Configure application.properties

spring.jpa.database=default
spring.jpa.generate-ddl=true
server.port=9191

#  DB - "DATABASE1"
DATABASE1.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE1.datasource.url=jdbc:oracle:thin:@100.00.0.001:1521/serviceName(SID)
DATABASE1.datasource.username=db1UserName
DATABASE1.datasource.password=db1Password

#  DB - "DATABASE2"
DATABASE2.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE2.datasource.url=jdbc:oracle:thin:@100.00.1.002:1521/serviceName(SID)
DATABASE2.datasource.username=db2UserName
DATABASE2.datasource.password=db2Password

#  DB - "DATABASE3"
DATABASE3.datasource.driver-class-name=oracle.jdbc.OracleDriver
DATABASE3.datasource.url=jdbc:oracle:thin:@100.00.1.003:1521/serviceName(SID)
DATABASE3.datasource.username=db3UserName
DATABASE3.datasource.password=db3Password

#### LOGE FILE BLOCK#####
logging.level.org.springframework.web=INFO
logging.level.guru.springframework.controllers=DEBUG
logging.level.org.hibernate=ERROR
logging.file=logs/SHIPTING/masterShift.log
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

Create DataBase Configuration java Files :
DBConfigDATABASE1.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE1EntityManagerFactory",
    transactionManagerRef = "DATABASE1TransactionManager", basePackages = {"com.a143mk.DATABASE1.CustomerRepo"})
public class DATABASE1DbConfig {

@Bean(name = "DATABASE1DataSource")
  @ConfigurationProperties(prefix = "DATABASE1.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE1EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE1EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE1DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE1.CustomerEntity").persistenceUnit("DATABASE1")
        .build();
  }

@Bean(name = "DATABASE1TransactionManager")
  public PlatformTransactionManager DATABASE1TransactionManager(
      @Qualifier("DATABASE1EntityManagerFactory") EntityManagerFactory DATABASE1EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE1EntityManagerFactory);
  }

}

DBConfigDATABASE2.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE2EntityManagerFactory",
    transactionManagerRef = "DATABASE2TransactionManager", basePackages = {"com.a143mk.DATABASE2.CustomerRepo"})
public class DATABASE2DbConfig {

@Bean(name = "DATABASE2DataSource")
  @ConfigurationProperties(prefix = "DATABASE2.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE2EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE2EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE2DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE2.CustomerEntity").persistenceUnit("DATABASE2")
        .build();
  }

@Bean(name = "DATABASE2TransactionManager")
  public PlatformTransactionManager DATABASE2TransactionManager(
      @Qualifier("DATABASE2EntityManagerFactory") EntityManagerFactory DATABASE2EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE2EntityManagerFactory);
  }

}

DBConfigDATABASE3.java

package com.a143mk;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "DATABASE3EntityManagerFactory",
    transactionManagerRef = "DATABASE3TransactionManager", basePackages = {"com.a143mk.DATABASE3.CustomerRepo"})
public class DATABASE3DbConfig {

@Bean(name = "DATABASE3DataSource")
  @ConfigurationProperties(prefix = "DATABASE3.datasource")
  public DataSource dataSource() {
    return DataSourceBuilder.create().build();
  }

@Bean(name = "DATABASE3EntityManagerFactory")
  public LocalContainerEntityManagerFactoryBean DATABASE3EntityManagerFactory(
      EntityManagerFactoryBuilder builder, @Qualifier("DATABASE3DataSource") DataSource dataSource) {
    return builder.dataSource(dataSource).packages("com.a143mk.DATABASE3.CustomerEntity").persistenceUnit("DATABASE3")
        .build();
  }

@Bean(name = "DATABASE3TransactionManager")
  public PlatformTransactionManager DATABASE3TransactionManager(
      @Qualifier("DATABASE3EntityManagerFactory") EntityManagerFactory DATABASE3EntityManagerFactory) {
    return new JpaTransactionManager(DATABASE3EntityManagerFactory);
  }

}

Create Scheduler ClassCreate Scheduler for Auto run Program and import some Packages Scheduler.java as below:

package com.a143mk.schedule;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import com.a143mk.DATABASE3.ServiceImpl.MastCustomerDATABASE3ServiceImpl;
import com.a143mk.DATABASE2.ServiceImpl.MastCustomerDATABASE2ServiceImpl;
import com.a143mk.DATABASE1.CustomerServicesImpl.CustomerMasterDATABASE1SericesImpl;
@EnableScheduling
@Configuration
public class Scheduler {
	
	
	@Autowired
	private CustomerMasterDATABASE1SericesImpl custDATABASE1ServiceImpl;
	
	@Autowired
	private MastCustomerDATABASE3ServiceImpl DATABASE3CustomerServiImpl;
	
	@Autowired
	private  MastCustomerDATABASE2ServiceImpl  DATABASE2CustServeImple;

@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE1() throws Exception {
		custDATABASE1ServiceImpl.customerinsertToDATABASE1();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE3() throws Exception {
	 DATABASE3CustomerServiImpl.customerinsertToDATABASE3();	
	}
	
	@Scheduled(cron = "0 */1 * ? * *")
	public void customerScheduletoDATABASE2() throws Exception {
	DATABASE2CustServeImple.customerinsertToDATABASE2();	
	}

}

Have you seen the previous post? You all know how to learn and create Entity Bean, Repository, Service Implementation in the project. If you don't know about it then go to the previous post and learn it.

How to PACKAGE Spring Boot application to JAR and WAR

java , java 8 , Spring Boot No comments :

Maven is a popular build tool, that takes your project’s Java source code, compiles it, tests it and converts it into an executable Java program: either a .jar or a .war file.

Package Spring Boot application to JAR OR WAR file:
The default packaging type of a Spring Boot project is jar if the attribute is not present in the pom.xml file. It’s better to check your project’s pom.xml file to make sure that the packaging type is jar or War:

If you use an IDE such as Eclipse or Spring Tool Suite, right-click on the project, then select Run As > Maven Configuration Like:

CLEAN
BUILD
INSTALL
PACKAGE.................etc.

LDAP Authentication with Spring Boots

java , LDAP , Spring Boot 3 comments :

LDAP is a lightweight version of the Directory Access Protocol (DAP).LDAP’s primary function is enabling users to find data about organizations, persons, and more. It accomplishes this goal by storing data in the LDAP directory and authenticating users to access the directory. It also provides the communication language that applications require to send and receive information from directory services.

Step-by-step authentication process with Some Ldap properties.
The client (an LDAP-ready system or application) sends a request to access information stored within an LDAP database. The client provides their LDAP server user credentials (username and password). The LDAP server cross-checks the user’s submitted credentials against the core user identity data stored in its LDAP database. If the provided credentials match the stored core user identity, the client can access the requested information. Incorrect credentials will lead to denied access to the LDAP database.

Some Ldap properties.

ldap.enable=true	Enable / disable LDAP support.
ldap.ldapUrl=ldap://HostIP:389	The URL/IP to your LDAP server, including port
ldap.ldapSystemDN=cn=Administrator,dc=olattest,dc=org	System user: used for getting all users and connection testing
ldap.ldapSystemPW=mySuperPassword	The LDAP password of the system user
ldap.ldapBases= ou=person,dc=olattest,dc=org	List of bases where to find users. To use multiple bases you must edit the config file manually
ldap.sslEnabled = false	Enable SSL connection
ldap.trustStoreLocation=/usr/lib/j2sdk1.5-sun/jre/lib/security/cacerts	Location of the Java trust store
ldap.trustStorePwd=changeit	The Java trust store password
ldap.trustStoreType=JKS	The Java trust store type
ldap.cacheLDAPPwdAsOLATPwdOnLogin=true	When users log in via LDAP, the system can keep a copy of the password as encrypted hash in the database. This makes OLAT more independent from an offline LDAP server and users can use their LDAP password to use the WebDAV functionality. When setting to true (recommended), make sure you configured password.change.allowed=false
ldap.convertExistingLocalUsersToLDAPUsers=true	When the system detects an LDAP user that does already exist in OLAT but is not marked as LDAP user, the OLAT user can be converted to an LDAP managed user. When enabling this feature you should make sure that you don't have a user 'administrator' in your ldapBases (not a problem but not recommended)
ldap.deleteRemovedLDAPUsersOnSync=false	Users that have been created vial LDAP sync but now can't be found on the LDAP anymore can be deleted automatically. If unsure, set to false and delete those users manually in the LDAP administration panel.
ldap.deleteRemovedLDAPUsersPercentage=50	Sanity check when deleteRemovedLDAPUsersOnSync is set to 'true': if more than the defined percentages of user accounts are not found on the LDAP server and thus recognized as to be deleted, the LDAP sync will not happen and require a manual triggering of the delete job from the admin interface. This should prevent accidential deletion of OLAT user because of temporary LDAP problems or user relocation on the LDAP side. Value= 0 (never delete) to 100 (always delete).
ldap.ldapSyncOnStartup=true	Should users be created and synchronized automatically on startup? If you set this and the cron configuration to false, the users will be generated on-the-fly when they log in the first time.
ldap.ldapSyncCronSync=true	Should users be created and synchronized periodically, not just during startup? If you set this and the startup configuration to false, the users will be generated on-the-fly when they log in the first time.
ldap.ldapSyncCronSyncExpression=0 0 * * * ?	Set the rule how often the LDAP synchronization should take place. Default is every hour. For the cron syntax see quartz cron syntax documentation
ldap.ldapUserObjectClass=person	Configuration for syncing user attributes during login or cron and batch sync. The user object class to use.
ldap.ldapUserCreatedTimestampAttribute=createdTimestamp	The LDAP attribute that tells the creation date of the LDAP user. In active Directory this is typically "whenCreated", in OpenLDAP "createdTimestamp". If not available, use the same as for the last modified date.
ldap.ldapUserLastModifiedTimestampAttribute=modifyTimestamp	The LDAP attribute that tells the creation date of the LDAP user. In active Directory this is typically "whenChanged", in OpenLDAP "modifiedTimestamp"
ldap.attributename.useridentifyer=uid	Mapping of the LDAP user identifyer to an OLAT user. In Active Directory this is typically "sAMAccountName", in OpenLDAP "uid".
ldap.attributename.email=mail	Mapping of the mandatory OLAT user properties. In this example the LDAP attribute "mail" will be mapped to the OLAT user property "email"
ldap.attributename.firstName=givenName	Mapping of the mandatory OLAT user properties. In this example the LDAP attribute "givenName" will be mapped to the OLAT user property "firstname"
ldap.attributename.lastName=sn	Mapping of the mandatory OLAT user properties. In this example the LDAP attribute "sn" will be mapped to the OLAT user property "lastName"
olatprovider.enable=false	Disable the normal OLAT login screen. When you set ldap.cacheLDAPPwdAsOLATPwdOnLogin=true, a fallback to the normal OLAT login is made in case the LDAP server can not be reached. You can set this variable also to true to have the OLAT and the LDAP login screen available
default.auth.provider=LDAP	Use the LDAP login screen as the default login screen.

Create Spring Boot Java (Microservices) Project Example

Create Spring Boot Java (Microservices).

Project Name: LdapAuthenticationConfigSpringBoots.
Group:Ldap-Auth-a143mk.
Artifactid:Ldap-Auth-a143mk.
Description:Learn-Configure LDAP Authentication.
Package:LDAPAutha143mk.

Select the technologies and library(Maven Dependency ) to be.

Spring Web
Spring ldap
ldapsdk
ldap security

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<?xml version="1.0" encoding="UTF-8"?>
<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>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.4.RELEASE</version>
		<relativePath/> 
	</parent>
	<groupId>Ldap-Auth-a143mk</groupId>
	<artifactId>Ldap-Auth-a143mk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>LdapAuthenticationConfigSpringBoots</name>
	<description>Learn-Configure LDAP Authentication</description>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
		<groupId>org.springframework.ldap</groupId>
		<artifactId>spring-ldap-core</artifactId>
</dependency>
<dependency>
		<groupId>org.springframework.security</groupId>
		<artifactId>spring-security-ldap</artifactId>
</dependency>
<dependency>
		<groupId>com.unboundid</groupId>
		<artifactId>unboundid-ldapsdk</artifactId>
</dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
			<optional>true</optional>
		</dependency>
		
</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</pluginRepository>
	</pluginRepositories>

</project>

Configure application.properties

Create ldap-data.ldif :
Directory Server uses LDAP Data Interchange Format is a standard text format for representing LDAP objects and LDAP updates (add, modify, delete, modify DN) in a textual form.

WebSecurityConfig ClassCreate new package, named LDAPAutha143mk.config. In this package, create Configuration class name is WebSecurityConfig.java as below:

package LDAPAutha143mk.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
@Configuration
public class WebSecurityConfig  extends WebSecurityConfigurerAdapter{
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.authorizeRequests().anyRequest().fullyAuthenticated().and().formLogin();
		http.csrf().disable();
	}
	  @Autowired
	  public void configure(AuthenticationManagerBuilder auth) throws Exception {
	    auth
	      .ldapAuthentication()
	        .userDnPatterns("uid={0},ou=people")
	        .groupSearchBase("ou=groups")
	        .contextSource()
	          .url("ldap://localhost:8389/dc=springframework,dc=org")
	          .and()
	        .passwordCompare().passwordAttribute("userPassword");      
	  }
}

Create Controllers
Create new package named LDAPAutha143mk.controller. In this package, create new java class named LoginWelcomeController.java

Run Project

Download Projects

Learn I- Report configuration with Spring boot/Microservices using Java

iReport , java 8 , Microservices , Spring Boot 1 comment :

iReport
iReport is a powerful graphical design tool for report designers and power users to define reports for execution using the JasperReports engine. Whether you are using the JasperReports library by itself as a critical component of your application or you are using it as a component of the JasperReports Server application, iReport can help you design reports to meet the most complex reporting demands. iReport is built on the NetBeans platform and is available as a standalone application or as a Netbeans plug-in.
Requirements For current Download JasperReports iReport Tools , Ckeck It is recommended that you run iReport with JDK v1.5,v1.6 or v1.7. Note that for Windows Vista users, it is recommended that you run JDK v1.7.

JasperReports Create very sophisticated layouts containing charts, images, subreports, crosstabs and much more. Access your data through JDBC, TableModels, JavaBeans, XML, Hibernate, CSV, and custom sources. Then publish your reports as PDF, RTF, XML, XLS, CSV, HTML, XHTML, text, DOCX, or OpenOffice. Through this post, we will tell you how to configure iReport in Mavan base java application(Microservices) project. follows step by step:

Create Spring Boot Java (Microservices)
Create/Design report.jrxml

Create Spring Boot Java (Microservices).

Project Name: I-ReportConfigurationApp
Group:I-Report-a143mk
Artifactid:I-Report-a143mk
Description:Learn I- Report configuration with Microservices Application
Package:I-Report-a143mk

Select the technologies and library(Maven Dependency ) to be.

Spring Web
Spring JPA
Jasperreports
javax.persistence
Tomcat
javax.servlet
mysql
jstl

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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>
	<url>http://maven.apache.org</url>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.4.RELEASE</version>
		<relativePath/>
	</parent>
	<groupId>I-Report-a143mk</groupId>
	<artifactId>I-Report-a143mk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>I-ReportConfigurationApp</name>
	<description>Learn I- Report configuration with Microservices Application</description>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
	
 <dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<dependency>
			<groupId>javax.servlet.jsp.jstl</groupId>
			<artifactId>javax.servlet.jsp.jstl-api</artifactId>
			<version>1.2.1</version>
		</dependency>

<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>1.1.2</version>
		</dependency>
		
		
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
			<scope>provided</scope>
		</dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

<dependency>
			<groupId>net.sf.jasperreports</groupId>
			<artifactId>jasperreports</artifactId>
			<version>6.7.0</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
		</dependency>
		 <dependency>
 <groupId>javax.persistence</groupId>
 <artifactId>javax.persistence-api</artifactId>
 <version>2.2</version>
 </dependency>
 <dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>

<dependency>
 <groupId>javax.servlet</groupId>
 <artifactId>javax.servlet-api</artifactId>
 <version>3.0.1</version>
 <scope>provided</scope>
 </dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.scala-lang</groupId>
			<artifactId>scala-library</artifactId>
			<version>2.11.0</version>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

For step by step development working watch the video and learn yourself. Download wampServer2.0i and install then run it.

1. Create Database: Database Name is hostel.
2. Create Table: Table Name is product.

Configure application.properties

Report:

In src/main/resources/reports/report.jrxml folder, create new folder named reports. In this folder, create new Jasper Report named report.jrxml as below:

Code:

<?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="report1" pageWidth="595" pageHeight="842" columnWidth="555" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20" uuid="84feeac3-d1f7-4503-84bf-fc3fa153df55">
	<property name="ireport.zoom" value="1.0"/>
	<property name="ireport.x" value="0"/>
	<property name="ireport.y" value="0"/>
	<queryString>
		<![CDATA[]]>
	</queryString>
	<field name="id" class="java.lang.Integer"/>
	<field name="price" class="java.math.BigDecimal"/>
	<field name="quantity" class="java.lang.Integer"/>
	<field name="categoryName" class="java.lang.String"/>
	<field name="name" class="java.lang.String"/>
	<background>
		<band splitType="Stretch"/>
	</background>
	<title>
		<band height="36" splitType="Stretch"/>
	</title>
	<pageHeader>
		<band height="49" splitType="Stretch">
			<staticText>
				<reportElement x="0" y="10" width="555" height="30" uuid="04d35299-5eb0-4a34-b340-3ca5cf8290fc"/>
				<textElement textAlignment="Center">
					
				</textElement>
				<text><![CDATA[Welcome to Product List]]></text>
			</staticText>
		</band>
	</pageHeader>
	<columnHeader>
		<band height="37" splitType="Stretch">
			<staticText>
				<reportElement x="0" y="10" width="70" height="20" uuid="bcaf85c0-57ff-4a34-af27-cbf1330125ae"/>
				<textElement>
					
					<paragraph leftIndent="5"/>
				</textElement>
				<text><![CDATA[Id]]></text>
			</staticText>
			<staticText>
				<reportElement x="90" y="10" width="100" height="20" uuid="faf9b9ee-7cf2-4ea5-80b8-d371c3c753b9"/>
				<textElement>
					
					<paragraph leftIndent="5"/>
				</textElement>
				<text><![CDATA[Name]]></text>
			</staticText>
			<staticText>
				<reportElement x="210" y="10" width="70" height="20" uuid="93727672-9f69-4856-aa26-33837e8dc417"/>
				<textElement>
					
					<paragraph leftIndent="5"/>
				</textElement>
				<text><![CDATA[Price]]></text>
			</staticText>
			<staticText>
				<reportElement x="314" y="10" width="70" height="20" uuid="09b47abe-09b2-479a-bb76-9770e361a23c"/>
				<textElement>
					
					<paragraph leftIndent="5"/>
				</textElement>
				<text><![CDATA[Quantity]]></text>
			</staticText>
			<staticText>
				<reportElement x="410" y="10" width="100" height="20" uuid="c258f47b-da6a-418d-a5e0-892388ec65c5"/>
				<textElement>
					
					<paragraph leftIndent="5"/>
				</textElement>
				<text><![CDATA[Category Name]]></text>
			</staticText>
		</band>
	</columnHeader>
	<detail>
		<band height="39" splitType="Stretch">
			<textField>
				<reportElement x="0" y="4" width="70" height="16" uuid="99fa4c16-cfe2-4482-828e-4439abb9e8f0"/>
				<textElement>
					<paragraph leftIndent="5"/>
				</textElement>
				<textFieldExpression><![CDATA[$F{id}]]></textFieldExpression>
			</textField>
			<textField>
				<reportElement x="210" y="4" width="70" height="16" uuid="ba6e9cfa-6d4c-470b-8bc4-eb2e3411c21e"/>
				<textElement>
					<paragraph leftIndent="5"/>
				</textElement>
				<textFieldExpression><![CDATA[$F{price}]]></textFieldExpression>
			</textField>
			<textField>
				<reportElement x="310" y="4" width="70" height="16" uuid="447253d3-d268-4873-b0b7-9c174c6a7c9f"/>
				<textElement>
					<paragraph leftIndent="5"/>
				</textElement>
				<textFieldExpression><![CDATA[$F{quantity}]]></textFieldExpression>
			</textField>
			<textField>
				<reportElement x="410" y="4" width="100" height="16" uuid="8992d0ad-1f5e-4210-b50b-1e29dc66f119"/>
				<textElement>
					<paragraph leftIndent="5"/>
				</textElement>
				<textFieldExpression><![CDATA[$F{categoryName}]]></textFieldExpression>
			</textField>
			<line>
				<reportElement x="-3" y="27" width="521" height="1" uuid="9b493a65-a499-4199-90bb-b3fedbe45f85"/>
			</line>
			<textField>
				<reportElement x="90" y="4" width="100" height="16" uuid="fcdd8979-dc44-46e3-be56-11e5f33b8e0c">
					<property name="com.jaspersoft.studio.spreadsheet.connectionID" value="73fad7b3-74b5-4436-bd46-d2b9c3c113fd"/>
				</reportElement>
				<textElement>
					<paragraph leftIndent="5"/>
				</textElement>
				<textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
			</textField>
		</band>
	</detail>
	<columnFooter>
		<band height="45" splitType="Stretch"/>
	</columnFooter>
	<pageFooter>
		<band height="54" splitType="Stretch"/>
	</pageFooter>
	<summary>
		<band height="42" splitType="Stretch"/>
	</summary>
</jasperReport>

Entities Class

Create new package, named IReporta143mk.entities. In this package, create entities class name is Product.java as below:

package IReporta143mk.entities;

import java.math.BigDecimal;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "product")
public class Product {

@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	private String name;
	private BigDecimal price;
	private int quantity;
	@Column(name = "category_name")
	private String categoryName;

public int getId() {
		return id;
	}

public void setId(int id) {
		this.id = id;
	}

public String getName() {
		return name;
	}

public void setName(String name) {
		this.name = name;
	}

public BigDecimal getPrice() {
		return price;
	}

public void setPrice(BigDecimal price) {
		this.price = price;
	}

public int getQuantity() {
		return quantity;
	}

public void setQuantity(int quantity) {
		this.quantity = quantity;
	}

public String getCategoryName() {
		return categoryName;
	}

public void setCategoryName(String categoryName) {
		this.categoryName = categoryName;
	}

}

Create ProductRepository Interface
Create new package named IReporta143mk.repositories. In this package create the ProductRepository interface implements from CrudRepository interface of Spring Data JPA that provides CRUD Operations for an entity.

Create ProductService Interface
Create new package named IReporta143mk.services. In this package create the ProductService interface and ProductServiceImpl as below:
First one is ProductService.java

Second one is ProductServiceImpl.java

Create Controllers
Create new package named IReporta143mk.controllers. In this package, create new java class named ProductController.java

package IReporta143mk.controllers;
import java.io.InputStream;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import IReporta143mk.services.ProductService;
import net.sf.jasperreports.engine.DefaultJasperReportsContext;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.export.HtmlExporter;
import net.sf.jasperreports.export.SimpleExporterInput;
import net.sf.jasperreports.export.SimpleHtmlExporterOutput;

@Controller
public class ProductController {

@Autowired
	private ProductService productService;

@RequestMapping("/index")
	public String index(ModelMap modelMap) {
		return "jsp/index";
	}

@RequestMapping(value = "report", method = RequestMethod.GET)
	public void report(HttpServletResponse response) throws Exception {
		response.setContentType("text/html");
		JRBeanCollectionDataSource dataSource = new JRBeanCollectionDataSource(productService.report());
		InputStream inputStream = this.getClass().getResourceAsStream("/reports/report.jrxml");
		JasperReport jasperReport = JasperCompileManager.compileReport(inputStream);
		JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, null, dataSource);
		HtmlExporter exporter = new HtmlExporter(DefaultJasperReportsContext.getInstance());
		exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
		exporter.setExporterOutput(new SimpleHtmlExporterOutput(response.getWriter()));
		exporter.exportReport();
	}

}

Create jsp page
Create new folder name is jsp. In thes folder /src/main/webapp/WEB-INF/jsp/index.jsp

Structure of Spring Boot Project:

Out Put:

Download Projects

Single Sign-On (SSO) Using SMTP Authentication With Spring Boot Microservices

java 8 , Microservices , Single Sign-On (SSO) , Spring Boot 2 comments :

Single sign-on is an authentication scheme that allows a user to log in with a single ID to any of several related, independent, software systems or web applications. In this Video user will login through Outlook and Google Mail for which we will develop Spring Boot Microservices Project here and will also use some Spring Boot Jar files javax.mail.jar and SendMailA143mkSSO.jar.

Process of Single sign-On (SSO) Authentication:

Download both the jar file and implement some methods / functions have been used, the names of the methods are as follows:

Create Class object SendMailA143mk getsess=new SendMailA143mk();

LoginMailAuthHost_PortA143mk();
OutLookMailAuthA143mk();
GmailMailAuthA143mk();

There are some parameters in five methods, which we initialize by creating and object like this.

String toAuthmail="EmailMail@mailDomen.com";

String toAuthmailPassword="mailPassword";

String host="smtp.office365.com";

String port="587";

How to create a project to follow us. Project Name is: EmailAuthenticationA143mk

while creating the project pom.xml file and some maven dependency, main class is automatically created when web add any dependency like.

pom.xml

<groupId>sso.a143mk</groupId>
	<artifactId>spring-sso</artifactId>
	 <version>1.5.4.RELEASE</version>
	<packaging>jar</packaging>

<name>EmailAuth</name>
	<description>Spring SSO (Singl Sign-On )example to deploy microservice</description>

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.6.RELEASE</version>
		<relativePath/> 
	</parent>

<dependencies>
		
	<dependency>
<groupId>com.a143mkMail</groupId>
 <artifactId>example-Mail</artifactId>
 <version>${activemq.version}</version>
 <scope>system</scope>
<systemPath>D:/Z-manoj/MY_JAR/mailJAR/javax.mail.jar</systemPath>
</dependency>
	
	 <dependency>
 <groupId>com.a143mkFN</groupId>
	 <artifactId>example-Mail</artifactId>
	 <version>${activemq.version}</version>
 <scope>system</scope>
 <systemPath>D:/Z-manoj/MY_JAR/mailJAR/SendMailA143mkSSO.jar</systemPath>
 </dependency>
 
 <dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-tomcat</artifactId>
 </dependency>
 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		
		<dependency>
 <groupId>org.apache.tomcat.embed</groupId> 
 <artifactId>tomcat-embed-jasper</artifactId>
 <scope>runtime</scope> 
 </dependency>
 <dependency>
 <groupId>javax.servlet</groupId> 
 <artifactId>jstl</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 </dependencies>
 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 <plugin>
 <groupId>org.apache.maven.plugins</groupId>
 <artifactId>maven-surefire-plugin</artifactId>
 <configuration>
 <useSystemClassLoader>false</useSystemClassLoader>
 </configuration>
 </plugin>
 </plugins>
 </build>
</project>

For step by step development working watch the video and learn yourself.

Download Projects

Some Helping Note: Some code and video are shown in this post, how we can use it in our application, the developer and jar file used in this is verified by mail id and password and after mail id is successful is returned, you can then write custom user roles and method entities in the block. and you can write error body in second part of it.

Subscribe to: Posts ( Atom )

How to Implement Design Patterns in Spring Boots Application

Inversion of Control (IoC) in Spring Frameworks

Multiples DATABASE Connection and Data shifting Using Spring Boots API

How to PACKAGE Spring Boot application to JAR and WAR

LDAP Authentication with Spring Boots

Learn I- Report configuration with Spring boot/Microservices using Java

Single Sign-On (SSO) Using SMTP Authentication With Spring Boot Microservices

OUR TECH-PROJECTS

DOWNLOAD ANY ONLINE VIDEOS

LABELS

Development Accessories

POPULAR POSTS