DEV Community: Pramuda Liyanage

Diffrence of Library and Framework in Computer Programming

Pramuda Liyanage — Wed, 10 Nov 2021 01:33:16 +0000

What is Library?

Libraries in programming languages are collections of prewritten code that users can use to optimize tasks.

Below are some library examples..

** Next.js (programming language ==> JavaScript)
** NumPy (programming language ==> Python)
** Apache Xerces (Java , C++ and Perl programming languages)
** Pillow (programming language ==> Python)
** SFML (programming language ==> C++)
** p5 (programming language ==> JavaScript)

What is Framework?

A framework is a real or conceptual structure created to serve as a support or guide for the building of something that expands the structure into something useful.
Frameworks can include various tools, code libraries, compilers and also application programming interfaces (APIs) bound together to enable development of a project or solution too a specific problem.

Below are some library examples..

** Angular ==> TypeScript-based free and open-source web application framework led by the Angular Team at Google and by a community of individuals and corporations.

** Vue.js ==> open-source model–view–viewmodel front end JavaScript framework for building user interfaces and single-page applications.

** Bootstrap ==> free and open-source CSS framework directed at responsive, mobile-first front-end web development.

** ASP.NET ==> open-source, server-side web-application framework designed for web development to produce dynamic web pages.

** Spring ==> application framework and inversion of control container for the Java platform.The framework's core features can be used by any Java application, but there are extensions for building web applications on top of the Java EE platform.

Thank you....

Cross Cutting Concerns in Spring Framework

Pramuda Liyanage — Tue, 02 Nov 2021 18:06:48 +0000

What is a Concern?
The concern is behavior that we want to have in a particular module of an application. A concern may be defined as a functionality we want to implement.

What is Cross Cutting Concerns?

In any application, there is some generic functionality that is needed in many places. But this functionality is not related to the application's business logic. Suppose you perform a role-based security check before every business method in your application. Here security is a cross-cutting concern. It is required for any application but it is not necessary from the business point of view, it is a simple generic functionality we have to implement in many places in the application. The following are examples of the cross-cutting concerns for the enterprise application.

** Logging and tracing
** Transaction management
** Security
** Caching
** Error handling
** Performance monitoring
** Custom business rules

Spring Aspect Oriented Programming Overview

Most of the enterprise applications have some common crosscutting concerns that are applicable to different types of Objects and modules. Some of the common crosscutting concerns are logging, transaction management, data validation, etc.
In Object Oriented Programming, modularity of application is achieved by Classes whereas in Aspect Oriented Programming application modularity is achieved by Aspects and they are configured to cut across different classes.
Spring AOP takes out the direct dependency of crosscutting tasks from classes that we can't achieve through normal object oriented programming model. For example, we can have a separate class for logging but again the functional classes will have to call these methods to achieve logging across the application.

What IS AOP?

AOP is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.
Before we dive into the implementation of Spring AOP implementation, we should understand the core concepts of AOP.

Aspect => An aspect is a modularization of a concern that cuts across multiple classes

Joinpoint => A Joinpoint is a point during the execution of a program, such as the execution of a method or the handling of an exception.

Pointcut => A Pointcut is a predicate that helps match an Advice to be applied by an Aspect at a particular JoinPoint.We often associate the Advice with a Pointcut expression, and it runs at any Joinpoint matched by the Pointcut.

Advice => An Advice is an action taken by an aspect at a particular Joinpoint. Different types of advice include "around," "before," and "after."In Spring, an Advice is modelled as an interceptor, maintaining a chain of interceptors around the Joinpoint.

Proxy => Proxy is the object which is created by the framework after applying the advice on the target object.

Target => Target is the application object on which the advice will be applied.

Sources : https://www.baeldung.com/spring-aop https://www.codejava.net/frameworks/spring/understanding-spring-aophttps://www.journaldev.com/2583/spring-aop-example-tutorial-aspect-advice-pointcut-joinpoint-annotations

Thank You….

SOLID Principles of Software Architectures

