Login form using Spring MVC part 2


LoginService:

LoginServiceImpl class:

In the LoginController we have to modify the validation logic to use the service class for validating the user. LoginController class:

For creating full login site we should add Hibernate and MySql driver dependencies in pom.xml file. Another thing is to add applicationContext.xml file for initializing Spring and Hibernate related components. For example bean definition for MySQL dataStructure and sessionFactor which will be used in DAO classes.

Thera are also a few changes in: web.xml:

Login form using Spring MVC part 1


For Energy Billing System I want to add login screen for the user that will be displayed before access to user panel. The user can enter username and password, click submit button to proceed the login. For this purpose, I create a simple database in mysql.

Create a table called: users, by using fallowing sql:

Checking information about table that we created:

Added two records into users table:

Now in a database, we should have two records. Next step is to create a model class. This Entity is mapped to the “users” table.

Created DAO class interface:

For now is a small part of login implementation. In the next post, I will present complete implementation.


Reference:

Initial controller, view and dispatcher servlet configuration


For the last few days, I have not had time to work on the project. Now there is simple page displayed as an initial project page.

Added spring framework dependencies in pom.xml file:

Simple view:

Controller:

Created dispatcher servlet configuration:

The picture above presents the basic appearance of the page that will appear after run changes. For now, there are not many changes, but it is a necessary attitude to make new changes and work on the application.


Reference:

Packages in java

Java allows to a group class and organizes them into packages. Packages are very simple and useful mechanism to organize, easily locate files, reuse code, use libraries and also save time. In real life, there are situations when we can tray to create the class in the same name. This provides to namespace collisions. Packages also help to prevent that kind of problems.

How to use a package

The class can use all of the classes from their package and all of the public class from packages that belong to other pancakes. To get access to the public class from other packages we can do it in two ways:

  • Call a full name: com.somePackage myClass = new com.somePackage();

However, it’s not a very practical way. Easier and much faster way is to use keyword: import. This keyword allows for easier use of a class from another package.

Of course, we can import all class from the package by add *, for example:

Adding a class to the package

To add class to package first we must to add package name on the beginning of source file, for example:

If we don’t add package name, a class will be placed in a default package. This package doesn’t have a name.

Part of the program that is listed bellow describes that HelloController.java belongs to com.billingsystem.controller. Therefore file HelloController.java must be stored in com/billingsystem/controller:

Using Travis CI

Getting started with Travis-Ci is pretty easy. First, we should create a .travis.yml file in root project directory. The second step is to create hooks between GitHub and Travis.

In my configuration of Travis, I used two operation systems: Windows and Linux. This configuration allows to runs each build in an isolated Google Compute Engine virtual machine that offer a vanilla build environment for each build. That allows creating clean slate and making clear output for our tests that runs in environment build from scratch every time.

Of course, this is some example of the initial setup for Travis, that I currently use for my pet project. In the near feature it will be updated for more components such as data store, environmental variables and adding APT Sources.

Travis will automatically create matrix environment variable with each Java version. In that case, all test will be run for every combination of three.

Eclipse IDE

Eclipse is an integrated development environment, a free platform widely distributed among Java developers, but also PHP, C ++. The last option especially highlights Visual Studio.

Why is writing about the Eclipse IDE? I’m writing about it because I started to develop my project seriously. Let’s get to know 2017 but IntellyJ Community version does not allow to create certain JEE components or use Spring Framework. That’s why I started looking for another solution and support for Spring. I choose Eclipse Neon. A few years ago I had quite a bit of tangency with this environment. It’s very powerful.

Installation is very simple. In the first step, we should primarily download versions from the eclipse.org project. Find the Downloads section and download Eclipse. I downloaded the Java Enterprise Edition (JEE). Installing such a package consists in extracting the * .zip archive to the appropriate folder. It depends primarily on our preferences and the operating system.

After the first start up location window should appear, in which we choose the workspace. This is the location where our projects will be stored. A perspective project is already ready for programming and the creation of the first project. We can also modify it with a simple drag and drop mechanism, dragging selected items into a convenient place for us, allowing partial personalization of the IDE perspective view.

On the left, we can see Package Explorer. The structure itself resembles a tree. On the right side, there is Outline, a quick preview of the class in the form of a sketch of the field and method, along with colored markings indicating the access specifiers. At the bottom, there is a box showing the errors, warnings, and problems that appear in his project. By default, the console also appears after launching the application.

A few words about automation

For some time, I  hear a lot about automation. And more and more often hear the statement: we should automate everything. In my opinion, you can automate a lot, but not everything. However, so far, the human factor is needed. Maybe in the near future, there will be advanced artificial intelligence that will allow people to take more creative tasks at work than they are today. And here comes the question of what is a more creative task?

