Scribd
Upload
16 views74 pages

JSP (Javaserver Pages)

JavaServer Pages (JSP) is a server-side technology for creating dynamic web applications using HTML and JSP tags to embed Java code. It is an advanced version of Servlet technology, converting JSP into servlets for processing client requests, and supports various scripting elements like scriptlet, expression, and declaration tags. JSP also includes implicit objects and directives for managing requests, responses, and error handling, and follows the MVC architecture for organizing code.

Uploaded by

sainikhil.arakanchi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
16 views74 pages

JSP (Javaserver Pages)

JavaServer Pages (JSP) is a server-side technology for creating dynamic web applications using HTML and JSP tags to embed Java code. It is an advanced version of Servlet technology, converting JSP into servlets for processing client requests, and supports various scripting elements like scriptlet, expression, and declaration tags. JSP also includes implicit objects and directives for managing requests, responses, and error handling, and follows the MVC architecture for organizing code.

Uploaded by

sainikhil.arakanchi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 74

JSP stands for (JavaServer Pages).

It is a server-side technology which is used for creating


web applications. It is used to create dynamic web content. JSP consists of both HTML tags
and JSP tags. In this, JSP tags are used to insert JAVA code into HTML pages. It is an
advanced version of Servlet Technology i.e. a web-based technology that helps us to create
dynamic and platform-independent web pages. In this, Java code can be inserted in HTML/
XML pages or both. JSP is first converted into a servlet by the JSP container before
processing the client’s request. JSP has various features like JSP Expressions, JSP tags, JSP
Expression Language, etc.

Creating a simple JSP Page

hello.JSP :

You will see the same output, but it will take longer! But only the first time. If you reload it
again, it will load normally.

What is happening behind the scenes is that your JSP is being turned into a Java file,
compiled, and loaded. This compilation only happens once, so after the first load, the file
doesn’t take long to load anymore. (But every time you change the JSP file, it will be re-
compiled again.)

Of course, it is not very useful to just write HTML pages with a .jsp extension! We now
proceed to see what makes JSP so useful.

<HTML>
<BODY>
Hello! The time is now <%= new java.util.Date() %>
</BODY>

</HTML>

Scriptlet tag

This tag allow user to insert java code in JSP. The statement which is written will be moved
to jspservice() using JSP container while generating servlet from JSP. When client make a
request, JSP service method is invoked and after that the content which is written inside the
scriptlet tag executes.

<html>

<body>

<% out.print("Hello"); %> <!-- scriptlet tag -->

</body>

</html>

Example

Java code

<html>

<body>

<form action="hello.jsp">

<!-- move the control to hello.jsp when Submit button is click -->

Enter Username:

<input type="text" name="username">

<input type="submit" value="Submit"><br/>

</form>

</body>

</html>

Jsp code

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>

<meta http-equiv="Content-Type" content="text/html;

charset=UTF-8">

<title>Insert title here</title>

</head>

<body>

<%

String name=request.getParameter("username");

out.print("Hello "+name);

%>

</body>

</html>

Expression tag

is one of the scripting elements in JSP. Expression Tag in JSP is used for writing your content
on the client-side. We can use this tag for displaying information on the client’s browser. The
JSP Expression tag transforms the code into an expression statement that converts into a
value in the form of a string object and inserts into the implicit output object.

<%@ page language="java" contentType="text/html;

charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>
<head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Sum</title>

</head>

<body>

<% out.println("Hello"); %> <!-- Sriptlet Tag-->

<% int n1=10; int n2=30; %><!-- Sriptlet Tag-->

<% out.println("<br>sum of n1 and n2 is "); %> <!-- Sriptlet Tag-->

<%= n1+n2 %> <!-- Expression tag -->

</body>

</html>

Declaration tag

is one of the scripting elements in JSP.


This Tag is used for declare the variables. Along with this, Declaration Tag can also declare
method and classes. Jsp initializer scans the code and find the declaration tag and initializes
all the variables, methods, and classes. JSP container keeps this code outside of the service
method (_JSPService()) to make them class level variables and methods.

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Greetings</title>

</head>
<body>

<!--declaration of username variable.... -->

<%! String username="Ramya"; %>

<!--In expression tag a string is initialised as Ramya-->

<%="Hello : "+username %>

<!-- Displaying expression using Expression Tag -->

</body>

</html>

Implicit objects are a set of Java objects that the JSP Container makes available to developers
on each page. These objects may be accessed as built-in variables via scripting elements and
can also be accessed programmatically by JavaBeans and Servlets.JSP provide you Total 9
implicit objects which are as follows

1. request: This is the object of HttpServletRequest class associated with the


request.

2. response: This is the object of HttpServletResponse class associated with


the response to the client.

3. config: This is the object of ServletConfig class associated with the page.

4. application: This is the object of ServletContext class associated with the


application context.

5. session: This is the object of HttpSession class associated with the request.

6. page context: This is the object of PageContext class that encapsulates the
use of server-specific features. This object can be used to find, get or remove
an attribute.

7. page object: The manner we use the keyword this for current object, page
object is used to refer to the current translated servlet class.
8. exception: The exception object represents all errors and exceptions which is
accessed by the respective jsp. The exception implicit object is of
type java.lang.Throwable.

9. out: This is the PrintWriter object where methods like print and println
help for displaying the content to the client.

request Object
The JSP request is an implicit object which is provided by HttpServletRequest.
In the servlet, we have to first import javax.servlet.http.HttpServletRequest
then we have to create its object for taking input from any HTML form as.
Syntax :
import javax.servlet.http.HttpServletRequest;

public class LoginServlet extends HttpServlet


{
protected void doPost(HttpServletRequest request, HttpServletResponse
response)
throws ServletException, IOException
{
HttpSession session = request.getSession()
}
}

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd ">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Insert title here</title>

</head>
<body>

<form action = "name.jsp">


<input type = "text" name = "username">
<input type = "submit" value = "submit"><br/>
</form>
</body>
</html>

response object
This is the HttpServletResponse object associated with the response to the client. The
response object also defines the interfaces that deal with creating new HTTP headers.
Through this object the JSP programmer can add new cookies or date stamps, HTTP status
codes, etc.

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

"http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Insert title here</title>

</head>

<body>

<%

String name=request.getParameter("username");

out.print("Welcome "+ name);

%>

</body>
</html>

Directives in JSP

JSP directives are the elements of a JSP source code that guide the web container on how to
translate the JSP page into its respective servlet.

<%@ directive attribute = "value"%>

Different types of JSP directives :

There are three different JSP directives available. They are as follows:

 Page Directives : JSP page directive is used to define the properties applying the JSP
page, such as the size of the allocated buffer, imported packages, and
classes/interfaces, defining what type of page it is, etc. The syntax of JSP page
directive is as follows:

<%@page attribute = "value"%>

 Different properties/attributes :
The following are the different properties that can be defined using page directive :

o import: This tells the container what packages/classes are needed to be


imported into the program.
Syntax:

<%@page import = "value"%>

<%-- JSP code to demonstrate how to use page

directive to import a package --%>

<%@page import = "java.util.Date"%>

<%Date d = new Date();%>


<%=d%>

 contentType: This defines the format of data that is being exchanged between the
client and the server. It does the same thing as the setContentType method in servlet
used to.
Syntax:

<%@page contentType="value"%>

 info: Defines the string which can be printed using the ‘getServletInfo()’ method.
Syntax:<%@page info="value"%>

<%-- JSP code to demonstrate how to use page

directive to set the page information --%>

<%@page contentType = "text/html" %>

<% = getServletInfo()%>

Exception handling in JSP

Java Server Pages declares 9 implicit objects, the exception object being one of them. It is an
object of java.lang.Throwable class, and is used to print exceptions. However, it can only be
used in error pages.

There are two ways of handling exceptions in JSP. They are:

 By errorPage and isErrorPage attributes of page directive

 By <error-page> element in web.xml file

Handling Exception using page directive attributes

The page directive in JSP provides two attributes to be used in exception handling. They’re:
 errorPage: Used to site which page to be displayed when exception occurred.
Syntax :

<%@page errorPage="url of the error page"%>

 isErrorPage: Used to mark a page as an error page where exceptions are displayed.
Syntax :

<%@page isErrorPage="true"%>

The following is an example illustrating exception handling using page directives:

<html>

<head>

<body>

<form action="a.jsp">

Number1:<input type="text" name="first" >

Number2:<input type="text" name="second" >

<input type="submit" value="divide">

</form>

</body>

</html>

// JSP code to divide two numbers

<% @page errorPage = "error.jsp" %> < %

String num1 = request.getParameter("first");

String num2 = request.getParameter("second");


// extracting numbers from request

int x = Integer.parseInt(num1);

int y = Integer.parseInt(num2);

int z = x / y; // dividing the numbers

out.print("division of numbers is: " + z); // result

%>

Handling Exceptions Using error-page Element En web.xml File

This is another way of specifying the error page for each element, but instead of using the
errorPage directive, the error page for each page can be specified in the web.xml file, using
the <error-page> element. The syntax is as follows:

<web-app>

<error-page>

<exception-type>Type of Exception</exception-type>

<location>Error page url</location>

</error-page>

</web-app>

<html>

<head>

<body>

<form action="a.jsp">
Number1:<input type="text" name="first" >

Number2:<input type="text" name="second" >

<input type="submit" value="divide">

</form>

</body>

</html>

// JSP code to divide two numbers

<%

String num1 = request.getParameter("first");

String num2 = request.getParameter("second");

// extracting the numbers

int x = Integer.parseInt(num1);

int y = Integer.parseInt(num2);

int z = x / y; // dividing

out.print("division of numbers is: " + z); // result

%>

// JSP code for error page, which displays the exception

<%@ page isErrorPage="true" %>


<h1>Exception caught</h1>

// displaying the exception

The exception is: <%= exception %>

<web-app>

<error-page>

<exception-type>java.lang.Exception</exception-type>

<location>/error.jsp</location>

</error-page>

</web-app>

Components of MVC

The MVC framework includes the following 3 components:

 Controller

 Model

 View
MVC Architecture Design

Controller:

The controller is the component that enables the interconnection between the views and the
model so it acts as an intermediary. The controller doesn’t have to worry about handling data
logic, it just tells the model what to do. It processes all the business logic and incoming
requests, manipulates data using the Model component, and interact with the View to render
the final output.

Responsibilities:

 Receiving user input and interpreting it.

 Updating the Model based on user actions.

 Selecting and displaying the appropriate View.

View:

The View component is used for all the UI logic of the application. It generates a user
interface for the user. Views are created by the data which is collected by the model
component but these data aren’t taken directly but through the controller. It only interacts
with the controller.

Responsibilities:

 Rendering data to the user in a specific format.


 Displaying the user interface elements.

 Updating the display when the Model changes.

Model:

The Model component corresponds to all the data-related logic that the user works with. This
can represent either the data that is being transferred between the View and Controller
components or any other business logic-related data. It can add or retrieve data from the
database. It responds to the controller’s request because the controller can’t interact with the
database by itself. The model interacts with the database and gives the required data back to
the controller.

Responsibilities:

 Managing data: CRUD (Create, Read, Update, Delete) operations.

 Enforcing business rules.

 Notifying the View and Controller of state changes.

Servlet – Pagination with Example

Pagination is a sequence of pages that are connected and have similar content. Pagination is a
technique for splitting a list of multiple records into subsists. For example, you search with a
keyword on Google and receive tens of thousands of results. It is important to note that even
when the content on a section of a page is split into distinct pages, we will still define that as
pagination.

Pagination in Java

To divide a large number of records into multiple parts, we use pagination. It allows users to
display a part of records only. Loading all records on a single page may take time, so it is
always recommended to created pagination. In java, we can develop pagination examples
easily. In this pagination example, we are using the MySQL database to fetch records.

CRUD OPERATIONS:
INSERT INTO table_name (column1, column2, column3,...) VALUES (value1, value2,
value3,...)

CREATE TABLE users

id int NOT NULL AUTO_INCREMENT,

first_name varchar(50),

last_name varchar(50),

city_name varchar(50),

email varchar(50),

PRIMARY KEY (id)

);

CREATE

create-table.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<%@ page import="java.sql.*" %>

<html>

<head>

<title>Create a Database using JSP</title>

</head>

<body>

<h1>Create a Database using JSP</h1>


<%

Connection connection = null;

try {

Class.forName("com.mysql.jdbc.Driver").newInstance();

connection = DriverManager.getConnection("jdbc:mysql://localhost:3306", "root",


"");

Statement statement = connection.createStatement();

String query = "CREATE DATABASE test";

statement.executeUpdate(query);

out.println("Database test created sucessfully.");

catch (Exception e)

out.println("An error occurred.");

%>

</body>

</html>

INSERT

<!DOCTYPE html>

<html>

<body>
<form method="post" action="process.jsp">

First name:<br>

<input type="text" name="first_name">

<br>

Last name:<br>

<input type="text" name="last_name">

<br>

City name:<br>

<input type="text" name="city_name">

<br>

Email Id:<br>

<input type="email" name="email">

<br><br>

<input type="submit" value="submit">

</form>

</body>

</html>

process.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<%@page import="java.sql.*,java.util.*"%>

<%

String first_name=request.getParameter("first_name");
String last_name=request.getParameter("last_name");

String city_name=request.getParameter("city_name");

String email=request.getParameter("email");

try

Class.forName("com.mysql.jdbc.Driver");

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test",


"root", "");

Statement st=conn.createStatement();