Pramuda Liyanage — Wed, 27 Oct 2021 22:09:18 +0000

SOLID design principles are five software design principles that enable you to write effective object-oriented code.
The SOLID name is a mnemonic acronym where each letter represents a software design principle, as follows:

01) S for Single Responsibility Principle
02) O for Open/Closed Principle
03) L for Liskov Substitution Principle
04) I for Interface Segregation Principle
05) D for Dependency Inversion Principle

The five principles overlap here and there, and programmers use them broadly. SOLID principles lead to more flexible and stable software architecture that’s easier to maintain and extend, and less likely to break.

Let's us consider each of the principles

Single Responsibility Principle ==>

Each of the services in the microservices architecture should be designed to adhere to a single objective. Simply put, they should have a unique responsibility and be the sole reason behind the change.

Open/Closed Principle ==>

It should be easy to expand the functionality of independent software modules. That is, the expandability of a specific service should not impact the original behavior of the software.

Liskov Substitution Principle ==>

Any two independent services should be able to communicate with each other whenever required through an API call. Also, two services having the same contract should be able to act as a substitute between each other, without altering the overall system.

Interface Segregation Principle ==>

The software should be divided into microservices in a way that there are no redundancies present. That is, the smaller modules should be loosely coupled to satisfy the client’s needs, along with minimizing the anti-patterns present in the code.

Dependency Inversion Principle ==>

The high-levels modules should not be depending on low-lower-level modules. Instead, they both should lean on abstractions. Following the same principle, abstractions should rely on details, while the vice-versa holds true. This principle ensures that changes to the higher-level modules will not affect the lower-level modules.

Thank you..........

Triple Constraints(The Project Management Triangle)

Pramuda Liyanage — Fri, 24 Sep 2021 16:22:48 +0000

The main component of the triple constraint theory is that scope, time and cost are interwoven aspects of any project that you are working on. When one changes the other two must be changed as well. This means if the budget for the project changes the timeline and the scope must immediately change as well. If the timeline changes the scope and cost must change and if the scope changes the cost and timeline must change. It is impossible to change any of the factors without affecting a change on the others. As the project manager, you have to manage each of these aspects and the concessions or changes that happen in each.

Because it is present in all projects, triple constraints are also referred to as the project management triangle with each of the three different aspects referring to an angle or line of the triangle. Together, they represent the most important factors in completing your project properly as everything else falls within these three broad categories. But there’s a little bit more to each of them then you might think about, so let’s take a little bit closer look at just what you’re getting into.

==Scope==

The scope refers to all the work necessary to complete a project. It must be identified during the planning stage by using a work breakdown structure. If the scope is not properly defined early in the project, it can expand during the execution phase due to unplanned activities. This is known as scope creep, and might cause projects to fail. The scope management process helps keep this constraint in check.

==Time==

Project managers must estimate the time required to complete a project. To do so, they use tools such as PERT charts or the critical path method. This must be done during the initiation and planning phases of the project life cycle to develop a schedule covering the duration of all the activities. Once the execution phase begins, the status of the project must be monitored to make changes to the schedule baseline. The project management process responsible for this constraint is schedule management.

==Cost==

There are many costs associated with a project. Project managers are responsible for estimating, budgeting and controlling costs so the project can be completed within the approved budget. All of this falls under the process known as cost management.

==The Importance of the Triple Constraint==

Clearly, the triple constraint is crucial to any project. And it’s critical to remember that the three points of this triangle are always influencing one another. If there is a setback in time, then there will have to be an adjustment in either scope or cost. The same being true for the other points. It’s the duty of the project manager to always keep these constraints in check.

Thank You.....

SQL Constraints

Pramuda Liyanage — Wed, 22 Sep 2021 20:54:21 +0000

Constraints are the rules enforced on data columns on table. These are used to limit the type of data that can go into a table. This ensures the accuracy and reliability of the data in the database.

Constraints could be column level or table level. Column level constraints are applied only to one column, whereas
table level constraints are applied to the whole table.

