Software Programming: java

Inversion of Control (IoC) in Spring Frameworks

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.

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.

Simple LDAP sign-on Authentication Using Ldap-a143mkJar

java , java 8 , LDAP 1 comment :

LDAP 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 post user will login through Outlook Mail. Ldap-a143mkJar.jar

Process of Ldap sign-On (LSO) Authentication:

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

Call Class object LdapClient ldapClientClass=new LdapClient();

A143mkLdapConnection(ldapUrl, ldapDnConn, userEmailId, password);

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

String ldapUrl= "ldap://172.0.0.0:389/";

String lDapDnConn="dc=domainName,dc=com";

String userEmailId="EmailMail@mailDomen.com";

String password="mailPassword";

How to create a project/main class/other class to follow us.

while creating the controller/main class Ldapconn.java.

package ldapconn;
import ldap.a143mkjar.LdapClient;
import ldap.a143mkjar.LdapConnUser;
/**
 *
 * @author manoj.vishwakarma
 */
public class Ldapconn { 
     public static void main(String[] args) {
         //ldap-server configuration
        String ldapUrl= "ldap://172.0.0.0:389/";
        String lDapDnConn="dc=domainName,dc=com";
        String userEmailId="EmailMail@mailDomen.com";
        String password="mailPassword";
        
       LdapClient ldapClientClass=  new LdapClient();
       LdapConnUser get=ldapClientClass.A143mkLdapConnection(ldapUrl, lDapDnConn, userEmailId, password);
       if(get.getErrorLdapConn()==null){
          System.out.println(" DNParaMeter: "+get.getLdapDNParaMeter()+
                             "\n UserFirstName: "+get.getLdapUserFirstName()+
                             "\n UserSN: "+get.getLdapUserSN()+
                             "\n UserMailID: "+get.getLdapUserMailID()+
                              "\n accPassExpires: "+get.getAccPassExpires()+
                               "\n department: "+get.getDepartment()+
                                "\n description: "+get.getDescription()+
                                 "\n st: "+get.getSt()+
                                   "\n streetAddress: "+get.getStreetAddress());
          
  } else{
         System.out.println(get.getErrorLdapConn());
       }
     }
    
    
}

Output :

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

Digital Steganography With Single Sign-On (SSO) Authentication Project For Students

java , java 8 , Single Sign-On (SSO) , Tech-Projects 2 comments :

The project here can be a minor and major project for final year students, and given in school and college by learning the project itself through videos.
INTRODUCTION:

Maintaining secrecy is very important in a large corporation and because of the intelligent of the hackers it becomes tedious. Already we have encryption for transmitting secret information. Even though encryption successfully transmitting secret information, it will give a suspicion to the hackers and it affects unintended users. Our project, DIGITAL STEGANOGRAPHY WITH Single Sign-On (SSO) Authentication overcomes this factor and it gives a solution for transmitting secret formation with out affecting

Unintended users. Steganography uses multimedia data as a covering medium (Covering secret information). By using steganography data (secret information) can hided with in

Data (multimedia data, here multimedia data is an image) and it can be sent anywhere to transfer the message easily without giving any suspicion to others.

Follow Steps by Steps

Encryption and Decryption implement using EncryptDecryptA143mk jar

Encoding & Decoding , java 2 comments :

In this post, we will learn how we can implement String/Password Base64 Encrypt and Base64 Decrypt as well as Hexadecimal (Base 16) Encrypt and Hexadecimal (Base 16) Decrypt with the help of a jar which is EncryptDecryptA143mk.jar Consists of 4 functions/methods understand its working as follows.

Base64EEncryptDecrypt:

EncryptA143MK()

DecryptA143MK()

HexadecimalEncryptDecrypt:

HexDecryptA143MK()

HexEncryptA143MK()

Create this Main Method, you can use this code in function/methods as per You wish.

ppackage EncryptDecryptA143mk;
import java.io.UnsupportedEncodingException;
import java.security.NoSuchAlgorithmException;

public class TestEncryptDecryptA143mk {
	
