J2ee

1
By Shaharyar Khan
shaharyar.khan555@gmail.com

 Before going to understand that what is J2EE, first We should
look into that what is Enterprise level
 We can say that
“When our application is composed of n-tier(mostly 3-
tier) , this will be Enterprise application”
2
So
“Implementation Provided By JAVA for the handling
enterprise level can be called J2EE”

 The J2EE platform provides an API and runtime
environment for developing and running enterprise
software, including
 network Services
 web services
 other large-scale multi-tiered services &
network applications
 As well as scalable, reliable, and secure
network applications
3
 Java EE extends the Java Platform, Standard Edition (Java
SE), providing an API for object-relational mapping,
distributed and multi-tier architectures, and web services

 Software for Java EE is primarily developed in the Java
programming language and uses XML for configuration.
 The platform was known as Java 2 Platform, Enterprise Edition
or J2EE until the name was changed to Java EE in version 5.
The current version is called Java EE 6.
4shaharyar.khan555@gmail.com

 The J2EE platform uses a multitier distributed application model. This
means application logic is divided into components according to
function, and the various application components that make up a
J2EE application are installed on different machines depending on
which tier in the multitier JEE environment the application
component belongs.
6

 JEE applications are made up of components
Application clients and applets are client
components.
Java Servlet and JavaServer Pages (JSP) technology
components are web components.
Enterprise JavaBeans (EJB) components (enterprise
beans) are business components.

 A J2EE application can be web-based or non-web-based. An
application client executes on the client machine for a non-
web-based J2EE application, and a web browser downloads
web pages and applets to the client machine for a web-based
J2EE application.
8

 J2EE web components can be either JSP pages or servlets
 Servlets are Java programming language classes that
dynamically process requests and construct responses
 JSP pages are text-based documents that contain static
content and snippets of Java programming language code to
generate dynamic content
9

10
 Business code, which is logic that solves or meets the needs
of a particular business domain such as banking, retail, or
finance, is handled by enterprise beans running in the
business tier
 There are three kinds of enterprise beans:
 session beans
 entity beans
 message-driven beans

 Component are installed in their containers during
deployment and are the interface between a component and
the low-level platform-specific functionality that supports
the component
 Before a web, enterprise bean, or application client
component can be executed, it must be assembled into a J2EE
application and deployed into its container.

 An Enterprise JavaBeans (EJB) container manages the execution of all
enterprise beans for one J2EE application. Enterprise beans and their
container run on the J2EE server.
 A web container manages the execution of all JSP page and servlet
components for one J2EE application. Web components and their
container run on the J2EE server.
 An application client container manages the execution of all application
client components for one J2EE application. Application clients and their
container run on the client machine.
 An applet container is the web browser and Java Plug-in combination
running on the client machine.They are also part of client machine

 J2EE ( Java 2 -Enterprise Edition) is a basket of 12 inter-
related technologies , which can be grouped as follows for
convenience.:
16
Group-1 (Web-Server & support Technologies )
=====================================
1) JDBC   ( Java Database Connectivity)
2) Servlets
3) JSP   (Java Server Pages)
4) Java Mail
_____________________________________________
Group-2   ( Distributed-Objects Technologies)
=====================================
5) RMI (Remote Method Invocation)
  6) Corba-IDL   ( Corba-using Java with OMG-IDL)
7) RMI-IIOP   (Corba in Java without OMG-IDL)
8) EJB   (Enterprise Java Beans)
________________________________________________

Group-3 ( Supporting & Advanced Enterprise technologies)
=============================================
9) JNDI   ( Java Naming & Directory Interfaces)
   10) JMS   ( Java Messaging Service)
   11) JAVA-XML ( such as JAXP, JAXM, JAXR, JAX-RPC, JAXB, and XML-WEB
SERVICE)
   12) Connectors ( for ERP and Legacy systems).
Now we will cover some important technologies from these.

 We all know about network sockets very well , their purpose
and usage
 Let us see the difference in implementation of sockets among