The following constraints are commonly used in SQL:

**NOT NULL - Ensures that a column cannot have a NULL value
**UNIQUE - Ensures that all values in a column are different
**PRIMARY KEY - A combination of a NOT NULL and UNIQUE. **Uniquely identifies each row in a table
**FOREIGN KEY - Prevents actions that would destroy links between tables
**CHECK - Ensures that the values in a column satisfies a specific condition
**DEFAULT - Sets a default value for a column if no value is specified
**INDEX - Used to create and retrieve data from the database very quickly

NOT NULL:

By default, a column can hold NULL values. If you do not want a column to have a NULL value, then you need to
define such constraint on this column specifying that NULL is now not allowed for that column.
A NULL is not the same as no data, rather, it represents unknown data.

For example, the following SQL creates a new table called CUSTOMER and adds five columns, three of which,
ID and NAME and AGE, specify not to accept NULLs:

UNIQUE:

The UNIQUE constraint ensures that all values in a column are different.
Both the UNIQUE and PRIMARY KEY constraints provide a guarantee for uniqueness for a column or set of columns.
A PRIMARY KEY constraint automatically has a UNIQUE constraint.
However, you can have many UNIQUE constraints per table, but only one PRIMARY KEY constraint per table.

For example, the following SQL creates a new table called CUSTOMER and adds five columns. Here, AGE
column is set to UNIQUE, so that you can not have two records with same age:

PRIMARY KEY:

A primary key is a field in a table which uniquely identifies each row/record in a database table. Primary keys must contain unique values.A primary key column cannot have NULL values.
A table can have only one primary key, which may consist of single or multiple fields. When multiple fields are used
as a primary key, they are called a composite key.If a table has a primary key defined on any field(s), then you can not have two records having the same value of that field(s).

Here is the syntax to define ID attribute as a primary key in a CUSTOMER table.

FOREIGN KEY:

A foreign key is a key used to link two tables together.This is sometimes called a referencing key.Foreign Key is a column or a combination of columns whose values match a Primary Key in a different table.
The relationship between 2 tables matches the Primary Key in one of the tables with a Foreign Key in the second table.If a table has a primary key defined on any field(s),then you can not have two records having the same value of that field(s).

Consider the structure of the two tables as follows:

CHECK:

The CHECK constraint is used to limit the value range that can be placed in a column.
If you define a CHECK constraint on a column it will allow only certain values for this column.
If you define a CHECK constraint on a table it can limit the values in certain columns based on values in other columns in the row.

DEFAULT:

The DEFAULT constraint is used to set a default value for a column.
The default value will be added to all new records, if no other value is specified.

For example, the following SQL creates a new table called CUSTOMERS and adds five columns. Here, SALARY
column is set to 5000.00 by default, so in case INSERT INTO statement does not provide a value for this column.
then by default this column would be set to 5000.00.

INDEX:

The CREATE INDEX statement is used to create indexes in tables.
Indexes are used to retrieve data from the database more quickly than otherwise. The users cannot see the indexes, they are just used to speed up searches/queries.

NOTE: Updating a table with indexes takes more time than updating a table without (because the indexes also need an update). So, only create indexes on columns that will be frequently searched against.

To create an INDEX on AGE column, to optimize the search on customers for a particular age, following is the SQL
syntax:

Main Building Blocks Of Angular

Pramuda Liyanage — Wed, 15 Sep 2021 18:03:35 +0000

Angular has main eight building blocks.There are,

01)Modules
02)Components
03)Templates
04)Metadata
05)Data binding
06)Directives
07)Services
08)Dependency injection

Let us consider the above building blocks one by one.

==Modules==

Angular apps are modular and to maintain modularity, we have Angular modules or you can say NgModules. Every Angular app contains at least one Angular module, i.e. the root module. Generally, it is named as AppModule. The root module can be the only module in a small application. While most of the apps have multiple modules. You can say, a module is a cohesive block of code with a related set of capabilities that have a specific application domain or a workflow. Any angular module is a class with @NgModule decorator.

