Follow me to learn how you can leverage AI to boost your productivity and accelerate your career. Scaled products to 8 Million+ users and built the world's biggest AI newsletter with 1 Million+ readers.

Zain Kahn

Self Employed

Final verdict on microservices:

• Like enterprise archive execution with Ejb's initial version which I learnt before paralysis.
• RestTemplate only helped in Spring framework microservices execution on ManikReddy-Kashibai FamilyWealth application.
• Which includes spring security and spring audit into.
• Every application has got a similar named method getIncomeBasedonMonthandYear in controller which gives income of that trade based on month and year as parameters.
• Following controllers in following applications holds. 
      Applications                      Controller 

1. In AjayRoadlines               TrucksLoadedController.java
2. In TractorDetails                TripController.java
3. In SachinAutomobiles        BillPayableController.java
4. In BhavaniChitfunds           ChitfundsController.java
5. In TruckManagementSystem     BalanceController.java
6. In FamilyWealth FamilyWealthController.java will be caller to remaining five applications. 

• In yesteryear means from past six months or so was trying and waiting for WebClient filters to give desired output.
• Also one more flavor has come named as RestClient which is also not upto.
• As always expectations lead to discrepancy so has this time too.
• Was fine that I kept checking as was coming to mind always as that is the force of God the universal power with RestTemplate to execute spring framework microservices else would have been delayed in updating.
• Whatever want to perceive my thinking or force of God the universal power should only lead to enrichment.
• RestTemplate left behind cloud flavours WebClient, WC-filters and RestClient and also all setback said about.
• With an enhancement to exchange api with HttpMethod as one of parameter does the trick.
• Exchange api of RestTemplate does perform CRUD operations which earlier was like a get operation only.
• Following is the url on github displaying same:
https://github.com/jmankari/spring-boot-microservices-ManikReddy-Kashibai-FamiliesWealth.git

Java Software Engineer

Prefinal verdict on microservices:

•Spring cloud dealing with spring data JPA microservices on Manik Reddy kashibai family wealth application is done.
•This is like enterprise archive(ear) execution with ejb's initial version.
•This is without spring security and spring audit which is yet to come.
•Impression and belief was to post along with spring framework microservices which caused and is still causing too much delay so now.
•Completed 4 to 5 months back, but held due to mystified belief or impression.
•LinkedIn also allows to add position with past dates which is a plus here so adding.
•Where family wealth application's controller is making a RestTemplate call to each application to get income for given month and year.
•Each trades application has a similar named method called as incomeBasedonMonthandYear.
•Family wealth application will have a table with application name's income as columns means five columns where one for each trade, date as other column and summed up income as another column.
•To execute spring framework microservices is delayed still so trying to execute with various available options.
•Difference will be spring security and spring audit feature will be included into.
•Delay in this aspect is definitely a way to generate business for Microsoft and Google I suspect.
•No not RestTemplate now since spring 5 WebClient which is going to be enhanced henceforth.
•WebClient has come with a concept called filters to execute spring framework microservices.
•Since Spring 6.1 cloud has also come up with another flavor RestClient to execute framework microservices.
•The following is the link https://github.com/jmankari/spring-dataJPA-microservices-ManikReddy-Kashibai-FamiliesWealth.git
•There are posts going along on generating income for each trade.
•A family wealth application post also going along to take a user call first and then make a RestTemplate call to each trade application internal to this microservice, but out of family wealth application.

Microservice evoluted further: 

• Microservice architectures are the new normal. Building small, self contained, ready to run applications can bring great flexibility and added resilience to code.
• Spring Boot’s many purpose built features make easy to build and run microservices in production at scale.
• Found out a new way of accessing jar from another jar using maven as well.
• So family wealth would be a jar calling all jars like Ajay Roadlines, Sachin Automobiles, etc.,.
• Complete module would be accessed including controllers even.
• So family wealth would be creating monthly income solitarily and cohesively.
• RestTemplate would be a parallel effort. 