the c# and JAVA
 Steps are same
 Open a socket.
 Open an input stream and output stream to the socket.
 Read from and write to the stream according to the server's
protocol.
 Close the streams.
 Close the socket.

19
 In c# (client Socket)
 System.Net.Sockets.TcpClient clientSocket = new
System.Net.Sockets.TcpClient();
And after then we will connect to specific server
 clientSocket.Connect("127.0.0.1", 8888);
 In JAVA(client Socket)
 Socket client = new Socket(("127.0.0.1", 8888);
Only in this line we can create socket as well as connect to the server

20
 In c # (Server Socket)
 TcpListener serverSocket = new TcpListener(8888);
And after then we will connect to specific server
 serverSocket.Start();
 In JAVA(Server Socket)
 serverSocket = new ServerSocket(8888);
This will acccept the connection from the client
 Socket server = serverSocket.accept();

21
import java.net.*;
import java.io.*;
public class GreetingClient {
public static void main(String [] args) {
String serverName = args[0];
int port = Integer.parseInt(args[1]);
try {
System.out.println("Connecting to " + serverName + " on port
" + port);
Socket client = new Socket(serverName, port);
System.out.println("Just connected to " +
client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);
out.writeUTF("Hello from " + client.getLocalSocketAddress());
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);
System.out.println("Server says " + in.readUTF());
client.close();
}catch(IOException e) {
e.printStackTrace();
}
}
}

22
import java.net.*;
import java.io.*;
public class GreetingServer extends Thread {
private ServerSocket serverSocket;
public GreetingServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(10000); }
public void run() {
while(true) {
try{
System.out.println("Waiting for client on port " +
serverSocket.getLocalPort() + "...");
Socket server = serverSocket.accept();
System.out.println("Just connected to “
+server.getRemoteSocketAddress());
DataInputStream in = new
DataInputStream(server.getInputStream());
System.out.println(in.readUTF());
DataOutputStream out = new
DataOutputStream(server.getOutputStream());
out.writeUTF("Thank you for connecting to " +
server.getLocalSocketAddress() + "nGoodbye!");
server.close();
}catch(SocketTimeoutException s) {
System.out.println("Socket timed out!");
break;
e.printStackTrace(); break;
}
}
}

public static void main(String [] args) {
int port = Integer.parseInt(args[0]);
try {
Thread t = new GreetingServer(port);
t.start();
}
}
}

24
Java Database Connectivity or JDBC for short is set of Java
API's that enables the developers to create platform and
database independent applications in java.
Connect to any database through java is very simple and
requires only few steps
Import the packages . Requires that you include the packages
containing the JDBC classes needed for
database programming. Most often, using
import java.sql.* will suffice.
Register the JDBC driver . Requires that you initialize a driver so
you can open a communications
channel with the database.
Open a connection . Requires using the
DriverManager.getConnection() method to
create a Connection object, which represents a
physical connection with the database.

25
Execute a query . Requires using an object of type Statement for
building and submitting an SQL statement to the database.
Extract data from result set . Requires that you use the
appropriate ResultSet.getAnyThing() method to retrieve the data
from the result set.
Clean up the environment . Requires explicitly closing all
database resources versus relying on the JVM's garbage
collection.