Decorators are functions that modify JavaScript classes. Decorators are basically used for attaching metadata to classes so that, it knows the configuration of those classes and how they should work. NgModule is a decorator function that takes metadata objects whose properties describe the module. The properties are:

**declarations: The classes that are related to views and they belong to this module. There are three classes of Angular that can contain view: components, directives, and pipes. We will talk about them in a while.

**exports: The classes that should be accessible to the components of other modules.

**imports: Modules whose classes are needed by the component of this module.

**providers: Services present in one of the modules which are to be used in the other modules or components. Once a service is included in the providers it becomes accessible in all parts of that application

**bootstrap: The root component which is the main view of the application. This root module only has this property and it indicates the component that is to be bootstrapped.

==Components==

Components are the most basic UI building block of an Angular app. An Angular app contains a tree of Angular components.

Angular components are a subset of directives, always associated with a template. Unlike other directives, only one component can be instantiated for a given element in a template.

Note that, in addition to these options for configuring a directive, you can control a component's runtime behavior by implementing life-cycle hooks.

more details..
https://angular.io/api/core/Component

==Templates==

You define a component's view with its companion template. A template is a form of HTML that tells Angular how to render the component.

Views are typically arranged hierarchically, allowing you to modify or show and hide entire UI sections or pages as a unit. The template immediately associated with a component defines that component's host view. The component can also define a view hierarchy, which contains embedded views, hosted by other components.

A view hierarchy can include views from components in the same NgModule, but it also can (and often does) include views from components that are defined in different NgModules.

==Metadata==

Metadata tells Angular how to process a class.

Looking back at the code for CustomerComponent, you can see that it's just a class. There is no evidence of a framework, no "Angular" in it at all.

In fact, CustomerComponent really is just a class. It's not a component until you tell Angular about it.

To tell Angular that CustomerComponent is a component, attach metadata to the class.

In TypeScript, you attach metadata by using a decorator. Here's some metadata for CustomerComponent:

Here is the @Component decorator, which identifies the class immediately below it as a component class.

The @Component decorator takes a required configuration object with the information Angular needs to create and present the component and its view.

Here are a few of the most useful @Component configuration options:

**selector: CSS selector that tells Angular to create and insert an instance of this component where it finds a tag in parent HTML. For example, if an app's HTML contains , then Angular inserts an instance of the CustomerComponent view between those tags.

**templateUrl: module-relative address of this component's HTML template, shown above.

**providers: array of dependency injection providers for services that the component requires. This is one way to tell Angular that the component's constructor requires a CustomerService so it can get the list of heroes to display.

The metadata in the @Component tells Angular where to get the major building blocks you specify for the component.

The template, metadata, and component together describe a view.

Apply other metadata decorators in a similar fashion to guide Angular behavior. @Injectable, @Input, and @Output are a few of the more popular decorators.

The architectural takeaway is that you must add metadata to your code so that Angular knows what to do.

==Data Binding==

Data binding automatically keeps your page up-to-date based on your application's state. You use data binding to specify things such as the source of an image, the state of a button, or data for a particular user.
more details…
https://angular.io/guide/binding-syntax

==Directives==

Angular templates are dynamic. When Angular renders them, it transforms the DOM according to the instructions given by directives.

A directive is a class with a @Directive decorator. A component is a directive-with-a-template; a @Component decorator is actually a @Directive decorator extended with template-oriented features.

While a component is technically a directive, components are so distinctive and central to Angular applications that this architectural overview separates components from directives.

more details…

https://angular.io/guide/built-in-directives#:~:text=Directives%20are%20classes%20that%20add,styles%2C%20and%20what%20users%20see.&text=Attribute%20directives%E2%80%94directives%20that%20change,%2C%20component%2C%20or%20another%20directive.

==Services==

Service is a broad category encompassing any value, function, or feature that an application needs. A service is typically a class with a narrow, well-defined purpose. It should do something specific and do it well.

Examples include:

**logging service
**data service
**message bus
**tax calculator
**application configuration