Coming to RestTemplate stuff all spring framework and jwt modules created till date hold same named api called getIncomeBasedonMonthandYear(@RequestParam int month, @RequestParam int year); and following are respective controller's name which holds. 

Springandjwt-ARL: TrucksLoadedController
Springandjwt-TractorDetails: TripController
Springandjwt-SA: BillPayableController
Springandjwt-BCF: ChitfundsController
Springandjwt-TkMS: BalanceController 

Following is the link for spring boot microservices which holds all five applications plus family wealth application which will be a caller. 

https://github.com/jmankari/spring-boot-microservices-ManikReddy-Kashibai-FamiliesWealth.git 

Following are the common properties in eureka server and client along. 

eureka server holds as follows: 

spring.application.name=service-registration-and-discovery-service
server.port                =8761
eureka.client.register-with-eureka = false
eureka.client.fetch-registry=false 

eureka clients hold as follows: 

eureka.client.register-with-eureka   = true
eureka.client.fetch-registry       = true
eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka/
eureka.instance.hostname  =  localhost
server.port   =  1111
spring.application.name = springandjwt-ARL
spring.cloud.config.name=springandjwt-ARL

Evolution of Spring-boot-microservices:

Initially evaluated to display welcome message from all microservices. 

https://github.com/jmankari/Microservices-spring-boot-ManikReddy-Kashibai-FamiliesWealth-welcome-message.git 

Then came down to spring data JPA  microservices on more than one client application with all crud operations. 

https://github.com/jmankari/Spring-data-JPA-microservices-with-all-crud-operations.git 

Then came down to one more step ahead with microservices on spring framework and jwt for more than one client application with all crud operations. 

https://github.com/jmankari/Spring-boot-microservices-with-spring-framework-and-jwt-excluding-cloud.git 

Then next enhancement would be on spring cloud i.e., RestTemplate executing spring data JPA only. 

https://github.com/jmankari/Spring-Boot-RestTemplate.git 

      Twist in the tail, aaha! 

Found out, If you see RestTemplate java docs, you will see this message: 

As of 5.0 this class is in maintenance mode, with only minor requests for changes and bugs to be accepted going forward. Please, consider using the WebClient which has a more modern API and supports synchronous, asynchronous and streaming scenarios. This simply means RestTemplate is no longer the recommended way to use. 

Since this is not going to production. Donot have to worry about what is going to remain and not in the upcoming versions. 

Then comes the original application with cloud of spring data JPA i.e., RestTemplate. It also consists basics of couple of microservices or applications with spring framework and jwt as well in core. 

https://github.com/jmankari/spring-boot-microservices-with-spring-framework-and-jwt-including-cloud-of-SpringdataJPA.git 

Need to wait more for WebClient another spring cloud flavor to come to full stack trace. 

Spring boot microservices with Spring framework and jwt including cloud of spring framework and jwt in Kashibai-Manik Gyan Reddy's family wealth and co as well as a next course.

Sachin Automobiles and Truck management system done using spring framework and json web token:

Sachin Automobiles is an application meant to maintain stock by summing up and reducing from inventory and calculation on billing system as well on credit & instant basis. 

Since free from client side activities as using postman, a client substitute. Idea of loading stock from bill receivable and reducing from bill payable has come. Usage of bill receivable and bill payable on credit and instant basis are also done. 

The following is repository created for above functionality 

https://github.com/jmankari/springandjwt-SA 

Truck management system has got balance table which is centrifugal. From here have got four one to one unidirectional relationship. Trip details, accessories tyre, accessories spares and itinerary are four different tables. 

On trip details balance will be summed up and reduction happens on accessories tyre, accessories spares and itinerary. 

The following is the repository created for above functionality 

https://github.com/jmankari/springandjwt-TruckManagementSystem 

