J2ee
57
-
Upload
shaharyar-khan -
Category
Technology
-
view
961 -
download
0
description
This is a introductory lecture of J2EE for those who want to learn what is j2ee technology and about its basics.You can also fine coding exmples in this lecture
Transcript of J2ee
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.
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.
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.
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
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)________________________________________________shaharyar.khan555@gmail
.com
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;
}catch(IOException e) { e.printStackTrace(); break;
} } }
public static void main(String [] args) {
int port = Integer.parseInt(args[0]);try {
Thread t = new GreetingServer(port);
t.start(); }catch(IOException e) {
e.printStackTrace(); }
} }
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){
e.printStackTrace(); }
}}
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();
} }
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 toRead form dataRead HTTP request headersSet HTTP status codes and response headersUse cookies and session trackingShare data among servletsRemember data between requestsGet fun, high-paying jobs
But, it sure is a pain to
Use those println statements to generate HTML
Maintain that [email protected]
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
DirectivesIn the directives we can import packages, define error handling pages or the session information of the JSP page
DeclarationsThis tag is used for defining the functions and variables to be used in the JSP
ScripletsIn this tag we can insert any amount of valid java code and these codes are placed in _jspService method by the JSP engine
ExpressionsWe 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.shaharyar.khan555@gmail
.com
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 :
includeforwardparamuseBeansetPropertygetProperty
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. shaharyar.khan555@gmail
.com
52
public class Person {
// name stringpublic String name;// gender : M or Fprivate 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.shaharyar.khan555@gmail
.com
57