There is nothing specifically Angular about services. Angular has no definition of a service. There is no service base class, and no place to register a service.

Yet services are fundamental to any Angular application. Components are big consumers of services.

more details…

https://angular.io/guide/architecture-services

==Dependency injection==

Dependency injection is a way to supply a new instance of a class with the fully-formed dependencies it requires. Most dependencies are services. Angular uses dependency injection to provide new components with the services they need.

Angular can tell which services a component needs by looking at the types of its constructor parameters. For example, the constructor of your CustomerComponent needs a CustomerService:

When Angular creates a component, it first asks an injector for the services that the component requires.

An injector maintains a container of service instances that it has previously created. If a requested service instance is not in the container, the injector makes one and adds it to the container before returning the service to Angular. When all requested services have been resolved and returned, Angular can call the component's constructor with those services as arguments. This is dependency injection.

Thank You…

HTTP Methods For Restful Services

Pramuda Liyanage — Mon, 13 Sep 2021 01:28:38 +0000

REST APIs enable you to develop any kind of web application having all possible CRUD (create, retrieve, update, delete) operations.The HTTP methods comprise a major portion of our “uniform interface” constraint and provide us the action counterpart to the noun-based resource. The primary or most-commonly-used HTTP methods are POST, GET, PUT, PATCH, and DELETE. These correspond to create, read, update, and delete (or CRUD) operations, respectively.

Method 1 : POST

POST is the only RESTful API HTTP method that primarily operates on resource collections. When creating a subordinate resource in a collection, applying POST to the parent resource prompts it to create a new resource, associate it with the proper hierarchy and return a dedicated URL for later reference. However, keep in mind that POST is not idempotent; you can't use this method more than once and expect a consistent outcome or result.

A significant benefit of POST is that it enables developers to explicitly define resources. This feature helps prevent teams from accidentally creating subordinate resources that pollute code, muddy references and cause applications to experience problems.

Method 2 : PATCH

A PATCH request is one of the lesser-known HTTP methods, but I'm including it this high in the list since it is similar to POST and PUT. The difference with PATCH is that you only apply partial modifications to the resource.

The difference between PATCH and PUT, is that a PATCH request is non-idempotent (like a POST request).

To expand on partial modification, say you're API has a /users/ (double brackets){userid} endpoint, and a user has a username. With a PATCH request, you may only need to send the updated username in the request body - as opposed to POST and PUT which require the full user entity.

Method 3 : GET

The most common HTTP method is GET, which returns a representational view of a resource's contents and data. GET should be used in read-only mode, which keeps the data safe and the resource idempotent. You should get the same results no matter how many times you use this method, unless it is modified by another client in the interim.

The GET method is sometimes used to change the contents of a resource, but this is a precarious use of the method. It's common to compromise a client's ability to PATCH a resource if the resource detects a change since the PATCH client last conducted a GET.

Method 4 : PUT

Similar to POST, PUT requests are used to send data to the API to update or create a resource. The difference is that PUT requests are idempotent. That is, calling the same PUT request multiple times will always produce the same result. In contrast, calling a POST request repeatedly make have side effects of creating the same resource multiple times.

Generally, when a PUT request creates a resource the server will respond with a 201 (Created), and if the request modifies existing resource the server will return a 200 (OK) or 204 (No Content).

Method 5 : DELETE

The last HTTP method to examine is DELETE. When a DELETE method targets a single resource, that resource is removed entirely.

Implementations of DELETE are typically somewhat inconsistent: The URL for the resource may remain available even if the actual resource is absent. In this type of scenario, it's possible the server or resource implementation will still change the state of the vanished resource using the URL, and likely react differently to subsequent DELETE executions.

While it's certainly possible, you should generally avoid using the DELETE method in a resource collection since it will delete all the contents within. Remember, the method isn't idempotent, and shouldn't be treated as such.

What is Dispatcher Servlet In Spring MVC

Pramuda Liyanage — Thu, 12 Aug 2021 16:22:50 +0000