Automation can be talked about in two ways. Automate tasks through bots or appropriate scripts that allow you to perform the right tasks automatically. The second approach is to run automated tests, which is related to the first point because it involves eliminating human interference in the process.

Automation, like every field, can bring a lot of good, save time and money, but it can also put a lot of time and money into it, and you don’t get any meaningful benefits.
Let’s be honest automation is not cheap. However, in an appropriate way, it will make testing more effective.

Many times I encountered a situation where when moving to a new environment, existing automated tests did not work or could not be started. This was due to two reasons. Firstly, a code has not been maintained for a long time, I mean half a year or often even a year. No one is able to say anything about the code after this period of time. And second, test code was written in a very chaotic way, without using any pattern to create automated tests. What does this really mean? Often it means that nobody has no idea how tests work and why they give such and not other results. A lot of time and energy are needed to maintain automated tests created without the use of a design pattern. It usually involves rewriting the entire architecture of test again. A very bad option is also to recording test and playing them once in some period of time. In my opinion, this is not a solution. Right until the next run of this type of recorded test scripts will be useless.

Several times I also met with the situation when the automation technology stack was different from the technological development stack. Such a solution required preparation of additional infrastructure, which involved costs, an additional environment for maintenance. This also causes trouble for the developer, especially when the product code is created iteratively. At this point, it is also worth mentioning CI – continuous integration. This is one of the basics of automation. This allows, above all, a quick feedback on the fact that a particular feature does not work. Sooner we find out that something is not working we’ll fix the problem faster. Otherwise, it may just not be enough time for a “quick fix”. It also saves us a lot of nerves on release day when everyone is praying that all tests will turn green. But the reports sometimes say something different than it actually is. Keep in mind that the automation product is the report, and each of them should be as well reviewed. It’s important to provide one source of information about the reports. I mean here that people tend to check one source and the others are omitted.  Besides, I also met with the coincidence that we have a problem only when the tests fail, and only then we take care of the repair. This is not quite true, tests may pass and functionality still does not work and no one knows why. In that case,  tests are badly written and they need to be thoroughly reviewed.

If automation test engineers only write UI tests, we should consider very well whether we do automation well. It also depends on the type of product we have to deal with, but there are some problems with it. First of all UI tests are most expensive to build and maintain. UI testing is never as testing the service layer and database layer. Automation can be made much more interesting and effective, so as not to lose the essence of automation. It may be better to write scripts, tooling, even a bot to inform you about the progress of the various activities that will save a few hours during each deployment and it make it less painful.

Ok, but test automation is suitable for checking repetitive tasks, then it is most useful. If we want to check feel, look and a good teste of the new feature then the best idea is to customer or people who have not previously had nothing to do with it. Then we get a fresh feedback.

If all tests pass 100% we probably do not test as much as we should. Properly matching boundary conditions in such a way that some of them pass and some certainly should not give us the result of 100% is on the pass.

A few additional words about automation. Automation testing is irreplaceable, but you have to be careful to do it with reason. The customer does not pay for the tests, but for the product, good quality and timely delivery at a reasonable price.

Multilayer architecture

For some time I am thinking about application architecture. Consider pros and cons and tried to redesign the concepts of how to develop an application that the architecture uses. However, after gathering more and more information I came to one simple conclusion: I try to invent a circle again, which I don’t really want to. Many web systems work in multi-layered architecture. What does that really mean? What is it and what is it? Regardless of whether we are building an internet portal, booking system, document circulation system in the company, electronic banking is a part of the elements remains very similar but never identical.

Why do we really need the architecture of the IT system? It is often the case that when the complexity of IT system increase, an appearance of additional components caused a need for their separation, a possibility of easy change to another component. This solution forced the use of specific protocols, declarations of abstract classes, or direct reference to fields and class methods.

Single-layer architecture
Usually, it is a single application that does not require any external communication to perform tasks.

Double layer architecture

Client – Server or Master – Slave. These are usually two programs located on one machine or scattered geographically. The service provider is a superior program and one or more programs use these services, for example, a web server, an email server, an application server.

Multilayer architecture

This model consists of more than two layers. Separation of the user interface, storage of data into several separate layers that can be separately developed and scaled. Such a division facilitates their maintenance and mutual development does not affect the other layers.

 

Description of specific elements in the layer:

  • Frontend
    • Unser Interface – implements the logic of handling the presentation layer for the user
    • Gateway – induces and  provides services to external systems
    • Admin Interface – implements logic for handling the presentation layer for the administrator
  • Backend
    • Message-service(Commons) – it supports common logic
    • Scheduler – responsible for periodically running processes
    • Security Management – permissions and authentication management
    • Process Managment – allows to running long-term processes with the need to maintain and interact with the user
    • Domain Specific Components – responsible for fixing and accessing objects
  • Database – relational database

Advantages and disadvantages of layered architecture:

