OracleAS 10gR3, so OC4J standalone, is using the standard Java logging framework. Some of the
benefits are easy configuration, and extensibility. The configuration of the level of logging of the different loggers has been exposes in
the Oracle Application Server Console. To see the logger configuration, click on the Administration Tab and then Logger Configuration, you can then configure the different loggers.
By default the logger will write all the information in the default log.xml file, and for application lever logger it will go in the application.log. You may want to send the information in the console during development to debug/analyze your application. This is done using the configuration of the Handler. This information is currently not available in the Application Server Console, so I am documenting in the next steps how
to send the information in the console (terminal window).
The configuration of the OracleAS Logging is saved in the $ORACLE_HOME/j2ee/home/config/j2ee-logging.xml file. In this file you can see that Oracle has defined
various handlers where information can be sent:
console-handler : Log the information in the console (the one we want to use in this sample)
oc4j-handler : the default handler for most of the loggers, saving the information in the $ORACLE_HOME/j2ee/home/log/oc4j/log.xml using the Oracle Logger formatting
oracle-webservices-management-auditing-handler : the handler used by the Web Services Auditing feature in the $ORACLE_HOME/j2ee/home/log/wsmgmt/auditing/log.xml
oracle-webservices-management-logging-handler : the handler used by the Web Service Logging feature in the $ORACLE_HOME/j2ee/home/log/wsmgmt/logging/log.xml
As you may know, OracleAS Web Service provides out of the box support for Auditing of the SOAP messages. You just need to go in the administration page of the Web Service and enable the auditing. By default the messages are logged in the auditing log pointed above. But during development it is really interesting to see the SOAP Messages in the console without having to configure a Proxy to capture the request/response. The easiest way to do that is to edit the j2ee-logging.xml file and associate the console-handler to the auditing logger using the following configuration:
The Oracle Technology Network (OTN) "Greatest Hits" is a compilation of the most popular technical articles, software downloads, podcasts, sample code, and documentation, we've published in a given 12-month period. The compilation provides you with convenient access to the "best" of OTN as well as an insight into the interests of the Oracle developer and DBA communities.
I was discussing with a customer not familiar with the JAX-WS standard. I was writing him a mail explaining the difference when I found this nice article on the IBM DeveloperWorks library:
I have been using JDeveloper
for many years, since the first release ;-). But I've never payed
attention to a simple and very useful feature. When you click the Help
> About menu you can access all the System properties of the
Java VM used by Jdeveloper by clicking on the Properties tab
already a Web Service deployed in OC4J that is running on the default HTTP port. The WSDL and Endpoint are available. In my sample
the non secure Web Service endpoint is: http://127.0.0.1:8888/math-service/MathServiceSoapHttpPort
The first thing to do to secure OC4J would be to create a new keystore
that will contain the different certificates. The easiest way to do
that for a Java developer is to use SUN's keytool:
OC4J stand alone is using the notion of Web-Site to expose HTTP resources (Web Applications). The default-web-site is define is he
$ORACLE_HOME/j2ee/home/config/default-web-site.xml. To secure an OC4J you can follow the steps describe in the OC4J Security guide that I have summarized in the following section.
What we want to achieve for the purpose of the demonstration is to have OC4J using HTTP and HTTPS, on port 8888 and 4443 for example.
Copy default-web-site.xml to secure-web-site.xml
Edit the secure-web-site.xml:
Change the web-site tag by changing the port to 4443 and adding the element secure="true"
Add the ssl-config element and point this to the new created keystore.
The file looks like:
<web-sitexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:noNamespaceSchemaLocation="http://xmlns.oracle.com/oracleas/schema/web-site-10_0.xsd"port="4443"secure="true"display-name="OC4J 10g (10.1.3) Default Web Site"schema-major-version="10"schema-minor-version="0"> ...<ssl-configkeystore="server.keystore"keystore-password="welcome"/> ...</web-site>
Import the new Web site in your OC4J instance by editing the $ORACLE_HOME/j2ee/home/server.xml
file. You need to add or replace the web-site tag. In my case I want to
add the secure web site to my instance so the configuration looks like:
Start OC4J using the standard Java command or shell script, I am adding the Java Network debug flag that would help you to see what is
happening at the SSL level.
java -Djavax.net.debug=ssl -jar oc4j.jar
You should be able to access the service WSDL using the HTTPS port for example in my case:
Event if this is possible to use the same keystore for the server and the client, I will guide you in the steps to create a client
certificate and import the certificate from the existing -server- one.
You have now the client certificate so you can use the Oracle Web
Service Assembler to generate the proxy. The only specific thing you
have to do is to specify which key store to use when running the tool.
The command to use when generating the proxy is:
Configure the Java Environment to use the client store is made using the following System properties:
javax.net.ssl.trustStore
javax.net.ssl.keyStore
javax.net.ssl.trustStorePassword
javax.net.ssl.keyStorePassword
This could be done using different approach, property file, -D command
line parameter or programmatically. To simply the example I am using
the programmatic approach, the following code is part of the main
method of the Client class:
It is possible to change the Endpoint dynamically in the Proxy using the setEndpoint method.
...democlient.proxy.MathServiceSoapHttpPortClient myPort = new democlient.proxy.MathServiceSoapHttpPortClient();...String ep = "https://127.0.0.1:4443/math-service/MathServiceSoapHttpPort";myPort.setEndpoint(ep);System.out.println("Result of the operation is "+ myPort.add(2,2));...
You should now be able to run the client and call the service using HTTPS. This would look like:
Oracle Open World is getting very close... And I am very excited to go to lot of sessions, two of them looks very interesting in the Oracle Develop track:
Rod Johnson - Spring Update: What's New and Cool in Spring 2.0 (Monday 10/23/2006, 12:45 PM - 1:45 PM in the Hilton Hotel Grand Ballroom A)
Brian Behlendorf - Bringing Open Source Software Development Practices and Principles Into Your Company (Tuesday 10/24/2006, 1:15 PM - 2:15 PM in the Hilton Hotel Grand Ballroom A)
This is quite exciting to have Open Source gurus coming to present to the Oracle conference, and explain how to use the new Spring in their projects or leverage Open Source practices to improve development in house... Take a look to the full program of Oracle Develop.
Start to use the Oracle OpenWorld Schedule Builder to organize your week in SF, if you have not registered yet for OOW click here.
WS-Security provides a standard way to secure Web Services. Since based on SOAP it is agnostic of the stack you are using. When using JAX-RPC implementation, you are running in a J2EE container. In this post I am giving a tip to access the Principal object.
I have a service service, and I need to access some user information in its implementation class ( org.tug.ws.sample.SimpleServiceImpl ). This service is secure with WS-Security, with for example simple authentication, the following screenshot, is the configuration of inbound security in OracleAS 10gR3:
Implement the init(Object context) method to access
the ServletEndpointContext,
that you can for example put as a local member of your implementation
class.
public void init(Object context) { _servleContext = (ServletEndpointContext)context;}
Then you can access the principal object using the getUserPrincipal() method:
Last week I discussed dynamic languages with some consultants. This discussion was done in the context of integration of scripting technologies into Java EE environment. So the integration to the VM is important, I also think that the learning curve is a thing to consider.
It is true that, like any developer Iike to learn things everyday, this is why I have done some development with PHP, with Ruby On Rails, and obviously with Groovy, Javascript and many other dynamic languages.
The discussion moved quickly to an argument about which language is the best... Hard to say, but I would expect that to be more productive in enterprise it is better to use a "Java Like" syntax that allows you to leverage the power of scripts. Based on this comment it is for me a no brainer to say that Groovy is more interesting to a core Java developer than JRuby (or other Jython, Jacl, ...). I do not even want to go in the details about VM integration, performances and so on...
If like me you like scripting technologies and in particular Groovy and
Grails, JavaOne 2006 will be a very good moment to learn more about it.
Beside the official sessions listed below, I would like to inform you
of various events interesting for the Groovy community:
Informal "Groovy Community Meeting&rdquo", Thursday night 5pm around the Oracle Demobooth where Guillaume, Graeme and Dierk will give you an
opportunity to learn more about these projects
Groovy presentations at the Oracle Booth in the pavilion
The official sessions about Groovy and Grails are
BOF-0554
Dynamic Scripting Languages BOF
Tuesday 05/16/2006 10:30 PM - 11:20 PM
Moscone Center Hall E 133
BOF-2521
Rapid Web Application Development With Grails
Thursday 05/18/2006 08:30 PM - 09:20 PM
Moscone Center Esplanade 307-310
TS-1246
Simplify Enterprise Development With Scripting
Thursday 05/18/2006 11:00 AM - 12:00 PM
Moscone Center Hall E 134
TS-3273
Groovy = Java™ Technology+ Ruby + Python for the JVM™
Wednesday 05/17/2006 02:45 PM - 03:45 PM
Moscone Center Gateway 104
TS-3714
Flash-Gridding with Java™ Technology: Using Project GlassfishSM, Jini™/JavaSpaces™, and Groovy as an Environment for an Open Source, Self-Assembling Supercomputer
Thursday 05/18/2006 02:45 PM - 03:45 PM
Moscone Center Gateway 104
TS-5386
Groovy Goes RFID with Smart Sensors for Real-World Control
OTN (Oracle Technology Network)
Readers have noticed, that Oracle has
published an article from Richard Monson-Haefel about Ruby On Rails on Oracle. This
article introduces the Ruby On Rails framework and explains how to use
it to access an Oracle database. (Oracle 10g Express Edition to be exact)
If you are not familiar at all with Ruby On Rails, it is important to
notice that it has nothing to do with Java, J2EE. It is a Ruby
based framework. So yes Ruby On Rails is really interesting,
powerful and so on... but for me as a Java developer I would like to do
the same using Java (or equivalent) leveraging the investment that I
have done in J2EE; also important I want to be able to deploy and
manage applications that are developed this way using my tools such as
Oracle Enterprise Manager Application Server Control.
The paradigm "coding by convention" that is the driver of Ruby on Rails
has been leveraged to developed a new framework: GRAILS. Grails uses
Groovy as the underlying language, so it runs on a JVM and can leverage
any existing Java API.
If you are a Java developer you will find very interesting to use this
framework to accelerate the development of Web applications. If you are
not yet a Java developer but need to develop Web application faster,
and deploy the to your J2EE application server, Grails is also a very
good tools.
Since I have started with Richard's article I will use the same
application/database schema to develop my first GRAILS application, and
also use the same structure in my article...(is it what we call lazy loading?)
Groovy is a dynamic language that leverage features from other
languages such as Ruby, Jython, and Smalltalk. Groovy is running at the
top of a Java VM and makes available any existing Java objects (so all
the API) to Groovy. Groovy is currently under standardization with the JSR-241.
You can learn more about Groovy on the Groovy site and is project leader's (Guillaume Laforge) blog.
GRAILS is to Groovy what Ruby On Rails is to Ruby. Originally named "Groovy On Rails",
this name has been dropped in favor of Grails to avoid
confusion/competition. Like Ruby on Rails, Grails is designed to
create CRUD
(Create Read Update Delete) Web applications. You can learn more
about Grail on the Grails site and is project leader's (Graeme Rocher) blog.
Let's now dive in the sample application, for this, as stated earlier I
am using the sample application described in the OTN articles.
Now we have installed the product, the next step is to create the application itself.
Create the application
The create-app command is
creating the full project, with the template
with placeholder for the different components of your application such
as configuration, MVC, and library and much more. To do it enter the
following command, in your command line interface:
> grails create-app.........create-app:[input] Enter application name:comics_catalog.....
As you will see, Grails uses Ant intensively, the create-app
command will ask you for an application name, enter for example comics_catalog.
The created application contains now a list of directory allowing
developer to start to build the application using Groovy, Grails and
any Web components.
Add the Business Logic and Model:Domain Classes
One of the biggest differences between Grails and RoR, is the fact that
the main components of your application development is not the Table
like you have in RubyOnRails but the "Domain Class". The
domain class are the core of the business application, they contains
the state and the behavior of your application.
So the next step is to create a Domain Class for the Comics, to do that
you just need to go in the home directory of your project, eg cd comics_catalog and run the create-domain-class.
> cd comics_catalog> grails create-domain-class....create-domain-class:[input] Enter domain class name:comics....
When the command ask you to enter the class name, enter comics. Grails, will not use the
same naming convention that RoR has, so you need to use the same name
for the class and the table you want to map your object on. The
persistence layer is made using GROM (Grails Object Relational Mapping)
that leverage hibernate.
Note: In our case what we are doing is to leverage an existing database
object and create the domain class at the top of it. Usually, Grails
uses a different approach where everything is driven by the
application, so you create the domain class first and then Grails will
create the different database objects.
The Comics class does not have any information related to the mapping
itself, so you have to create the different attributes in the domain
class. This is where you you start to use Groovy, the domain class is
located in the following location:
./comics_catalog/grails-app/domain/Comics.groovy
Note hat by default Grails create the class with 2 attributes: id and
version, keep them in place, and add title, issue and
publisher.
class Comics { @Property Long id @Property Long version // new properties for the Comics class @Property String title @Property Long issue @Property String publisher String toString() { "${this.class.name} : $id" }}
We are all set, we are ready to run the magic command that will create the different screens and flow.
Create the different screens from the domain class
You can now run the generate-all command to create all the different screens.
> grails generate-all....input-domain-class:[input] Enter domain class name:comics....
This command creates the different Views and Controllers, you can take a look to the directories:
./comics_catalog/grails-app/controllers
./comics_catalog/grails-app/views
Configure the database access
What we have to do is now to configure the application to use the Oracle database and schema.
Let's edit this file to connect to our Oracle database.
class ApplicationDataSource { @Property boolean pooled = true @Property String dbCreate = "update" // one of 'create', 'create-drop','update' @Property String url = "jdbc:oracle:thin:@localhost:1521:XE" @Property String driverClassName = "oracle.jdbc.OracleDriver" @Property String username = "ruby" @Property String password = "ruby"}
Nothing special concerning the properties such as URL, DriverClassName,
username and password.
The one that is interesting is the dbCreate,
that allows you to configure the behavior on the schema to create or
not objects.In our sample the table exists, so we want to reuse the
object, but we want to be sure that we have all the mandatory objects,
columns too, so I selected update.
The next thing to do is to add the Oracle JDBC driver to the
application, to make it available. To make it available you just need
to copy the JDBC driver into the lib directory of your application. In
my case I am using Oracle XE so I copy the file from the following
location:
ORACLE_XE_HOME/app/oracle/product/10.2.0/server/jdbc/lib/ojdbc14.jar
to
Grails provide a way to run the application in stand alone mode, the command is run-app. This command starts an Web container (based on Jetty) with the application deployed.
grails run-app
Note: Jetty will start on port 8080, in order to start in on a different port like e.g. 9090 use:
grails -Dserver.port=9090 run-app
You can now access the application using the following URL:
http://localhost:8080/comics_catalog/comics/
Your browser should show the list of comics from the Comics table.
List of Comics
You can create a new entry by clicking on the "New Comics" tab, and view/edit/delete existing record by clicking on the "Show" link.
Edit/Create entry
As you see the creation of an application is really easy. The next step is to deploy the application in your application server.
Grails provides a command to package the application as a WAR ready to
be deployed, so in the root directory of your project you can run the
following command:
grails war
When you run this command you end with a WAR with the name of your
application located in the root of your project, in our case: comics_catalog.war
If you take a look to this WAR you'll see that it is quite big ~10Mb,
this is because all the libraries are included in the Lib directory of
the web application. You can see the exact structure of the WAR in the
./tmp (./comics_catalog/tmp/war) directory of the application.
You can deploy the application as it is to Oracle Application Server 10g,
but to avoid the issue with the class loader you should configure the
Web application to load the local classes first. It can be done during
deployment with the class loader configuration screen:
You can also save this configuration in a deployment plan to facilitate later deployment.
When the deployment is done you can access the application using the OracleAS host and port, something like:
http://localhost:8888/comics_catalog/comics/list
You can now administer and monitor the application like any other J2EE application deployed in OracleAS 10g.
Better Deployment Options
I personally do not like the idea of shipping all the Jar
files in the WAR file, so instead you can use the OracleAS Shared
Libraries to create a Grails library by uploading and configuring all
the Jars. And package the War without all these libraries.
Also you should be able to configure Hibernate/Spring to
use a standard define Data source and use the JNDI name to lookup the
connections.
GRAILS like Ruby On Rails are really interesting frameworks allowing
developers to create quickly Web application that access relational
database and especially the Oracle Database.
Grails is quite new (release 0.2), but the documentation is really nice
and complete. I will encourage all developers that are interested by
such framework to use it and provide feedback to the development team.
I will try provide other post about deployment of Grails on OracleAS,
but also related to other interesting features of this framework, for
example Ajax support, Validations etc etc.
If like me you like scripting technologies and in particular Groovy and
Grails, JavaOne 2006 will be a very good moment to learn more about it.