	 public static void main(String args []) throws Exception
	    {
	        
		 try {
		 EncryptDecryptA143mk td= new EncryptDecryptA143mk();

/* Base64EEncryptDecrypt*/
	      
	        String encrypted=td.EncryptA143MK("https://a143mk.blogspot.com");
	        String decrypted=td.DecryptA143MK(encrypted);

System.out.println("\n*******Base64 String To EncryptDecrypt *******");    
	        System.out.println("Base64 Encrypted String: " + encrypted);
	        System.out.println("Base64 Decrypted String: " + decrypted);
	        
			/* Hexadecimal EncryptDecrypt */
	        
	        String encryptedMd5=td.HexDecryptA143MK("https://a143mk.blogspot.com");
	        String decryptedMd5=td.HexEncryptA143MK(encryptedMd5);
	        System.out.println("\n*******Hexadecimal String To EncryptDecrypt *******");    
	        System.out.println("Hexadecimal Encrypted  of string: " + encryptedMd5);
	        System.out.println("Hexadecimal Decrypted  of string: " + decryptedMd5 );
	        } catch (NoSuchAlgorithmException e) { 
	            // TODO Auto-generated catch block 
	            e.printStackTrace();
	        } catch (UnsupportedEncodingException e) { 
	            // TODO Auto-generated catch block 
	            e.printStackTrace();
	        }

}
}

Output:

Important Information: we do this type of development/implement to provide security to the online user in the web application or other user application like online platform, your personal information like password is neither in the database of the online platform nor with anyone else.

How to Implement SMTP (Simple Mail Transfer Protocol: To, Cc and Bcc Mails) Using Java

Email , java , java 8 , smtp 1 comment :

In this post we will learn how To, Cc and Bcc mails are sent and also how the file is attached to the mail. Some jar files are available in java for the development of mails, which is javax.mail jar file, as well as a jar named SendMailA143mk, download both the jar file and the names of the jar SendMailA143mk in which two methods / functions have been used, the names of the methods are as follows:

1. SendMaleWPathFile();

2. SendMaleWBody();

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

String noReplayEmailID="noreplyMail@mailDomen.com";

String noReplayEmailPass="mailPassword";

String host="smtp.office365.com";

String port="587";

String sentTomail="toMail@mailDomen.com";

String sentToCCmail="ccMail@mailDomen.com";

String sentToBCCmail="bccMail@mailDomen.com";

String Subject="SMTP Implementation Using Java";

String bodyText=" Hi A143mk blogs Test Mail. Thanks. ";

String PathFile="D:\\logo.png";

Create this Main Method, you can use this code in functions/methods as per you wish.

package testSendMailJar;
import SendMailA143mk.SendMailA143mk;

public class testmail {
	
	@SuppressWarnings("unused")
	public static void main(String[] args) throws Exception {
		
		 String noReplayEmailID="noreplyMail@mailDomen.com";
		String noReplayEmailPass="mailPassword";
		String host="smtp.office365.com";
		String port="587";
		String sentTomail="toMail@mailDomen.com";
		String sentToCCmail="ccMail@mailDomen.com";
		String sentToBCCmail="bccMail@mailDomen.com";
		String Subject="SMTP Implementation Using Java";
		String bodyText=" Hi A143mk blogs Test Mail. Thanks. ";
		String PathFile="D:\\logo.png";
		
		SendMailA143mk getJarfielF=new SendMailA143mk();
		
		String returnSuWithFileApth=getJarfielF.SendMaleWPathFile(noReplayEmailID, 
				noReplayEmailPass, host, port, sentTomail, 
				sentToCCmail, sentToBCCmail, Subject, bodyText, PathFile);
		System.out.println("File and Email Send Success!"+returnSuWithFileApth);
		
		String returnSuWithMailBody=getJarfielF.SendMaleWBody(noReplayEmailID,
				noReplayEmailPass, host, port, sentTomail, sentToCCmail, sentToBCCmail, 
				Subject, bodyText);
				
		System.out.println("Mail Body and Email Send Success!"+returnSuWithFileApth);	
		
	}
}

Output is:

Important Information: We develop/implement this type of web application or other user application in online platform like How to send To, Cc and Bcc mails to online user providing security and also we are able to send email to user through OTP in this development Whether or not your personal information such as password/email OTP is neither in the database of the online platform nor in the possession of anyone else. By this we identify the authenticity of the user.

How to upload password Protected Excel Using java

Excel Code , java No comments :

In the previous post, we saw how some columns were made password protected, now we will see how to upload the created file.

First of all we make brows form.

Uploading Excel

NPOIFSFileSystem class is inside the "org.apache.poi.poifs.filesystem.NPOIFSFileSystem" package Biff8EncryptionKey class is inside the "org.apache.poi.hssf.record.crypto.Biff8EncryptionKey" package

