A practical example of how to build real-world applications in Java and create a simple but useful front-end with basic HTML.

This Pet Catalog app explains a web application that uses JSF 2.0, Java EE 6, GlassFish and MySQL. I took this example GlassFish and MySQL, Part 2: Building a CRUD Web Application With Data Persistence and modified it to use some of the new features of JSF 2.0 and Java EE 6. Download the sample code Explanation of the usage of JSF 2.0 and Java EE 6 in a sample Store Catalog Application The image below shows the Catalog Listing page, which allows a user to page through a list of items in a store. JSF 2.0 Facelets XHTML instead of JSP For JSF 2.0, Facelets XHTML is the preferred way to declare JSF Web Pages. JSP is supported for backwards compatibility, but not all JSF 2.0 features will be available for views using JSP as their page declaration language. JSF 2.0 Facelets has some nice features like templating (similar in functionality to Tiles) and composite components, which I'm not going to discuss here but you can read about that in this article: http://www.ibm.com/developerworks/java/library/j-jsf2fu2/index.html and in this Tech Tip Composite UI Components in JSF 2.0. The Catalog application's resources JSF 2.0 standardizes how to define web resources. Resources are any artifacts that a component may need in order to be rendered properly -- images, CSS, or JavaScript files. With JSF 2.0 you put resources in a resources directory or a subdirectory. In your Facelets pages, you can access css files with the , javascript files with the , and images with the JSF tags. The list.xhtml uses the The Catalog application uses a resource bundle to contain the static text and error messages used by the Facelets pages. Putting messages in a resource bundle makes it easier to modify and internationalize your Application text. The messages are in a properties file in a java package directory. Title=Pet Catalog Next=Next Previous=Prev Name=Name The resource bundle is configured in the faces-config.xml File (you don't need any other configuration in the faces-config.xml for JSF 2.0, as explained later you no longer have to configure managed beans and navigation with XML). web.WebMessages msgs The List.xhtml facelets page uses a JSF dataTable component to display a list of catalog items in an html table. The dataTable component is useful when you want to show a set of results in a table. In a JavaServer Faces application, the UIData component (the superclass of dataTable) supports binding to a collection of data objects. It does the work of iterating over each record in the data source. The HTML dataTable renderer displays the data as an HTML table. In the list.xhtml web page the dataTable is defined as shown below: (Note: Red colors are for Java EE tags, annotations code, and Green is for my code or variables) The value attribute of a dataTable tag references the data to be included in the table. The var attribute specifies a name that is used by the components within the dataTable tag as an alias to the data referenced in the value attribute of dataTable. In the dataTable tag from the List.jsp page, the value attribute points to a list of catalog items. The var attribute points to a single item in that list. As the dataTable component iterates through the list, each reference to dataTableItem points to the current item in the list. JSF 2.0 Annotations instead of XML configuration The dataTable's value is bound to the items property of the catalog managed bean. With JSF 2.0 managed beans do not have to be configured in the faces-config.xml file, you annotate the managed beans instead as shown below: @ManagedBean @SessionScoped public class Catalog implements Serializable { By convention, the name of a managed bean is the same as the class name, with the first letter of the class name in lowercase. To specify a managed bean name you can use the name attribute of the ManagedBean annotation, like this: @ManagedBean(name = "Catalog"). This Catalog ManagedBean items property is defined as shown below: private List items = null; public List getItems() { if (items == null) { getPagingInfo(); items = getNextItems(pagingInfo.getBatchSize(), pagingInfo.getFirstItem()); } return items; } The getItems() method returns a List of item objects. The JSF dataTable, supports data binding to a collection of data objects. The dataTable object is modeled as a collection of row objects that can be accessed by a row index. The APIs provide mechanisms to position to a specified row index, and to retrieve an object that represents the data that corresponds to the current row index. The Item properties name, imagethumburl, and priceare displayed with the column component: The column tags represent columns of data in a dataTable component. While the dataTable component is iterating over the rows of data, it processes the UIColumn component associated with each column tag for each row in the table. The dataTable component iterates through the list of items (catalog.items) and displays the item (var="row") attribute value. Each time UIData iterates through the list of items, it renders one cell in each column. The dataTable and column tags use facet to represent parts of the table that are not repeated or updated. These include headers, footers, and captions. Java EE 6: JSF 2.0, EJB 3.1, and Java Persistence API (JPA) 2.0 The Catalog ManagedBean annotates the field private ItemFacade itemFacade; with @EJB , which causes an itemFacade EJB to be injected when the managed bean is instatiated. The Catalog getNextItems method calls the ItemFacade Stateless EJB which uses the Java Persistence API EntityManager Query object to return a list of items. @ManagedBean @SessionScoped public class Catalog implements Serializable { @EJB private ItemFacade itemFacade; public List getNextItems(int maxResults, int firstResult) { return itemFacade.findRange(maxResults, firstResult); } EJB 3.1 No-interface local client View With EJB 3.1, local EJBs do not have to a implement separate interface, that is, all public methods of the bean class are automatically exposed to the caller. Simplified Packaging With Java EE 6, EJBs can be directly packaged in a WAR file just like web components. The ItemFacade EJB uses the Java Persistence API EntityManager Query object to return a list of items. The ItemFacade EJB annotates the field private EntityManager em; with @PersistenceContext , which causes an entity manager to be injected when it is instatiated. @Stateless public class ItemFacade { @PersistenceContext(unitName = "catalogPU") private EntityManager em; public List findRange(int maxResults, int firstResult) { Query q = em.createQuery("select object(o) from Item as o"); q.setMaxResults(maxResults); q.setFirstResult(firstResult); return q.getResultList(); } The Java Persistence Query APIs are used to create and execute queries that can return a list of results. The JPA Query interface provides support for pagination via the setFirstResult() and setMaxResults() methods: q.setMaxResults(int maxResult) sets the maximum number of results to retrieve. q.setFirstResult(int startPosition) sets the position of the first result to retrieve. In the code below, we show the Item entity class which maps to the ITEM table that stores the item instances. This is a typical Java Persistence entity object. There are two requirements for an entity: annotating the class with an @Entity annotation. annotating the primary key identifier with @Id Because the fields name, description.... are basic mappings from the object fields to columns of the same name in the database table, they don't have to be annotated. The O/R relationships with Address and Product are also annotated. For more information on defining JPA entities see Pro EJB 3: Java Persistence API book. @Entity public class Item implements java.io.Serializable { @Id private Integer id; private String name; private String description; private String imageurl; private String imagethumburl; private BigDecimal price; @ManyToOne private Address address; @ManyToOne private Product product; public Item() { } public String getName() { return name; } public void setName(String name) { this.name = name; } ... } The Catalog ManagedBean pages through the list of Items by maintaining the PagingInfo.firstItem and PagingInfo.batchSize attributes and passing these as parameters to the getNextItems(firstItem, batchSize) method. The catalog's scope is defined with the annotation @SessionScoped, a JSF Managedbean with session scope will be stored in the session meaning that the bean's properties will stay alive for the life of the Http Session. A JSF commandButton is used to provide a button to click on to display the next page of items. The commandButton tag is used to submit an action event to the application. This commandButton action attribute references the catalog Managed bean next() method which calculates the next page's first row number and returns a logical outcome String, which causes the list.xhtml page to display the next page's list . The catalog next method is defined as shown below: public String next() { if (firstItem + batchSize < itemCount()) { firstItem += batchSize; } return "list"; } JSF 2.0 Simplified Navigation The JavaServer Faces 2.0 NavigationHandler convention adds .xhtml to the logical outcome of the action method (in this example list) and loads that file, in this case, it loads the list .xhtml page after this method returns. If the action doesn't begin with a forward slash (/), JSF assumes that it's a relative path. You can specify an absolute path by adding the slash like this "/items/list". A JSF commandLink is used to provide a link to click on to display a page with the item details. This commandLink action attribute references The catalog showDetail() method: With JSF 2.0 you can now specify parameters in method expressions. The dataTable row object associated with the selected link is passed as a parameter in the "#{catalog.showDetail(row)}" method expression. The Catalog showDetail() method gets the item data from the input parameter, and returns a string which causes the detail.xhtml page to display the item details : public String showDetail(Item item) { this.item = item; return "detail"; } The JavaServer Faces NavigationHandler adds .xhtml to the logical outcome of the action, detail and loads that file. In this case, the JavaServer Faces implementation loads the detail.xhtml page after this method returns. The detail.xhtml uses the outputText component to display the catalog ManagedBean's item properties: GlassFish v3 is a lightweight server OSGi-based; Embedded API; RESTful admin API; Lightweight and fast startup; iterative development cycle "edit-save-refresh browser": Incremental compile of all JSF 2.0 artifacts when you save. Auto-deploy of all web or Java EE 6 artifacts Session retention: maintain sessions across re-deployments Conclusion This concludes the sample application which demonstrates a pet catalog web application which uses Java EE 6, GlassFish v3 and MySQL. Running the Sample Application Download and install NetBeans IDE 6.8 M1 with GlassFish v3 b57 (Glassfish v3 preview is Java EE 6 Preview) , and MySQL Community Server . Follow these instructions to set up a jdbc-driver for MySQL. (Normally this is already setup with Glassfish, but I got an errror message with Glassfish v3 b57 that it was missing) Download the sample code. Unzip the catalog.zip file which you downloaded, this will create a catalog directory with the project code. Create the Pet Catalog database In order to run the sample code you first have to create the Pet Catalog database and fill in the Item table. Start NetBeans IDE Ensure that GlassFish is registered in the NetBeans IDE, as follows: Click the Services tab in the NetBeans IDE. Expand the Servers node. You should see GlassFish v2 in the list of servers. If not, register GlassFish v2 as follows: Right-click the Servers node and select Add Server. This opens an Add Server Instance wizard. Select GlassFish v2 in the server list of the wizard and click the Next button. Enter the location information for the server and click the Next button. Enter the admin name and password and click the Finish button. Start the MySQL or Java DB database as follows: Click the Services tab in the NetBeans IDE. Expand the databases node. You should see the Java DB database in the list of databases. If you have installed the MySQL server database, you should also see the MySQL database in the list of databases.. Note: Java DB comes bundled with Netbeans, you can download MySQL separately. Right-mouse click on the Java DB or MySQL server database and select Start. If you installed MySQL, set the properties of the MySQL server database as follows: Right-click on the MySQL server database and select Properties. This opens the MySQL Server Properties dialog box, as shown in Figure 8. Figure 8. MySQL Server Basic Properties In the Basic Properties tab, enter the server host name and port number. The IDE specifies localhost as the default server host name and 3306 as the default server port number. Enter the administrator user name, if not displayed, and the administrator password -- the default administrator password is blank. Click the Admin Properties tab. Enter an appropriate path in the Path/URL to admin tool field. You can find the path by browsing to the location of a MySQL Administration application such as the MySQL Admin Tool. Enter an appropriate path in the Path to start command. You can find the path by browsing to the location of the MySQL start command. To find the start command, look for mysqld in the bin folder of the MySQL installation directory. Enter an appropriate path in the Path to stop command field. You can find the path by browsing to the location of the MySQL stop command. This is usually the path to mysqladmin in the bin folder of the MySQL installation directory. If the command is mysqladmin, in the Arguments field, type -u root stop to grant root permissions for stopping the server. The Admin Properties tab should look similar to Figure 9. Figure 9. MySQL Server Administration Properties Click the OK button. Right-click on the MySQL server or Java DB database and select Start. Create the petcatalog database as follows: Right-mouse click on the Java DB or MySQL server database and select Create Database. This will open a create Database window. Enter the database name catalog for Java DB or petcatalog for MySQL. For Java DB enter userid password app app as shown below: Click O.K. to accept the displayed settings. Create the tables in the catalog database as follows: Underneath Databases you should see a database connection for the petcatalog database. For example MySQL: or Java DB: Right-mouse click on the petcatalog connection and select Connect. Right-mouse click on the petcatalog connection and select Execute Command. This will open up a SQL command window. Copy the contents of the catalog.sql file in the catalog directory and paste the contents into the SQL command window, as shown in below: Click the Run SQL icon (Ctrl+Shift+E) above the SQL command window. Note: It is ok to see this: "Error code -1, SQL state 42Y55: 'DROP TABLE' cannot be performed on 'ITEM' because it does not exist. Line 2, column 1" . This just means you are deleting a table that does not exist. If you need to delete and recreate the tables you will not see this message the second time. View the data in the Pet Catalog database Item table as follows: Underneath Databases you should see a database connection for the petcatalog database. For example MySQL: or Java DB: If the database connection is broken like in the following diagram: Right-mouse click on the petcatalog connection and select Connect. as shown below: if prompted for a password, for MySQL leave it blank, for JavaDB enter user app password app. Expand the Tables node below the petcatalog database in the Services window. You should see the item table under the Tables node. You can expand the item table node to see the table columns, indexes, and any foreign keys, as shown in below : Figure 12. An Expanded Table Node You can view the contents of a table or column by right-clicking the table or column and selecting View Data as shown below: Figure 13. Viewing the Contents of a Table Follow these instructions to Create a JDBC Connection pool and JDBC resource. Name the pool mysql_petcatalog_rootPool and the jndi resource jdbc/petcatalog. Note: you do not have to create a JDBC connection pool and resource if you use the Netbeans wizard to generate JPA entities from database tables as described in this article GlassFish and MySQL, Part 2: Building a CRUD Web Application With Data Persistence. Open the catalog/setup/sun-resources.xml file and verify that the property values it specifies match those of the petcatalog database and jdbc resources you created. Edit the property values as necessary. Running the Sample solution: If you want to run the sample solution, you have to create the catalog database tables first as described above. Open the catalog project as follows: In NetBeans IDE, click Open Project in the File menu. This opens the Open Project dialog. Navigate in the Open Project dialog to the catalog directory and click the Open Project button. In response, the IDE opens the catalog project. You can view the logical structure of the project in the Projects window (Ctrl-1). Run the catalog by right-clicking on the catalog project in the Projects window and selecting Run Project. The NetBeans IDE compiles the application, deploys it on Glassfish, and brings up the default page in your browser. (at http://localhost:8080/catalog/). For more information see the following resources: A Sampling of EJB 3.1 Java EE 6 Technologies JSF 2.0 Home page Project Mojarra SDN JavaServer Faces Page JSF 2 fu, Part 1: Streamline Web application development Composite UI Components in JSF 2.0 Creating Your First Java EE 6 Application Roger Kitain's Blog (co-spec lead for JSF 2.0) Ed Burns's Blog (co-spec lead for JSF 2.0) Cay Horstmann's Blog: JSF 2.0 specifying parameters in method expressions JavaServer Faces 2.0 Ref Card Jim Driscoll's Blog Top reasons why GlassFish v3 is a lightweight server Beginning Java™ EE 6 Platform with GlassFish™ 3: From Novice to Professional Book

After a long career at Sun Microsystems and an impressive run at Liquid Robotics (a Boeing company subsidiary), the pioneer of the Java programming language has officially joined the team at AWS.

Want to get up-to-date on the latest happenings in Java? Check out this post to learn more about future events, conferences, JDK releases and more!

Check out this month's compilation of IoT news and tutorials, including advice for getting started with IoT, building with Arduinos and RPis, and monetizing IoT data.

In this article, navigate bidirectionally through the database by following foreign-key-based or user-defined relationships with Jailer.

A pumpkin-themed tutorial!

Let's look back on this Istio Service Mesh tutorial series to summarize the features of the Istio service mesh with Red Hat OpenShift and Kubernetes for microservices.

Data quality and transparency of the model are two big issues.

People, determining service size, identifying dependencies, monitoring, and data.

In this article, we discuss the dangers behind ISPs selling user data and how VPNs can protect your privacy.

When it comes to choosing a language for Microservices, Python might see the perfect one. Let’s see if that’s true in this analysis of Python efficiency.

In NoOps, you wouldn’t require an operations team to oversee your lifecycle because everything would be automated. But is that really a good idea?

A few questions that you should be asking yourself as you’re building your connected product to keep your IoT device secure.

The online shopping industry is growing rapidly. This article discusses how to choose the most effective multi-channel stock sync software for your business.

From our latest Cloud Guide, we take a look at how one of the latest cloud innovations is designed to bring your data closer to you than ever before.

If you're looking to develop a new career in the IT field, consider seeking a career in the still-growing field of DevOps.

As data needs scale, teams need to start prioritizing reliability. Here’s why DataOps might be the answer—and how you can get started.

As the Internet of Things becomes a ubiquitous idea and a fact of life, what happens to all the aging and increasingly insecure Things? According to Wired's Robert Mcmillan, responding to a recent question on the security of IoT from Dan Geer, this may be a serious problem [1][2]. The solution, Mcmillan suggests, is to design these devices with an expiration date. In other words: they need to be programmed to die. The problem may not be too severe now, but the future of the Internet of Things will look different than it does now. Security will likely loosen, because software will be a part of everything, and it tends to be the case that things mass produced to that degree experience a bit of a drop in quality. That, Mcmillan argues, presents a problem: ...all code has bugs, and in the course of time, these bugs are going to be found and then exploited by a determined attacker. As we build more and more devices like thermostats and lightbulbs and smart trashcans that are expected to last much longer than a PC or a phone, maybe we need to design them to sign off at the point where they’re no longer supported with software patches. Otherwise, we’re in for a security nightmare. A similar argument came from Bruce Schneier's interview with Scott Berinato about how future bugs like Heartbleed could impact IoT [3]. Schneier's conclusion is that processes must be built into IoT devices and development to allow for regular patching and securing of embedded systems. How practical is that, though? Mcmillan points to some recent scenarios where these fears have already come true: the lack of support for Linksys routers infected with Moon Worm, for example. Long-term patching would solve these issues, but will the increasing number of organizations developing IoT products be forward-thinking enough to care? It's also not as if the problem will fade as the products become less popular, Mcmillan says: Researchers have studied the way that security vulnerabilities are discovered, and what they’ve found is that security bugs will keep cropping up, long after most software is released... in fact, they’ll only get worse. Open sourcing technology as it ages may also be a solution, Mcmillan says. However, even that is imperfect and requires a lot of cooperation from companies who may not be enthusiastic about such cooperation, as well as a base of developers interested enough in the technology to maintain it. So, creating devices with an expiration date may be one of the most practical solutions. Otherwise, what happens when IoT is everywhere? What happens when we stop taking care of the things that we build? [1] http://www.wired.com/2014/05/iot-death/ [2] http://geer.tinho.net/geer.secot.7v14.txt [3] https://dzone.com/articles/heartbleed-iot-how-much-worse

Okay, so maybe an apocalyptic uprising of connected machines is not going to happen. Don't worry, though - there's still plenty of reason to believe that the Internet of Things will somehow lead to your death! According to Stuart Lauchlan at diginomica, the next great risk is almost here, and it's not even the Things themselves. It is, of course, the terrorists. To be specific, Lauchlan points (tongue firmly in cheek) to the 2014 iOCTA (Internet Organised Crime Threat Assessment) from Europol’s European Cybercrime Centre (EC3), which has predicted that the world will witness its first IoT murder within the next few months, and that it will be the work of criminals and terrorists: That . . . lurid prediction is actually parroting a report by US security firm IID, but Europol is warning that criminals and terrorists will use the IoT – or the Internet of Everything (IoE) as Europol calls it – and all its connected smart devices as weapons against the innocent. There is certainly something familiar about the image of IoT-hacking ne'er-do-wells: But Europol's prediction is not so tongue-in-cheek. A big part of their reasoning is that IoT is insecure. That seems to be a fairly valid concern. After all, we've heard quite a bit about how a possible (if not likely) future for IoT includes a security hellscape in which clueless companies fail to patch products as they stop supporting them, and everybody ends up with Doom installed on their toaster (or something along those lines). According to Europol, the problem is that an insecure IoT is big playground for crime: With the Internet of Everything expanding and becoming more widely adopted, new forms of critical infrastructure will appear and dependencies on existing ones will become more critical. As public and private sector organisations are outsourcing data, applications, platforms and entire infrastructures to large cloud service providers, cloud computing itself will become a critical infrastructure. Which is a problem because: . . . Big and Fast Data, the Internet of Everything, wearable devices, augmented reality, cloud computing, artificial intelligence and the transition to IPv6 will provide additional attack vectors and an increased attack surface for criminals. This will be exacerbated by how emerging and new technologies will be used and how they will influence people’s online behaviour. Europol has a few recommendations for curbing these dangers, but they aren't particularly innovative ideas - make sure policy-makers understand IoT, and make sure companies consider security, and things like that. Take comfort, though: according to Europol, you've still got a few months left to live.