Microservices have got basic fundamentals on like server and client functionalities. Built even mine which will eventually have a server and five clients interconnecting with a sixth new spring boot application client only, which displays results. This is formally only, since can be done without having folder structure of client and server also. 

In course of finding a way to execute microservice with total spring framework which includes spring security, spring audit and spring data JPA as clients along.

Tractor details and Ajay Roadlines done using spring framework and jwt(json web token): 

Tractor details is to manage various proposals, rents, instruments costs and usage in fields. 

Create with worker or owner to successfully create proposals, rents and trips as well by placing Authorization as key under headers tab and value should hold jwt obtained with Bearer prefixed. All depends on the way configured on different roles. 

Many to many relationships between users and roles table, unidirectional done using join table. 

One to one relationship between rent and instrument table. 

Following is the project developed for above functionality: 

https://github.com/jmankari/springandjwt-TractorDetails.git 

Ajay  Roadlines is basically a truck supplying agency. 

Managed using trucks available and goods available then match happens and truck loaded. 

Receipts and refunds are also maintained with various states along with commission paid and unpaid state as a follow up. 

Balance of each and every truck is maintained based on various debits and credits done by truck owner or driver in cognition. 

Many to many relationships between users and roles table, unidirectional done using join table. 

One to one relationship between trucks loaded and receipt or refund table respectively. 

Following is the project developed for above functionality: 

https://github.com/jmankari/springandjwt-ARL.git 

Microservices: Got to start working with microservices going ahead. Once this jar work on various applications which forms inter processes to microservice are done.

Chitfunds are group of people where collaborative effort in inter course of money is made. Understanding and paying based on few conditions.

Many to many relationships between users and roles table, unidirectional done using join table. 
Many to one relationship between chitfunds and iterations table, unidirectional done using join column. 

Unidirectional means navigation of objects in one direction. 

Finally entity relationship has got prominence. 

Every month there needs to be a drawer so number of months should be equal to number of customers, a golden rule. 

Drawer cannot repeat and is decided based on highest diminishing amount called competing with leftover peers based on needs. If there is a tie then chits will be spilled and picked name will be drawer for that month. First iteration will have all customers then on every month one customer will be laid off in drawing. 

Might happen to pick up fixed amount earlier or later based on highest diminishing amount called, but paying monthly is mandatory as decided for number of months. 

Modified the project to involve criteria builder and criteria query where there are few predicates for modified methods. Not the whole project, but added few methods. Here done for the sake of doing, might prove handy in JPA which was actually suggested. The following are the methods added. 

In chitfunds repository
• findByName 

In iteration repository
• findByChitFundsId
• findByChitFundsIdAndIterationN
umber
• findByChitFundIdAndNameAndIt
erationNumber 

Following are four files added
• ChitfundsRepositoryCustomImpl
• ChitfundsRepositoryCustom
• IterationsRepositoryCustomImpl
• IterationsRepositoryCustom 

This is only to prove what best I can do. 

With webservices learnt soap and rest, looks like turn of microservices now. 

Following is the project developed for above functionality: 
https://github.com/jmankari/springandjwt-BCF

Doing yoga and meditation only in morning for more than an hour, thoroughly enjoying.

Software Engineer (Bhavani chitfunds done using spring security, spring audit and json web token)

Authentication and authorization: 

Spring security is a powerful and highly customizable authentication and authorization framework, A de fecto standard. 

Both are handled by different configure methods with different parameters in class which extends WebSecurityConfigureAdapter. 

Concept of method overloading is beautifully portrayed or exhibited. 

AuthenticationManagerBuilder is the only parameter of configure method to authenticate. 

Authorization is done using HttpSecurity as only parameter where what path is accessible by which user. Users are again bifurcated based on different roles present. 

JWT(JSON WEB TOKEN): 

It provides 

1.Password encryption and
2.Session management. 

