enterprise java overview panos konstantinidis java developer jug leader & java champion
TRANSCRIPT
Enterprise Java Overview
Panos KonstantinidisJava Developer
JUG Leader & Java Championhttp://thejavablog.wordpress.com
Java Enterprise Edition
Introduction to JEE JEE architecture/technologies JEE Application Servers SOA – The next step Spring Framework.
Enterprise Systems
Enterprise Systems Large scale and complex systems n number or tiers Distributed Thousands of users Multithreading Thousands or millions of requests per hour Support for fail-over Support for transactions Support for security
Before JEE
Developer had to do everything Care about multithreading Care about transactions Care about fail-over Care about security ... on top of that care about the business logic
After JEE
Application Server/Container takes care of application details
Multithreading Security Fail-over etc.
Developer takes care of business logic
JEE Architecture
JEE architecture layers (image taken from http://www.itindepth.com/)
Servlets
Servlets Java objects that extend the functionality of a
web server Run on the server Require a servlet container to run in Platform and server independent They access all the Java APIs Having HTML/XML/WML code within a Java
class is ugly, error-prone and hard to maintain
JSP
JSP A simple and easy way to create dynamic web
content HTML/XML/WML/etc with Java code (scriplets)
embedded into it Runs on the server Platform and server independent Needs to be pre-compiled into a servlet
Servlets & JSP
They work together JSP used for presentation Servlets are used as controllers/implement
logic By separating logic from presentation
(design) it is easier to maintain, scale and build web applications
EJB
The cornerstone of a JEE application Server side components They enable fast and simplified
development of distributed, transactional, secure and portable enterprise applications
They are deployed into a container
EJB (continued)
Three types of EJB (Session, Entity, Message driven)
The container is responsible for Loading and initialising Transactions Persistence (activation/passivation and db
persistence) communication with clients via remote
interfaces JNDI for finding EJB instances
Session Beans
Perform actions on behalf of a particular client
Stateful Maintains conversational state with the client
Stateless Does not maintain state between client calls.
The container can substitute beans as necessary between method calls.
Entity Beans
Map data to a database row Provide abstraction layer so when working
with an entity the storage mechanism is not specific.
Container Managed The container persists the data to the db
automatically. Beans Managed
Developer writes code that persists data to the db and container calls these methods
Message Driven Beans
Receive asynchronous notifications from a JMS server
for example send a purchase order to a JMS queue
Client does not interact with them directly but only through message queues
Java Messaging Service
Software that provides service for messaging
Can be stand-alone or consolidated within an application server
JMS Queue Messages are sent into a queue and read from
the queue. One consumer only JMS Topic
Publish/subscribe mode. Messages are broadcast to all the consumers
JNDI
Java Naming and Directory Interface It is used to store and retrieve objects by
name Object have to register with a naming service
first Can interact with existing naming services
like LDAP
JTA
The Java Transaction API allows application servers to handle transactions
Developer declares the transaction properties
The application server takes care of the rest
Java Mail
The Java Mail API provides classes that model a mail system
Supports many common protocols IMAP POP SMTP MIME
JAAS
Java Authentication and Autorisation Service Authenticates users, makes sure users can log
into the system and execute Java code Authorises users, makes sure users have the
right permissions to perform the actions required Authentication modules include
Kerberos Keystore Windows NT
JDBC
Java Database Connectivity Lets developers access database from
Java Also provides access to other form of data
such as excel files There are drivers for all the known
databases
J2EE Connectors
Connectors provide a way to connect J2EE applications to heterogenous systems not written in Java (Siebel, SAP, etc)
System vendor provides the right connector
Application Servers
Take care of application-related functionality
Provide sophisticated means to handle multithreading/transactions/security/etc
Handle the life-cycle of the installed components
Usually cost thousands of pounds per CPU
Application Servers (continued)
All of application servers provide their own services (JMS, JNDI, servlet containers, etc)
Some application servers WebLogic WebSphere Oracle JBoss (free and open source, but you pay for
support) Glassfish (same)
Deployment
You deploy the application onto the application server in a form of EAR (Enterprise ARchive) file
EAR is nothing more than a zipped file that contains all relevant files needed.
It is expanded on deployment
Console
Application servers usually provide a console where the administrator or developer can manage the application
Deploy/undeploy applications Define JDBC resource Define users and roles etc
Web Services
Services residing somewhere on the web Web services enable application to
application interaction via the web Built on existing standards (SOAP over
HTTP) Web services are focused on messages
not APIs (we don't care what created the message)
Web Services (continued)
Interoperability between disparate systems You can access a .NET web service from a
Java client (the opposite is also true), etc Enable Service Oriented Architecture
(SOA) Traditional approach is based on objects, we
discover and use objects With SOA we discover and use services
Web Services protocol
Simple Object Access Protocol (SOAP) Transmission over existing HTTP protocol
In essence we send HTTP requests with the whole SOAP message in the body of the POST
XML based
WSDL
Web Services Description Language Describes a web service Describes methods and parameter types Describes return types How to access it (what port it's running on,
where it's running on) XML based
Complicated, use tools to generate the WSDL
UDDI
Universal Description, Discovery and Integration
It's a registry of services Publishes information about a web service
(similar to yellow pages) Publishes the access point of a web service
Spring
Aims behind Spring Enterprise Java should be easier. Interfaces are better than classes. JavaBeans better than EJBs. Testability is important and should be easier.
Spring (continued)
Small size (around 6MB). One core jar file (and a few more
dependencies). Spring manages life-cycle and
configuration of application objects. Dependency Injection
Objects are given their dependencies instead of creating/looking for them.
Spring gives dependencies upon instatiation.
Spring (continued)
Application data are configured through an XML configuration file.
Can be complicated and hard to maintain if there are too many beans configured.
Like JEE, developer is only concerned about business logic, Spring takes care of application related functionality.
Spring Modules
Spring contains several modules, each one can be used on its own.
Core and Context modules, the heart of the Spring framework. Provide fundamental functionality.
AOP module. JDBC module. ORM Module (hooks for other ORM
implementations). Web Module.
Spring Core Modules
Initialise all the application objects (JavaBeans) by reading the XML configuration file.
Supply enterprise services such as JNDI, multithreading, remote calls etc.
Provide support with integration with other frameworks (FreeMarker, iBatis etc).
Spring & AOP
Aspect – a general feature we want to apply globally to our application (e.g. logging or exception handling).
Aspects are declared through the XML configuration file.
Container executes the aspect after, before or around a method call.
Around can change the method behaviour.
Spring & JDBC
Provides functionality for JDBC. Database information (url, port etc) is
configured via the XML configuration file. Handles the creation of connections, result
sets, statements, pools etc. Closes the connection and returns it to the
pool of available connections.
Spring & Transactions
Declare transactions in the configuration file/class meta data by using annotations.
Can declare roll back behaviour per method or exception type.
You can't do that with EJBs, only programmatically.
No native support for distributed transactions. Only through JTA.
EJBs support distributed transactions by default.
Spring & Persistence
Doesn't support out of the box ORM solutions.
We need to integrate with existing technologies (Hibernate, TopLink etc). Spring provides the right plumbing to do so.
Alternatively use plain JDBC.
Spring & Web applications
Provides its own web framework (Spring MVC).
Typical MVC pattern with a central servlet acting as controller.
Spring supports several web-oriented tasks (multipart file uploading, session handling etc).
Can be integrated with other web frameworks like Struts, Tapestry, JSF.
Spring & Distributed computing
Remote calls to Spring ca be done via RMI (same as EJBs) JAX/RPC (for Web Services)
Spring & Security
Spring Security (formerly Acegi security) Supports declarative security via XML
configuration or class meta data annotations for security (EJBs also support declarative security via roles and users).
Spring & Deployment
Platform independent. A Spring application should run the same
on any other machine that supports Spring. Migration should be easy (just copy & paste
the application data & the XML configuration file).
Same with EJBs, although a bit tricky.
Learning more Enterprise Java - http://java.sun.com/javaee/ JEE compatible servers -
http://java.sun.com/products/servlet/industry.html JEE tutorial - http://java.sun.com/javaee/5/docs/tutorial/doc/ JDBC tutorial - http://java.sun.com/docs/books/tutorial/jdbc/basics/ JNDI - http://java.sun.com/products/jndi/tutorial/ Servlets tutorial -
http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/Servlets.html JMS - http://java.sun.com/products/jms/ Spring Framework - http://www.springframework.org/ Spring projects - http://www.springsource.org/projects WebLogic Server - http://www.bea.com WebSphere server - http://www.ibm.com/software/info/websphere/r JBoss Server - http://www.jboss.org/ Glassfish Server - https://glassfish.dev.java.net/
Questions?