tooling support for enterprise development · tooling support for enterprise development . ... in...
TRANSCRIPT
R YA N C U P R A K & R E Z A R A H M A N
TOOLING SUPPORT FOR ENTERPRISE DEVELOPMENT
JAVA EE DEVELOPMENT
• Java EE has had a bad reputation: • Too complicated • Long build times • Complicated/expensive tooling • Copious amounts of repetitive code • Expensive application servers • Overkill for most projects
• Times have changed since 2000! • Java EE 5 made great strides leveraging new features
introduced in Java 5. Java EE 6 pushes us forward. • Excellent tooling support combined with a simplification of
features makes Java EE development fast, easy, and clean (maintainable).
• It is Java EE – NOT J2EE!!!
OBJECTIVE
Challenge: Starting a new project is often painful. In this presentation you’ll learn: • How to setup a new Java EE project. • Disconnect between theory and practice. • Tools that you should consider learning/adding. • Best practices for Java EE development from tools
side.
When is the last time you evaluated your tools?
APPLICATION TYPES
Types of Java EE applications: • Prototype – verify technology, try different techniques,
learn new features. • Throw-away – application which has a short-life space,
temporary use. • Internal/external portal – application with a long life
expectancy and which will grow over time. • Minimize dependence on tools.
• Product – an application which deployed at a more than one customer site. Possibly multiple code branches. • Minimize dependence on tools.
Life expectancy drives tooling decisions.
PRELIMINARIES
Considerations for a Java EE toolbox: • Build system: Ant, Maven, IDE
specific? • Container: GlassFish/JBoss/
WebLogic/etc. • Technologies: EJB/JPA/CDI/JSF • IDE: Eclipse, NetBeans, IntelliJ IDEA • Other tools: Unit testing,
integration testing, UI testing, etc.
IDES
• NetBeans • Easy to use Java EE templates. • Includes a pre-configured GlassFish container. • Support for bleeding edge Java EE features.
• IntelliJ • Excellent editor support – auto-completion and analysis. • Support for complex project structures. • Support for a myriad of web technologies.
• Eclipse • Wide industry adoption. • External Java EE tools from JBoss. • External plugins – large ecosystem.
If exploring Java EE, start with NetBeans.
ADD-ON TOOLS
Beyond the IDE: • JBoss Tools – extends Eclipse’s Java EE capabilities. • JRebel – greatly speeds deployments so that you only swap in the code
that changes. http://zeroturnaround.com/ • Arquillian – integration testing – enables EJBs to be tested an in embedded
Java EE container (GlassFish/JBoss etc.). http://www.jboss.org/arquillian.html • Liquidbase – “version control” for database schemas – important for
applications that are going to grow over time. http://www.liquidbase.org
• JMeter – web application stress testing tool (http://jmeter.apache.org). • Hudson/Jenkins – continuous integration (http://hudson-ci.org). • Selenium – functional web UI testing (http://seleniumhq.org). • SOAP UI – testing SOAP/rest web services (http://www.soapui.org). • Monitoring Tools – NAGIOS/HP OpenView/IBM Tivoli/Oracle Enterprise
Management Tools • Profiling – NetBeans Profiler/Jprofiler/VisualVM/etc.
Impossible to cover everything.
BUILD SYSTEMS
Ant • Pro: • Infinitely flexible – write
once. • Integrated support with
most IDEs.
• Cons • No defined project
standard • Maintenance headache • IDE integration.
Maven • Pro • Standard project layout • Dependency management • Supported by all IDEs
• Cons • Steep learning curve • Harder to customize • Build cycle-time (lacks
incremental compilation)
BUILD SYSTEM
IDE • Pro • Fast build/deployment • GUI management
• Cons • Not portable • Continuous integration
support
Hybrid (bad idea): • Pro • Fast build times • Tool independence
• Cons • Twice the work
JAVA EE PACKAGING
Traditional EE: EJB-JAR (.jar)EAR (.ear)
META-INF
XML
ejb-jar.xml
XML
persistence.xml
XML
beans.xml
EJB 1
EJB 1
WAR (.war) WEB-INFXML
web.xml
index.xhtml
XML
application.xml
libdependency 1.jar
dependency 2.jar
SIMPLIFIED JAVA EE PACKAGING
Simplified EJB packaging (WAR):
Introduced in EJB 3.1
WEB-INFWAR (.war)
classes
XML
XML
beans.xml
EJB 2
EJB 1
XML
web.xmlindex.xhtml
XML
faces-config.xml
persistence.xml
login.xhtml
CONFIGURATION FILES
beans.xml web.xml
ejb-jar.xml
faces-config.xml persistence.xml
application.xml
PACKAGING & CONFIGURATION
Tooling challenge – how do you: • Create a new project scratch? • Import an existing project? • Create valid Java EE configuration files? • Edit Java EE configuration files? • Navigate Java EE features effectively? • Manage the evolution of a project and Java EE
technology changes?
IDES
• Leading Java IDEs: • NetBeans 7.2 • IntelliJ IDEA 11 • Eclipse Juno
• Is one IDE better than the others? • NO! Each has a unique set of features.
• What are the major differences: • Available project templates • Supported containers • Setup/external libraries • Ease of use
• Unique features: • NetBeans: Profiling, Hudson integration, CDI, HTML5, JavaFX, etc. • IDEA: Code inspection/completion, SOAP UI, Android, Flash/Flex, SQL/
JavaScript editor, etc. • Eclipse: BIRT, Perspectives, GWT, AspectJ, JBoss Tools, gigantic unique of
add-ons.
IDES
Key features to consider: • Project creation/management
(wizards) • Container integration (launching/
deploying/debugging) • Generating/checking configuration
files • Generating entities/CRUDs • Embedded libraries • JQL query code completion/
verification • EL code completion (CDI support) • CDI/JSF/JPA validation/error detection
IDEA
• JetBrains IDEA – two editions: • Community – core Java development (free) • Ultimate – support for enterprise technologies (purchase
$199 personal license/$99 academic) • Support for running in application servers. • CDI/JPA coding support etc.
• Ultimate edition needed for Java EE development.
IDEA
IDEA build system support: • Build system options with IDEA: • Maven – supported project type • IDEA specific
• IDEA uses its own build system by default. • Drawbacks: • Other developers must use IDEA to compile/package • Cannot integrate into continuous integration services such Hudson,
CruiseControl, etc. • Benefits: • Optimized for fast builds and incremental compiling • Tight integration with IDEA – complete management in UI.
• Options: • Create an Ant build file: Build | Generate Ant Build… • Create project using Maven • Create a Maven project using mvn idea:idea
IDEA
• Before creating a project: • Configure the application server you are going to be using. • Create data sources in IDEA for a database.
• Supported containers: • Apache Tomcat (4.0-7.0) • WebLogic (7.0-12.1.1) • WebSphere (5.1-8.0) • JBoss (4.2-7.0.2) • GlassFish (2-3) • Resin (3-4) • Jetty (6-8.1) • JSR45 Compatible server
• Container can be either local or remote
IDEA
• Important concepts: • Project – organizational unit that represents a complete
solution. It is composed of modules. • Module – discrete unit of functionality with can be compiled/
run/tested independently. (WAR/EJB JAR) • Facets – represents a framework/technology/language used in
a module. (CDI/JSF/JPA) • Two project formats: • Directory based: .idea • Configuration settings are stored in separate XML files (compiler.xml,
encoding.xml, etc.) • workspace.xml should not be stored in VCS.
• File based: • .ipr – project settings to be stored in VCS. • .iws – machine specific settings – do not put in VCS.
IDEA
• Java EE Projects: • No pre-defined Java EE templates. • Three starting points: • New project from scratch • Create from external model (Maven/Eclipse/Gradle) • Existing sources (ignores build file)
• Add facets/frameworks for Java EE features. • Configure artifacts to define Java EE packaging. • Create a Project and a Module.
IDEA
New Project Wizard
Pick Java Module
Configure technologies
Configure Facets
• Java • Web • Plugin • J2ME • Flash • Maven • Grails • Griffon • Android
• Web Application • Struts • JSF • Struts 2
• Application Server • EJB • Java EE Application • Java EE Persistence • Hibernate • SQL Support
Java EE Pertinent
Configure Artifacts
• JPA • CDI • EJB • GWT • JRebel • JSF • Seam • Struts • etc.
• WAR • EAR • JAR • Exploded
IDEA
DEMO
IDEA
Wizard Summary • Wizard creates a single module project. • Project uses the technologies that you selected. • Downloads Java EE dependencies. Important • Additional modules can be created after the
project is created. • Don’t select all of the technologies if creating an EAR!!
• Wizard does not create a “EAR” project with multiple modules.
IDEA
What have we accomplished? • Created a new IDEA project from scratch. • Single enterprise web module • Downloaded and configured CDI. • Added facets for CDI, JPA, and EJB. • Deployed the application to GlassFish. Challenges: • Container installation performed separately. • Libraries had to be downloaded separately. • Config files must be created separately. • Required project setup post configuration.
NETBEANS
• Excellent support for Java EE. • Java EE support is not a separate download (features
can be activated). • 3 Java web templates: • Web Application – supports CDI/EJB (simplified project) • Web Application with Existing Sources • Web Free Form Application
• 6 Java EE templates: • Enterprise Application • Enterprise Application with Existing Sources • EJB Module • EJB Module with Existing Sources • Enterprise Application Client • Enterprise Application Client with Existing Sources
NETBEANS
• Full support for Java EE 6 • Integrated IDE support for CDI • Service integration/monitoring: • Database editor • Container integration: • Tomcat • GlassFish • JBoss • WebLogic
• JPA support • Web Services (consume/produce) • JSF support • Integration with Hudson
NETBEANS
NetBeans Java EE File Templates
NETBEANS
Service integration:
Deployed application
Deployed web services
Hudson servers
JDBC Resources
GlassFish Server
NETBEANS
• NetBeans doesn’t have the concept of ‘modules’. • “Modules” concept from IntelliJ/Maven are represented as
separate NetBeans projects.
• Projects can depend upon other projects. • Dependencies are not exported! • Project must produce an artifact.
• Projects types: • Standard projects – use NetBeans generated Ant build file. • Maven projects – use Maven natively. • Free-form projects – delegate to custom Ant file.
• Ant/Maven native projects – no custom build system.
NETBEANS
Choosing a project template:
Existing project?
Existing build?
Ant or Maven?
Java Free Form Project
Java project with existing
sources
Java project template
Maven project
template
Yes No
Yes No ANT Maven
IDEA
DEMO
NETBEANS
Output:
ctjava.ear
Ctjava-ejb.jar
Ctjava-war.jar
NETBEANS
Customizing Ant build:
NETBEANS
NetBeans specific files: • .nbproject contains project related settings. • .nbproject/private contains local settings that
should not be checked in VCS. • build.xml contains is the modifiable Ant build file. • build-impl.xml should never be edited, changes/
overrides belong in build.xml.
NETBEANS
Differences between IntelliJ and NetBeans: • Many pre-defined project templates to simplify
initial project creation. • No need to download a CDI implementation. • Still must create a beans.xml configuration file to use CDI.
• GlassFish comes pre-packaged with NetBeans and pre-configured. • Smaller subset of supported containers. • NetBeans has numerous templates to simplify basic
tasks. • Integrated support for Ant.
ECLIPSE
• Eclipse IDE for Java EE provides numerous Java EE templates and plug-ins. • Java EE Projects: • Application Client Project • Connector Project • Enterprise Application Project • Utility Project • EJB Project • JPA Project
ECLIPSE
• JBoss Tools – invaluable collection of tools. • Available through MarketPlace or directly:
http://www.jboss.org/tools • Greatly expands Eclipse’s baseline Java EE support: • Maven/git • CDI • Templates and wizards for EJB, Web Services (SOAP/REST),
JSF configuration, SEAM, etc.
• Tools are a necessity for Java EE developers using Eclipse.
ECLIPSE
DEMO
MAVEN
• Maven is much more than a build tool. • Provides a standard layout to projects. • Dependency management.
• Supported as a project type by all IDEs: • Seamless support (no need for a plugin): • NetBeans • IntelliJ IDEA
• Plugin required (provided by JBoss tools): • Eclipse
• Maven is IDE independent – can move between IDEs easily.
MAVEN
• Pre-configured archetypes in NetBeans & Eclipse.
MAVEN
Create Java EAR project: mvn archetype:generate
-DgroupId=org.ctjava
-DartifactId=portal
-DarchetypeArtifactId=jboss-javaee6-ear-webapp
-DarchetypeGroupId=org.jboss.spec.archetypes
portal
portal-ear portal-ejb portal-web
MAVEN
IDE support: • IDEA: • Built-in support for Maven • Open existing Maven project – no support for creating a
new Maven Java EE project.
• NetBeans: • Built-in support for Maven. • Open existing Maven projects. • Create new Java EE Maven projects using wizards.
• Eclipse: • No Maven support-out of the box. • Download JBoss tools for Maven support
ARQUILLIAN
Basics • JBoss Arquillian automates in-container testing. • EJB and CDI code can be tested – code that uses
JPA, invokes EJBs, etc. • Integration tests are run inside of a container such
as GlassFish, JBoss. • Integrates with Selenium available. • Can perform regression performance tests. • Less painful when using Maven.
ARQUILLIAN
Maven configuration:
ARQUILLIAN
• Supporting artifacts: • arquillian.xml – specifies domain.xml for GlassFish. • domain.xml – custom GlassFish configuration file. • web.xml – custom web app configuration file.
ARQUILLIAN
LIQUIBASE
Database Schema Versioning • JPA handles object relational mapping but how are the
database schema being managed? • Could you replicate the current database schema in
production? • Could you recreate a database schema required for a specific
code tag? • How do you “upgrade” a database schema to a new version?
Liquibase • Tool for tracking and managing database changes. • Open source project. • http://www.liquibase.org • Command line tool • Changes tracked in a change log, store in EAR/WAR.
LIQUIBASE
changelog.xml tracks database operations.
LIQUIBASE
Changes are tracked in the database.
SUMMARY
• Explorations and Java EE prototypes: • Use NetBeans to explore Java EE and create new projects.
• Large projects: • Use Maven as the build system. • Dependency management. • Standard project layout. • Profiles to build sub-systems. • IDE independence – mix and match IDEs for different features.
• Modularize the system into manageable chunks. • Use Arquillian for integration testing – unit testing isn’t enough
for large applications. • Use JRebel to reduce deployment times. • Use Liquibase to manage database changes.
• Invest in tooling! • Don’t forget there is NetBeans Certification!
Re-evaluate your tools regularly!
Q&A