JavaServer Faces (JSF) 2 lets you implement user interfaces that are easy to
modify and extend with two powerful features: templating and composite components. In
this article — second in a three-part series on JSF 2's new features — JSF 2 Expert
Group member David Geary shows you how your Web applications can best take advantage of templating and composite components.
Transaction strategies series author Mark Richards describes how to implement a transaction strategy in the Java platform for applications with high-throughput and high-user-concurrency requirements. An understanding of the trade-offs involved will help you ensure a high level of data integrity and consistency — and spare you painful refactoring work late in the development process.
The sample code consists of a small JSP tag library that you can reuse in your own
Get an introduction to the principles of public key cryptography, then see how WS-Security applies them for signing and encrypting SOAP messages using public-private key pairs in combination with secret keys. Dennis Sosnoski continues his Java Web services series with a discussion of WS-Security and WS-SecurityPolicy signing and encryption features, along with example code using Axis2 and Rampart.
The Java Native Interface (JNI) is a standard Java API that enables Java
code to integrate with code written in other programming languages. JNI can be
a key element in your toolkit if you want to leverage existing code assets —
for example, in a service-oriented architecture (SOA) or a cloud-based system.
But when used without due care, JNI can quickly lead to poorly performing and
unstable applications. This article identifies the top 10 JNI programming
pitfalls, provides best practices for avoiding them, and introduces the tools
available for implementing these practices.
WS-Security offers powerful features for securing web service
applications, and for many applications these features are essential. But these
features come at a high cost in terms of performance and message overhead. Dennis
Sosnoski continues his Java web services column series with a look at how using WS-Security or WS-SecureConversation affects Axis2 performance, and he discusses when the simpler (and better performing) alternative of HTTPS-secured connections is a more appropriate choice.
JavaServer Faces (JSF) 2 Expert Group member David Geary wraps up his three-part series on JSF 2's new features. Find out how to use the framework's new event model and built-in support for Ajax to make your reusable components all the more powerful.
In this final installment, Transaction strategies series author Mark Richards describes how to implement a transaction strategy in the Java platform for high-performance applications. Your application can maintain fast processing times while still supporting some degree of data integrity and consistency — but you need to be aware of the trade-offs involved.
WS-Security for SOAP Web services doesn't have to be an all-or-nothing proposition. By configuring WS-Security at the operation or message level, you can apply an appropriate degree of protection to every exchange, reducing or eliminating the WS-Security overhead for operations that don't need full protection. Dennis Sosnoski continues his Java Web services series with a look at granular WS-Security in Web Services Description Language (WSDL) using Apache Axis2 and Rampart.
In this article, learn about Apache Lucene, the high-performance,
full-featured text search-engine library. Explore the Lucene architecture and
its core APIs. Learn to use Lucene for cross-platform full-text searching,
indexing, displaying results, and extending a search.
Nowadays, with the widespread use and deployment of Object-Relational Mapping (ORM) tools, you don't generally have to think too hard about such arcane issues as composite keys. Normally, the choice of key design can be a simple integer, and this can be left with confidence to the tooling. Occasionally, you come across a situation where a composite key is required, and you need a strategy for this. This tip shows you how to implement composite keys with JPA and Hibernate.
Apache Axis2 supports a range of data-binding technologies, including the official Java standard, JAXB 2.x. Axis2 also supports the Java standard for Web service configuration, JAX-WS 2.x, as an alternative to its own custom configuration technique. Dennis Sosnoski continues his Java Web services column series by demonstrating how you can use each of these Java standards with Axis2 and discussing some of the limitations of Axis2's current support for them.
Use the Eclipse Integrated Development Environment (IDE) and Java
Platform, Standard Edition (Java SE) 6 to create a stand-alone Web services
application that can be run from the console. In this tutorial, the second in
the series, continue getting familiar with the Eclipse IDE and its built-in
feature the TCP/IP Monitor. View the network traffic between server and client
applications and then run the applications from the command line.
A query for persistent Java objects is typesafe if a compiler can verify
it for syntactic correctness. Version 2.0 of the Java Persistence API (JPA)
introduces the Criteria API, which brings the power of typesafe queries to
Java applications for the first time and provides a mechanism for constructing
queries dynamically at run time. This article describes how to write dynamic,
typesafe queries using the Criteria API and the closely associated Metamodel
Java developers have a variety of choices when it comes to serializing and deserializing Extensible Markup Language (XML) objects. Simple is one such example, and it offers a number of advantages over its competitors. In this article, explore an introductory overview of how to use Simple within an XML communication system.
Since taking the reins of the Java technology zone, Jenni Aloi has
published nearly 1000 pieces of content and collaborated with writers from
(seemingly) every specialty in Java development. As developerWorks celebrates
its 10th anniversary, she thought it would be nice to give props to those
writers who've made the zone a success.
The Metro Web services stack is based on the reference implementations of the JAXB 2.x and JAX-WS 2.x Java standards but also includes support for a full range of WS-* SOAP extension technologies. This article continues Dennis Sosnoski's Java Web services column series with coverage of WS-Security configuration and usage in Metro.
Elliotte Rusty Harold explores the native idioms, dialects, and accents
of the Java language and community. By following this article's guidance,
C/C++ and other nonnative programmers can blend right in with native Java speakers.
The Metro Web services stack provides the same functionality as the Axis2 stack
but, aside from the optional use of JAXB and JAX-WS in Axis2, uses completely different implementations of the technologies involved. In this article, Dennis Sosnoski continues his Java Web services column series with a performance comparison between the Metro and Axis2 stacks, both with and without WS-Security.
The Apache CXF web services stack supports JAXB 2.x data binding (along
with some alternative data bindings) and JAX-WS 2.x service configuration.
Like the Metro JAXB/JAX-WS alternative discussed in earlier columns, CXF uses
XML files to extend the JAX-WS configuration information. In this article,
Java web services series author Dennis Sosnoski looks into the basics of
working with CXF for client and server development.