Software Programming: Spring Boot

Wednesday 27 December 2023

Multiples DATABASE Connection and Data shifting Using Spring Boots API

December 27, 2023 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.

Tuesday 19 September 2023

How to PACKAGE Spring Boot application to JAR and WAR

September 19, 2023 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.

Monday 26 June 2023

LDAP Authentication with Spring Boots

June 26, 2023 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

Wednesday 17 May 2023

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

May 17, 2023 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

Tuesday 3 January 2023

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

January 03, 2023 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.

Wednesday 13 July 2022

Social Client Login with OAuth2 Spring Boot Application

July 13, 2022 java , Microservices , OAuth2 Security , Spring Boot 2 comments :

First of all you have to take auth2 access to the social web site, we see it in the video, then we will create a services and test it and see some services we learned in the previous post, we will give their link below which includes Eureka (client-1, client-2), ApiGetway, services.

Add client and secret Id in ApiGetway application.properties file:

spring.security.oauth2.client.registration.Oauth2_Security.client-id = Write your Client ID spring.security.oauth2.client.registration.Oauth2_Security.client-secret = Write your Secret ID

Add use Dependency in ApiGetway pom.xml file:

Add New Package in ApiGetway-> com.javatechie.spring.zulu.api.cofig and create SecurityConfiguration.java file.

package com.javatechie.spring.zulu.api.cofig;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.configuration.EnableGlobalAuthentication;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
@EnableGlobalAuthentication
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
	
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		
		http.csrf().disable().antMatcher("/**").authorizeRequests()
         .antMatchers("/cli-api/**","/cli2-api/**").authenticated()
         .anyRequest().authenticated()
         .and()
         .oauth2Login().permitAll()
         .and()
         .logout()
         .invalidateHttpSession(true)
         .clearAuthentication(true)
         .logoutSuccessUrl("/");
		
	}
}

See the video step by step to run/learn past post video and current configuration post.

How to Develop Some Other Rest API How to Develop Eureka Server and Eureka Client Configuration How to Develop GateWayAPI How to get Google Token

Wednesday 6 July 2022

OAuth2 Security with Spring Boot

July 06, 2022 java , OAuth2 Security , Spring , Spring Boot 1 comment :

Introduction
OAuth2 is a token-based security authentication and authorization framework that breaks security down into four components. These four components are

A protected resource—This is the resource (in our case, a microservice) you want to protect and ensure that only authenticated users who have the proper authorization can access
A resource owner—A resource owner defines what applications can call their service, which users are allowed to access the service, and what they can do with the service. Each application registered by the resource owner will be given an application name that identifies the application along with an application secret key. The combination of the application name and the secret key are part of the credentials that are passed when authenticating an OAuth2 token.
An application—This is the application that’s going to call the service on a behalf of a user. After all, users rarely invoke a service directly. Instead, they rely on an application to do the work for them.
OAuth2 authentication server—The OAuth2 authentication server is the intermediary between the application and the services being consumed. The OAuth2 server allows the user to authenticate themselves without having to pass their user credentials down to every service the application is going to call on behalf of the user.

OAuth2 is a token-based security framework. A user authenticates against the OAuth2 server by providing their credentials along with the application that they’re using to access the resource. If the user’s credentials are valid, the OAuth2 server provides a token that can be presented every time a service being used by the user’s application tries to access a protected resource (the microservice). The OAuth2 specification has four types of grants:

Password
Client credential
Authorization code
Implicit

To set up an OAuth2 authentication server, you need the following Spring Cloud dependencies in the authentication-service/pom.xml file

For Example: You have to Create Project Node Name is: "a143mk-Oauth2-Security" on STS4 Tools.

Pom.xml file.

<?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>2.1.3.RELEASE</version>
		<relativePath/> 
	</parent>
	<groupId>a143mk.Controller.jpa</groupId>
	<artifactId>springsecurity</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>a143mk-Oauth2-Security</name>
	<description>Demo project for Spring Boot Oauth2 Security</description>
	<properties>
		<java.version>1.8</java.version>
		<spring-cloud.version>Greenwich.SR3</spring-cloud.version>
		
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-oauth2</artifactId>
		</dependency>

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>${spring-cloud.version}</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>

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

</project>

Create AuthServer.java class for use Authorization Server Configuration.

package a143mk.Security;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.crypto.password.NoOpPasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;

@Configuration
@EnableAuthorizationServer
public class AuthServer extends AuthorizationServerConfigurerAdapter{

@Autowired
	AuthenticationManager authenticationManager;
	
	@Override
	public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
		clients.inMemory().withClient("abcds").secret("12345").scopes("read"). //abcd is client name/ID
		accessTokenValiditySeconds(1000)  // write the token expiry time.
		.authorizedGrantTypes("password","refresh_token");
		
		
		
	}

@SuppressWarnings("deprecation")
	@Override
	public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
		security.passwordEncoder(NoOpPasswordEncoder.getInstance());
		security.checkTokenAccess("isAuthenticated()").tokenKeyAccess("permitAll()");
		
	}

@Override
	public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
		 
		endpoints.authenticationManager(authenticationManager);
	}

}

The first thing to note in this listing is the @EnableAuthorizationServer annotation. This annotation tells Spring Cloud that this service will be used as an OAuth2 service and to add several REST-based endpoints that will be used in the OAuth2 authentication and authorization processes.

Like other pieces of the Spring Security framework, to set up users (and their roles), start by extending the WebSecurityConfigurerAdapter class and mark it with the @Configuration annotation.
As such, you need to provide the OAuth2 server a mechanism to authenticate users and return the user information about the authenticating user. This is done by defining two beans in your Spring WebSecurityConfigurerAdapter implementation: authenticationManagerBean() and userDetailsServiceBean(). These two beans are exposed by using the default authentication authenticationManagerBean() and userDetailsServiceBean() methods from the parent WebSecurityConfigurerAdapter class.
you have to Create ConfigWeb.java class.

package a143mk.Security;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@SuppressWarnings("deprecation")
@Configuration
public class ConfigWeb extends WebSecurityConfigurerAdapter{

@Bean
	public UserDetailsService userdetailsservice()
	{
		InMemoryUserDetailsManager user=new InMemoryUserDetailsManager();
		user.createUser(User.withUsername("abcd")
				.password(passwordEncoder().encode("123")).roles("USER").authorities("read").build());
		return user;
	}
	
	@Bean
	public PasswordEncoder passwordEncoder()
	{
		return new BCryptPasswordEncoder();
	}

@Override
	@Bean
	public AuthenticationManager authenticationManagerBean() throws Exception {
		// TODO Auto-generated method stub
		return super.authenticationManagerBean();
	}

@Override
	protected void configure(HttpSecurity http) throws Exception {
		http.formLogin();
		http.authorizeRequests().anyRequest().authenticated();
	}
		
}

Run As-> Spring Boot App for Output:

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

Subscribe to: Posts ( Atom )

Wednesday 27 December 2023

Multiples DATABASE Connection and Data shifting Using Spring Boots API

Tuesday 19 September 2023

How to PACKAGE Spring Boot application to JAR and WAR

Monday 26 June 2023

LDAP Authentication with Spring Boots

Wednesday 17 May 2023

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

Tuesday 3 January 2023

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

Wednesday 13 July 2022

Social Client Login with OAuth2 Spring Boot Application

Wednesday 6 July 2022

OAuth2 Security with Spring Boot

OUR TECH-PROJECTS

DOWNLOAD ANY ONLINE VIDEOS

LABELS

Development Accessories

POPULAR POSTS