Java EE web project introduction

Contents
● Java EE project setup
● Introduction to Maven
● Web application structure
● JSF basics
● CDI basics
● GIT overview (optional)

Java EE project setup in Eclipse
Prerequisites:
● Eclipse Luna
● WildFly application server
● Maven support in Eclipse - m2eclipse
● Git support in Eclipse eGIT
● JBoss Tools for Eclipse
● Download prepared sources from GitHub

Java EE project setup in Netbeans
Prerequisites:
● Netbeans 7 or 8
● Glassfish application server
● Download prepared sources from GitHub

DEMO
Presentation of the demo application in IDE
and running on app server

Introduction to Maven
● project build and configuration tool
● it can:
o execute build tasks using command line
o automatically download necessary libriaries
(dependencies)
o configure project independently from IDE

Introduction to Maven - artifacts
Artifacts are files produced by a maven build.
They are specified by:
● groupId
● artifactId
● version
● packaging - JAR, WAR, EJB, EAR, POM, ...
An artifact can be dependency of another module

Maven - goals and phases
To execute maven build: > mvn goal
Goal can be a name of phase that we want to complete. All phases before that
phase are completed in order.
The order of basic maven phases:
compile, test, package, integration-test, install
Steps to complete each phase may differ between module
types (packging)

Maven - dependencies
Specified by: groupId, artifactId, version, type
(jar is default type)
Scope of a dependency:
● compile (default)
● test - only used when running unit tests
● provided - not included in artifact

DEMO
Example of Maven pom.xml.
Example of running maven in IDE.

Java EE Web application
In simplest for a single WAR file.
● WEB-INF folder
o web.xml
o faces-config.xml
o optionally beans.xml for CDI
o classes folder with compiled java classes
● web resources in root folder
o JSF facelets, css, images, etc.

WAR Maven module
Single module of type WAR
● pom.xml specifies:
o packaging WAR
o dependency on javaee-api (scope=provided)
● src/main/java - java sources
● src/main/webapp - Web resources
● src/main/resources - classpath resources

JSF overview
● run by FacesServlet mapped in web.xml
● configured by faces-config.xml and contex
parameters in web.xml
● FacesServlet executes several phases in
MVC style
o Request -> Execute code in Java Bean -> Create
view from Facelet -> Response

JSF lifecycle
● Restore view phase
● Apply request values phase; process events
● Process validations phase; process events
● Update model values phase; process events
● Invoke application phase; process events
● Render response phase

JSF component tree
● logical tree of UI components
● created from a definition in facelet
● encoded to xhtml at the end of the request
o to bring new state of the view to browser (new page)
● recreated at the begining of the request
o to represent the current state of the view before
request is processed

JSF Facelets
● XHTML based templates for a web page
● define components in a component tree
● specify binding to Java code
o data
o conditional rendering
o controller methods / listeners

JSF Managed Beans
● provide controller methods and data model
for facelets
● bound to component properties using
Expression Language
● identified in facelets by textual name
● marked by @Named CDI qualifier

Expression language
EL is a script used in facelets to bind values to
component properties
● Results in a value - primitive values, object,
even a method pointer
● Fields are converted to getters and setters
● Never throws a Null Pointer -> blank value
instead

Usage of Expression language
● enclosed in #{ ... }
● do not mix with ${ … } used in JSP
o JSP and JSTL tags should not be mixed with JSF
● in facelet: rendered="#{ bookView.displayed }
● in BookView bean:
@Named class BookView {
public boolean isDisplayed() { return true; }
}

Basic components - display
● h:outputText - textual output in <span>
● h:outputLabel - <label>
● h:outputLink - <a href…>
● h:messages - display of JSF messages
● h:graphicImage - <img>
● h:dataTable - table for collection of rows

Basic components - layout
● h:panelGroup - container - <span> or <div>
● h:panelGrid - grid layout container (table)