What is Dispatcher Servlet in Spring MVC?

Dispatcher Servlet is actually the heart of Spring MVC.Every single web request which is supposed to be processed by Spring MVC goes through DispatcherServlet.In general, its an implementation of Front Controller Pattern which provides a single point of entry in your application. It handles all incoming requests. It is also the bridge between Java and Spring.he DispatcherServlet, as any Servlet, needs to be declared and mapped according to the Servlet specification by using Java configuration or in web.xml. In turn, the DispatcherServlet uses Spring configuration to discover the delegate components it needs for request mapping, view resolution, exception handling.

It is responsible for request handling by delegating requests to additional components of Spring MVC e.g. actual controller classes i.e. those which are annotated using @Controller or @RestController (in case of RESTful Web Services), Views, View Resolvers, handler mappers, etc.

Though the job of actual request mapping is done by @RequestMapping annotation, it's actually the DispatcherServlet which delegates request to the corresponding controller.

In the case of RESTful web services, it is also responsible for finding the correct message converter to convert the response into the format client is expecting like JSON, XML, or TEXT.

For example, if a client is expecting JSON then it will use the MappingJacksonHttpMessageConverter or MappingJackson2HttpMessageConverter (depending upon whether Jackson 1 or Jackson 2 is available in Classpath) to convert the response returned by convert into a JSON string.

==DispatcherServlet Request Processing===

Essentially, a DispatcherServlet handles an incoming HttpRequest, delegates the request, and processes that request according to the configured HandlerAdapter interfaces that have been implemented within the Spring application along with accompanying annotations specifying handlers, controller endpoints, and response objects.

Let's get more in-depth about how a DispatcherServlet processes a component:

**The WebApplicationContext associated to a DispatcherServlet under the key DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE is searched for and made available to all of the elements of the process

**The DispatcherServlet finds all implementations of the HandlerAdapter interface configured for your dispatcher using getHandler() – each found and configured implementation handles the request via handle() through the remainder of the process

**The LocaleResolver is optionally bound to the request to enable elements in the process to resolve the locale

**The ThemeResolver is optionally bound to the request to let elements, such as views, determine which theme to use

**if a MultipartResolver is specified, the request is inspected for MultipartFiles – any found are wrapped in a MultipartHttpServletRequest for further processing

**HandlerExceptionResolver implementations declared in the WebApplicationContext picks up exceptions that are thrown during processing of the request.

Thank You....
Pramuda Liyanage
-Fullstack Developer-

What is Deno js?

Pramuda Liyanage — Wed, 04 Aug 2021 10:58:57 +0000

=======What is Deno?==========

Deno is a simple, modern and secure runtime for JavaScript and TypeScript that uses V8 and is built in Rust.Deno is essentially a shell around the Google V8 JavaScript engine.

======Why use Deno?===========

Deno’s features are designed to improve upon the capabilities of Node.js. Let’s take a closer look at some of the main features that make Deno a compelling alternative to Node.

Security (permissions) in Deno
Among the most important of Deno’s features is its focus on security.

As opposed to Node.js, Deno by default executes the code in a sandbox, which means that runtime has no access to:

**The file system
**The network
**Execution of other scripts
**The environment variables

====Deno Features====

This is a list of few of Deno's features:

**Modern JavaScript: Node.js was created in 2009, and since then JavaScript has gotten a lot of updates and improvements. So Deno, as expected, takes advantage of more modern JavaScript.

**Top-level await: Normally, when using async/await in Node.js, you have to wrap your awaits inside of an asynchronous function, and you have to label it async. Deno makes it possible to use the await function in the global scope without having to wrap it inside an async function, which is a great feature.

**Typescript support out of the box: This is my second favorite feature—there is nothing more fun than having a little more control over your types in projects. This is the reason why I started building most of my projects in Go.

**Built-in testing: Deno has a built-in test runner that you can use for testing JavaScript or TypeScript code.

**A single executable file: If you have used Golang, the idea of shipping just a single executable file will be familiar. This is now present in JavaScript with the help of Deno. So say bye to downloading hundreds of files to set up your development environment.