1.@preauthorize annotation: placed above accessible method to check roles based on token passed under headers tab in postman.
2.This token is obtained by signing in as different user of various roles by providing username and password.
3.Token has an expiration time set in application.properties file.
4.Token also holds a secret key which prevents from accessibility fraud even after token is stolen. 

Audit: 

Tracking when entities were created, modified and by whom by means of four fields. 

• @createdBy
• @createdDate 
• @modifiedBy 
• @modifiedDate 

Annotations based auditing metadata as above, whose values are auto generated after setting up a method called get current auditor in a class called spring security auditor aware. 

Also have to config a bean which calls spring security auditor aware class in order to generate auditor when created or modified an entity. 

For default operations, just have to call API'S. If you want to write non default operations in spring audit, have to use 
               @Query annotation. 

Following is the project developed for above skills 

https://github.com/jmankari/journal-with-security-jwt-and-audit 

Physic o therapy and walking weekly once, but doing yoga and meditation daily in morning for more than a hour, thoroughly enjoying.

Software Engineer(Journal extended using spring security, json web token(jwt) and spring audit)

 I have got server side project not the whole, but only a part. My friend is like a helping hand; meanwhile I can also be well equipped with latest trends of software development.

 All crud operations along with read based on id and pagination & sorting are functioning using spring data JPA and REST web services methods on h2 and mysql database. The same is tested by using postman and exported & ran it's collections using newman on commandline too.

 With spring data jpa, default crud operations have become very easy, as it provides one layer of abstraction for default operations, if there is anything out of ordinary needed, then have to implement. In JPA, dao implementation class was meant for writing all operations whereas in Spring data JPA, repository is an interface which extends simplecrud or paginationandsorting or jparepository class depending on requirements, which in turn does the implementation and is abstracted for us. This is only called REST webservice implementation.

Project consists of

1.   Journal
       a.Events
       b.Articles
       c.Tipster of the month.

Github: GitHub is an online code hosting platform for collaboration and version control.
There is a repository created for the current one too on GitHub.

https://github.com/jmankari/Journal-0.0.1

Amazon web services: I have learnt and deployed my spring based application on AWS ec2.
AWS is a place where everything is at one place instead of services like web hosting at one vendor then to save data at another.

EC2: Connected to Linux server using putty, which is tested by means of inbound rules of security groups.

With ejb3, jpa, REST and spring almost all latest technologies of j2ee are into my stride. So, flow of mind is towards best practices of software development a little now.

Need to explore: Oauth, Json web token, microservices and dockers.

Physical workout: I am able to discretely do workout and walking.

Software Engineer (Journal using Spring data JPA and REST webservices)

Trips: Implemented and calculated using only source of revenue available and expenses in couple of forms like visible being diesel, shipment or transit charges of goods for loading and unloading by labour, itinerary types, etc., and invisible expenses like tyre, spare part, etc., to generate income of an truck.

Accessories: To know durability of Tyres and Spare parts. New module called Accessories has been added. Contains two sub modules tyres and spare parts.

Balance: Main essence which will hold all debits and credits of a particular truck in certain instances respectively.

Updates debits in following instances
Tyre purchase,
Retreading of tyre,
Spare parts purchase,
Itinerary purchase and renewal and
Installment payment, if hypothecated.

Updates credits in following instances
Income on trip and
Payment on halting.

Need to maintain two balances for each truck.
1. Bank account in connection to each truck in bank table, only if hypothecated.
2. Each truck in balance table as it loads goods and earns freight.

Pagination and sorting: Implemented pagination and sorting in synchronization on display of
• trips, 
• banks, 
• balance, 
• accessories - spare parts and 
• accessories - tyres.

All of these happens using select truck i e., a common page.

Exploring technologies:
• Refinement has come in exploring. Based on that, further exploring technologies such as Spring data JPA & MVC(Especially JSTL in spring), REST controller & webservices on server side and AngularJS on client side.
• Also in course of exploring and learning spring security, auditing and json web token. Spring security is the basic for any application development and helps in auditing too. 
• Also exploring maven, a build tool.

