You might be building a product using cutting edge technologies, writing a bestseller book or breaking into a new market withholding great potential. No matter what you are doing, it is all in vain if the product is not brought to the notice of your target audience. The need for a killer marketing strategy is extremely important for the success of your product or service. 


Even Though the process of rolling out a product in the market seems straightforward, it is not so in reality. Having a product in the market does not solely entail serving a group of people, informing them about the existence of your product and pricing it at a value that is acceptable to them. It is much more than that. 


It is important to have a solid marketing strategy which takes into consideration detailed account of 
* **WHO** your customers are?
* **WHAT** are the **NEEDS & DESIRES** of your customer?
* **WHAT** are the **SOLUTIONS** used by your customer currently to solve their problem and the **CHALLENGES** faced by them while using that solution?
* In case the customer faces challenges, **WHAT** can be done to help them **OVERCOME those CHALLENGES**?
* **HOW** do you **DISTINGUISH** yourself from the competition?
* **HOW** does your consumer **INTERACT** with the product?
You can only have a marketing strategy on the road to success once the answers to these questions are researched in detail.


If you don’t identify your customers, their needs from the product you are offering and the price they are willing to pay for your product, you might see your sales declining even before they pick up. An example would be selling a luxury item at a low price so that more people can buy it. However, by pricing a luxury item too low and making it accessible to a mass audience, it would lose its target customers who would want to buy the product for the status symbol associated with the product. The 4 Ps of marketing is a great tool to avoid such mistakes.


The key factors that are to be taken into account while positioning your product or service in the market and influencing customers to buy your product are - 

* `Product`
* `Price`
* `Place`
* `Promotion`