**Redesigned module system: This is my favorite feature:, Deno has no package.json file, nor huge collections of node_modules. It has its package manager shipped in the same executable, fetching all the resources for you. Modules are loaded onto the application using URLs. This helps to remove the dependency on a centralized registry like npm for Node.js.

**Security: With Deno, a developer can provide permission to scripts using flags like --allow-net and --allow-write. Deno offers a sandbox security layer through permissions. A program can only access the permissions set to the executable as flagged by the user. You're probably asking yourself, "How will I know which flags I have to add to execute the server?" Don't worry; you will get a message in the console log asking you to add a given flag. Here is a list of the flags:

--allow-env allow environment access
--allow-hrtime allow high resolution time measurement
--allow-net= allow network access
--allow-plugin allow loading plugins
--allow-read= allow file system read access
--allow-run allow running subprocesses
--allow-write= allow file system write access
--allow-all allow all permissions (same as -A)

Thank You....
Pramuda Liyanage
-Fullstack Developer-

What Is REST API?

Pramuda Liyanage — Mon, 02 Aug 2021 14:48:28 +0000

What is REST API?

The term REST stands for REpresentational State Transfer. It is an architectural style that defines a set of rules in order to create Web Services. In a client-server communication, REST suggests to create an object of the data requested by the client and send the values of the object in response to the user. For example, if the user is requesting for a movie in London at a certain place and time, then you can create an object on the server-side.

So, over here, you have an object and you are sending the state of an object. This is why REST is known as Representational State Transfer.

The architectural style of REST helps in leveraging the lesser use of bandwidth to make an application more suitable for the internet. It is often regarded as the “language of the internet” and is completely based on the resources.

==============Java RESTful Web Services API=============

Java API for RESTful Web Services (JAX-RS) is the Java API for creating REST web services. JAX-RS uses annotations to simplify the development and deployment of web services. JAX-RS is part of JDK, so you don’t need to include anything to use it’s annotation

===========Restful Web Services Annotations===============

Some of the important JAX-RS annotations are:

@Path: used to specify the relative path of class and methods. We can get the URI of a webservice by scanning the Path annotation value.

@GET, @PUT, @post , @DELETE and @HEAD: used to specify the HTTP request type for a method.

@Produces, @Consumes: used to specify the request and response types.

============Principles of REST API========================

Well, there are six ground principles laid down by Dr. Fielding who was the one to define the REST API design in 2000. Below are the six guiding principles of REST:

Stateless :
The requests sent from a client to a server will contain all the required information to make the server understand the requests sent from the client. This can be either a part of URL, query-string parameters, body, or even headers. The URL is used to uniquely identify the resource and the body holds the state of the requesting resource. Once the server processes the request, a response is sent to the client through body, status or headers

Client-Server :
The client-server architecture enables a uniform interface and separates clients from the servers. This enhances the portability across multiple platforms as well as the scalability of the server components.

Uniform Interface :
To obtain the uniformity throughout the application, REST has the following four interface constraints:

**Resource identification
**Resource Manipulation using representations
**self-descriptive messages
**Hypermedia as the engine of application state

Cacheable :
In order to provide a better performance, the applications are often made cacheable. This is done by labeling the response from the server as cacheable or non-cacheable either implicitly or explicitly. If the response is defined as cacheable, then the client cache can reuse the response data for equivalent responses in the future.

Layered system :
The layered system architecture allows an application to be more stable by limiting component behavior. This type of architecture helps in enhancing the application’s security as components in each layer cannot interact beyond the next immediate layer they are in. Also, it enables load balancing and provides shared caches for promoting scalability.

Code on demand :
This is an optional constraint and is used the least. It permits a clients code or applets to be downloaded and to be used within the application. In essence, it simplifies the clients by creating a smart application which doesn’t rely on its own code structure.

Thank You...
Pramuda Liyanage
-Fullstack Developer-

Java OOP Concepts

