Function tags provide many functions we can use to perform common operations, most of which are for String manipulation, such as String COncatenation, Split String, etc.
Here are some tags that you can refer to before looking at examples.
SQL tags support interaction with relational databases such as Oracle, MySql etc. Using JSTL SQL tags, we can run database queries. We first need to create a table with the totoro account to demonstrate.
create table test(
num number,
name varchar2(10),
primary key(num) );
In the code, first, we insert the data and print out the data with the select SQL.
<%@ page language="java" contentType="text/html; charset=EUC-KR"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>
<html>
<head>
<title>JSTL sql Tags</title>
</head>
<body>
<sql:setDataSource var="conn" driver="oracle.jdbc.driver.OracleDriver"
url="jdbc:oracle:thin:@localhost:1521:xe" user="totoro"
password="totoro123" />
<sql:update dataSource="${conn}">
INSERT INTO test (num, name) VALUES (1, 'Meadow')
</sql:update>
<sql:update dataSource="${conn}">
INSERT INTO test (num, name) VALUES (2, 'Dodo')
</sql:update>
<sql:update dataSource="${conn}">
INSERT INTO test (num, name) VALUES (3, 'Forest')
</sql:update>
<sql:update dataSource="${conn}">
INSERT INTO test (num, name) VALUES (4, 'Jenny')
</sql:update>
<sql:query var="rs" dataSource="${conn}">
SELECT * FROM test WHERE name=?
<sql:param>Meadow</sql:param>
</sql:query>
<c:forEach var="data" items="${rs.rows}">
<c:out value="${data['num']}" />
<c:out value="${data['name']}" />
<br>
</c:forEach>
</body>
</html>
Search the table with select * from test; , you will see the inserted data.
As we discussed, Model 2 consists of Java Servlet, EL(Expression Language), and JSTL(JSP Standard Tag Library). In this post, we will learn about JSTL.
JSLT, itself stands for JSP Standard Tag Library. So what do we need to do first?
Provide many functions that we can use to perform common operation, most of them are for String manipulation such as String Concatenation, Split String etc.
<%@ page language="java" contentType="text/html; charset=EUC-KR"
pageEncoding="EUC-KR"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<c:if test="true">
If the test value is "true", it always runs. <br>
</c:if>
<c:if test="${param.name == 'Meadow' }">
Hello ${param.name }, welcome! <br>
</c:if>
<c:if test="${param.age >= 18 }">
You are an adult! haha!<br>
</c:if>
choose tag
choose ~ when ~ otherwise tag is used when we process multiple conditions.
It is the same as switch ~ case ~ default in java.
If there is a condition that the value meets, it will execute the tag and stop execution.
<%@ page language="java" contentType="text/html; charset=EUC-KR"
pageEncoding="EUC-KR"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="EUC-KR">
<title>Insert title here</title>
</head>
<body>
<ul>
<c:choose>
<c:when test="${param.name == 'Meadow' }">
<li>Your name is ${param.name }.</li>
</c:when>
<c:when test="${param.bloodtype == 'O' }">
<li>Your bloodtype is O! People with type O blood less
susceptible to malaria.</li>
</c:when>
<c:when test="${param.bloodtype == 'A' }">
<li>Your bloodtype is A! People with type A blood are more
likely to develop stomach cancer.</li>
</c:when>
<c:when test="${param.bloodtype == 'AB' }">
<li>Your bloodtype is AB! People with type AB blood are much
more likely to develop cognitive issues.</li>
</c:when>
<c:when test="${param.bloodtype == 'B' }">
<li>Your bloodtype is B! About 9% of the population have B
positive blood.</li>
</c:when>
<c:otherwise>
<li>Your name is not Meadow, and there is no such bloodtype.
</li>
</c:otherwise>
</c:choose>
</ul>
</body>
</html
If I enter the name "Meadow", it will stop executing at the first condition since it meets the condition.
If I enter the other name and the blood type(O,A,AB, or B), it will execute that condition.
To develop with the Model2 MVC patterns, we need to know Java Servlet, EL(Expression Language), and JSTL(JSP Standard Tag Library), and we already covered the Java Servlet class in the last posts. If you want to go check out, please click the link below.
In this post, we will discuss Expression Language, which we use instead of Expression tags in the model2, we use Expression language. It looks different from the expression tags we have been using, but once we get used to it, it will be easier and simpler.
For example, param is used as${param.name} and sessionScope is used as${sessionScope.id}
For a better understanding, let us look through the examples.
Example 1
Arithmetic Operators
To print out the EL on the browser, you must use "\".
<TR>
<TD>\${2 + 5}</TD>
<TD>${2 + 5}</TD>
</TR>
To divide, you can use either "/" or "div" and the result will be the same. "mod" is to get the remainder.
<TR>
<TD>\${4/5}</TD>
<TD>${4/5}</TD>
</TR>
<TR>
<TD>\${5 div 6}</TD>
<TD>${5 div 6}</TD>
</TR>
<TR>
<TD>\${5 mod 7}</TD>
<TD>${5 mod 7}</TD>
</TR>
Comparison Operators
"<" is same as "gt"(greater) and ">" is same as "le"(less).
<%@ page contentType="text/html;charset=utf-8"%>
<% request.setCharacterEncoding("utf-8");%>
<HTML>
<HEAD>
<TITLE>EL Example2</TITLE>
</HEAD>
<BODY>
<H3>Processing parameter value</H3>
<P>
<FORM action="eLEx2.jsp" method="post">
Name : <input type="text" name="name" value="${param['name']}">
<input type="submit" value="Submit">
</FORM>
<P>
Hello <%=request.getParameter("name") %>, how are you today? <br>
Would you like to have a cup of tea, ${param.name}?
</BODY>
</HTML>
The followings bring the same result, but as you can see, EL is simpler than JSP expression tag.
You can also use ${param['name']}.
Hello <%=request.getParameter("name") %>, how are you today? <br>
Would you like to have a cup of tea, ${param.name}?
${param['name']}
There are several ELs that you can use simpler way.
Object
EL
JSP expression tag
param
${param.name}
<%=request.getParameter("name"%>
sessionScope
${sessionScope.id}
<%=session.getAttribute("id")%>
requestScope
${requestScope.page}
<%=request.getAttribute("page")%>
Example 3
Product.java
package jspbook;
public class Product {
// Products (Array)
private String[] productList = {"item1","item2","item3","item4","item5"};
// Variables
private int num1 = 10;
private int num2 = 20;
public int getNum1() {
return num1;
}
public int getNum2() {
return num2;
}
public String[] getProductList() {
return productList;
}
}
In the last post, we talked about the difference between Model1 and Model2.
To know more about Model2, we need to know Java Servlet, EL(Expression Language), and JSTL(JSP Standard Tag Library). First, let us discuss about Java Servlet Class.
Java Servlet Class Java Servlet Class means all the web programs that is written in Java language. This class can include the HTML, and JavaScript codes and it can print out the codes on the web browser right away.
To create the Java Servlet Class in Eclipse, Java EE has to be selected as a perspective.
In the new dynamic web project, in the src folder, create a new Servlet.
The class name and the file name will be the same. As you can see, its superclass is automatically designated as the HttpServlet class, so this class will be inherited as extends.
Since we don't need any constructors, we are ticking out the box, and we will leave others as they are.
Then, you will see this codes with doGet method and doPost method, as we checked the box.
So far, in JSP, what we do was Model1, and in this post, we will explore Model2.
The biggest difference between Model1 and Model2 is whether there is Servlet(Controller class) or not.
Here are the architectures of each model.
Source: OracleSource: Oracle
In Model1, we use only JSP, JSP, or Java Bean. It is relatively easy to learn and fast to develop.
However, it can be confusing on the JSP page since the presentation, and business logic are on one page. For this reason, it is sometimes hard to separate the developer's and the designer's work.
On the other hand, Model2 separates the roles of the application into model, view, and controller. It is certainly easy to maintain and expand the service and split the responsibility of each developer and the designer. However, as it is better arranged than Model1, the projects often take longer. Moreover, the programmers must understand the MVC(Model-View-Controller) structure.
So, what is MVC?
MVC is a development methodology that separates the application into three parts: Model, View, and Controller.
Model process the application's data by using the service and DAO class. View process the user interface, normally designers develop this part, consisting of EL(Expression Language) and JSTL(JSP Standard Tag Library). The controller adjusts the flow between the Model and View with the Java Servlet.
To know better about the MVC patterns, we first need to study Java Servlet, EL(Expression Language), and JSTL(JSP Standard Tag Library) and in the next posts, we will study more about them.
It would help if you had some place to store your data on any website or webpage. Even if you made a perfect website with JSP, unless you connect it to DB, it wouldn't have any function to store the users' information. So, It is essential to know how to connect the two sources.
There are three significant ways to connect JSP and Oracle: JDBC(Java DataBase Connectivity), DBCP(DataBase Connection Pool), and ORM(Object Relational Mapping) framework. iBatis, MyBatis, hibernate, and JPA are ORM frameworks. Among them, we will discuss JDBC first.
JDBC
JDBC Configuration
To connect to Oracle, you first need a JDBC Driver. Depending on the version set on your PC, I will download an ojdbc6.jar.
After then, we will test if the connection is successfully run or not. Oracle Smith account must be connected if you want to connect them successfully.
Now, to run the Oracle in Eclipse, we will make a folder named "sql" in the webcontent folder and create a new SQL file.
Open the Data Source Explorer and connect the Scott account to run the codes.
Now, let us look at the overall procedure of connecting the database to JSP.
1. Load JDBC Driver
Create a class.forName()
2. Connect Database
java.sql.Connection
3. Create SQLs
java.sql.Statement
java.sql.PreparedStatement - The most used
java.sql.CallableStatement
4. Send SQLs
executeQuery()
executeUpdate()
5. Receive result
java.sql.ResultSet
6. Disconnect
Connection.close()
To start connecting, we need first to create a table.
create table member1(
id varchar2(12) primary key,
passwd varchar2(12) not null,
name varchar2(10) not null,
reg_date timestamp not null );
select * from tab;
select * from member1;
Before, let us look at the JSP Model1 architecture.
JSP Model1 architecture
We already made a DTO class in Java, and that is JavaBean.
JavaBean is a component written in Java.
There are some things that you need to consider when you make a Javabean.
1. In JavaBean, the member variable is called property. 2. Property is a field for storing values created by declaring the access controller private. 3. Properties are used as intermediate data storage when the contents of the JSP page are stored in the DB or when the contents stored in the DB are printed on the JSP page. 4. set() method and get() method are used a lot in JavaBean, and they mainly use public access modifiers. 5. The Java Bean file's storage location should be in the WEB-INF/classes folder.
We will make a java file called "SimpleBean.java" in the src folder.
You can easily write generate getters and setters by right-clicking the mouse.
SimpleBean.java
// JavaBean, DTO Class(Data Transfer Object)
package javaBean;
public class SimpleBean {
private String msg; // Property
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
The <jsp:include>action tag includes other pages along with (<%@include file=heheader.jsp" %>). While the include directive simply contains text from a specific source, the <jsp:include> action tag includes the processing results of the page. You can include HTML, JSP, Servlet, and etc.
Let us look at the examples for a better understanding.
Both include directive tag and include action tag are similar in that they all include other pages, but the include directive tag contains only the text, whereas the include action tag contains the results of the page's processing.
Here is another example.
<Example 3>
includer.jsp
<%@ page contentType = "text/html; charset=euc-kr" %>
<html>
<head><title>include Directive</title></head>
<body>
<%
int number = 10;
%>
<%@ include file="includee.jspf" %>
Common Variable DATAFOLDER = "<%= dataFolder %>"
</body>
</html>
includee.jspf
The 'f' in jspf means 'fraction'.
<%@ page contentType = "text/html; charset=euc-kr" %>
Number saved in includer.jsp page: <%= number %>
<p>
<%
String dataFolder = "c:\\data";
%>
The error data should exceed 512 bytes. If the length of the error page is less than 512 bytes, Internet Explorer does not print the error page that this page prints It outputs its own 'HTTP error message' screen. To print the contents of an error page correctly in Internet Explorer, you need to include the same in responding to this comment.
So far, we have discussed the formal way of handling exceptions, but unless you have just several pages, you will need to use the latter way tohandle exceptions using error-page element en web.xml file.
Instead of the errorPage directive, the error page can be specified in the web.xml file of <error-page> tags.
The web.xml file has to be in WEB-INF folder. Anything you need, to handle the exceptions, you have to put in the web.xml file. Here is the web.xml file.