int i=st.executeUpdate("insert into


users(first_name,last_name,city_name,email)values('"+first_name+"','"+last_name+"','"+city
_name+"','"+email+"')");

out.println("Data is successfully inserted!");

catch(Exception e)

System.out.print(e);

e.printStackTrace();

%>

Retrieve

<%@page import="java.sql.DriverManager"%>

<%@page import="java.sql.ResultSet"%>

<%@page import="java.sql.Statement"%>

<%@page import="java.sql.Connection"%>
<%

String id = request.getParameter("userid");

String driver = "com.mysql.jdbc.Driver";

String connectionUrl = "jdbc:mysql://localhost:3306/";

String database = "test";

String userid = "root";

String password = "";

try {

Class.forName(driver);

} catch (ClassNotFoundException e) {

e.printStackTrace();

Connection connection = null;

Statement statement = null;

ResultSet resultSet = null;

%>

<!DOCTYPE html>

<html>

<body>

<h1>Retrieve data from database in jsp</h1>

<table border="1">

<tr>

<td>first name</td>
<td>last name</td>

<td>City name</td>

<td>Email</td>

</tr>

<%

try{

connection = DriverManager.getConnection(connectionUrl+database, userid, password);

statement=connection.createStatement();

String sql ="select * from users";

resultSet = statement.executeQuery(sql);

while(resultSet.next()){

%>

<tr>

<td><%=resultSet.getString("first_name") %></td>

<td><%=resultSet.getString("last_name") %></td>

<td><%=resultSet.getString("city_name") %></td>

<td><%=resultSet.getString("email") %></td>

</tr>

<%

connection.close();

} catch (Exception e) {
e.printStackTrace();

%>

</table>

</body>

</html>

Update:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"


"http://www.w3.org/TR/html4/loose.dtd">

<%@ page import="java.sql.*" %>

<%@ page import="java.io.*" %>

<%@page import="java.sql.DriverManager"%>

<%@page import="java.sql.ResultSet"%>

<%@page import="java.sql.Statement"%>

<%@page import="java.sql.Connection"%>

<%

String id = request.getParameter("id");

String driver = "com.mysql.jdbc.Driver";

String connectionUrl = "jdbc:mysql://localhost:3306/";

String database = "test";

String userid = "root";

String password = "";


try {

Class.forName(driver);

} catch (ClassNotFoundException e) {

e.printStackTrace();

Connection connection = null;

Statement statement = null;

ResultSet resultSet = null;

%>

<html>

<body>

<h1>Retrieve data from database in jsp</h1>

<table border="1">

<tr>

<td>id</td>

<td>first name</td>

<td>last name</td>

<td>City name</td>

<td>Email</td>

<td>update</td>

</tr>
<%

try{

connection = DriverManager.getConnection(connectionUrl+database, userid,


password);

statement=connection.createStatement();

String sql ="select * from users";

resultSet = statement.executeQuery(sql);

while(resultSet.next()){

%>

<tr>

<td><%=resultSet.getString("id") %></td>

<td><%=resultSet.getString("first_name") %></td>

<td><%=resultSet.getString("last_name") %></td>

<td><%=resultSet.getString("city_name") %></td>

<td><%=resultSet.getString("email") %></td>

<td><a href="update.jsp?id=<%=resultSet.getString("id")%>">update</a></td>

</tr>

<%

connection.close();

} catch (Exception e) {

e.printStackTrace();

%>

</table>
</body>

</html>

DELETE

<%@page import="java.sql.DriverManager"%>

<%@page import="java.sql.ResultSet"%>

<%@page import="java.sql.Statement"%>

<%@page import="java.sql.Connection"%>

<%

String driver = "com.mysql.jdbc.Driver";

String connectionUrl = "jdbc:mysql://localhost:3306/";

String database = "student";

String userid = "root";

String password = "";

try {

Class.forName(driver);

} catch (ClassNotFoundException e) {

e.printStackTrace();

Connection connection = null;

Statement statement = null;

ResultSet resultSet = null;

%>

<!DOCTYPE html>

<html>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<body>

<h1>Retrieve data from database in jsp</h1>

<table border="1">

<tr>

<td>first name</td>

<td>last name</td>

<td>City name</td>

<td>Email</td>

<td>Action</td>

</tr>

<%

try{

connection = DriverManager.getConnection(connectionUrl+database, userid, password);

statement=connection.createStatement();

String sql ="select * from users";

resultSet = statement.executeQuery(sql);

int i=0;

while(resultSet.next()){

%>

<tr>

<td><%=resultSet.getString("fname") %></td>
<td><%=resultSet.getString("lname") %></td>

<td><%=resultSet.getString("city_name") %></td>

<td><%=resultSet.getString("email") %></td>

<td><a href="delete.jsp?id=<%=resultSet.getString("id") %>"><button type="button"


class="delete">Delete</button></a></td>

</tr>

<%

i++;

connection.close();

} catch (Exception e) {

e.printStackTrace();

%>

</table>

</body>

</html>

delete.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"


pageEncoding="ISO-8859-1"%>

<%@page import="java.sql.*,java.util.*"%>

<%

String id=request.getParameter("id");

try
{

Class.forName("com.mysql.jdbc.Driver");

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/student",


"root", "");

Statement st=conn.createStatement();

int i=st.executeUpdate("DELETE FROM users WHERE id="+id);

out.println("Data Deleted Successfully!");

catch(Exception e)

System.out.print(e);

e.printStackTrace();

%>
Co-3

Java Server Faces

JavaServer Faces (JSF) is a framework developed by Oracle for building web applications
in Java. It simplifies the development of user interfaces (UIs) by providing a set of reusable
UI components and a standardized way to handle user interactions.

MVC Architecture

JSF adheres to the Model-View-Controller (MVC) design pattern, which separates the
application logic into three interconnected components:

1. Model:

o Represents the application’s data and business logic.

o In JSF, models are typically represented by JavaBeans or managed beans.


These are regular Java classes that contain properties (data) and methods
(business logic).

o The model holds the state of the application and responds to requests from the
view.

2. View:

o Represents the user interface of the application.

o In JSF, views are usually defined using XHTML files, which describe how the
UI components (like buttons, text fields, and tables) should be displayed to the
user.

o The view retrieves data from the model and presents it to the user, while also
capturing user input to send back to the model.

3. Controller:

o Manages the flow of the application and handles user input.

o In JSF, the controller functionality is primarily handled by the managed beans.


These beans process user actions (like button clicks) and determine how the
application should respond.
o JSF provides a built-in mechanism for routing and navigation between
different views based on user actions.

Key Features of JSF

 Component-Based Architecture: JSF promotes the reuse of UI components.


Developers can create custom components or use existing ones, reducing redundancy
and enhancing maintainability.

 Rich Set of UI Components: JSF comes with a library of standard components (e.g.,
forms, tables, buttons) and integrates easily with third-party component libraries (like
PrimeFaces) that offer additional features.

 Data Binding: JSF allows for easy binding between UI components and managed
bean properties. This means that changes in the UI can automatically reflect in the
underlying data model and vice versa.

 Navigation Handling: JSF simplifies navigation between views through a built-in


mechanism. You can define navigation rules in XML or use annotations, making it
easier to manage user flows within the application.

 Event Handling: JSF supports an event-driven programming model, allowing


developers to respond to user actions (like clicks) through event listeners, providing a
more dynamic user experience.

Example Flow in a JSF Application

1. User Interaction: A user interacts with the UI (e.g., filling out a form).

2. Request Processing: When the user submits the form, JSF captures the request and
routes it to the appropriate managed bean (the controller).

3. Business Logic Execution: The managed bean processes the request, possibly
updating the model with the new data.

4. View Update: After processing, JSF prepares the response, updating the view with any
data changes (e.g., showing a success message).

5. Rendering: The updated view is rendered back to the user, displaying the latest
information.
JSF's ability to connect UI widgets, data sources, and server-side event handlers is one of its
key features, enabling the creation of dynamic and interactive web applications.

1. UI Widgets

In JSF, UI widgets are the components that users interact with in a web application. These
include elements like buttons, text fields, checkboxes, dropdown lists, and tables. JSF
provides a rich set of standard components, and you can also create custom components.

 Example: A simple text input for a user to enter their name

<h:inputText value="#{userBean.name}" />

2. Data Sources

Data sources in JSF refer to the underlying data models that hold the application’s data. This
can include simple JavaBeans, databases, or any other data storage mechanism. In JSF, these
data models are typically represented as managed beans.

 Example: A managed bean named UserBean could have a property name to hold the
user’s input:

@ManagedBean

public class UserBean {

private String name;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

}
3. Event Handlers

Event handlers in JSF are methods in managed beans that respond to user actions, such as
button clicks or form submissions. These handlers can contain business logic to process the
data and perform operations like validation, data manipulation, or navigation to another page.

 Example: A method in the UserBean to handle a button click:

public String greet() {

// Logic to process the input

return "Hello, " + name + "!";

Life cycle
Phase 1: Restore view

JSF begins the restore view phase as soon as a link or a button is clicked and JSF receives a
request.

During this phase, JSF builds the view, wires event handlers and validators to UI components
and saves the view in the FacesContext instance. The FacesContext instance will now contain
all the information required to process a request.

Phase 2: Apply request values

After the component tree is created/restored, each component in the component tree uses the
decode method to extract its new value from the request parameters. Component stores this
value. If the conversion fails, an error message is generated and queued on FacesContext.
This message will be displayed during the render response phase, along with any validation
errors.

If any decode methods event listeners called renderResponse on the current FacesContext
instance, the JSF moves to the render response phase.

Phase 3: Process validation


During this phase, JSF processes all validators registered on the component tree. It examines
the component attribute rules for the validation and compares these rules to the local value
stored for the component.

If the local value is invalid, JSF adds an error message to the FacesContext instance, and the
life cycle advances to the render response phase and displays the same page again with the
error message.

Phase 4: Update model values

After the JSF checks that the data is valid, it walks over the component tree and sets the
corresponding server-side object properties to the components' local values. JSF will update
the bean properties corresponding to the input component's value attribute.

If any updateModels methods called renderResponse on the current FacesContext instance,


JSF moves to the render response phase.

Phase 5: Invoke application

During this phase, JSF handles any application-level events, such as submitting a
form/linking to another page.

Phase 6: Render response

After the content of the view is rendered, the response state is saved so that subsequent
requests can access it and it is available to the restore view phase.

JSF - Managed Beans

Managed Beans is a Java bean managed by JSF framework. Managed bean contains the
getter and setter methods, business logic, or even a backing bean (a bean contains all the
HTML form value).

Managed beans works as Model for UI component. Managed Bean can be accessed from JSF
page.

Using XML Configuration

<managed-bean>
<managed-bean-name>helloWorld</managed-bean-name>

<managed-bean-class>com.example.test.HelloWorld</managed-bean-class>

<managed-bean-scope>request</managed-bean-scope>

</managed-bean>

Using Annotation

@ManagedBean(name = "helloWorld", eager = true)

@RequestScoped

@ManagedBean Annotation

@ManagedBean marks a bean to be a managed bean with the name specified in name
attribute. If the name attribute is not specified, then the managed bean name will default to
class name portion of the fully qualified class name. In our case, it would be helloWorld.

Scope Annotations

Scope annotations set the scope into which the managed bean will be placed. If the scope is
not specified, then bean will default to request scope.

S.No Scope & Description

@RequestScoped

Bean lives as long as the HTTP request-response lives. It gets created upon a HTTP
1
request and gets destroyed when the HTTP response associated with the HTTP request is
finished.

@NoneScoped

2 Bean lives as long as a single EL(Expression Language) evaluation. It gets created upon
an EL evaluation and gets destroyed immediately after the EL evaluation.
@ViewScoped

Bean lives as long as the user is interacting with the same JSF view in the browser
3
window/tab. It gets created upon a HTTP request and gets destroyed once the user
postbacks to a different view.

@SessionScoped

Bean lives as long as the HTTP session lives. It gets created upon the first HTTP request
4
involving this bean in the session and gets destroyed when the HTTP session is
invalidated.

@ApplicationScoped

Bean lives as long as the web application lives. It gets created upon the first HTTP request
5 involving this bean in the application (or when the web application starts up and the
eager=true attribute is set in @ManagedBean) and gets destroyed when the web
application shuts down.

@CustomScoped

6 Bean lives as long as the bean's entry in the custom Map, which is created for this scope
lives.

Navigation
Navigation rules are those rules provided by JSF Framework that describes which view is to
be shown when a button or a link is clicked.

Navigation rules can be defined in JSF configuration file named faces-config.xml. They can
be defined in managed beans.

Navigation rules can contain conditions based on which the resulted view can be shown.

Implicit Navigation
JSF 2.0 provides auto view page resolver mechanism named implicit navigation. In this
case, you only need to put view name in action attribute and JSF will search the
correct view page automatically in the deployed application.

Auto Navigation in JSF Page

Set view name in action attribute of any JSF UI Component.

<h:form>

<h3>Using JSF outcome</h3>

<h:commandButton action = "page2" value = "Page2" />

</h:form>

Here, when Page2 button is clicked, JSF will resolve the view name, page2 as page2.xhtml
extension, and find the corresponding view file page2.xhtml in the current directory.
Auto Navigation in Managed Bean

Define a method in managed bean to return a view name.

@ManagedBean(name = "navigationController", eager = true)

@RequestScoped

public class NavigationController implements Serializable {

public String moveToPage1() {

return "page1";

Get view name in action attribute of any JSF UI Component using managed bean.

<h:form>

<h3> Using Managed Bean</h3>

<h:commandButton action = "#{navigationController.moveToPage1}"

value = "Page1" /glt;

</h:form>

Here, when Page1 button is clicked, JSF will resolve the view name, page1 as page1.xhtml
extension, and find the corresponding view file page1.xhtml in the current directory.
Conditional Navigation

Using managed bean, we can very easily control the navigation. Look at the following code
in a managed bean.

@ManagedBean(name = "navigationController", eager = true)

@RequestScoped

public class NavigationController implements Serializable {

//this managed property will read value from request parameter pageId

@ManagedProperty(value = "#{param.pageId}")

private String pageId;


//condional navigation based on pageId

//if pageId is 1 show page1.xhtml,

//if pageId is 2 show page2.xhtml

//else show home.xhtml

public String showPage() {

if(pageId == null) {

return "home";

if(pageId.equals("1")) {

return "page1";

}else if(pageId.equals("2")) {

return "page2";

}else {

return "home";

Pass pageId as a request parameter in JSF UI Component.

<h:form>

<h:commandLink action = "#{navigationController.showPage}" value = "Page1">

<f:param name = "pageId" value = "1" />


</h:commandLink>

<h:commandLink action = "#{navigationController.showPage}" value = "Page2">

<f:param name = "pageId" value = "2" />

</h:commandLink>

<h:commandLink action = "#{navigationController.showPage}" value = "Home">

<f:param name = "pageId" value = "3" />

</h:commandLink>

</h:form>

Here, when "Page1" button is clicked.

 JSF will create a request with parameter pageId = 1

 Then JSF will pass this parameter to managed property pageId of


navigationController

 Now navigationController.showPage() is called which will return view as page1 after


checking the pageId

 JSF will resolve the view name, page1 as page1.xhtml extension

 Find the corresponding view file page1.xhtml in the current directory


EJB
Enterprise JavaBeans (EJB) is a server-side software component that encapsulates business
logic of an application. It is part of the Java EE (Enterprise Edition) specification and is used
to develop scalable, distributed, and secure enterprise-level applications. EJB provides an
abstraction over the complexities of transaction management, security, remote access,
concurrency, and more, enabling developers to focus on writing business logic rather than
infrastructure code.
Key Features of EJB:
1. Business Logic Encapsulation: EJBs encapsulate business logic and are reusable
components that can be deployed in different applications.
2. Transaction Management: EJBs automatically handle transaction management,
ensuring data consistency and integrity during operations like banking or financial
applications.
3. Security: EJBs provide declarative security, allowing developers to specify security
constraints (like user roles and permissions) in configuration files without altering
the application code.
4. Remote and Local Access: EJB allows both remote and local access. Remote access is
when the EJB is accessed from a different JVM (Java Virtual Machine), while local
access happens within the same JVM.
5. Concurrency Handling: EJB takes care of concurrent access to business logic
components, ensuring thread safety.
6. Persistence: EJB can interact with databases to manage persistent data via Entity
Beans (though they are now replaced by Java Persistence API (JPA) for this
purpose).
Types of EJB:
1. Session Beans: Manage the business logic and are invoked by clients to perform
operations.
o A Stateless Session Bean (SLSB) is a type of Enterprise JavaBean (EJB) used in
Java EE (Enterprise Edition) applications. Stateless session beans are part of
the business logic layer and are designed to handle tasks that do not need to
maintain any conversational state between client calls.

import javax.ejb.Stateless;
@Stateless
public class CalculatorBean implements CalculatorRemote
{
@Override
public int add(int a, int b)
{
return a + b;
}
@Override
public int subtract(int a, int b)
{
return a - b;
}
}
o Stateful: A Stateful Session Bean (SFSB) is another type of Enterprise
JavaBean (EJB) in Java EE, which is designed to maintain state across multiple
method calls and transactions for a single client. Unlike stateless session
beans, stateful session beans are used when there is a need to keep
conversational state, meaning the bean retains data across method calls
made by the same client.
import javax.ejb.Stateful;
@Stateful
public class ShoppingCartBean implements ShoppingCart
{
private List<String> items = new ArrayList<>();
@Override
public void addItem(String item)
{
items.add(item);
}
@Override
public void removeItem(String item)
{
items.remove(item);
}
@Override
public List<String> getItems()
{
return items;
}
@Override
public void checkout()
{
// Perform checkout logic, such as processing payment and order
items.clear();
}
}

o Singleton: A Singleton Session Bean is another type of Enterprise JavaBean


(EJB) in Java EE, designed to have a single instance shared across all clients
within the application. This bean type is used when you need to maintain a
shared state or coordinate behavior across multiple clients.

import javax.ejb.Singleton;
import javax.ejb.Lock;
import javax.ejb.LockType;
@Singleton
public class AppConfigBean
{
private String config;
@PostConstruct
public void init()
{
// Load initial configuration
config = "Default Configuration";
}
@Lock(LockType.READ)
public String getConfig()
{
return config;
}
@Lock(LockType.WRITE)
public void updateConfig(String newConfig)
{
config = newConfig;
}
@PreDestroy public void cleanup()
{
// Perform any cleanup actions before shutdown
System.out.println("Cleaning up singleton bean resources.");
}
}

2. Message-Driven Beans (MDB): Handle asynchronous message processing, typically


used with messaging systems like JMS. They listen for messages and process them as
they arrive. a special type of Enterprise JavaBean (EJB) in Java EE designed to process
messages asynchronously. Unlike session beans (stateless, stateful, or singleton),
which are invoked by client requests, message-driven beans are invoked by
messages sent to a messaging system like Java Message Service (JMS). MDBs are
typically used in scenarios where an application needs to react to events or
messages without direct client interaction.

Application Server

An Application Server in the context of Enterprise JavaBeans (EJB) is a server-side


software framework that provides an environment in which EJB components can be
deployed, managed, and executed. The application server is responsible for handling
infrastructure-level services like transaction management, security, concurrency, and resource
pooling, freeing developers from dealing with these complex tasks directly.

Popular Application Servers for EJB:

1. JBoss (WildFly):
o An open-source, widely-used Java EE application server that supports EJB
and other enterprise technologies. JBoss/WildFly is known for its flexibility
and robust performance in handling enterprise applications.

2. GlassFish:

o The reference implementation for Java EE (now Jakarta EE). It’s open-source
and provides a full-featured EJB container. GlassFish is often used for learning
or testing Java EE features.

3. WebLogic:

o A commercial application server from Oracle, known for its high performance
and strong support for large-scale, distributed enterprise applications. It
provides excellent clustering, high availability, and scalability features.

4. WebSphere:

o IBM’s enterprise application server that supports EJB, along with a host of
other enterprise services. It is known for its strong integration with enterprise-
level middleware and database solutions.

5. Apache TomEE:

o A lightweight, open-source application server built on top of Apache Tomcat,


supporting EJB and other Java EE technologies. It’s ideal for projects
requiring a smaller footprint but still needing enterprise features.

 Cross-Platform Deployment: EJB-based applications can be deployed across


different environments (on-premises or cloud) without changing the code.

 Component Portability

EJB (Enterprise JavaBeans) refers to the ability of EJB components to be easily deployed
and executed across different Java EE-compliant application servers without modification.
This portability is one of the core goals of EJB, allowing developers to write business logic
once and deploy it in any application server that adheres to the Java EE specification.
How Component Portability Works in EJB:

1. Standardized Specification:

o which ensures that any application server implementing the specification must
follow a set of well-defined APIs and behaviors. This means that an EJB
component written according to the specification will work on any compliant
server (e.g., WildFly, WebLogic, GlassFish).

2. Separation of Business Logic and Infrastructure:

o EJB abstracts infrastructure concerns like transaction management, security,


and resource management from the business logic. The EJB container (within
the application server) provides these services, so developers can write their
business logic without worrying about the specific implementation of these
services in different environments.

3. Deployment Descriptors and Annotations:

o EJB components can use deployment descriptors (XML-based


configuration) or annotations to define how they should be deployed and
managed. Since these configurations are standardized, the same EJB can be
deployed on multiple servers with little to no modification.

EJB Component Model

The EJB Component Model defines how business components, or Enterprise JavaBeans
(EJBs), are developed within an enterprise application. These components are managed by
the EJB container within an application server, providing services like transaction
management, security, concurrency, and persistence. The EJB component model simplifies
enterprise-level development by abstracting away the complexity of building distributed,
scalable, and secure applications.
Key Components of the EJB Component Model:

1. Session Beans:

o Session beans implement business logic and handle user requests.

o Types:

 Stateless Session Beans: Do not retain state across method calls. They
are used for operations that do not require client-specific data to be
stored between invocations.

 Stateful Session Beans: Maintain client state between method calls.


Suitable for processes that involve multiple steps and require
remembering data between interactions.

 Singleton Session Beans: Ensure a single instance of the bean is


created across the entire application, often used for application-wide
settings or data.

2. Message-Driven Beans (MDBs):

o MDBs are used to process asynchronous messages. They listen for messages
sent via messaging services (such as JMS – Java Message Service) and
perform background tasks when messages are received.

3. Entity Beans (Replaced by JPA):

o In earlier versions of EJB, Entity Beans represented persistent data in a


relational database. They have largely been replaced by Java Persistence API
(JPA), which offers more flexibility and ease of use for managing database
persistence.

4. EJB Interfaces:

o EJBs are accessed through interfaces that define the contract between the
client and the business logic:

 Local Interface: Used when the client and the bean are in the same
application or JVM.
 Remote Interface: Allows remote clients to invoke EJB methods from
outside the application server or from a different JVM.

5. Annotations and Deployment Descriptors:

o EJB components can be configured using annotations (in modern versions) or


deployment descriptors (XML configuration files).

o Common EJB annotations include:

 @Stateless for stateless session beans.

 @Stateful for stateful session beans.

 @Singleton for singleton session beans.

 @MessageDriven for MDBs.

6. Transaction Management:

o The EJB container manages transactions, providing declarative transaction


support using annotations such as @TransactionManagement and
@TransactionAttribute. It ensures that all operations within a transaction are
completed successfully or rolled back if a failure occurs.

7. Lifecycle Management:

o The EJB container manages the lifecycle of EJBs, from instantiation to


destruction, as well as activating and passivating beans when needed. This
allows for efficient resource management and performance optimization.

 For example, stateful session beans can be passivated (temporarily


stored) to conserve memory when not in use and activated when
needed again.

8. Security:

o Security in EJB is managed declaratively via annotations (@RolesAllowed,


@PermitAll, @DenyAll) or deployment descriptors, specifying which roles or
users are allowed to access certain methods or beans.

9. Dependency Injection:
 EJB supports dependency injection through the @EJB annotation, allowing the
container to automatically inject references to other EJBs or resources (like data
sources) into the bean.

EJB Architecture Java

Java beans incorporate a set of objects into one accessible object that can be accessed
easily from any application. This single accessible object is maintainable,
customizable, and reusable. The setter/getter method and the single public constructor
are used to govern that single accessible object. We can update and read the value of
any variable of any object by using the setter and getter, respectively.

The EJB architecture has two main layers, i.e., Application Server and EJB
Container,

In the above diagram, the logical representation of how EJBs are invoked and
deployed by using RMI(Remote Method Invocation) is defined. The containers of the
EJB cannot be self-deployed. In order to deploy the containers, it requires the
Application server.

Application Server

In the EJB architecture, the Application server is the outermost layer that holds or
contains the Container to be deployed. The application layer plays an important role
in executing the application developed using the beans. It provides the necessary
environment to execute those applications. Some most popular application servers are
Web-logic, Tomcat, JBoss, Web-sphere, Wildfly, and Glass-finish. The main tasks of
the application server are:

1. Manage Interfaces

2. Execution of the processes

3. Connecting to the database

4. Manage other resources.

Container

In EJB architecture, the Container is the second outermost layer. It is a very important
layer for enterprise beans that are contained in it. For the enterprise bean, the
Container provides various supporting services, which are as follows:

o It provides support for transactional services such as registering the objects, assign
remote interfaces, purge the instances.

o It provides support for monitoring the object's activities and coordinating distributed
components.

o It provides support for security services.

o It provides support for the pooling of resources.

o It provides support for managing the Life-cycle of beans and their concurrency.

o It provides support to concentrate on business logic.

Beans

Java beans of the enterprise are installed in the Container in the same way as a Plain
old java object (POJO) is installed and registered to the Container. For developing
secured, large scale and robust business applications, beans provide business logic.

Types of EJB

There are three types of Enterprise Java Beans or EJB available, which are as
follows:
1. Stateless Enterprise Java Beans

2. Stateful Enterprise Java Beans

3. Message-driven Enterprise Java Beans

Stateless EJB

In order to implement the stateless business logic, the stateless EJBs are primarily
used. Storing a user's physical address into an inventory system's database is an
example of the stateless EJB. In addition, a stateless bean would be perfect for this
type of business logic because it is not necessary to have more than two forms on the
user interface at all stages of the transaction.

StatelessBeanExample.java

Advertisement

1. package com.javatpoint.ejbarchitecture;

2. import javax.ejb.Stateless;

3.

4. @Stateless

5. public class StatelessBeanExample {

6. }

Stateful EJB

The Stateful EJB is just opposite to the Stateless EJB. The Stateful EJBs are used
when we have to maintain the state of the application on the backend during the user
session. The shopping cart of an online shopping application is an example of
the Stateful EJB.

StatelessBeanExample.java

1. package com.javatpoint.ejbarchitecture;

2. import javax.ejb.Stateful;

3.
4. @Stateful

5. public class StatelessBeanExample {

6. }

Message-driven EJB

Another special type of EJB that is used for sending and receiving messages from
message brokers implements the JMS specification. The systems based on the broker
are loosely coupled. The components that communicate through the broker have the
advantage of not waiting for one request to finish before submitting another request
because the broker by nature is asynchronous.

MessageDrivenBeanExample.java

1. package com.javatpoint.ejbarchitecture;

2. import javax.ejb.MessageDriven;

3. import javax.jms.MessageListener;

4. import javax.jms.Message;

5. import javax.ejb.ActivationConfigProperty;

6.

7. @MessageDriven(mappedName = "jms/Queue", activationConfig = {

8. @ActivationConfigProperty(propertyName = "reciverType", propertyValue


= "javax.jms.Queue"),

9. @ActivationConfigProperty(propertyName = "reciver", propertyValue = "ja


va:/queue/testqueue")

10. })

11. public class MessageDrivenBeanExample implements MessageListener {

12.

13. public MessageDrivenBeanExample() {

14. }
15. public void onMessage(Message message) {

16. System.out.println("Message received successfully .");

17. }

18. }

Difference b/w EJB and JB

These are the following differences between EJB and JB:

S.No. EJB JB

EJB is not visible because it runs


1. JB is visible.
as a remote.

EJB is executed on the server- EJB can execute on both the


2.
side. client-side and the server-side.

For interpreting the bean's


EJB works with an external
3. functionality, EJB uses its
builder tool or its IDE.
external interface.

EJB uses the technology of By using generic components


4. components but cannot build or created by Java beans, it is able
extend it over beans. to build applet and application.

It has no bean information


It has property editors,
classes. It has only information
5. customizers, and bean
about what is provided by the
information classes.
deployment descriptor.

6. It supports transactions. It doesn't support transactions.

7. Three types of EJB possible. No types.


Lifecycle of an EJB:

The lifecycle of an EJB varies depending on the type of bean:

 Stateless Session Bean:

1. Instantiation: The container creates an instance of the bean.

2. Pooling: The instance can be pooled for reuse.

3. Business Method Invocation: The client calls business methods on the bean.

4. Removal: The bean instance is removed when it is no longer needed.

 Stateful Session Bean:

1. Instantiation: The container creates an instance of the bean.

2. State Maintenance: The bean maintains state information for the client.

3. Business Method Invocation: The client calls methods, and the bean retains its
state.

4. Removal: The bean is removed when the session ends or the client invokes the
remove() method.

 Singleton Bean:

1. Instantiation: The container creates a single instance of the bean.

2. Business Method Invocation: The client calls methods, accessing the same
instance.

3. Destruction: The bean is destroyed when the application is stopped.

EJB clients
are components or applications that interact with Enterprise JavaBeans (EJBs) to utilize their
business logic and services. Clients can be either local or remote, depending on their location
relative to the EJB server. Here’s a detailed overview of EJB clients, their types, and how
they interact with EJBs.

Types of EJB Clients

1. Local EJB Clients:

o Local clients run in the same Java Virtual Machine (JVM) as the EJB
container. They can access EJBs directly without using network protocols,
making the invocation faster and more efficient.

o Local clients typically use local interfaces to call EJB methods.

o Example: A servlet running on the same application server can be a local client
to session beans.

2. Remote EJB Clients:

o Remote clients run in different JVMs and need to communicate with the EJB
container over a network. Remote clients use remote interfaces for method
calls.

o The EJB container exposes remote interfaces using RMI (Remote Method
Invocation), making it possible for clients to invoke methods as if they were
local.

o Example: A standalone Java application or a web application hosted on a


different server can be a remote client.

Plain old Java objects

Although POJOs existed before, they play a more important role in the programming
methodology of Java. now create EJB applications with persistence capabilities by using
enterprise beans and entities created from POJOs.

The POJO programming model enables you to unit test outside of the application server,
making the whole programming experience smoother.

A simple POJO
public class Test {

String name;

/**

* This is a constructor for a Test Object.

**/

public Test(){

name = "Jane";

To create an EJB 3.0 bean, inject a component defining annotation at the class level. The
following example turns a POJO into a stateless session bean by adding the @Stateless
annotation.

@Stateless

String class Test {

String name;

/**

* This is a constructor for a Test Object.

**/

public Test () {

name = "jane";

In a real application, the POJO needs additional business logic. The fundamental idea of
using POJOs in the context of the Java EE specification is to associate Metadata about
your component to be associated directly in your POJO. This approach reduces the
number of artifacts you need to deal with and makes it easier to ensure the integrity of
your Metadata.

Managing Entity Relationships

EJB 3.0 provides option to define database entity relationships/mappings like one-to-
one, one-to-many, many-to-one, and many-to-many relationships.

Following are the relevant annotations −

 One-to-One − Objects have one-to-one relationship. For example, a passenger can


travel using a single ticket at a time.

 One-to-Many − Objects have one-to-many relationship. For example, a father can


have multiple kids.

 Many-to-One − Objects have many-to-one relationship. For example, multiple kids


having a single mother.

 Many-to-Many − Objects have many-to-many relationship. For example, a book can


have multiple authors and an author can write multiple books.

We will demonstrate use of ManyToMany mapping here. To represent ManyToMany


relationship, three following tables are required −

 Book − Book table, having records of books.

 Author − Author table, having records of author.

 Book_Author − Book Author table, having linkage of above mentioned Book and
Author table.

Create Tables
Create a table book, author, book_author in default database postgres.

CREATE TABLE book (

book_id integer,

name varchar(50)

);

CREATE TABLE author (

author_id integer,

name varchar(50)

);

CREATE TABLE book_author (

book_id integer,

author_id integer

);

Create Entity Classes

@Entity

@Table(name="author")

public class Author implements Serializable{

private int id;

private String name;

...

}
@Entity

@Table(name="book")

public class Book implements Serializable{

private int id;

private String title;

private Set<Author> authors;

...

Use ManyToMany annotation in Book Entity.

@Entity

public class Book implements Serializable{

...

@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}

, fetch = FetchType.EAGER)

@JoinTable(table = @Table(name = "book_author"),

joinColumns = {@JoinColumn(name = "book_id")},

inverseJoinColumns = {@JoinColumn(name = "author_id")})

public Set<Author> getAuthors() {

return authors;

...

}
JAX-RS Example Jersey

We can create JAX-RS example by jersey implementation. To do so, you need to load
jersey jar files or use maven framework.

In this example, we are using jersey jar files for using jersey example for JAX-RS.

Click me to download jersey jar files.

There are created 4 files for hello world JAX-RS example:

1. Hello.java

2. web.xml

3. index.html

4. HelloWorldClient.java

The first 3 files are created for server side and 1 application for client side.

JAX-RS Server Code

File: Hello.java

1. package com.javatpoint.rest;

2. import javax.ws.rs.GET;

3. import javax.ws.rs.Path;

4. import javax.ws.rs.Produces;

5. import javax.ws.rs.core.MediaType;

6. @Path("/hello")
7. public class Hello {

8. // This method is called if HTML and XML is not requested

9. @GET

10. @Produces(MediaType.TEXT_PLAIN)

11. public String sayPlainTextHello() {

12. return "Hello Jersey Plain";

13. }

14. // This method is called if XML is requested

15. @GET

16. @Produces(MediaType.TEXT_XML)

17. public String sayXMLHello() {

18. return "<?xml version=\"1.0\"?>" + "<hello> Hello Jersey" + "</hello>";

19. }

20.

21. // This method is called if HTML is requested

22. @GET

23. @Produces(MediaType.TEXT_HTML)

24. public String sayHtmlHello() {

25. return "<html> " + "<title>" + "Hello Jersey" + "</title>"

26. + "<body><h1>" + "Hello Jersey HTML" + "</h1></body>" + "</html> ";

27. }

28. }

File: web.xml

1. <?xml version="1.0" encoding="UTF-8"?>


2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

3. xmlns="http://java.sun.com/xml/ns/javaee"

4. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

5. http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

6. id="WebApp_ID" version="3.0">

7. <servlet>

8. <servlet-name>Jersey REST Service</servlet-name>

9. <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>

10. <init-param>

11. <param-name>jersey.config.server.provider.packages</param-name>

12. <param-value>com.javatpoint.rest</param-value>

13. </init-param>

14. <load-on-startup>1</load-on-startup>

15. </servlet>

16. <servlet-mapping>

17. <servlet-name>Jersey REST Service</servlet-name>

18. <url-pattern>/rest/*</url-pattern>

19. </servlet-mapping>

20. </web-app>

File: index.html

1. <a href="rest/hello">Click Here</a>

Now run this application on server. Here we are using Tomcat server on port 4444. The
project name is restfuljersey.

After running the project, you will see the following output:
JAX-RS Client Code

The ClientTest.java file is created inside the server application. But you can run client
code by other application also by having service interface and jersey jar file.

Advertisement

File: ClientTest.java

1. package com.javatpoint.restclient;

2. import java.net.URI;

3. import javax.ws.rs.client.Client;

4. import javax.ws.rs.client.ClientBuilder;

5. import javax.ws.rs.client.WebTarget;

6. import javax.ws.rs.core.MediaType;

7. import javax.ws.rs.core.UriBuilder;

8. import org.glassfish.jersey.client.ClientConfig;

9. public class ClientTest {

10. public static void main(String[] args) {

11. ClientConfig config = new ClientConfig();

12. Client client = ClientBuilder.newClient(config);


13. WebTarget target = client.target(getBaseURI());

14. //Now printing the server code of different media type

15. System.out.println(target.path("rest").path("hello").request().accept(MediaT
ype.TEXT_PLAIN).get(String.class));

16. System.out.println(target.path("rest").path("hello").request().accept(MediaT
ype.TEXT_XML).get(String.class));

17. System.out.println(target.path("rest").path("hello").request().accept(MediaT
ype.TEXT_HTML).get(String.class));

18. }

19. private static URI getBaseURI() {

20. //here server is running on 4444 port number and project name is restfuljersey

21. return UriBuilder.fromUri("http://localhost:4444/restfuljersey").build();

22. }

23. }

Output:

Hello Jersey Plain

<?xml version="1.0"?><hello> Hello Jersey</hello>

<html> <title>Hello Jersey</title><body><h1>Hello Jersey HTML</h1></body></html>

Consume a REST Service

Last modified: August 19, 2024


Introduction

Mendix applications frequently need to communicate with existing systems. Whether


you are creating an app to replace an older platform or a legacy system or want to
integrate an existing database, the ability to integrate with existing systems is a
necessary feature. In your Mendix app, you can use published REST services for this
integration.

This how-to shows you how to do this using an example in which you create an app that
retrieves Wikipedia pages from a REST service. The resulting app is available for
download.

This how-to teaches you how to do the following:

 Integrate with an existing system using a REST service

 Call the REST service in a microflow

Creating a published REST service on top of the system you want to integrate with is
outside the scope of this how-to; for instructions on how to do this, refer to the
configuration of your non-Mendix Platform.

Creating a JSON Structure

If the system you want to integrate into your app has the functionality for exposing its
data to REST services, you can integrate it easily into your Mendix app using consume
REST service. Each system has a different JSON structure based on internal data
models.

You are going to use the Wikipedia REST service as an example in this how-to. It allows
you to retrieve the summary of a Wikipedia page – in this case information about a
country. This service can be reached
at https://en.wikipedia.org/api/rest_v1/page/summary/{title}, where {title} is the title of
a page.

We will start by providing to Studio Pro an example of what the REST service returns:

1. Open your browser and go


to https://en.wikipedia.org/api/rest_v1/page/summary/Tahiti.
2. This calls the REST service with a GET request – the result is the summary of
the Tahiti page on Wikipedia in the JSON format:

3. Copy the whole JSON snippet. Make sure that you select the Raw Data tab to
copy the whole code structure.

4. Create a module and name it RESTconsume. To add a new JSON structure to


your module with the sample JSON that you can use in the app, right-click the
module in the Project Explorer and select Add other > JSON structure.

5. Enter a Name for the structure: JSON_structure and click OK.

6. In the JSON Structure dialog box, paste the JSON snippet in the General tab
and click Refresh. This analyzes the structure of the JSON snippet that we can
use later.
7. Click OK.

Creating an Import Mapping

An import mapping specifies how the JSON relates to entities. You can map the JSON
to any entity you like. The following steps describe how to generate the entities and
create an import mapping:

1. Right-click the module in the Project Explorer and select Add other > Import
Mapping.

2. Enter a Name for the import mapping: Import_mapping and click OK.

3. In the Select schema elements for import mapping dialog box, click the radio
button for JSON structure and then click Select.

4. Double-click JSON_structure in the Select JSON Structure dialog box.


5. Click Expand all and then click Check all.

6. Click OK. The Import_mapping document is displayed and the JSON structure
is on the right.

7. Click Map automatically in the editor toolbar.

8. A pop-up box is displayed informing you that can See the details for the changes
that have been applied. You can click Details to see details of the mapping to the
entities that are generated to match the JSON structure.

9. Click Close to see the entities corresponding to the JSON structure.

Adding an Input Entity to the Domain Model

The service takes the title of the page as an input and it returns the summary of the
page from Wikipedia.

In this section, you will create an entity that represents this input and associate it with
its summary.

To add an input entity to the domain model, follow these steps:

1. In the Project Explorer, double-click the Domain Model.


2. Rename Root to Summary.

3. From the Toolbox, drag an Entity into the domain model.

4. Double-click the entity and enter Input for the Name.

5. For Persistable, select No.

6. On the Attributes tab, click New to add a string attribute and name it Title.

7. Click OK.

8. Drag an association from Input to Summary.


9. Go to the Import_mapping and from the Connector pane drag Input as the input
parameter for the input mapping.

10. Double-click Summary.

11. In the Map entity ‘Summary from the object element ‘Summary dialog box, Set
association to Yes and select the RESTconsume_input_Summary for
the Association to have the import mapping set the association:

12. Click OK.

Calling the REST Service in a Microflow

You will now call the REST service in a microflow to build the integration with
Wikipedia. The microflow takes Input as the input parameter and sets the
associated Summary.

To call the REST service in a microflow, follow these steps:

1. Right-click the module and select Add > Microflow and accept the
default Name Microflow for the name of the microflow and click OK.

2. From the tool bar, drag a Parameter object to the microflow document.

3. Click Select for the Data type and select the Input entity as the input parameter.
Click OK.
4. Right-click the mouse and select Insert > Activity to insert an activity to the
microflow. Double-click the activity and select the Call REST service to change
the activity.

5. In the Call REST dialog box, click Edit for the Location and add the following
to Template: https://en.wikipedia.org/api/rest_v1/page/summary/{1}, with the
parameter being the Title attribute from the Input parameter $Input/Title.
Click OK.

6. In the Response tab, the response has to be mapped using the import mapping.
For Response handling select Apply import mapping.

7. For Mapping, click Select and double-click Import_mapping. For the Parameter,
select Input.

8. For Output select Yes for Store in variable and specify Summary for the Variable
name.
9. Click OK.

10. Right-click after the Call REST service object and select Insert > Activity and
double-click it and change it to a Change object.

11. For the Input Object, select Input (RESTconsume.Input).

12. For Refresh in client, select Yes. This ensures that the summary is displayed on
the screen.

13. Click New.

14. On the Edit Change Item dialog box, for Member,


select RESTconsume.Input_Summary (RESTconsume.Summary).

15. Under Value, enter $Summary.


16. Click OK.

17. Click OK. You have created microflow that takes the title of an article as input
and associates it with its summary.
You have successfully consumed a REST service and created a microflow to show the
results. The rest of this how-to describes how to use this microflow in an app so that you
can see the REST call in action.

Creating a Page

To create a page for this app, follow these steps:

1. Open the **** and add a Data view.

2. Right-click the [Unknown] bar and click, Select entity. Select the Input entity.

3. For the Data source – Type, select Microflow.

4. For the Name, enter CreateInput. Note that when this page loads, it needs a
new Input object – you will define the CreateInput microflow that creates this
object in Filling In the Create Input Microflow.

5. Click OK.

6. From Container widgets, add a new Table with one row and two columns.

7. Drag the Title field onto the left column.

8. From the Project Explorer, drag Microflow into the right column.

9. Double-click the Microflow button and in the Edit Action Button dialog box,
enter Get summary for the caption of the button.

10. Add a Data view below the table (inside the other data view).
11. From the Connector, drag the Summary entity onto the [Unknown] bar.

12. Click OK.

13. From this data view, delete all the fields except Extract.

14. Double-click Extract.

15. For Show label, select No.

16. Click OK.

17. Delete the Save and Cancel buttons.

Filling In the Create Input Microflow

Now all that is left is to have the CreateInput microflow create a new Input object.

To fill in the CreateInput microflow, follow these steps:

1. In the Project Explorer, double-click CreateInput.

2. From the Toolbox, drag a Create object activity to the microflow.

3. Double-click the activity.

4. For Entity, click Select and double-click Input, then click OK.

5. Double-click the red End event.

6. Under Return value, enter $NewInput, then click OK

You might also like