26
import java.sql.*;
public class InsertValues{
public static void main(String[] args) {
System.out.println("Inserting values in Mysql database table!");
Connection con = null;
String url = "jdbc:mysql://localhost:3306/";
String db = “deltaDB";
String driver = "com.mysql.jdbc.Driver";
try{
Class.forName(driver);
con = DriverManager.getConnection(url+db,"root","root");
try{
Statement st = con.createStatement();
int val = st.executeUpdate("INSERT employee
VALUES("+13+","+"‘shaharyar'"+")");
System.out.println("1 row affected");
}catch (SQLException s){
System.out.println("SQL statement is not
executed!");
}
}catch (Exception e){
}
}
}

27
Oracle  oracle.jdbc.driver.OracleDriver
MSSQL  com.microsoft.sqlserver.jdbc.SQLServerDriver
Postgres  org.postgresql.Driver
MS access  sun.jdbc.odbc.JdbcOdbcDriver
DB2  COM.ibm.db2.jdbc.app.DB2Driver

31
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import javax.servlet.*;
import javax.servlet.http.*;
public class TestServlet extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws IOException, ServletException {
res.setContentType("text/html");
PrintWriter out = res.getWriter(); /* Display some response to
the user */
out.println("<html><head>");
out.println("<title>TestServlet</title>");
out.println("t<style>body { font-family:
'Lucida Grande', " + "'Lucida Sans Unicode';font-
size: 13px; }</style>");
out.println("</head>");
out.println("<body>"); out.println("<p>Current Date/Time: " +
new Date().toString() + "</p>");
out.println("</body></html>"); out.close();
}
} shaharyar.khan555@gmail.com

32
Object Class
application javax.servlet.ServletContext
config javax.servlet.ServletConfig
exception java.lang.Throwable
out javax.servlet.jsp.JspWriter
page java.lang.Object
PageContext javax.servlet.jsp.PageContext
request javax.servlet.ServletRequest
response javax.servlet.ServletResponse
session javax.servlet.http.HttpSession

33
Sessions are very easy to build and track in java servlets.
We can create a session like this
And easily we can get its value on anyother servlet
param = (Integer) session.getAttribute(“name");

34
Cookies are also very simple to build and track in java servlets like sessions.
We can create a cookies like this
And easily we can get its value on anyother servlet
String cookieName = "username";
Cookie cookies [] = request.getCookies ();
Cookie myCookie = null;
if (cookies != null)
{
for (int i = 0; i < cookies.length; i++)
{
if (cookies [i].getName().equals (cookieName))
{
myCookie = cookies[i];
break;
}
}
}

35
 With servlets, it is easy to
Read form data
Read HTTP request headers
Set HTTP status codes and response headers
Use cookies and session tracking
Share data among servlets
Remember data between requests
Get fun, high-paying jobs
But, it sure is a pain to
Use those println statements to generate HTML
Maintain that HTML

36
 Functionality and life cycle of JSP and servlet are exactly
same.
 A JSP page , after loading first convert into a servlet.
 The only benefit ,which is surly very much effective is that a
programmer can be get rid of hectic coding of servlets
 A designer can eaisly design in JSP without knowledge of
JAVA

37
 All code is in Tags as JSP is a scripting language.
 Tags of JSPs are given below
Directives
In the directives we can import packages, define error handling
pages or the session information of the JSP page
Declarations
This tag is used for defining the functions and variables to be used
in the JSP
Scriplets
In this tag we can insert any amount of valid java code and these
codes are placed in _jspService method by the JSP engine
Expressions
We can use this tag to output any data on the generated page.
These data are automatically converted to string and printed on
the output stream.

38
 Action Tag:
Action tag is used to transfer the control between pages and
is also used to enable the use of server side JavaBeans.
Instead of using Java code, the programmer uses special JSP
action tags to either link to a Java Bean set its properties, or
get its properties.

39
 Syntax of JSP directives is:
<%@directive attribute="value" %>
Where directive may be:
 page: page is used to provide the information about it.
Example: <%@page import="java.util.*, java.lang.*" %>

 include: include is used to include a file in the JSP page.
Example: <%@ include file="/header.jsp" %>

 taglib: taglib is used to use the custom tags in the JSP pages (custom tags
allows us to defined our own tags).
Example: <%@ taglib uri="tlds/taglib.tld" prefix="mytag" %>


42
 Syntax of JSP Declaratives are:
<%!
//java codes
%>
JSP Declaratives begins with <%! and ends %> with .We can
embed any amount of java code in the JSP Declaratives. Variables
and functions defined in the declaratives are class level and can be
used anywhere in the JSP page.


44
Syntax of JSP Expressions are:

<%="Any thing" %>
JSP Expressions start with
Syntax of JSP Scriptles are with <%= and ends with %>. Between
these this you can put anything and that will converted to the
String and that will be displayed.
Example:
<%="Hello World!" %>
Above code will display 'Hello World!'.

45
These are the most commonly used action tags are :
include
forward
param
useBean
setProperty
getProperty
Let discuss some tags among these ….

46
Include directive:
<%@ include file= "index.jsp" %>
Include Action
<jsp: include page= "index.jsp
Forward Tag:
<jsp:forward page= "Header.html"/>
Pram Tag:
<jsp:param name="result" value="<%=result%>"/>

47
Everywhere, in any programming language , it is
recommended that apply best programming practices.
In JAVA, a java programmer always prefer to apply
design patterns while coding.
Design Patterns are specific type of coding styles that
should use in specific scenarios.
Let Discuss some basic Design Patterns that we should
use

48
The Singleton design pattern ensures that only one
instance of a class is created.
it provides a global point of access to the object and allow
multiple instances in the future without affecting a
singleton class's clients
To ensure that only one instance of a class is created we
make SingletonPattern’s instance as static
Let Discuss some basic Design Patterns that we should
use

49
class SingletonClass{
private static SingletonClass instance;
private SingletonClass(){
}
public static synchronized SingletonClass getInstance(){
if(instance == null)
instance = new SingletonClass();
return instance;
}
}

50
class MyClass{
public static void main(String[] args) {
SingletonClass sp = SingletonClass.getInstance();
System.out.println("first Instance: "+sp.toString());
SingletonClass sp1 = SingletonClass.getInstance();
System.out.println("2nd Instance: "+sp1.toString());
}
}
You will see in output that both references will be
same

51
 Factory pattern comes into creational design pattern category
 the main objective of the creational pattern is to instantiate an object
and in Factory Pattern an interface is responsible for creating the
object but the sub classes decides which class to instantiate
 The Factory patterns can be used in following cases:
1. When a class does not know which class of objects it must
create.
2. A class specifies its sub-classes to specify which objects to
create.
3. In programmer’s language (very raw form), you can use
factory pattern where you have to create an object of any one of
sub-classes depending on the data provided.

52
public class Person {
// name string
public String name;
// gender : M or F
private String gender;
public String
getName() {
return name;
}
public String
getGender() {
return gender;
}
}// End of class

53
public class Male extends Person {
public Male(String fullName)
{
System.out.println("Hello Mr.
"+fullName);
}
}// End of class
public class Female extends Person {
public Female(String fullNname) {
System.out.println("Hello Ms.
"+fullNname);
}
}// End of class

54
public class SalutationFactory {
public static void main(String args[]) {
SalutationFactory factory = new
SalutationFactory();
Person p =
factory.getPerson(“Shaharyar”,”M”);
}
public Person getPerson(String name, String
gender) {
if (gender.equals("M"))
return new Male(name);
else if(gender.equals("F"))
return new Female(name);
else
return null;
}
}// End of class

55
To keep things simple you can understand it like, you have a
set of ‘related’ factory method design pattern. Then you will
put all those set of simple factories inside a factory pattern
In abstract factory , We create a interface instead of class and
then use it for the creation of objects
Simply , When we have a lot of place to apply factory method
then we combine all of them in a interface and use them
according to our needs

56
Facade as the name suggests means the face of the building.
The people walking past the road can only see this glass face
of the building. They do not know anything about it, the
wiring, the pipes and other complexities. The face hides all the
complexities of the building and displays a friendly face.
hides the complexities of the system and provides an interface
to the client from where the client can access the system
In Java, the interface JDBC can be called a facade. We as users
or clients create connection using the “java.sql.Connection”
interface, the implementation of which we are not concerned
about. The implementation is left to the vendor of driver.

J2ee

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to J2ee

Similar to J2ee (20)

Recently uploaded

Recently uploaded (20)

J2ee

Editor's Notes