The following is repository created

https://github.com/jmankari/TruckManagementSystem.git

Physical workout:
• Hope is still alive, physical workout continues and walking too recently added, due to emergence of knee movement.

Truck management System continues...

• Completed reengineering of SachinAutomobiles_Revisited.

• In progress: Industry's view point: Get the core business into automation first i.e., Truck Management System.

• Highlights of Truck Management System : 
1. Couple of columns in combination needs to be unique(composite key). 
2. Done in mysql database, itinerary table using managing indexes.
3. Done in itinerary entity, using @table annotation.
4. Page links and sorting are working fine independently, but as soon as you transact, interchanging each other, problem arises, as they were not in synchronization with each other. Status of this, for following is as follows:
• Display User: done.
• Display Trucks: done.
• Select truck for trips and itinerary: done.
• Display Trips: need to take up.
• Itinerary: done.
• ItineraryTypes: done.

• Atleast this: Need to look at configuration of foreign key mapping in JPA(one to many, unidirectional). Itinerary types table should hold one to many, unidirectional mapping with itinerary table i.e., foreign key.

• Implemented pagination and sorting with synchronization, as well on display of user, truck, select truck, itinerary and itinerary types. Need to take up trips.

• Still exploring Spring data JPA, Spring MVC & Controller with JSTL and AngularJS.

• Also, still in course of learning maven.

• Hope is still alive, physical workout continues.

Repository for above project is

https://github.com/jmankari/SachinAutomobiles_Revisited.git

Software Engineer

Sachin Automobiles Revisited Reengineered. 

• Industry's view point: Get the core business into automation first.
• Well versed with JSTL, Java Persistent API and ejb3. 
        1. Pagination is present and functioning                well, in almost all the projects.               
        2. Lately, Explored and implemented the                concept of sorting as well.            
• Now, Exploring Spring data on server side, Spring controller with JSTL on web and AngularJS on client side to include in next project.
• Also, in course of learning maven, which should also be included in Truck Management System. 
• Ant is good, but maven is better. Ant was suitable, for context here, in village but now, things seemed to have changed.
• Reengineered bill payable, as I have only one Mind.
• Implementing changes, required to fulfill new vision into bill payable.
• Also taken care of, one user handling more than one trucks, in Bill Payable.
• Foreign key, identified in couple of places for which, innoDB functional is required.
• InnoDB: 
                  Storage engine for database               management system, mysql. 
                  Provides standard ACID compliant transaction features, along with foreign key support.
• Hope is still alive, physical workout continues.

The following is the repository

https://github.com/jmankari/SachinAutomobiles_Revisited.git

Sachin Automobiles Revisited

-There is no head created and branch out from there, since there is no CVS (version control system)
-Done with configurable servicing 
-Done with Bill Receivable.
-working on Bill Payable now.
-Working on instant and credit customers.

Ajay Roadlines

Modified AjayRoadlines to AjayRoadlines_UAT and incorporating changes. 
Due to demonetisation, banks have come into picture so the whole payment system is changed not the main flow. so need to wait and see till the whole system stabilizes. Mean while I can fix issues or handle changes that are to be made in main flow of application.

Demonetisation

Ajay Roadlines

Modified lorrysupplieragency to Ajay Roadlines software. 
incorporating changes and upgradation of software.
The following are the change as of now.
1) Receipt: change in receipt where as it incorporates different type of receipt.                                                        - No progress 
 - Partial progress and
 - Complete progress.
2) Goods Available: parties call up and say credited 100 ton of goods. you are made responsible for this goods to be transported.
3) Accessibility: who should access what is handled.
4) Changes in Receipt: After received receipt, payment done and payment received needs to be interchangeably accessible.
5) payment of commission through different modes is being handled.
6) Now the whole payment system is changed due to demonetisation and banks coming into picture. So need to wait till the whole system stabilizes.