Import Jar Name is poi-3.17.jar and call Some class

import org.apache.poi.hssf.record.crypto.Biff8EncryptionKey;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;

import org.apache.poi.ss.usermodel.DataFormatter;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.ss.usermodel.Sheet;

import org.apache.poi.ss.usermodel.Workbook;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

Java controlling Method is uploadFile:

@RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
	public ModelAndView uploadFile(
	@ModelAttribute("SlrUploadxlsFromBean") SlrUploadxlsFromBean mvcJavaBeanObj) throws Exception {
	
                CommonsMultipartFile filePath = mvcJavaBeanObj.getFilePath();
				mvcJavaBeanObj.setFileName(filePath.getOriginalFilename());
				String FILE_PATH = contextPath.getRealPath("/WEB-INF/downloads/" + filePath.getOriginalFilename());
				byte[] bytes = filePath.getBytes();
				FileCopyUtils.copy(bytes, new File(FILE_PATH));
				String FILE_PATH2 = contextPath.getRealPath("/WEB-INF/downloads/" + mvcJavaBeanObj.getFileName());
				File fiobj = new File(FILE_PATH2);
				NPOIFSFileSystem fileSystem = new NPOIFSFileSystem(fiobj, true);
				Biff8EncryptionKey.setCurrentUserPassword("a143mk");
				Workbook crdeitdebitbook = new HSSFWorkbook(fileSystem);
				String name = crdeitdebitbook.getSheetAt(0).getSheetName();
				Sheet mySheet = crdeitdebitbook.getSheet(name);
				List<Row> rows = Lists.newArrayList(mySheet.rowIterator());
				final DataFormatter df = new DataFormatter();
				Iterator<Row> rowIterator = rows.iterator();
				System.out.println("Password_Protected_Column_1 |Password_Protected_Column_2 | EDIT_ABLE_COLUMN");
				while (rowIterator.hasNext()) {
					Row row = rowIterator.next();
					if (rowRounter == 0) {
						rowRounter++;
					} else {
					     String colum_obj1 = row.getCell(0).toString().trim();
						String colum_obj2 = row.getCell(1).toString().trim();
						String colum_obj3 = row.getCell(2).toString().trim();
					System.out.println(colum_obj1+" | "+colum_obj2+" | "+colum_obj3);
					}
					}
					
					}

Output:

How to create password Protected Excel for some Column Label in java

Excel Code , java , Spring MVC 1 comment :

Introduction
How to password protect some columns of Excel using java and editable some columns inside an excel sheet.
Spring MVC comes with AbstractJExcelView class to export data to Excel file via JExcelAPI library. In this tutorial, it show the use of AbstractJExcelView class in Spring MVC application to export data to Excel file for download

Write the jasper-view.xml configuration.

Import Jar Name jxl-2.6.12.jar and spring-webmvc-4.3.7.RELEASE.jar and call Some classes

package dms.a143mk.excel;
import java.util.ArrayList;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.view.document.AbstractJExcelView;
import antlr.Utils;
import jxl.CellView;
import jxl.Sheet;
import jxl.SheetSettings;
import jxl.format.Colour;
import jxl.write.Label;
import jxl.write.Number;
import jxl.write.NumberFormats;
import jxl.write.WritableCellFormat;
import jxl.write.WritableSheet;
import jxl.write.WritableWorkbook;