Advantages:

  • I don’t need a specific technology or vendor platform to create multi-layer architecture
  • Testability – Is very easy to create tests in automated testing environment as JUnit for example, for each layer
  • Separation of layers permits to easily map functional requirement with system modules
  • Enhanced Security
  • Layered architecture enables to update only the application servers, not all clients in case that we want to modify only business logic
  • Hidden database structure

Disadvantages:

  • Communication that can be complex
  • Performance and it’s required to use additional tools for measure and reporting this information
  • Difficult to implement and maintain

That’s why I decided that Energy Billing System will be based on a multi-layered architecture. There is one more aspect, I will be creating applications for the first time based on this architecture, so I will make a lot of mistakes, which is very good. Why? Because I will be able to solve them later.


Reference:

Maven #02 ~ pom.xml

pom.xml is the main element of our project. In file are defined all of the dependencies for example:

  • a way of building a project
  • testing
  • running a project
  • generating documentation
  • creating a release

 

After generating project pom.xml file looks as follows:

It looks very raw. Only groupId, artifactId, modelVersion, version. This information on this step is not very important for us. First, change that we will make will be adding JUnit library.

Now we can compile our project:

As we can see project build successfully. For now, we should look at three commands:

  • mvn  – this command runs maven and proper pom.xml file
  • clean – delete target catalog and old files version
  • compile – runs java compiler

Maven #01 ~ What is Maven?

Apache Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting, and documentation from a central piece of information.

Primarily used for Java-based projects but that can also be used to merge projects in other programming languages like C# and Ruby. Many integrated development environments provide plugins for Maven. Typical tasks if a build tool is a compilation of source code, running test and packaging results into jar files. Maven can also perform related activities, for example, creating websites, uploads build results or generate reports.

Automating process of creating the initial project structure for Java application is very important, especially when doing it manually may take much more time and also there is a possibility for making typos during using some commands in the console, the last one is very frequent.

A little bit history.
Originally Maven was designed to simplify building process in Jakarta Turbine project.

What for?
Maven can be used for:

  • handle dependencies and intermediate dependencies
  • easy selection of tasks from the command line
  • versioning and tagging code
  • a large number of plugins to simple and complex tasks
  • Integration with all IDE such as Eclipse, NetBeans or IntellyJ
  • ability to manage a number of the modules of the project at a time
  • support for:
    • unit tests
    • integration tests
    • load tests
    • performance tests
  • application builds
  • generating documentation
  • releases
  • mailing list management

Maven is working according to the Convention Over Configuration pattern, which means that the configuration requires only those components that are nonstandard or user will want to adopt them for their needs, and the same configuration change can also be found under only one file – pom.xml.
Developers can build Maven project without the need to understand how the individual plugin works.

Installation
I use several systems start from Linux, Windows and Mac OS X machines. For this post, I will use Mac OSX.
Open terminal and type: brew install maven

If we have already maven installed, in a terminal should appear:

After installing Maven should check if everything is working properly, this purpose should be in the command line to run Maven and check the versions of what was installed:

As you can see installation is not difficult in inches. Some different looks to install Maven on Linux and Windows.

Before we turn to the creation of the first project we need to discuss a matter of a few, namely what they are:

  • artefact
  • group
  • version

The artifact is a name that identifies the project in the group. The group allows you to organize the namespace in which it is the artifact.

Both the group and artifact and version uniquely identifies the library of which we want to use. There is also something like what is called a plugin and archetype. The plugin is a special Java language, class in which performs the appropriate actions on the basis of asking configuration, for example, to pack compiled class to a jar file, generate documentation. An artifact is a specific plugin using which created them st project. It contains in its structure mapping of tree directories a new project, or file pom.xml contains basic project data.

Generating project
To generate maven project we have two options. First from a console and second from IDE.
Creating maven project looks as follows:

With this command Maven generates a Java project:

This last step can take some time depends on how much RAM memory do you have (These days it’s 16 GB).
Structure of the genereted project looks like follows:

We have generated whole Maven project structure Java source code. Maven created App.java class which is just simple “Hello World” program. We have also can see AppTest.java that is the simple test class. In root catalog, we can find our pom.xml file:

To compile Java source code we need to trigger: mvn compile in root project directory. This command runs through all life cycle phase, which is needed to compile a project.

To run test phases instead to run a full build we need just to trigger: mvn test

To clean project and remove all generated files from ./target directory we can use: mvn clean


Reference:

  1. Apache Maven Project
  2. MVN Repository
  3. IntellyJ IDEA Maven
  4. Supported tags and respective Dockerfile links

  5. Jakarta Projekt

  6. Five things you didn’t know about Maven by IBM

  7. Introduction to Apache Maven 2

  8. Deployment of artifacts with FPT

  9. Maven Wrapper GitHub repo