New feature added called Balance.  
Balance comes instead of commission. The following are the things, that updates balance
-Commission paid through balance.
-Receipt changing status.
-Refund changing status.
-Debit/Credit happening during Trucks Available.
-Debit/Credit happening during Trucks Loading.

          Inorder to take care of Atomicity(ACID properties), need to learn transaction management.

- was actually planning to take it live then, as it's a straight forward application. No data to handle and all, but luck didn't favour.

The following is the repository

https://github.com/jmankari/AjayRoadlines_UAT.git

Usability Testing.

Sachin Automobiles

-Hope is still alive. I still do physic o therapy morning and evening.
-Built software for Virinchi Technologies called Ticket Management System.
-Built software for Ajay Roadlines.
-Planning to do usability testing for Ajay Roadlines.
-Built software for Tractor Details.
-In the process to build software for Sachin Automobile's.
-Built inventory to maintain stock and in process to learn to build billing system for sachin automobiles.
-Did some sample projects on jquery: Ajax -which is used for server invocation and : Json used for data handling. Still not that perfect to incorporate into projects.

-All this softwares are built using EJB3.
-JPA and Hibernate also learnt. 
-All this stuff is to be in touch with technology for my learning purpose.

The following is the repository created

https://github.com/jmankari/SachinAutomobiles.git

Lorry supplying agency

it's a transport business, we deal in with truck supplying.
I take care of accounts here as of now.
-Came up with an application called LorrySupplierAgency, which covers basic flow

The following is the repository created

https://github.com/jmankari/LorrySupplierAgency.git

Tractor details

-was in village and saw tractor management, so came up with a project called tractor details.

The following is the repository created

https://github.com/jmankari/TractorDetail.git

Nimaya inc:

-Working on product integration with SIEBEL.
-No salary just to get back on track.

Virinchi technologies:

SRS was provided by Sridhar gudimela. so I built a application for the given SRS.

The following is the repository created

https://github.com/jmankari/Ticket-Management-System.git

Ticket Management System

GrayOpus Technologies

Software Architect

Publicis Sapient

-Attended in house training.
-Attended demos on various projects.
-was paralysed due to brain haemorrhage, while returning home on bike.

Nimaya, Inc.

-was appointed as a tester, became developer.
-Software Development on product.
-was provided as Best Learner of year 2005 for handling development task.
-Tested Integrated Pricing System.

              Evolution as developer

I was recruited for substituting or replacing Mr Naveen Srinivasan for testing Integrated pricing system project. He was there for a month to do the knowledge transfer of Integrated Pricing System, which was perfectly done to meet the requirements. As a part of knowledge transfer only, also taught me to load test the application on loadrunner which was available to us on some temporary key.

I needed some ignition, which was provided in this form. I went on to find open source load testing tool, eventually finding and automating the whole project on OpenSTA, a load, stress and functional testing tool. The whole process of automation involved writing or tweaking some scripts which I had done, then. The whole thing was observed by my chief technology officer Mr. Krishna R kadali and moved me to temporary development team on javascript.

I did this, for a couple of months under Mr Ramana Reddy Maddikunta and then, making me to develop a component called business rule in c#.net on client side under Mr Kalyan Chintam, which I perfectly did. This provided me an opportunity to win Best learner award and hence forth making me a developer in java as I was already well versed.

Pramati Technologies Private Limited

-Learning and Experienced with Software Development

Trainee

Where there is a will, there is a way.

      professionally : proved 
      physically        : In course of proving.

Paralysis patient: Trying to compete enough physically through various means like walking, physical workout, yoga and meditation and mentally through updated skillset of j2ee.

taplio

The Battle

Zain Kahn

Jeevan Manik Reddy

Followers

Posts

Engagements

Likes

Ready to grow your LinkedIn presence?