![4 P's of Marketing](https://i.imgur.com/kzkZqb5.png "")

#### PRODUCT

* A product or a service that solves the problem or need of a consumer. It can be a book in a bookstore, SaaS like Slack or Salesforce or even a service like a club membership.
* The product should have a USP (Unique Selling Point) or so to say a competitive edge over your competitors. 
* There has to be a differentiating factor between your product and what your competitor is selling for your product to stand out and your customers to choose your product.


#### PRICE

* The monetary value the customer pays for the product
* It is very important to determine the right price for your product in order to get enough profit for your product
* Pricing decides the customers that will come to your brand. A higher priced product would attract customers who want status value attached to the product and a lower priced product would attract customers who don’t care as much about the status as about getting their problem solved at an economical price.
* Pricing should also be determined by the kind of market your product will be operating in and the pricing your competitors offer for their product. If it's a newly discovered market you can charge a premium amount for the product. However if the market space is already saturated, the product is best sold at a cheaper price.


#### PLACE

* To bring the product to the notice of your target audience , it is essential to define **WHERE** the product will be 
		- `marketed (email, website, social media, hoardings, etc)` 
		- `sold (Online or offline)`
* If your targeted users prefer online shopping over visiting stores, the more viable option would be to sell the product or service online.
* It is important to research the demographics of your customer as well as where your competitor operates. Asking the following questions can help - 
		- `Where are the customers and where do they usually look for your 	service or product (online/ offline)?` 
		- `Is the product sold to businesses or directly to customers?` 
		- `Where are the competitors based? Can you operate away from them?` 


#### PROMOTION

* This factor defines how to reach out to the target audience and inform them about your product or service.
* It includes the strategies you use to bring your product to the notice of your customers. Some ways to promote your product include Direct emails, Influencer marketing, TV, Magazines, Billboards, Blogs, etc.
* Instead of going for all the possible promotion strategies , it is more useful to identify the strategies that will work the best for your target audience. For example - Promoting your product via a mailing list won’t be a viable strategy if your target audience is not tech savvy. 
* Every business should have its own promotion strategy tailored according to the target audience.

 
 

### How to use the 4 P's of Marketing?

1. Know your product inside out - It is important to know about the WHY behind every feature that your product offers or the service that you provide. 


2. Research about the customers, competition and the market before going through the 4 P’s in a detailed manner. 


3. Ask questions while deciding about the 4 P’s and keep asking these questions till you are satisfied with the facts and figures related to the product. 
	- **_Does the product meet the needs of the target audience?_** 
	- **_How different is your product from your competitors? What is its unique selling point?_** 
	- **_What will your target audience think about the price of the product?_** 
	- **_Will you position the product as a luxury product or an economical budget friendly product?_** 
	- **_Where will your customers shop for the product? How is the product going to reach them?_** 
	- **_How will your customers get to know about the product? What will be the most effective promotion strategies for your target audience?_** 


4. Review the marketing mix regularly as the market may change as the product matures.

 
 

While the 4 P’s of Marketing might look like a theoretical concept only to be read in books and articles, it provides a great insight while developing a marketing strategy for your product or service and differentes your business from that of your competitors.

4 P's of Marketing

The most crucial aspect of SaaS marketing is to understand who your customers are and to focus on their problems. However situations may arise where the product caters to the needs of the identified target group, but the product does not generate outputs or perform as expected. 

The answer to this uncanny behavior of getting unexpected results despite following the checklist lies in understanding the Product Adoption Curve. It is important to understand that the consumers won’t adopt the product at the same time. The reason to use the product may differ for each one of them. The driving force behind using the product depends on what phase of its life cycle the product is in. 

The Product Adoption Curve depicts a model which simplifies how and when to target specific groups from the consumer base. 
Customers lie in one of the categories described in the product adoption curve namely 

- **Innovators**
- **Early Adopters**
- **Early Majority**
- **Late Majority**
- **Laggards**
 
 

### Stages of Product Adoption Process

![5 Stages of Product Adoption Process](https://i.imgur.com/KPN0AOU.png "5 Stages of Product Adoption Process")

`THE INNOVATORS`
 
This is a relatively small group of people and will be one of the first ones to invest in your product. They are not looking for a solution to any problem but are interested in technology. They are open to taking risks and trying new products. 
This group is instrumental in giving a lot of feedback on the product. The product doesn’t need to be perfect before rolling it out to them and instead can be used to improvise based on the feedback received from these customers. 
This group does not want to spend a lot of money on your product. A freemium model can be used in this stage to gather feedback for your product. It is important to determine what improvements in the product should be made for better market penetration at later stages.
 
 
`THE EARLY ADOPTERS`
 
This is a comparatively larger group of customers who are keen on trying new products. They not only use your products to test waters but also because they have a problem that the product solves. 
These people might not mind paying a price for your product but will expect some level of customisation and a solution to their problem. 
They will give importance not only to the diverse features that the product offers but also to the customer problems that the product solves. 
Reviews and testimonials from these customers can be used in later stages of the curve to entice new customers. Additionally the suggestions provided by these customers can be used to improve the product.
 
 
`THE EARLY MAJORITY`
 
A third of the users belong to this group. This is the stage which offers maximum market size and potential to grow. Reaching this stage signifies that the product has a place in the market. The sales of your product is good from the previous two phases and after various iterations and improvements the product is also stable. 
The customers in this phase are open to change and innovation provided their pain points get solved through the solution that the product offers. They can be motivated to use the product with the help of case studies and testimonials from the customers of the previous two stages. These people would like to use the products which have been thoroughly tested and have provided value to other people. They are not very tolerant of technical issues with the product.
 

![Chasm in Product Adoption Curve](https://i.imgur.com/zj7c9ay.png "src : https://upload.wikimedia.org/wikipedia/commons/d/d3/Technology-Adoption-Lifecycle.png")
> While crossing from the **Early Adopters** stage to the **Early Majority** stage , there is a divide between the two stages which is to be crossed for the product to establish its roots concretely in the mainstream market. This divide is called a **CHASM** and exists mainly because of the gap in expectations between the customers of the two stages. 
> The most integral part of crossing the chasm is Product positioning. The product has to go from being marketed to visionaries and technology enthusiasts to users who will use the product to solve their problems. The perspective has to change from higlighting all the cool new exciting features the product offers to highlighting how the features of the product solve the problems of the customers. 
> This can be achieved by using testimonials collected in the previous two stages (**Innovator & Early Adopter**), showcasing the success other people have had with the product and highlighting the features that solve the problems of this user base. The feedback received from the first two groups becomes very integral to improvise the product, so that it becomes fit for the non technical users to use.


`THE LATE MAJORITY`
 
This stage sees as many users as the Early Majority stage. However these users are more hesitant in opting for new solutions and technologies and only start considering your product once the product has managed to create a name for itself in the market. They want to be sure that the product is tried and tested before using it themselves. 
They will use your product not out of curiosity but out of need. They will not want to miss out on an opportunity to use a product that their competitors (from the Early Majority stage) might already be using. 
It is somewhere between the early majority and late majority phases where the sales of the product will be at its highest. It is very important to showcase to the consumers how the product solves their problem and the advantages that the product will provide them over the competitor product. 
 
 
`THE LAGGARDS`
 
The size of this group is considerably large,, making it an important stage for the success of the product. This group of people will be the last to buy your product. They are opposed to change and feel threatened by it. They are skeptical about your product and only start considering using your product once all of the buzz about the product is starting to quiet down. The popularity of the product does not convince them to adopt it and they only do so once things start becoming difficult for them by not using the product and are forced to adopt it.
 
 

### Conclusion

The product life cycle starts at a stage where no one or a very few people know about the product and may gradually reach a stage where everyone knows about it. As the product ages , the way it is promoted to the customers should also change. The message that you put forward at every stage should change according to the customer. **Innovators and Early adopters** will seek **uniqueness** whereas the **Early Majority** would want to know **what others think about your product.** 
The Innovators and Early Adopters are showcased the features of the product and the benefits it offers. On the other hand for the later stages, testimonials and reviews can be used to appeal to the customers and end their skepticism towards the product. 
Product Adoption Curve is a difficult concept to implement in your product lifecycle but can be very rewarding if mastered. If you pay attention to `WHICH customer needs WHAT and WHEN`, you can create an awesome product which is adopted by different customers at different stages. The key is to know who your customers are and what they want from your product.

What is Product Adoption Curve?

Building a competitive product involves a lot of steps. Among these myriad tasks , it is very easy to lose focus and go off track.  To make sure that the product is being built in line with the vision , a detailed product strategy acts as a constant guiding source.

![Steps involved in building a product](https://i.imgur.com/VfcMmzV.png "Steps involved in building a product")

Product strategy entails a high level plan focussing on what a business plans to accomplish, the kind of market the business operates in and explains what steps should be taken to accomplish that business goal.

It is very important to be mindful of

- **WHO** the product will serve (Personas)
- **HOW** will the product benefit them
- **WHAT** will be the goals to attain that
 Before diving headfirst into building a roadmap and developing features, it is important to define a larger goal with the intent to provide real value to the customers.
 
 

### Why is strategy important?

1. **Clarity** 
 Having a product strategy lays down the answer to every question about the product (**Whom is the product being built for, who are the competitors, what will be the product features, etc**) and helps the stakeholders have a clear idea about the product they are building. 

 A designer who does not understand the audience the product is being built for and what problems it intends to solve won’t be as efficient and clear about the product being built. For marketing and sales people , a product strategy makes them understand the what and who of the product which helps them convert a potential user to a retained user. Customer success teams would understand the features and use cases better and thus be able to provide better support in solving and understanding customer problems.

2. **Prioritisation of roadmap** 
 Instead of directly jumping the bandwagon and defining features and epics on the roadmap, it is important to understand the goals of the product. There might be cases where wrong feature items may be prioritised because of unclarity of what the goals for the product are. It is therefore extremely important to consult the product strategy before making any decisions that impact the product. A strategy lays down what is to be accomplished through the product, giving one a clearer picture and thus helping to build more reliable, efficient and accurate roadmaps.

3. **Make tactical decisions** 
 The initial product roadmap is not followed all the time as situations may arise where the priorities may need to be changed. In order to make decisions about adjusting or changing your plans, a product strategy acts as a reference point to make decisions regarding the product.
 
 

### Components of Product Strategy

Product strategy is all about defining the direction you want your product or service to take in the future. It therefore becomes important to define whom the product is for, what are their pain points and needs ( this gives the problem to which the product provides a solution), why would they want to buy and use this product, what gives an edge to the product over their competitors and what are the business goals of the company. Business goals help to define how the product will be beneficial to the company, what kind of and how much revenue the product will generate, etc.

A product strategy should primarily answer :

- `Business goals`

- `The market the product will be launched into`

- `What are the needs and problems of the users that the product aims to solve`

- `What differentiates the product from similar products (Unique Selling Point)`

![](https://i.imgur.com/cxiNBUN.png "Components of Product Strategy")

#### WHAT DO YOU WANT TO ACHIEVE?

* **_Product Vision (The WHY behind the product)_** 
The vision should be concise and should include what the product aims to achieve. The vision of the product should not change. 
It is important to conduct a thorough market research, understand the customers and the problems you are trying to solve for them and know the strengths and weaknesses of your company to define a clear vision. 
For example the vision statement of IKEA is `To create a better everyday life for the many people.`
This vision statement is short, concise and to the point and clearly states that the company wants to offer products which can improve the lives of people, in their case in terms of affordability as well as quality furnishings.

 

#### FOR WHOM IS THE PRODUCT BEING BUILT?

* **_Product Positioning_** 
Defining where the product fits in the market and what differentiates the product from other similar products **(Unique Selling Point/ Proposition)** is very important for the product to succeed.
This drives the market go-to plan and plays a crucial role in driving the marketing strategy as well. 
A thorough understanding of the target audience and a detailed analysis of the market where you wish to launch your product is extremely integral in making the product successful.

 

#### HOW DO YOU WANT TO BUILD THE PRODUCT

* **_Product Goals_** 
Once the vision is defined - the next step to follow is defining high level goals which play an important role in prioritization of the product roadmap. 
Goals should be `specific, measurable, attainable, relevant, time-bound (SMART)` 
They represent the to do checkpoints needed to turn vision into reality. Product goals should ideally have a fixed time frame.
For example-

1. `Increase downloads by 100% in the next one year`
2. `Double the revenue in the next one year`


* **_Product Initiatives_** 
Initiatives are objectives which can be broken down into actionable tasks. An Initiative comprises of different epics, features, requirements. Product initiates are efforts that need to be made to accomplish each goal. Initiatives can be established at company, product line or product levels. These tend to cross multiple sprints and releases and include many features and user stories. 
For example-
`Enhancing user onboarding experience` - This initiative could have various features or requirements like including progress bars to indicate the level of completion of user registration process, giving a virtual product tour, etc.
 
 
Once the product strategy is made it is translated to a product roadmap. Product Strategy is not constant and grows with the product. It should continue to evolve as the product moves through different stages in its lifetime. Strategy to launch the product in the market can be very different from strategy to maintain the product performance and sustain growth till it declines.
Once the growth of the product stagnates, the product life cycle can be extended by taking the product to a new market or can be left to decline and die.

What is Product Strategy?

**Hooked** by **Nir Eyal** offers a very interesting model on how to hook consumers to a product by diving into what triggers them to use the product, what makes them keep coming back and inculcate the product into their lives as a habit.
Not only that but the book also offers interesting insights into consumer psychology and even talks about the ethics of building habit forming and addicting products.

 

### HOOKED MODEL

The book deep dives into what exactly makes the user come back to a product repeatedly as much as that the product can be labelled as a habit the customer has incorporated into their lifestyle.

 

### NEED FOR HABIT FORMATION AND HABIT ZONE

> The HOOKED Model is divided into 4 phases namely **TRIGGER , ACTION , VARIABLE REWARD, INVESTMENT**

A trigger prompts the user to use the product and can be **internal or external**.
Initially external triggers are used to bring them to the product through emails, push notifications, etc.

Once the user starts using the product , the next step that follows is to make them perform an action in anticipation of a reward. However the user experience should be simple and there should be a psychological motivation attached to it.

The reward that the user gets after performing the action should be kept variable. If the reward becomes predictable, they lose the incentive to use the product and are eventually driven away. However when they do not know what reward will follow, it creates a sense of mystery around it which motivates them to use the product.

Once the user invests resources like time, money, data into the product , they also attach a sense of value to it which makes them use the product more often.

The repeated cycle through the above mentioned phases forms an association with internal triggers of the user and brings them to the product without the need of an external trigger to prompt them to use the product.

 

### Triggers

Triggers are what brings the users to the product and motivates them to use it.

> External triggers are embedded with information which makes the user perform the desired action.

`Paid Triggers` — These are costly but very effective. They are used to bring the product to the attention of the users. Once they are brought to the product other triggers can be used to bring them back. Some examples of paid triggers are advertisements on various digital mediums like google, youtube, etc or physical mediums like magazines, billboards, etc.

`Earned Triggers` — These triggers are not bought directly but require investment in terms of media marketing. Some examples include being a part of a viral video or blog post, featured app, promoting the product through an interview, etc. However this form of trigger does not have a long term effect on the customer.

`Relationship Triggers` — Another form of trigger is when people who already use the product promote it to other people. However to utilise this trigger, there must be a an engaged user base who can recommend the product to others.

`Owned Triggers` — Once the user has started using the product, these triggers can be used to keep the them engaged with the product in form of newsletters, email notifications about the product. Opting in for these triggers is a choice.

Using the above mentioned external triggers, users are drawn to the product repeatedly and after successive cycles of engagement with the product, external triggers are replaced by internal triggers.

Once the product becomes tightly coupled with the thoughts, emotions or routine of a user, internal triggers come into play.

Emotions play a very important role as internal triggers. Any kind of negative emotion makes the user resort to actions which alleviates their pain. If the product successfully manages to distract them from the negative emotion, they resort to the product any time a negative emotion be it boredom , irritation, etc arises. Positive emotions like being part of a community; sharing news, knowledge ,etc can also act as great triggers and the users start forming associations with the product over a period of time.

Once a product is attached to an emotion, any time we experience that emotion we turn to the product. For example any time we click new photos, we have the urge to share them on Instagram for our friends and family to see.

Habit forming products are focussed on pain points that need to be solved for the user. If the product solves a particular problem , the user comes to identify the product as a source of relief.

 

### Action

Triggers bring the user to the product to perform an action. However if the user does not perform the intended action, the trigger is of no use. Therefore the action must be easy to perform and should not require a lot of effort on the part of user.

User must have the **motivation** to do the action, the **ability** to complete the action and a **trigger** to inform the user about the action.

**Motivation** defines the desire to take an action.

Some core motivators are seeking pleasure to avoid pain, seeking hope to avoid fear, seeking social acceptance to avoid rejection. Successfully identifying what motivates the target audience can play a huge role in them finally carrying out the intended action.

**Ability** defines how easily an action can be performed. If the action is simple and easy to perform, the user is more likely to perform the action.

Elements which should be taken into account while designing the product to increase usability are

- Time — Will the user spend a lot of time performing the action?
- Money — Does the user need to spend money to perform the action?
- Physical Effort and Mental Effort — Does the user need to carry out any physical task or - spend a lot of energy thinking about how to carry out the desired task?
- Social Deviance — Will the action be socially acceptable?
- Non Routine — Will the action disrupt the routine of the user?

 

### Variable Reward

Once the user has performed the desired action, they are rewarded with a problem being solved which in turn reinforces their motivation.

`Rewards of the Tribe` are social rewards which makes the user feel accepted in the society. This type of reward works well with the target audience who seek social acceptance. For example — on uploading a picture on Instagram (which is an Action), variable reward would be gaining followers or followers liking the uploaded picture which would make the users feel accepted, creating a positive motivation cycle for them to use the product.

`Rewards of the Hunt` — Hunting is a primal instinct in humans and where hunting for food and other resources is not as common nowadays, the same logic can be applied to the need of users to be on the constant lookout for new deals on E-Commerce stores, new posts on social media platforms like Pinterest, Twitter , etc. In such scenarios the user gets hooked onto the experience of not knowing what they will come across and the anticipation motivates them to use the product.

`Rewards of the Self` are the ones which we seek for personal gratification. These rewards are fueled by intrinsic motivation and the driving factors may involve gaining a sense of competency. Adding rewards that the user might not expect would hook them onto the product. Games are a good example of products which cater to the needs of the user to seek pleasure.

- Rewards must be in alignment with the pain points the product intends to solve and must improve the user’s life.
- Users must feel they are in control while using the product and not made to feel like they have to perform actions they aren't willing to do.
- Element of mystery is important to keep the user engaged in the product. If the rewards become predictable, the user loses motivation to keep using the product. However it is important to realise, not every product requires variability and the decision to include variability depends on the type of product.

 

### Investment

Investment is a key factor in the user being hooked to the product. Users value the products in which they invest time and effort.

Investments are done in anticipation of long term rewards — not instant gratification. Users should be asked to invest a resource after the _variable reward_ phase or else it causes friction in the user experience. Once they receive a reward, they might be willing to do some work.

Investment can be done in the form of

`Content` — When the user invests time to perform the action of putting up content (like photos on Instagram) on the product, it becomes harder to leave the product.

`Data` — When a user has data stored in a product, it becomes difficult for them to switch to some other product as they might end up losing the data or would have to make great efforts to migrate that data.

`Followers` — Once the user starts gaining followers on a product, it becomes harder for them to stop using the product.

`Reputation` — In some products users invest their effort to maintain a good reputation score and it becomes unlikely for them to switch to some other product where they would have to start from point zero.

`Skill` — Once the user has spent time and effort to acquire skills to use a product, they are less likely to switch to some other product.

Investment phase should include future triggers to bring back the user to the product.

When user A buys clothes from an online retailer, they could get a cashback coupon for the next time they shop. This would encourage the user to come back to the product and shop again.

A lot of time users lose interest in the product after once cycle. In such situations external triggers should be used here to bring back the user to the product. For example, if a user adds items to the cart but never comes back to the product to buy those items, a mail informing them about items waiting in the cart could bring them back to the product.Once the user goes through the above cycle a few times, the triggers get internalized and the user does not need external motivation or triggers to use the product.

All in all, HOOKED is a must read for anyone who wants to know how to build habit forming products. It offers great insights into what motivates the customer and what brings them back time and again to the product.

Key Lessons from “Hooked : How to Build Habit Forming Products”

Building a new product can be confusing with a lot of uncertainty considering the different processes involved. This may lead to an inefficient product development process which might in turn also affect the product.

New Product Development Process is a process to convert an idea into a workable software product, consisting of various stages from conception of an idea to launching a software product in the market.

It involves the following stages — **_Idea Generation, Idea Screening, Concept Development and Testing, Marketing Strategy Development, Business Analysis, Product Development, Market Testing and Commercialisation._**

> The process has the term **New Product** as it deals with creating new products, adding new features to an already existing product line, adding new product lines to an already existing product and improving already existing products.

 

**_Idea Generation/Discovery_**

This is the first phase and is important in order to gather ideas which will in turn become the possible features of the product.

It is important to identify the customer problems and then brainstorm solutions focussed on those problems. The problems can be classified on the basis of
1. if they actually address customer problems or fill in any existing gaps in the solutions already being provided to the customer
2. the extent to which the problems need to be solved and how urgent it is to solve the problem
3. if there are any other solutions in the market already solving the same problem.

The ideas/solutions don’t have to be concrete as this phase only revolves around coming up with as many ideas as possible.

There are many sources that can be referred to for ideas like
* requests from customers
* brainstorming with the internal team
* analysing customer feedback on competitor products
* suggestions, reviews and complaints on social media platforms for an existing product.

The solutions can introduce already existent solutions to a new market, adding new features to an already existing product or improving already existing features of a product.

 

**_Idea Screening_**

Once the ideas are gathered, it is important to filter and categorise them and select the ideas that seem to showcase the highest potential.The ideas are evaluated on the basis of whether they align with the vision and goal of the company and if they are feasible in financial and technical terms. Based on these criterias the ideas can be grouped into three categories — ideas which look promising, ideas which can be implemented but don’t lead the board and ideas which can be discarded.

![](https://imgur.com/ulHNlvb.png "Idea Screening")

 

**_Concept Development and Testing_**

The idea is converted into a concept in this stage. The idea is elaborated in detail identifying the functionality (use case) it meets and how it solves the problem.

> Some important information about the kind of customers who will use the product and when they will use it, the benefits and pain points the product will bring to them, performance of the competitor product in the market — the good solutions they bring to the table, where they lack and the problems they have not addressed is important to gather as well.

Once the most valued features/concepts are identified, they can be validated through customer feedback. Different sources of data can be used (qualitative and quantitative) like surveys, competition research, focus groups, interviews, reports, data from previous projects to identify the direction.

The main insights to come out of this process would be the focus groups , what they think about the suggested features and alternative features which maybe preferred by focus groups.

 

**_Marketing Strategy Development_**

A marketing strategy is created for the features/ concepts that have a positive feedback in the concept testing phase. It is a way to reach out to the target audience.

It is important to identify the needs and demands of the market(focussing on the customers) the product will be rolled out in. It is also important to analyse the current market scenario and the kind of competition the product is likely to have.

The Marketing Strategy is based on 4 Ps of Marketing.

![src: https://images.yourstory.com/cs/wordpress/2016/10/4-ps-marketing-outdated.png](https://imgur.com/Bcs6lFV.png "4 Ps of Marketing")


`Product` — The product should stand out in the market either because of its unique features or features which are better than the already existing features in the market.The product is finalised based on the concept testing phase results.
 
`Price` — Many factors such as the price of competitor products, cost of materials and production, market fluctuations are taken into account while determining the price of the product or service.
The company might also inflate the price to increase the value of the product to build customer loyalty.
 
`Place` — Where and how the customer is exposed to the product. This factor is important in determining where should the product be sold how should it be delivered to the market. It governs strategies such as if the product is localised or global, distribution strategy, etc.
 
`Promotion` — This P helps in uniquely distinguishing the product through creating brand awareness, social media marketing, etc building an interaction with the consumer regarding the product.


The marketing strategy is the reviewed and revised according to need. Market research can be performed using the online data available online. Various sources online can be used to collate and build a tentative market scenario for the product.

 

**_Business Analysis_**

This stage focuses on analysing if the product is feasible to build from a financial perspective. A detailed business plan is built which includes estimating selling price based on intensive market research of competition and customer feedback. It analyses how the product will fit in the market and estimates the financial model on the basis of assumptions made on market share.

Pricing can be done in 3 different ways —
* **_Price higher than the market_** for solutions which solve an urgent problem of the customer
* **_Price equivalent to the market_** which is a safe move but needs better marketing to perform better than the competitor
* **_Price lower than the market_** to build a loyal customer base


The business plan also looks into the investment during product development and the associated costs once the product is launched. Break even analysis helps identify the point at which the product becomes profitable.
If the business plan is in alignment with the goals of the company, the Product Concept moves to the Product Development stage.

 

**_Product Development_**

The Product concept is now developed into a physical product.

Based on the gathered solution to the problem , wireframes and prototypes are built which can be later refined according to the need and response. It is an iterative process. The prototype/ wireframes are then tested with the customers. The test results are analysed in the form of
* customer responses and feedback
* how they reacted to the product
* how they used it
* the difficulties they faced while using the product
* whether they were able to perform the actions the product intended them to perform.

Testing can be done in formal groups or informally with existing customers. The product is also validated in terms of market and seen if it would be financially viable.The data yielded from the testing provides valuable input to what features should be kept and what features should be dropped or if there are any transitions that can be made to the existing features. Analysing the data can be helpful to make modifications to the final product that will be rolled out.

This process gives way to a well defined product. This is also where a roadmap is made to define the journey of the product and the goals that are to be achieved. It showcases the conceptual as well as technical benchmarks that are to be achieved through collaboration between the different stakeholders of the product team.


Training — Once the final product is made, training is important to inform the users internally and externally on how to use the product.

 

**_Market Testing_**

The developed product is now tested in a market setting to check the viability of the software product.

* **Alpha Testing** - The test engineers in the organisation test the product on its performance and validate the software for missing features, features not performing according to requirements, etc. This gives way to Beta Testing.

* **Beta Testing** - The target groups use the product and give their feedback to the organisation on usability and functionality of the product.

* The product can also be tested with intended customers. They are allowed to use the product and their feedback is collected.

* Once the alpha and beta testing is done, the product can also be tested by placing the product for sale in certain areas and observing the performance against the initially laid out marketing plan.

 

**_Commercialisation_**

If the results of market testing are positive, the product is decided to be launched on a larger scale. The launch is planned with details like **WHOM,WHEN,HOW,WHERE.**

The product can also be launched in waves i.e gradually launching the product in different areas.
Commercialisation involves production, distribution, marketing, sales and customer support strategies to ensure the success of the product. Without these, the product cannot be successfully launched into the market. performance and validate the software for missing features, features not performing according to requirements, etc. This gives way to Beta Testing.

 

The New Development Product Process brings out a systemic approach to innovation.It proves to be very important in the lifecycle of building a product. It not only helps to streamline processes into a smooth flow but also helps in identifying challenges early on in the process of building the product. It involves better management of ideas and solutions into product features and ensures faster time to market.

Introduction to New Product Development Process

**JPA(Java Persistance API)** — JPA is a specification of Java which is used to map Java objects to a relational database, acting as a bridge between the two. It doesn’t perform operations on its own but requires implementation with ORM tools like Hibernate.


> Object relational mapping (ORM) is the mapping of Java objects to Database tables.


JPA is used to work directly with objects rather than using SQL statements to perform operations. Persistance metadata (defined by annotations of XML file) defines the mapping between Java objects and the database tables.


JPA defines a SQL-like Query language for the implementation of static and dynamic queries. **JPA JPQL** is an object oriented query language used to perform database operations. It uses the entity object to perform operations on the database records. The JPQL queries are then transformed to SQL using a JPA implementation. This can be used with any type of database such as MySQL, H2, Oracle, etc.
 
 
## Implementation
### Technology Stack

- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 

### Setting up the Project

1. Go to https://start.spring.io/ 
2. Choose the Project type depending on what build tool you want to use. We have chosen maven as the build tool. 
3. Choose the Spring Boot version. 
4. Fill in the Project Metadata info. 
5. Add the dependencies . In the case of this project we need Spring Web, Spring Data JPA, MySQL Driver. 
6. Generate the project and import it in your preferred editor

![Dependencies](https://i.imgur.com/QqkHn1y.png "Dependencies")

![Setting up the Project](https://i.imgur.com/o5xUaIo.png "Setting up the project")
 
 

### Setting up the Database

- Create database **employees** in MySQL
- Create table **employee**

![Create Database & Table](https://i.imgur.com/rQDU1pI.png "")

![Table Description](https://i.imgur.com/YVvedeK.png "")

The Employee Model will contain the following attributes — **id, name, gender, experience in years, experience in months, experience in days.**
 
 

### Add database configuration with application.properties

The configuration for datasource is added in application.properties.


_**spring.datasource.url** indicates the url of the database_


_**spring.datasource.username** and **spring.datasource.password** indicates the username and password of the database being used._


_**spring.jpa.hibernate.ddl-auto** is a Spring Data JPA property which manipulates how the database schema will be transformed on application startup. The values can be **create** (creates a new schema every time the application is started), **create-drop** (the schema is dropped once the application is stopped and only created once the application is started again), **update** (updates the schema in case of any change) and **validate** (only validates the schema, not making any changes)._


_**spring.jpa.properties.hibernate.dialect** property makes hibernate generate better SQL for the database._


_**spring.jpa.show-sql** property when set to true logs the SQL Queries in the console._

![Property file](https://i.imgur.com/S86rMks.png "")
 
 

### Define the Entity

The basic unit of persistence in JPA is the **entity**. It is a Java class which uses metadata described be in the form of annotations or defined in an XML file(in this example annotations are used) to map the class to the database table.

![Entity](https://i.imgur.com/M2AqfUi.png "")

**@Entity** annotation is used on all the classes which need to be persisted in the database. An instance of the class is persisted as a row in the database table.


The database table name can be defined specifically using **@Table(name=”______”)** annotation. Otherwise the table takes the name of the corresponding class.


**@Id** is used to define the primary key


The primary key can be auto generated in the database using the **@GeneratedValue** annotation.


The fields in the Entity are saved as columns in the database table. The column name can be defined specifically using **@Column(name=”______”)** annotation. Otherwise the column takes the name of the corresponding field.


If the field does not need to be persisted in the database as a column it can be annotated with **@Transient** .
 
 

### Different ways to execute a query using JPQL

Before starting to implement the queries , it is important to acquire an EntityManager instance.


> EntityManager can be container-managed or application-managed.


Application-managed EntityManager is managed by the application, It needs to be created manually and the lifecycle has to be managed by us well.

In this example we use a container managed EntityManager instance where the container is responsible for creating the instance from EntityManagerFactory for us, beginning the transaction, committing it or rolling it back.



![Entity Manager Usage](https://i.imgur.com/AaerU4E.png "")


JPQL queries can be executed in different ways.


1. **createQuery**

The createQuery method is used to query the database using JPQL. This method is used to execute **dynamic queries** which are defined within the business logic of the application.


Query retrieves the matching record from the database table and also maps it to the Entity object.


![Get All Employees method](https://i.imgur.com/8jcLH8Z.png "")

**getAllEmployees** method retrieves the list of employees using **createQuery(String jpql)** method. The JPQL query is defined in **GET_EMPLOYEE_QUERY**. Instead of mentioning the table name (employee) in the query, the Entity name (Employee) is mentioned. Since JPA cannot determine the result type, we need to cast the result type before returning it. The **getResultList()** method is used to retrieve a list of the results after executing the JPQL query.

`TypedQuery`

JPA also provides a special Query sub-type known as a **TypedQuery** as a solution to JPA not being able to determine what the result type will be. This is a good solution whenever the result type is known beforehand and also helps in avoiding casting exceptions.

![TypedQuery example](https://i.imgur.com/7q16GjB.png "")

**getEmployeesByYearsOfExperience** method retrieves the list of employees having specified years of experience using **createQuery(String jpql)** method. The JPQL query is defined in **GET_EMPLOYEES_BY_YEARS_OF_EXPERIENCE**.


Positional Parameter has been used to specify the year of experience.


Parameters are used when we don’t want to hardcode values in our query but want the client to specify it. In this example we have used positional parameter.


> Positional parameters are declared with a question mark (?) followed by the numeric position of the parameter in the query. We start with 1 and increment the position with every parameter. The Query.setParameter(integer position, Object value) method is used to set the parameter values. We can also use the same parameter more than once within the same query.


We can execute the queries using the following Query interface methods :-
- executeUpdate() — This method executes the update and delete operation.

- getFirstResult() — This method returns the first positioned result the query object was set to retrieve.

- getMaxResults() — This method returns the maximum number of results the query object was set to retrieve.

- getResultList() — This method returns the list of results as an untyped list.

- getSingleResult() — This method returns a single untyped result.

 


2. **createNamedQuery**

The createNamedQuery method is used to execute **static queries**. The queries can be defined in the metadata by using the NamedQuery annotation on the Entity class itself. The name element of @NamedQuery specifies the name of the query that will be used with the createNamedQuery method. All NamedQueries must have a unique name.

![Get Employees by Months of Experience](https://i.imgur.com/P76Pnti.png "")

**getEmployeesByMonthsOfExperience** method retrieves the list of employees having specified months of experience using **createNamedQuery(String name)** method. The name of the **NamedQuery** is specified in the metadata.

![Find Employees by Months of Experience](https://i.imgur.com/Kc9vzNx.png "")

 


3. **createNativeQuery**

The **createNativeQuery** method is used to execute native/pure SQL queries.


A NativeQuery is simply an SQL query. This allows us to utilise features not available in JPQL syntax. However we lose database portability of the application.

![Get Employees by Days of Experience](https://i.imgur.com/TrY9wI1.png "")

**getEmployeesByDaysOfExperience** method retrieves the list of employees having specified days of experience using **createNativeQuery(String sql)** method. The SQL query is defined in **GET_EMPLOYEES_BY_DAYS_OF_EXPERIENCE**. Positional parameters can be used with Native SQL Queries as well.


Some extra methods -:


* **CREATE**

The persist method of EntityManager is used to save the Employee instance in the database.

![Create Method](https://i.imgur.com/ABygA7p.png "")


* **UPDATE AND DELETE**

Updating and deleting the Employee instance using createQuery method of EntityManager and executeUpdate method of the Query interface.

![Update and Delete Method](https://i.imgur.com/QzmTQ6I.png "")


* **GET BY ID**

This method retrieves an employee record based on the passed ID.

![Get By ID Method](https://i.imgur.com/qWKFpdi.png "")


* **BETWEEN … AND…**

The JPQL Query for getting employee list based on a **range of specified values** is executed in the following method.

![Between and And method](https://i.imgur.com/ZZSkcff.png "")


* **COUNT, MAX AND MIN**

The JPQL Queries to execute Aggregation methods like getting employee count, **maximum ** years of experience and **minimum** years of experience are executed in the following method.

![Count, Max and Min Method](https://i.imgur.com/U8UlyC6.png "")

* **SORTING**

The JPQL Query to retrieve records in sorted order. The following method retrieves records **sorted in descending order** based on years of experience.

![Sorting Method](https://i.imgur.com/9y5pryT.png "")


Find the link to complete code [**here**](https://github.com/AnviPuri/JPA-JPQL-Demo).

Implementation of Data Access Layer with JPA JPQL in Spring Boot

In the previous part i.e. [**Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC — Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1) , we implemented **REST APIs** for **CRUD** operations using Data JPA. In this part, we will be implementing the same functionalities using **JDBC**.
 
 
### Technology Stack
- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 
### Setting up the Project and Database
Set up the project and database as done in [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).

In the case of this project add the following dependencies: **Spring Web, Spring Data JDBC, MySQL Driver.**

![Dependencies](https://i.imgur.com/9sSmyhR.png "Dependencies")

The **REST endpoints** also remain the same.
 
 
### Project Layout

![Project Layout](https://i.imgur.com/XPwYhJP.png "Project Layout")

 
 

### Implementation of REST CRUD APIs

1. **Presentation Layer — UserController**

![Presentation Layer](https://i.imgur.com/1GfMIym.png "")

**UserController** is a **Rest Controller** which exposes REST APIs to the client.

**UserServiceImpl** class **(Service Layer)** is **autowired** in the controller. The methods in the controller call the exposed methods of the service layer to create, update, delete and retrieve users.

The APIs send back a response to the client with a **HTTP status** (**CREATED** or **OK**) along with user/s object in case of **GET** methods.

To understand the working of the Rest Controller and the annotations used refer [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).



2. **Service Layer — UserService & UserServiceImpl**

![Service Layer](https://i.imgur.com/p2DDecS.png "")

**UserService** is an interface which defines the methods implemented in **UserServiceImpl** class. They are a part of the service layer and used to implement the business logic of the code.

**UserDaoImpl** class **(DAO Layer)** is **autowired** which exposes the methods of the DAO Layer.



3. **User Bean**

![User Bean](https://i.imgur.com/tbztYvg.png "")

The User bean is used by the Data Access Layer to perform CRUD operations.



4. **Data Access Layer — UserDao & UserDaoImpl**

![Data Access Layer](https://i.imgur.com/HI5QUFr.png "")

**UserDao** is an interface which defines the methods implemented in **UserDaoImpl** class. They are a part of the DAO layer and contain the methods which are used to perform operation on the database.

**JDBC** produces a lot of boilerplate code like managing the connection to the database, handling SQL exceptions. The Spring JDBC API is an adaptation of the standard JDBC API. **JdbcTemplate** is one of the ways provided by Spring JDBC to remove boilerplate code, mapping data to classes.

JdbcTemplate manages the connection to the database, executes SQL queries, iterates over the result set retrieving the values. It also handles the exceptions and translates the exceptions into exceptions which are defined under **org.springframework.dao** package.

The properties for the datasource are configured in **application.properties** and utilised by JdbcTemplate which is autowired in UserDaoImpl class.

![App Properties](https://i.imgur.com/WSx5jmF.png "")

Spring Boot gets the datasource properties and injects it to JdbcTemplate object while auto wiring.

Refer to [**Part 1**](https://anvipuri14.medium.com/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1-9eb0d6cd1358) to understand the properties defined above.

A RowMapper is implemented to process the ResultSet, mapping each row to an object.

![Row Mapper](https://i.imgur.com/3EyMJjJ.png "")

The **UserRowMapper** class implements **RowMapper** and overrides its **mapRow** method which maps a row of the result to the **User** class.

 
 

---

_**Creating a User**_

The query to create a user is defined in **INSERT_USER_QUERY.**

The **save** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.

```
update(String sql, Object... args)
```

> _The parameters are defined in new Object[] {……} in the order they are written in the query.
> 
> 
> The update method binds the given arguments with the sql query and performs an update operation to insert, update or delete with the help of a prepared statement.
> 
> 
> It returns an integer count of the number of rows that were changed after the execution of the query._


_**Updating a User**_

The query to update a user is defined in **UPDATE_USER_QUERY.**

The **update** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.


_**Deleting a User**_

The query to delete a user is defined in **DELETE_USER_QUERY.**

The **delete** method of the UserDaoImpl class then uses the **update** method of JdbcTemplate.


_**Retrieving all Users**_

The query to retrieve all users is defined in **GET_USERS_QUERY.**

The **findAll** method of the UserDaoImpl class then uses the **query** method of JdbcTemplate.

```
query(String sql, RowMapper<T> rowMapper)
```

> _The query method executes the SQL query and maps each row to the result object using the RowMapper specified in the argument.
> 
> 
> It returns a list of the result object which was mapped by the mapper._

The custom RowMapper used in this example is the **UserRowMapper** defined above.


_**Retrieving a User by ID**_

The query to retrieve a user by ID is defined in **GET_USER_BY_ID_QUERY.**

The **findById** method of the UserDaoImpl class then uses the **queryForObject** method of JdbcTemplate.

```
queryForObject(String sql, RowMapper<T> rowMapper, Object... args)
```

> _The SQL query and the list of arguments are bound by the prepared statement to execute the query, the result of which is mapped to the result object using the RowMapper.
> 
> 
> It returns the result object which was mapped by the mapper._

**Test the APIs** as shown in [**Part 1**](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-1).

Find the link to complete code [**here**](https://github.com/AnviPuri/CRUD-JDBC).

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 2

Spring Boot is a highly used and popular framework in Java which is easy to start with and understand as well. In order to get a head start into the framework we will be creating a Spring Boot Application which exposes REST APIs to create, edit, retrieve and delete a user.
 
 
### Technology Stack
- Spring Boot Framework 
- Maven 3.6.3 
- MySQL 8.0.19
 
 
### Setting up the Project
1. Go to https://start.spring.io/ 
2. Choose the Project type depending on what build tool you want to use. We have chosen maven as the build tool. 
3. Choose the Spring Boot version 
4. Fill in the Project Metadata info. 
5. Add the dependencies . In the case of this project we need **Spring Web, Spring Data JPA, MySQL Driver.** 
6. Generate the project and import it in your preferred editor


![Dependencies](https://i.imgur.com/TIPuR0w.png "Dependencies")

![Setting up a Spring Boot Project](https://i.imgur.com/sSNpeZW.png "Setting up a Spring Boot Project")
 
 
### Setting up the Database
- Create database **userdb** in MySQL
![Database Creation](https://i.imgur.com/La1rfZR.png "")
- Create table **user**
The User Model will contain the following attributes — _**id, first name, last name, gender and age.**_
![Database Table Creation](https://i.imgur.com/97pDWFR.png "")
 
 

### REST API Endpoints
1. **Create User** 
Method: **POST** 
Endpoint: **/users/save-user**

2. **Update User** 
Method: **PUT** 
Endpoint: **/users/update-user/{id}** 

3. **Delete User** 
Method: **DELETE** 
Endpoint: **/users/delete-user/{id}** 

4. **Get all Users** 
Method: **GET** 
Endpoint: **/users** 

5. **Get User by Id** 
Method: **GET** 
Endpoint: **/users/{id}**
 
 

### Project Layout 

![Project Layout](https://i.imgur.com/034eKqh.jpg "Project Layout")

1. **Application Property File** — This contains configuration of the spring boot project like database properties, port number, etc .

![application.properties](https://i.imgur.com/Cwdg4sb.png "application.properties")
 

- **server.port** indicates the port number the application will run on. 
- **spring.datasource.username** and **spring.datasource.password** indicates the username and password of the database being used. 
- **spring.datasource.url** indicates the url of the database. 
- **spring.jpa.hibernate.ddl-auto** is a Spring Data JPA property which manipulates how the database schema will be transformed on application startup. The values can be **create** (creates a new schema every time the application is started), **create-drop** (the schema is dropped once the application is stopped and only created once the application is started again), **update** (updates the schema in case of any change) and **validate** (only validates the schema, not making any changes). 
- **spring.jpa.properties.hibernate.dialect** property makes hibernate generate better SQL for the database

2. **ENTITY** — The Entity class is mapped to the respective table in the database. It is a bean which represents the table structure.

![User Entity](https://i.imgur.com/ifQBIGq.png "User Entity")

In the above figure the User entity is mapped to the user table in the database using **@Table** annotation where the name property specifies the name of the table.

The annotation **@Entity** annotation specifies the class an an entity bean and defines that a class can be mapped to a table.

The fields of the User class are mapped to the columns of the user table using **@Column** annotation. In case the name of the field and the column is different, name property can be used to map the field to the differently named column.

**@Id** annotation specifies the field which will be the primary key of the entity and **@GeneratedValue** specifies that the field will be automatically generated according to the specified strategy like in the above case the Identity strategy.

3. **PERSISTENCE LAYER** — This layer helps in transforming the business objects to database rows and vice versa, containing the logic to persist data to or retrieve data from the datastore.

![User Repo for Data Access](https://i.imgur.com/evCOzjY.png "User Repo for Data Access")

We are using Spring Data which simplifies the data access procedure for databases. JPA (Java Persistence API) is a API specification for object relational mapping which maps the objects of a class to rows of a table (in this example — maps User class to user table).

The Repository interface represents the DAO layer which takes care of database operations.

In the above example JpaRepository can carry out basic CRUD operations and also contains API for pagination and sorting without us having to specify the methods separately. With the help of this the boilerplate code written to access data is reduced.

The Entity (**User**) and the datatype of the primary key (**Integer**) of the entity ( i.e the field marked with **@Id** ) are specified as well.

4. **PRESENTATION LAYER AND SERVICE LAYER**

_Presentation Layer_ — This layer contains REST Controllers which expose the REST endpoints to the client , receives the Rest API request, transforms the JSON received by the client to the mapped model object present in the Rest API as parameters. The model object is then transferred to the service layer.

![Presentation Layer Structure](https://i.imgur.com/RegpjDZ.png "Presentation Layer Structure")

In the above figure UserController annotated with **@RestController** annotation making it a controller which receives HTTP requests from the client. It returns an object which is directly written into the HTTP response as JSON or XML. The annotation is a combination of **@Controller** (marks a class as a Spring MVC controller) and **@ResponseBody** (tells a controller that the returned object returned is to be serialised into JSON and written into HTTP response) annotations.

**@RequestMapping** maps HTTP requests to the handler classes/methods of REST controllers.

**@PostMapping, @GetMapping, @PutMapping, @DeleteMapping** annotated methods handle the respective HTTP POST, GET, PUT, DELETE requests matched with given URI expression.

_Service Layer_ — Implements any business logic on the request model and uses the methods exposed by the Data Access Layer.

**UserServiceImpl** class is the service class which is **autowired** in **UserController**. It exposes the methods of the service layer in the controller.

![Service Layer Structure](https://i.imgur.com/wgpQMTj.png "Service Layer Structure")

**@Service** annotation is a specialisation of **@Component** annotation. It is used to define service-layer classes.
 
 

### Implementation of REST CRUD APIs

1. **Creating a User**

![Creating a User](https://i.imgur.com/TduKGtn.png "")

**@RequestBody** converts the HTTP Request body to java objects using HTTP message converters.

The user object received in **createUser** method of **UserController** is then passed to the service layer.

![Creating a User](https://i.imgur.com/jZf5urn.png "")

**createUser** method in **UserServiceImpl** receives the user object from the controller and saves it in the database using the JpaRepository **UserRepo** and returns the saved user back to the controller.



2. **Updating a User**

![Updating a User](https://i.imgur.com/FpGf1Tv.png "")

**@PathVariable** annotation binds the request parameter of the handler method to the URI making it dynamic. Hence it is used for data passed in URI. In the above example id is the path variable which can have dynamic values.

The user object along with the id received in **updateUser** method of **UserController** is then passed to the service layer.

![Updating a User](https://i.imgur.com/jWPLkq6.png "")

**updateUser** method in **UserServiceImpl** receives the user object and id from the controller, checks if data is present in the database corresponding to that id using **findById** method of the JpaRepository. If data is present, the user object is copied to the updatedUser object using **BeanUtils.copyProperties()** and saved in the database corresponding to the id. The updated user is then returned to the controller.



3. **Deleting a User**

![Deleting a User](https://i.imgur.com/Gf84bCO.png "")

The id received as the path variable in **deleteUser** method of **UserController** is passed to the service layer.

![Deleting a User](https://i.imgur.com/exX0Q3l.png "")

**deleteUser** method in **UserServiceImpl** receives the id from the controller, checks if data is present in the database corresponding to that id using **findById** . If data is present, it is deleted using the **delete** method of JpaRepository.



4. **Retrieving all Users**

![Retrieving all Users](https://i.imgur.com/YTwOhaC.png "")

**getUsers** method of **UserController** calls the service layer method.

![Retrieving all Users](https://i.imgur.com/PrvU0Z1.png "")

**getUsers** method in **UserServiceImpl** uses the **findAll** method of JpaRepository to retrieve all users from the database. The data is then passed back to the controller.



5. **Retrieving a User by User ID**

![Retrieving a User by User ID](https://i.imgur.com/wNijrws.png "")

The id received as the path variable in **getUserById** method of **UserController** is passed to the service layer.

![Retrieving a User by User ID](https://i.imgur.com/PrvU0Z1.png "")

**getUserById** method in **UserServiceImpl** receives the id from the controller, checks if data is present in the database corresponding to that id using **findById** and retrieves the user. If user is present, the retrieved user is returned to the controller.
 
 

### Testing the APIs with Postman

1. **Creating a User**

![Testing Creating a User](https://i.imgur.com/ipgnwQR.png "")

2. **Updating a User**

![Testing Updating a User](https://i.imgur.com/ShGg9th.png "")

![Testing Updating a User](https://i.imgur.com/MTjnNYI.png "")

3. **Deleting a User**

![Testing Deleting a User](https://i.imgur.com/WJj9CdQ.png "")

4. **Retrieving all Users**

![Testing Retrieving all Users](https://i.imgur.com/TV9yIW3.png "")

5. **Retrieving a User by User ID**

![Testing Retrieving a User by User ID](https://i.imgur.com/UdmzHvx.png "")


Find the link to complete code [here](https://github.com/AnviPuri/CRUD-Data-JPA)

Find **Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC — Part 2** [here](https://www.anvipuri.com/blog/creating-spring-boot-crud-rest-apis-with-data-jpa-and-jdbc-part-2)

Creating Spring Boot CRUD Rest APIs with Data JPA and JDBC - Part 1

**Spring framework** is a lightweight yet powerful Java framework which is used for application development. It provides support for developing Java applications and handles the infrastructure configuration, letting the developer focus on business logic (What more could a developer want, right?).
The fact that Spring promises modularity, makes it a famous framework among developers.
 
 

> _Modularity is the ability to use only the modules that are needed without worrying about using the other modules._
> 
> 
> The best part about Spring being modular is that the modules can be used according to the use case/ need of the product/ developers (can’t miss out any, can we?). Spring has modules like Spring AOP, Spring messaging, Spring Transaction, Spring Data Access, etc which provide a diverse range of services. The Spring Core module provides the base implementation on top of which these modules can be utilised.

 
 

### A Brief History Lesson…

Before understanding the different features the framework is built upon , let us have a quick history lesson on our much (or soon to become) favourite topic.
An Open source Framework, Spring was written by Rod Johnson and was first released in June 2002. It was built with the purpose of overcoming a number of major complexities with Java EE and Enterprise Java Beans by using a simpler solution (now affectionately known as Spring Framework) which is based on the use of **POJOs**( explained further in the article), **Dependency Injection** and **Inversion of Control**.
 
 

> **What is Java Enterprise Edition and EJB?**
> Java EE is used to develop enterprise apps. EJB is a specification of Java EE for server side architecture. One of the first technologies to make the development of server side enterprise applications easier, it handles myriad of concerns like implementation of concurrency, transaction management, etc.

 
 

### Drawbacks of applications built without Spring:

- A lot of configurations were needed — it was proving to be a performance bottleneck, slowing down applications.
- code could become complicated with increasing XML files
- applications could become heavy, affecting the performance of the system
- hard coding dependencies for each component made the development experience frustrating

Over the years , Spring has become a favourite among many developers as it has not only solved the above problems, but provided a higher learning curve, providing ease of development with its organised packages and classes, and a variety of other features.

 
 

### And Beyond...
Some concepts that Spring Framework is based upon
1. **Dependency Injection**
It is an implementation of Inversion of Control where instead of hardcoding the objects and their dependencies, the dependencies are simply specified via external configuration files, annotations or java code. The objects which have been registered during the startup of the container are injected at compile time only whenever they are required.
Different ways to implement Dependency Injection are:
1. Using Setters
2. Using Constructors
3. Field Based

![Dependency Injection Example](https://i.imgur.com/3hsLlBY.png "Dependency Injection Example")

The above example shows three different ways to implement Dependency Injection. Annotation based configuration has been used where we first define a Configuration class that will be used to define and inject the bean. **@Bean** annotation is used to let Spring framework know that the method defined with this annotation should be used to get the bean implementation to inject in Component classes. **@Autowired** allows constructor-based, field-based or setter dependency injection.

> _**Annotations** are tags which are used to represent the metadata associated with interfaces, classes, methods or fields to provide some additional information about them. Some commonly used annotations in Spring include — **@Component** ( a Java class annotated with @Component is found during classpath scanning and registered in the container as a Spring bean).**@Controller**, **@Service** ,**@Repository** are special cases of the component annotation which are used to define different types of components._

2. **Inversion of Control**
> _Inversion of Control introduces the concept of letting the Spring Framework container handle the creation of objects instead of the developer instantiating the object every time they are needed. This makes the objects loosely coupled._

This is a design framework which inverts the flow of control i.e it enables a container to manage the lifecycle of an object. This can be further explained by looking into a piece of software where the logical components which interact with each other are instances of classes (objects) and depend on one another. Invocation of one object may lead to the invocation of other objects , leading to these objects being tightly coupled.

The IoC container instantiates the application class, configures the objects and assembles the dependencies between the objects according to the information received by it through annotations, configuration files or java code.

Spring Framework allows the container to manage lifecycle of various processes. All the developers need to do to make this work is write some code to register the classes/objects using annotations, external configuration files, etc and the rest is by Spring ( from creation to destruction of the object).

![Example of tightly coupled objects](https://i.imgur.com/FrL4JRF.png "Example of tightly coupled objects")

In the following example the FoodMaker class is tightly coupled with the Ingredient class to perform **makeFood()**. In this case the parent object knows more about the child object and the child object cannot be changed by anyone except the parent class introducing a dependency, making it tightly coupled.

![Example of loosely coupled objects](https://i.imgur.com/J3zvaDC.png "Example of loosely coupled objects")

In the above example **FoodMaker** gets the **Ingredient** object from external sources, in this case the Spring container (using dependency injection). This makes the objects independent of each other.

3. **Using POJOs**
> _POJOs are Java Objects containing properties, their getters and setters and certain methods(like to String which can be overridden) ._

There are no restrictions on the scope of the properties (they can be public, private, protected with public getters and setters.) . They do not extend any pre-specified classes, interfaces or annotations and are exclusive of all frameworks. Further, Java Beans are special kinds of POJOs which must implement Serialisable interface. The fields should be private with getters, setters or both. These fields can be accessed only through getters or setters.The use of Plain Old Java Objects make the Java Program more readable and reusable.

![Example of a POJO](https://i.imgur.com/J3zvaDC.png "Example of a POJO")

 
 

### SPRING ARCHITECTURE

![Spring Architecture](https://i.imgur.com/b5okeWO.png "Source:https://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/images/spring-overview.png")

The architecture of Spring framework comprises of several modules which are built on top of the core container and can be utilised according to need of the developer. This feature of modularity allows Spring to integrate with other frameworks as well.

1. **Core Container**

>_This module is responsible for creating and managing beans along with their dependencies_

The **Spring Core** and **Spring Bean** modules provide the means to implement Dependency Injection. It allows the object to define its dependencies. Whenever a bean is created, the container injects those dependencies. BeanFactory (which is an implementation of factory pattern) allows to decouple the configuration and specification of object dependencies from the actual business logic of the program.

The **Spring Context** module is built upon the Spring Core and Bean module. It provides a mean to access the objects that have been defined and configured in the Spring container. The module is responsible for providing various enterprise level services like internationalisation, support for scheduling, caching etc. The Application Context (container defined by ApplicationContext interface) is an integral part of the Context module. It can load bean definitions, wire beans together and provide functionalities like reading messages from a properties file or publishing application events.

The **Spring Expression** Module is an expression language which enables runtime manipulation and querying of objects. It can be used with annotation or XML based configurations.
 
2. **Spring Data Access/Integration**

>_This module is responsible for providing integration with various data access mechanisms / frameworks and communication with data sources._

**Spring JDBC** (Java Database Connectivity) is an API which helps the client to access a database and perform operations on it using Statements, Queries, ResultSets. The complexity related to this is removed using JDBCTemplate which allows easy access, iteration and mapping of data.

**Spring ORM** (Object Relational Mapping) frameworks map a java object to a database table using an ORM API. Some ORM frameworks are Hibernate, JPA ,etc. Spring ORM provides integration with these frameworks.

**Spring JMS** (Java Messaging Service) defines specification for producing and consuming messages (pub-sub communication). Spring JMS provides an abstraction over JMS implementations like ActiveMQ, RabbitMQ.

**Spring OXM** (Object XML Marshalling) defines specifications to transfer and access data in form of XML. Spring OXM provides abstraction over Java using OXM implementations like JAXB .

**Spring Transactions** provides a support for transaction management of classes.
 
3. **Web**

>_Responsible for providing a base for building web applications and integration with other MVC frameworks like Struts, JSF ,etc_

**Spring-Web** modules provides web oriented integration features.

**Spring Web MVC** module is used to create web applications. It enforces a design pattern which allows a single point of entry — the DispatcherServlet, which acts as the Front Controller and forwards the request to other objects for processing. Different concerns are separated into different layers- Model, View and Controller, which helps in building a loosely coupled application. Model is the application data, View is used to render the response to end user using the model and Controller is responsible for processing the request, generating a model and selecting the view based on the model.

**Spring Web-Socket** module provides support for building Web Sockets with spring, enabling bidirectional communication socket between client and servers so that server can also push messages directly to the clients.

**Spring Web-Portlet** helps in the easier development of Portlets and use the same concept as Spring MVC with a Dispatcher Portlet(Dispatcher servlet in the case of Spring MVC), front controller, handler mappings, controllers, views and model.
 
4. **AOP**

>_Aspect Oriented Programming provides modularity like Object Oriented Programming does. The key difference between both is that a class is the unit of modularity in OOPs whereas an aspect is the unit of modularity in AOP ._

AOP breaks the program logic into distinct parts using cross cutting concerns which are features that affect the whole application and are not specific to business logic. AOP can be used for logging, exception handling, implementing security, etc. AOP can be implemented with Spring using XML based configurations or annotations with AspectJ, which is a very popular way to implement AOP nowadays.
 
5. **Instrumentation**

Spring Instrumentation enables the developers to monitor the performance, track and trace code, its errors and the related information . Spring supports instrumentation through AOP and Logging in various environments.
 
6. **Test**

Spring test module helps in easy unit testing with JUnit, TestNG as well as integration testing. Mock objects can also be used to unit test the code in isolation.
 
7. **Messaging**

It serves as a foundation to implement messaging based applications.

 
 

### Conclusion
The Spring framework has evolved into an efficient and developer friendly framework with its modular architecture and a very active community of developers. Spring can be used to develop applications in an easy , flexible and secure manner. So when in doubt…**GO TEAM SPRING!**

Anvi Puri

Blog