Tooling Support for Enterprise Development

TOOLING SUPPORT FOR ENTERPRISE DEVELOPMENT

RYAN CUPRAK & REZA RAHMAN 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 Maven • Pro: • Pro • Infinitely flexible – write • Standard project layout once. • Dependency management • Integrated support with • Supported by all IDEs most IDEs. • Cons • Cons • Steep learning curve • No defined project • Harder to customize standard • Build cycle-time (lacks • Maintenance headache incremental compilation) • IDE integration.

BUILD SYSTEM

IDE Hybrid (bad idea): • Pro • Pro • Fast build/deployment • Fast build times • GUI management • Tool independence • Cons • Cons • Not portable • Twice the work • Continuous integration support JAVA EE PACKAGING

Traditional EE: XML META-INF ejb-jar.xml EAR (.ear) EJB-JAR (.jar)

XML XML

application.xml EJB 1 persistence.xml

XML

EJB 1 beans.xml

XML WEB-INF WAR (.war) web.xml

lib index.xhtml dependency 1.jar

dependency 2.jar SIMPLIFIED JAVA EE PACKAGING

Simplified EJB packaging (WAR):

WEB-INF classes WAR (.war) EJB 1

XML

index.xhtml web.xml EJB 2

XML

faces-conﬁg.xml

XML

persistence.xml Introduced in EJB 3.1 CONFIGURATION FILES

beans.xml web.xml ejb-jar.xml application.xml persistence.xml faces-config.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 Configure Configure Configure Module technologies Facets Artifacts

Java EE Pertinent • Java • JPA • WAR • Web • Web Application • CDI • EAR • Plugin • Struts • EJB • JAR • J2ME • JSF • GWT • Exploded • Flash • Struts 2 • JRebel • Maven • Application Server • JSF • Grails • EJB • Seam • Griffon • Java EE Application • Struts • Android • Java EE Persistence • etc. • Hibernate • SQL Support 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:

GlassFish Server

Deployed application

JDBC Resources

Deployed web services

Hudson servers 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?

Yes No Existing Ant or build? Maven?

Yes No ANT Maven

Java project Maven Java Free Java project with existing project Form Project template sources template 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