public class PasswordProteExcelDemo extends AbstractJExcelView {
	@Override
	protected void buildExcelDocument(WritableWorkbook workbook, HttpServletRequest request, 
	HttpServletResponse response) throws Exception {
          
		  Map<Integer, ArrayList<String>> viewCustomer = new HashMap<Integer, ArrayList<String>>();
			ArrayList<String> recvReportList = new ArrayList<String>();
				recvReportList.add("a143mk");
				recvReportList.add("Programming");
				recvReportList.add("");
				viewCustomer.put(1, recvReportList);
		
		    WritableSheet sheet = null;
		    response.setHeader("content-disposition", "attachment; filename=FineName.CSV");
			sheet = workbook.createSheet("Excel_View", 0);
			sheet.getSettings().setPassword("a143mk");
			sheet.getSettings().setProtected(true);
			sheet.setColumnView(0, 30);
			sheet.setColumnView(1, 30);
			sheet.setColumnView(2, 30);
			
			
			WritableCellFormat readonly = new WritableCellFormat();
			readonly.setBackground(Colour.GRAY_25);
			readonly.setLocked(true);
			
			
			WritableCellFormat cellNumberFor = new WritableCellFormat(NumberFormats.INTEGER);
			cellNumberFor.setBackground(Colour.GRAY_25);
			cellNumberFor.setLocked(true);
		    
			WritableCellFormat unlockedresion = new WritableCellFormat();
			unlockedresion.setLocked(false);
			WritableCellFormat untpCell = new WritableCellFormat(NumberFormats.INTEGER);
			untpCell.setLocked(false);
			
			if(!viewCustomer.isEmpty()){
				sheet.addCell(new Label(0, 0, "Password_Protected_Column_1",readonly));	
				sheet.addCell(new Label(1, 0, "Password_Protected_Column_2",readonly));
			    sheet.addCell(new Label(3, 0, "EDIT_ABLE_COLUMN",unlockedresion));
            	int rowCount = 1;
				for (Map.Entry<Integer, ArrayList<String>> entry : viewCustomer.entrySet()) {
					
					sheet.addCell(new Label(0, rowCount,  entry.getValue().get(0),readonly));
					sheet.addCell(new Label(1, rowCount,  entry.getValue().get(1),readonly));
					sheet.addCell(new Label(2, rowCount,  entry.getValue().get(2),unlockedresion));
						
					rowCount++;
				}
			}
		
	}

}

Social Client Login with OAuth2 Spring Boot Application

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

OAuth2 Security with Spring Boot

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.

Functional Interface in Java

Functional Interface , Interfaces , java 1 comment :

Introduction
An Interface which has only one abstract method (SAM: Single Abstract Method) is called Functional Interface. It is used annotation @FunctionalInterface: An informative annotation type used to indicate that an interface type declaration is intended to be a functional interface as defined by the Java Language Specification. Conceptually, a functional interface has exactly one abstract method. Since default methods have an implementation, they are not abstract. If an interface declares an abstract method overriding one of the public methods of java.lang.Object, that also does not count toward the interface's abstract method count since any implementation of the interface will have an implementation from java.lang.Object or elsewhere.

@FunctionalInterface

interface adition{

void add(int a, int b);

}

Runnable, ActionListener, Comparable, Comparator, Callable Are some of the examples of functional interface. There is no need to use the abstract Keyword as it is optional to use the interface
why use Functional Interface?

It is used for enabling functional programming to java language.

Functional Interface is also used for defining Lambda Expressions to Pass a function directly as argument to method.

package com.a143mk.SpringBoot.interfaces;

public class Java8InmlInterfaceLambda {

public static void main(String[] args) {

// lambda expression to create the object

new Thread(() -> { System.out.println("New thread created Lambda"); }).start();

}

Some Other Functional Interfaces

Consumer Interface
Predicate Interface
Marker Interfaces

Consumer Interface: Consumer interface has no return value it returns nothing. there are functional variables of the consumer -DoubleConsumer, IntConsumer and LongConsumer. These variables accept primitives values as arguments.

package com.a143mk.SpringBoot.interfaces;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerInterfaceExample {
	
	static void addList(List<Integer> list){  
        // Return sum of list values  
        int result = list.stream().mapToInt(Integer::intValue).sum();   
        //The Integer class wraps a value of the primitive type int in an object. An object of 
        //type Integercontains a single field whose type is int. 
        //:: is used for Direct Call method intValue.
        System.out.println("Sum of list values: "+result);  
    }  
	
	public static void main(String[] args) {  
        // Creating a list and adding values  
                List<Integer> list = new ArrayList<Integer>();  
                list.add(10);   
                list.add(20);  
                list.add(30);  
                list.add(40);  
        // Referring method to String type Consumer interface  
                
        Consumer<List<Integer>> consumer = ConsumerInterfaceExample::addList;   // :: is used for Direct Call method.
        consumer.accept(list);  // Calling Consumer method  
          
        Consumer<String> print = x -> System.out.println(x);
        print.accept("javaA143mk");   // java
        
    }

}

Predicate Interface : it is a functional interface whose functional method is test(obj), that takes an argument and return boolean value.

The predicate functionl interface can also be implemented using a class.

class ClassNme implements Predicate {}

Marker Interfaces: Marker Interface is an empity interface (no field or argument).
Marker Interface are serializable, cloneable and remote interface. All these interfaces are empity interfae.

Subscribe to: Posts ( Atom )