Basic components - Forms
● h:inputText
● h:inputTextarea
● h:selectManyListbox, h:selectOneMenu, etc.
- selection components, listboxes,
checkboxes
● h:form - all input components must be in
some form to function

Basic components - actions
● All action components submit form and call
action on web server via javascript
● They accept link to a listener method
● h:commandButton
● h:commandLink

Contexts & Dependency Injection
● Injection: instead of myVar = Factory.getVar()
or myVar = new Var() declare that I need Var
● @Inject Var myVar
● instance of Var is created by the container
● works only in container managed beans
o JSF beans, Servlets, EJBs, all injected beans -
generally Java objects created by the container

Dependency injection rules
● never use “new” on a bean with a CDI
dependency
● all injected beans must have constructor
without parameters
● do not put initialization to constructor but to
method marked with @PostConstruct

Lifecycle of injected beans
● when bean created
o constructor is executed first
o then are dependencies injected
o method marked with @PostConstruct is called
● during injection, beans are either created or
reused
o it depends on current context of execution and
scope of injected bean

Basic scopes
● Dependent (default)
o a new bean is always created for injection
o similar to calling constructor directly
● Application scope
o single bean is created for whole application
o the same bean is reused afterwards, retaining its
complete state
o singleton pattern

Basic Java EE scopes
Most scopes are bound to a lifecycle of a
specific action
● Request scope
o bound to lifecycle of HTTP request
o within HTTP request, only single instance of request
scoped bean is created and reused
● Session scope
o bound to lifecycle of HTTP session

Java EE scope annotations
package javax.enterprise.context:
● Dependent (optional)
● ApplicationScoped
● RequestScoped
● SessionScoped
Only single instance of Java object with defined scope is created and
reused for single application, request, session

Dependency declaration
● inject by class
o inject instance of the class or its subclass
● inject by interface
o inject instance of java class with given interface
● inject by qualifier
o inject instance with given qualifier
o qualifier is a java annotation marked with @Qualifier
For one injection point, one class should match

Runtime / conditional injection
@Inject Instance<Var> myVarInjector;
…
myVar = myVarInjector.get();
● matching bean is resolved when necessary
● can be injected directly when needed
● resolution errors can be treted at runtime

Creating new CDI beans
● possible to create a completely new CDI
bean regardless of context
● @New annotation overrides bean scope
● can be used instead of new keyword:
@Inject @New Instance<Var> varInjector;
...Var myVar1 = varInjector.get();
...Var myVar2 = varInjector.get();

Producers
● CDI usually creates new beans via
constructor without parameters
● Producers allow to customize creation
● instead of a class, a method of a producer is
marked with annotations and scope
o this method returns created bean of matching type
o it is called when bean with the same definition is
requested

Producers - example
class MyVarProducer {
@Produces @RequestScoped
public Var createVar(@New Var var) {
var.setState("NEW");
return var;
}
}

Introduction to GIT
GIT is a source code version control system.
It is a distributed version control system.
● multiple repositories can be interconnected
and synchronized

GIT repository
● single instance of storage of versioned files
● stores latest version of files, history of
changes, metadata (commit messages), and
connection to other upstream repositories
● repositories are organized in a tree
o from upstream repositories to downstream

Simplest GIT topology
● Central GIT repository - accesible via public
link
o local GIT repository
● Local repositories exist only on local
computers
o they are created from central using clone command

2-step synchronisation
● clone - downloads new copy of repository
● edit files
o add (add new files if created)
o edited and removed files are already handled
● commit - save changes locally (checkpoint)
● pull - download changes from central repo
o merge and resolve conflicting changes
o commit if files changed
● push - upload locally commited changes

Java EE web project introduction

Recommended

More Related Content

What's hot (20)

Viewers also liked (7)

Similar to Java EE web project introduction (20)

More from Ondrej Mihályi (12)

Recently uploaded (20)

Java EE web project introduction

Editor's Notes