Pramuda Liyanage — Thu, 15 Jul 2021 19:39:39 +0000

================Java OOP Concepts==========

What is OOP?

OOP Stands for Object-Oriented Programming.Object-Oriented Programming is paradigm that provides many concepts,such as inheritance,polymorphism etc.It simplifies software development and maintenance by providing some concepts.

What are the OOPs Concepts?

There are,
*Object
*Class
*Abstraction
*Encapsulation
*Inheritance
*polymorphism

Java Is an Object-Oriented Programming language.Everything in Java is associated with class and objects,along with it's attributes and methods.Classes and Objects are two main aspects of object-oriented programming.

Let us consider the above oop concepts one by one..

Objects=> Any Entity that has state and behaviour is known as a object.Examples are Chair,Pen,Table etc.

Class=> Class is a Collection of objects.It is a Logical Entity.So, Class is a Definition of object,template for objects, and object is an instance of a class.

Object-Oriented Programming is a methodology or pradigm to design a program using classes and objects

Inheritance=> Inheritance is an important pillar of OOP(Object Oriented Programming). It is the mechanism in java by which one class is allow to inherit the features(fields and methods) of another class.

Important terminology:
**Super Class: The class whose features are inherited is known as superclass(or a base class or a parent class).

**Sub Class: The class that inherits the other class is known as subclass(or a derived class, extended class, or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.

**Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.

Important point:

**In the inheritance the class which is give data members and methods is known as base or super or parent class.

**The class which is taking the data members and methods is known as sub or derived or child class.

**The data members and methods of a class are known as features.
The concept of inheritance is also known as re-usability or extendable classes or sub classing or derivation.

Why use Inheritance ?

*For Method Overriding (used for Runtime Polymorphism).
*It's main uses are to enable polymorphism and to be able to reuse code for different classes by putting it in a common super class
*For code Re-usability

Real Life Example of Inheritance in java:

The real life example of inheritance is child and parents, all the properties of father are inherited by his son.

Polymorphism=> If one tasks is performed in different ways,It is known as polymorphism.Polymorphism is derived from 2 greek words: poly and morphs.The word "poly" means many and "morphs" means forms. So polymorphism means many forms.In java We used method overloading and method overriding to achieve polymorphism.

Polymorphism is not a programming concept but it is one of the principal of OOPs.For many objects oriented programming language polymorphism principle is common but whose implementations are varying from one objects oriented programming language to another object oriented programming language.

Two types of Polymorphism

01)Compile time Polymorphism(Static or Early Binding)
02)Runtime Polymorphism(Dynamic or late Binding)

Real Life Example of Polymorphism in java:

Suppose if you are in class room that time you behave like a student, when you are in market at that time you behave like a customer, when you at your home at that time you behave like a son or daughter, Here one person present in different-different behaviors.

Abstraction=> Abstraction is the concept of exposing only the required essential characteristics and behavior with respect to a context.

Hiding of data is known as data abstraction. In object oriented programming language this is implemented automatically while writing the code in the form of class and object.

Real Life Example of Abstraction in java:

Another real life example of Abstraction is ATM Machine; All are performing operations on the ATM machine like cash withdrawal, money transfer, retrieve mini-statement…etc. but we can't know internal details about ATM.

Encapsulation=> Encapsulation is a process of wrapping of data and methods in a single unit is called encapsulation. Encapsulation is achieved in java language by class concept.

A java class is the example of encapsulation. Java bean is the fully encapsulated class because all the data members are private here.

Advantage of Encapsulation:

The main advantage of using of encapsulation is to secure the data from other methods, when we make a data private then these data only use within the class, but these data not accessible outside the class.

Benefits of encapsulation:

*Provides abstraction between an object and its clients.
*Protects an object from unwanted access by clients.
*Example: A bank application forbids (restrict) a client to change an Account's balance.

Real life example of Encapsulation in Java:

The common example of encapsulation is capsule. In capsule all medicine are encapsulated in side capsule.

Thank You...
Pramuda Liyanage
-Fullstack Developer-