Java Bridge Use Cases
This section describes some of the common uses for the Java Bridge.
The usage scenarios and examples discussed here provide a framework for
the Java Bridge’s uses, rather than a complete picture. Real world experience
indicates that companies are finding more and more applications for the
Java Bridge, beyond what was initially anticipated.
Usage Scenarios
There are two usage scenarios that describe the most common applications
for the PHP/Java Bridge:
- Integration with
Existing Java Infrastructure - PHP is a fully featured scripting
language engineered to cover virtually all of an enterprise’s requirements.
At the same time, many enterprises have a long history of application
development in Java. The Java Bridge enables enterprises to continue
to use their Java infrastructure - applications, databases, business
logic and various Java servers (WebLogic, JBoss, Oracle Application
Server, etc.).
- Accessing Java
Language and Architecture - Some enterprises require the full
set of PHP capabilities, yet have a specific need for select Java
based applications. SIP signaling in the communications industry or
JDBC for creating connectivity to SQL databases are two examples of
impressive, industry specific products. The Java Bridge enables enterprises
to adopt a PHP standard and to use their preferred Java based applications.
Activities
This section describes two sample activities that indicate some of what
you can do with the PHP/Java Bridge. In the sample activities, it is important
to differentiate between Java and J2EE. The difference will impact on
architecture and in turn, on the script code.
The important differences are:
- Java is a programming language. Java applications created in Java
for the enterprise are not bound to a specific framework. Therefore,
it is possible and perhaps preferable for an enterprise to relocate
code libraries to the server that runs Zend Server.
- J2EE is a structured framework for application scripts developed
for J2EE. It is preferable that J2EE servers be left intact.
Example 1: A Case Study in Java Bridge Performance (Java)
The Forever Times newspaper maintains a PHP-based website - let’s call
it ForeverOnline.com. The newspaper has been searching for a real-time
Stock Ticker application to add to their already successful and heavily
visited website. The Forever Times Newspaper feels that real-time financial
information is the one thing their website is lacking.
Forever Times believes they have found exactly the Stock Ticker application
they need. The application provides up-to-date quotations from all the
major markets, currency rates, and even links to some of the local exchanges.
However, the application is written in Java and uses existing Java libraries.
Forever Times realizes that a PHP-based Web implementation that handles
Java requests - a Java Bridge - is their best bet. At the same time, they
are concerned that the performance of their Website remains optimal. To
Forever Times’ horror, in testing the new application, they find that
loading the site with user-requests for the Stock Ticker slows down the
performance of the whole website.
The following code example illustrates how the Java Bridge applies to
this business scenario and others like it:
|
|
Example:
<?
// create Java object
$stock = new Java("com.ticker.JavaStock");
// call the object
$news = $stock->get_news($_GET['ticker']);
// display results
foreach($news as $news_item) {
print "$news_item<br>\n";
}
?>
|
|
The example code can be understood as follows:
- The code example is written in PHP and forms part of a
PHP Web application.
- The PHP code creates the Java object-"com.ticker.JavaStock"-which
is the PHP proxy.
-
Requests come into the PHP based Website - ForeverOnline.com
- which then references the Stock Ticker application.
- Stock Ticker references a custom object- get_news-in the
JVM library. This is all in native Java.
- The PHP code then outputs the results on the Website.
|
As opposed to a typical Java Bridge Implementation, the Zend Server Java Bridge implementation
addresses performance issues through the Java Bridge architecture.
Implementing the Java Bridge is a way to address scalability issues
by using the Java Bridge to handle all communication in a single JVM instance,
instead of in several instances.
Note:
While the single JVM constitutes a single point of
failure, the fact is, Zend’s PHP-Java connection is the most robust on
the market. Failures in systems of this type generally tend to occur when
the Java Server is overloaded, rather than as a result of glitches in
the applications. Zend Server
’s system architecture insures performance by diminishing overhead. However,
in the event of failure, the Java Bridge supports a restart feature that
makes monitoring the status of the Java Server and restarting quick and
simple. One last point: if the failure was caused by a glitch in the application,
the same thing would most likely occur in each of the JVMs in the non-Zend
system!
Example 2: A Case Study in Management Integration (J2EE)
A company called FlowerPwr.com sells flowers over the Internet. They
are a successful East Coast-based firm that has an aggressive management
profile. They are currently in the process of acquiring a West Coast competitor
- let’s call it Yourflowers.com - that provides a similar service.
FlowerPwr.com has its own website: Its various enterprise applications
are written in PHP. Yourflowers.com also has its own Website: However,
all its applications are Java-based and were developed for J2EE. They
have their own J2EE application server. FlowerPwr.com needs to begin operating
as an integrated commercial entity as soon as possible, in a way that
conceals the fact that the companies have merged.
Using the Java Bridge, FlowerPwr.com can create a common portal in PHP.
The company can leave Java up and running and take full advantage of their
acquisition’s existing Java services. FlowerPwr.com can do this over an
existing portal using PHP.
The following code example illustrates how the Java Bridge can apply
to this business scenario and others like it:
|
|
Example:
<?
// EJB configuration for JBoss. Other servers may
need other settings.
// Note that CLASSPATH should contain these classes
$envt = array(
"java.naming.factory.initial" => "org.jnp.interfaces.NamingContextFactory",
"java.naming.factory.url.pkgs" =>
"org.jboss.naming:org.jnp.interfaces",
"java.naming.provider.url" => "
jnp://yourflowers.com:1099");
$ctx = new Java("javax.naming.InitialContext",
$envt);
// Try to find the object
$obj = $ctx->lookup("YourflowersBean");
// here we find an object - no error handling in
this example
$rmi = new Java("javax.rmi.PortableRemoteObject");
$home = $rmi->narrow($obj, new Java("com.yourflowers.StoreHome"));
$store = $home->create();
// add an order to the bean
$store->place_order($_GET['client_id'], $_GET['item_id']);
print "Order placed.<br>Current shopping
cart: <br>";
// get shopping cart data from the bean
$cart = $store->get_cart($_GET['client_id']);
foreach($cart as $item) {
print "$item['name']: $item['count'] at $item['price']<br>\n";
}
// release the object
$store->remove();
?>
|
|
The example code can be understood as follows:
-
The code example is written in PHP and forms
part of a PHP Web application.
-
The PHP application first initializes an operation
with the EJB, located at a specific URL that has the name:"//yourflowers.com:1099."
-
The code then specifies the bean-YourflowersBean-that
the application will look for.
-
Next, the bean object is returned from the
EJB server.
-
The application then calls methods-in this
case, the Java application includes two functions:
-
- place_order receiving
two numbers - client ID and the item ID to add
to shopping cart
- get_cart receiving
one number - client ID and returning the list of
the items placed in the shopping cart so far.
|
After script execution, the referenced class may be disposed.
