|
What is BEA Weblogic?
BEA WebLogic is a J2EE application server and also an HTTP web server by BEA Systems
of San Jose, California, for Unix, Linux, Microsoft Windows, and other platforms.
WebLogic supports Oracle, DB2, Microsoft SQL Server, and other JDBC-compliant databases.
WebLogic Server supports WS-Security and is compliant with J2EE 1.3.
BEA WebLogic Server is part of the BEA WebLogic Platform™. The other parts of WebLogic
Platform are:
► Portal, which includes Commerce Server and Personalization Server (which
is built on a BEA-produced Rete rules engine),
► WebLogic Integration,
► WebLogic Workshop, an IDE for Java, and
► JRockit, a JVM for Intel CPUs.
WebLogic Server includes .NET interoperability and supports the following native
integration capabilities:
► Native enterprise-grade JMS messaging
► J2EE Connector Architecture
► WebLogic/Tuxedo Connector
► COM+ Connectivity
► CORBA connectivity
► IBM WebSphere MQ connectivity
BEA WebLogic Server Process Edition also includes Business Process Management and
Data Mapping functionality.
WebLogic supports security policies managed by Security Administrators. The BEA
WebLogic Server Security Model includes:
► Separate application business logic from security code
► Complete scope of security coverage for all J2EE and non-J2EE components
Why
is there no polymorphic-type response from a create() or find() method?
The EJB Specification prohibits this behavior, and the weblogic.ejbc compiler checks
for this behavior and prohibits any polymorphic type of response from a create()
or find() method.
The reason the create() and find() methods are not polymorphic is similar to the
reason constructors are not polymorphic in Java. The derived classes generally do
not know or cannot initialize the base class properly.
Can I use a native two-tier driver for a browser applet?
No. Within an unsigned applet, you cannot load native libraries over the wire, access
the local file system, or connect to any host except the host from which you loaded
the applet. The applet security manager enforces these restrictions on applets as
protection against applets being able to do unsavory things to unsuspecting users.
If you are trying to use jDriver for Oracle from an applet, then you are violating
the first restriction. Your applet will fail when it attempts to load the native
(non-Java layer) library that allows jDriver for Oracle to make calls into the non-Java
Oracle client libraries. If you look at the exception that is generated, you will
see that your applet fails in java.lang.System.loadLibrary, because the security
manager determined that you were attempting to load a local library and halted the
applet.
You can, however, use the WebLogic JTS or Pool driver for JDBC connectivity in applets.
When you use one of these WebLogic multitier JDBC drivers, you need one copy of
WebLogic jDriver for Oracle (or any other two-tier JDBC driver) for the connection
between the WebLogic Server and the DBMS.
I tried to run two of the applets in the examples directory of the distribution?
I tried to run two of the applets in the examples directory of the distribution.
I installed the WebLogic classes on my local machine (NT server) and on another
machine (a Windows 95 client). I am not using any browsers, just trying to run the
applets with Appletviewer. The applets work fine when I run Appletviewer from the
NT server, but do not work at all from the Windows 95 client.
There are two possible problems: Either the CODEBASE tag is not properly set in
the applet HTML file, or the class files are not properly loaded on the HTTP server.
The applet works on the NT server because you installed the WebLogic distribution
on your NT server. Even if the applet cannot successfully load the necessary classes
from the HTTP server, it does find them in your local CLASSPATH. But when you try
to run it from the Windows 95 client, the applet must load the classes over the
wire from the HTTP server, and if you haven't installed them correctly, it
will fail.
How do stubs work in a WebLogic Server cluster?
Clients that connect to a WebLogic Server cluster and look up a clustered object
obtain a replica-aware stub for the object. This stub contains the list of available
server instances that host implementations of the object. The stub also contains
the load balancing logic for distributing the load among its host servers.
Why did my JDBC code throw a rollback SQLException?
Your JDBC code may throw the following exception:
"The coordinator has rolled back the transaction.
No further JDBC access is allowed within this transaction."
The WebLogic JTS JDBC driver throws this exception when the current JDBC connection
transaction rolls back prior to or during the JDBC call. This exception indicates
that the transaction in which the JDBC connection was participating was rolled back
at some point prior to or during the JDBC call.
The rollback may have happened in an earlier EJB invoke that was part of the transaction,
or the rollback may have occurred because the transaction timed out. In either case,
the transaction will be rolled back, the connection returned to the pool and the
database resources released. In order to proceed, the JTS JDBC connection must be
closed and reopened in a new transaction.
Which of the following are recommended practices to be performed in the ejbPassivate()
method of a stateful session bean?
a. Close any open resources, like database connections
b. All non-transient, non-serializable fields(except some special types) should
be set to null.
c. All transient fields should be set to null
d. Make all database connection reference fields transient
e. All primitive type fields should be set to null
Choices A, B and D are correct. When a bean is about to be passivated, its ejbPassivate()
method is invoked, alerting the bean instance that it is about to enter the Passivated
state. At this time, the bean instance should close any open resources and set all
non transient, non serializable fields to null. This will prevent problems from
occurring when the bean is serialized. Transient fields will simply be ignored.Serializable
fields will be saved.Open resources such as sockets or JDBC connections must be
closed whenever the bean is passivated. In stateful session beans, open resources
will not be maintained for the life of the bean instance. When a stateful session
bean is passivated, any open resource can cause problems with the activation mechanism.
A bean's conversational state may consist of only primitive values, objects
that are serializable, and the following special types-SessionContext, EJBHome,
EJBObject, UserTransaction and Context (only when it references the JNDI ENC) .
The types in this list (and their subtypes) are handled specially by the passivation
mechanism. They don't need to be serializable; they will be maintained through
passivation and restored automatically to the bean instance when it is activated
How do I set up my CLASSPATH?
Setting up your CLASSPATH correctly depends on what you are trying to do. The most
common tasks are described below:
* Starting WebLogic Server. See Setting the Classpath Option in the Starting and
Stopping WebLogic Servers section of the Administration Guide. In addition, your
WebLogic distribution includes shell scripts that you can use to start the server.
These scripts, which are located in the domain directories under the config directory
of your WebLogic Server distribution, automatically set up the CLASSPATH variable
in the shell before starting the server.
When deploying a resource adapter (.rar) to WebLogic Server, are its classes placed
in the WebLogic classpath?
For instance, I am deploying an EJB and a resource adapter (.rar), the EJB has no
dependencies on the .rar because the EJB is writing to the common client interface
(CCI). The EJB client application has sends/marshals as parameter classes that are
defined in the .rar. For some reason the EJB's class loader hierarchy cannot
find the definition of this .rar-specific class, even though the .rar is deploying
successfully. I receive the following error on the EJB client:
java.rmi.UnmarshalException: error unmarshalling arguments; nested
exception
is:
java.lang.ClassNotFoundException:
com.mycompany.InteractionSpecImpl
When you pass an instance of com.myclientcompany.server.eai.InteractionSpecImpl
as an argument to your EJB, the appServer needs to de-serialize (unmarshal) the
object under the EJB context, and it needs the required class for unmarshalling,
inside the ejb-jar(raTester.jar). So if you include the interactionspecimpl class
in your ejb-jar file, then you do not need to include those classes in your server's
classpath.
Can I enable requests to a JDBC connection pool for a database connection to wait
until a connection is available?
No, there's no way to allow a request to wait for a pool connection, and from
the system point of view there should not be. Each requests that waits for a connection
ties up one of the fixed number of execute threads in the server, which could otherwise
be running another server task. Too many waiting requests could tie up all of the
execute threads and freeze the server.
How do I connect to an SQL Server instance that is running on a machine with multiple
instances of SQL Server 2000?
Each instance of MS SQL Server must be listening on a different port. So, you can
use the port number in the properties that you pass to the getConnection() method
or, in case of connection pools, you can specify the port property in the following
properties:
server=machineName
port=instancePort
To find the port number where each MS SQL Server instance is running, run the server
network utility (in the Microsoft SQL Server program group), select the server instance,
select TCP/IP, and click the properties button.
What causes an OCIW32.dll error?
You may receive the following error message when using your JDBC driver for Oracle:
"The ordinal 40 could not be loaded in the dynamic link library OCIW32.dll."
This problem is caused by an out-of-date version of OCIW32.DLL in your system directory.
Some programs install this file in the system directory in order to run. If you
remove this file from the system directory you should no longer receive this error.
What transaction isolation levels does the WebLogic jDriver for Oracle support?
Your servlet application may use Oracle Thin Drivers to access a database that includes
BLOB fields. If you install and try to use WebLogic jDriver for Oracle and the same
code fails and produces an exception similar to the following:
com.roguewave.jdbtools.v2_0.LoginFailureException:
TRANSACTION_READ_UNCOMMITTED isolation level not allowed
The Stack Trace:
com.roguewave.jdbtools.v2_0.LoginFailureException:
TRANSACTION_READ_UNCOMMITTED isolation level not allowed
at
com.roguewave.jdbtools.v2_0.jdbc.JDBCServer.createConnection
(JDBCServer.java :46)
at com.roguewave.jdbtools.v2_0.ConnectionPool.getConnection_
(ConnectionPool.jav a:412)
at com.roguewave.jdbtools.v2_0.ConnectionPool.getConnection
(ConnectionPool.java :109)
Setting the Isolation_level to 1 in the code that calls the RogueWave JDBCServer
class works with the Oracle thin driver but fails with WebLogic jDriver for Oracle.
WebLogic jDriver for Oracle supports the following transaction isolation levels:
SET TRANSACTION ISOLATION LEVEL READ COMMITTED
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
According to the Oracle documentation, the Oracle DBMS only supports these two isolation
levels. Unlike other JDBC drivers, WebLogic's drivers throw an exception if
you try to use an isolation level that is unsupported. Some drivers silently ignore
attempts to set an unsupported isolation level. WebLogic suggests testing whether
the Oracle thin driver is not just ignoring settings for unsupported isolation events.
What type of object is returned by ResultSet.getObject()?
WebLogic jDriver for Oracle always returns a Java object that preserves the precision
of the data retrieved. WebLogic jDriver for Oracle returns the following from the
getObject() method:
* For columns of types NUMBER(n) and NUMBER(m,n): a Double is returned if the defined
precision of the column can be represented by a Double; otherwise BigDecimal is
returned.
* For columns of type NUMBER: Because there is no explicit precision, the Java type
to return is determined based on the actual value in each row, and this may vary
from row to row. An Integer is returned if the value has a zero-valued fractional
component and the value can be represented by an integer.
For example, 1.0000 will be an integer. A long is returned for a value such as 123456789123.00000.
If a value has a non-zero fractional component, a Double is returned if the precision
of the value can be represented by a Double; otherwise a BigDecimal is returned.
How do I call Oracle stored procedures that take no parameters?
Here is what we use that works:
CallableStatement cstmt = conn.prepareCall("Begin procName;
END;");
cstmt.execute();
where procName is the name of an Oracle stored procedure. This is standard Oracle
SQL syntax that works with any Oracle DBMS. You might also use the following syntax:
CallableStatement cstmt = conn.prepareCall("{call procName};");
cstmt.execute();
This code, which conforms to the Java Extended SQL spec, will work with any DBMS,
not just Oracle.
How do I learn what codesets are available in Oracle?
To find out what codesets you currently have available in Oracle, execute the following
SQL query from SQLPlus at the command line:
SQL> SELECT value FROM v$nls_valid_values WHERE parameter='CHARACTERSET';
The response lists of all codesets currently installed on your system. This listing
will look something like the following shortened list:
VALUE
---------------
US7ASCII
WE8DEC
WE8HP
US8PC437
WE8EBCDIC37
WE8EBCDIC500
WE8EBCDIC285
...
If you want to constrain the value in the query to a specific codeset you are searching
for, you might use a SQL query like the following:
SQL> SELECT value FROM v$nls_valid_values
WHERE parameter='CHARACTERSET' and VALUE='AL24UTFFSS';
This would produce the following response if the codeset is installed:
VALUE
-------------------
AL24UTFFSS
You can use Oracle's installation tools to install additional codesets. Contact
Oracle for more information.
Why
do I get an error while trying to retrieve the text for ORA-12705?
This error occurs when you have not set the ORACLE_HOME environment variable properly
— a common mistake. In order to use WebLogic jDriver for Oracle, the Oracle client
software needs to be installed and ORACLE_HOME must be set.
You may also see this error message if you try to use WebLogic jDriver for Oracle's
internationalization capabilities with a language/codeset combination that is not
installed on your system. If you get the ORA-12705 error with the correct error
text, then either you have set NLS_LANG improperly, or you do not have the right
codesets installed on your system.
How do I prevent errors when running t3dbping?
When you are testing your Oracle database connections under UNIX, you can run SQL*PLUS
and can successfully ping the database using utils.dbping. However, when you use
the multitier utils.t3dbping utility, you receive an ORA-12154 error message.
First, make sure that your ORACLE_HOME environment variable is correctly set to
point to your Oracle installation. This variable must be set in the environment
where the WebLogic server is running.
In the C-shell issue the following command:
$ setenv ORACLE_HOME path
where path is the path to your Oracle installation.
In the Bourne shell, issue the following commands:
$ ORACLE_HOME=path
$ export ORACLE_HOME
where path is the path to your Oracle installation. When you ping your database
using the two-tier utils.dbping utility, the JDBC driver loads the database client
library and establishes the connection to the database. When you use the multitier
utils.t3dbping utility, the WebLogic Server loads a two-tier driver and uses it
to establish a database connection. In both cases, the same method is used to connect
to the database. SQL*PLUS works because it doesn't require ORACLE_HOME to find
the client libraries.
If you are still experiencing problems, try this:
1. Open a command shell.
2. Run the two-tier version of utils.dbping in this shell.
3. Start WebLogic in this shell from the command line:
$ java -ms32m -mx32m weblogic.server
4. Open a second command shell.
5. Run the utils.t3dbping in the second shell against the server running in the
first command shell.
If this procedure doesn't work, please send the output from these commands
to WebLogic technical support.
Why am I getting an ORA-01000: maximum open cursors exceeded error, even though
I closed all ResultSet, Statement, and Connection objects?
This is an Oracle issue. According to Oracle's documentation, dynamic cursors
can remain open from run to run in a session and are not closeable when a procedure
closes. To work around this issue, you can increase the number of open cursors allowed
in the database or you can reset the connection pool (close and reopen database
connections in the connection pool).
To reset the connection pool, you can untarget and retarget the connection pool
using the Administration Console. You can also use the reset() method through the
JMX API or the RESET_POOL command on the WebLogic Server command line interface.
Are there C/C++ interfaces to WLS JMS?
No, this is not supported.
* Write your own interfaces using JNI.
* Setup a Servlet that your C/C++ client calls to generate a JMS message. You should
spawn multiple threads in C++ and use multiple posts to pass messages via http.
How do I configure JMS security?
The correct way to set up security for JMS is to go to the console, select ACLs
in the tree view, then create some access control lists.
1. Set the ACL name which should be weblogic.jms.queue.QUEUENAME or weblogic.jms.topic.TOPICNAME.
2. Select Create.
3. Enter the New Permission of send or receive.
4. Select Create.
5. Enter a comma separated list of users or groups.
6. Select Grant Permission.
7. Select "saved to the realm implementation" to save your changes.
8. Select Yes.
This will update the fileRealm.properties file with lines that look like the following:
acl.send.weblogic.jms.queue.TestQueue1=user1
acl.receive.weblogic.jms.queue.TestQueue1=user1
If you don't have an ACL for a queue or topic, security is wide open.
There are also ACL's for accessing the JNDI context; the JNDI context is a
requirement for initially accessing JMS. See the JNDI documentation.
Why does JMSSession.createTopic or JMSSession.createQueue fail to create a destination
in WLS JMS 6.1 (it worked in 5.1)?
In WLS 5.1 createTopic() or createQueue() creates the destination permanently in
the database if it doesn't already exist, but does not modify the weblogic.properties
file.
According to the JavaSoft JMS specification version 1.0.2 regarding createQueue()
and createTopic(), they are not for creating destinations dynamically. They are
used to retrieve the destination referenced by using a string name instead of using
JNDI lookup. The destination has to be in your config.xml file first. This change
is documented in WLS 6.0 since it behaves differently than the previous release.
You can use the WLS JMS helper class (weblogic.jms.extensions.JMSHelper) or the
console to create destinations at the run time (note that there was a bug in 6.0
that caused a problem when the server restarted; this is fixed in Service Pack 1).
These mechanisms create the destination and also modify the configuration file.
For more information on the JMSHelper classes, see the subsection called Creating
Destinations Dynamically in Programming WebLogic JMS.
The following program creates a Topic.
import java.io.*;
import java.util.Hashtable;
import javax.jms.*;
import javax.naming.*;
import weblogic.jms.extensions.JMSHelper;
class t {
public final static String
JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";
public final static String JMS_SERVER_NAME="TestJMSServer";
public final static String DEST_JNDI_PREFIX="javax.destination.";
static public void main(String [] args) throws Exception {
try {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, "t3://localhost:7001");
Context ctx = new InitialContext(env);
String topicName = "JMSHelperTestQueue01";
String topicJNDI = DEST_JNDI_PREFIX + topicName;
System.out.println("topic name=" + topicName + ", jndi=" +
topicJNDI);
JMSHelper.createPermanentTopicAsync(ctx, JMS_SERVER_NAME,
topicName,
topicJNDI);
} catch (JMSException e) {
e.printStackTrace();
}
}
}
How do I use a temporary destination?
You must create a template on every JMSServer where you want to be able to create
temporary destinations. You can specify multiple JMSServer entries to support TemporaryTemplate
and the system will load balance among those JMS servers to setup the temporary
destination. See How do I start WLS and configure JMS? for a description about how
to configure JMS. The resulting template definition looks something like the following:
<JMSTemplate Name="MyTemplate"/>
The JMSServer is defined something like:
<JMSServer Name="MyJMSServer" TemporaryTemplate="MyTemplate"
Targets="MyServer" >
After the template name, you can set any queue/topic attribute you want in the template
(not including a JNDI name or topic multicast settings). The template is at the
outer most level; that is, it should not be nested in your <JMSServer>.
Temporary destinations can only be consumed by the creating connection. Using topics,
you create your temporary topic and subscribe to that temporary topic. If you want
someone to publish to that temporary topic, you need to tell that someone what your
topic is. You can send them a message and include your temporary topic in the JMSReplyTo
field. The creator of the TemporaryTopic and the subscriber must be one in the same.
import javax.jms.TopicSession;
TemporaryTopic myTopic = mySession.createTemporaryTopic();
TopicSubscriber = mySession.createSubscriber(myTopic);
Temporary topics do not get names and cannot be subscribed to by other connections.
When you create a temporary topic, the JMS provider returns a javax.jms.Topic. You
then need to advertise that topic to other parties (those who want to publish to
the topic), putting it in your JMSReplyTo field so that they can respond. In general,
no one else can subscribe to the topic. You advertise the topic any way you want.
Topics are serializable (or, in our case, externalizable), which allows you to pass
them around in RMI calls, through a file, binding it to a name in JNDI, etc. In
short, create the topic at the subscriber side and advertise so that others can
publish. You can get multiple subscribers on the same connection and get concurrent
processing using multiple sessions.
Which types of JDBC databases does WebLogic JMS support?
The JMS database can be any database that is accessible through a JDBC driver. WebLogic
supports and provides JDBC drivers for the following databases:
* Cloudscape
* Informix
* Microsoft SQL (MSSQL) Server (Versions 6.5 and 7)
* Oracle (Version 8.1.6)
* Sybase (Version 12)
The Multicast TTL setting for a cluster in the WebLogic Admin console sets which
of the following values?
The Multicast TTL setting for a cluster in the WebLogic Admin console sets which
of the following values?
a. Maximum time taken for multicast messages to reach their final destination
b. The number of routers a multicast message can pass through before the packet
can be discarded
c. The multicast address to be used by the messages sent from the cluster
d. Minimum time taken for broadcasting a multicast message from the cluster
Choice B is correct. The Multicast TTL(TTL-Time to Live) setting specifies the number
of routers a multicast message can pass through before the packet can be discarded.
To configure the multicast TTL for a cluster, you should change the Multicast TTL
value in the WebLogic Server administration console. This sets the number of network
hops a multicast message makes before the packet can be discarded.
If you choose to distribute a cluster over a WAN (or across multiple subnets), you
must plan and configure your network topology to ensure that multicast messages
are reliably transmitted to all servers in the cluster. One of the requirements
to be met by the network is that the multicast Time To Live (TTL) value must be
high enough to ensure that routers do not discard multicast packets before they
reach their final destination.
How do I use persistence?
Use the following guidelines:
1. Make sure the JMSServer you are using has a store configured. The JMSServer configuration
entry in the config.xml file should contain a line of the form
Store="<YOUR-STORE-NAME>"
Note that if JMS boots without a store configured, it is assumed the customer did
not want one, and persistent messages are silently downgraded to non-persistent
(as specified for JMS 1.0.2).
2. Make sure you are not using "Message.setJMSDeliveryMode". This is overwritten,
as it is a vendor-only method.
3. Make sure you are calling either:
QueueSender.send(msg, deliveryMode, ...)
-- or --
QueueSender.setDeliveryMode(deliveryMode)
-- or --
set the DefaultDeliveryMode mode on connection factory in the config.xml file to
persistent (the QueueSender.setDeliver/send overrides this value). Similarly, for
topics, you would set this via the TopicPublisher.
4. Make sure you don't have "DeliveryModeOverride" set to Non-Persistent
on the Destination in the config.xml file.
5. If you are using pub/sub, only durable subscriptions persist messages. Non-durable
subscriptions have no need to persist messages, as by definition they only exist
for the life of the server.
6. If you are using JDBC, the JDBC tables, JMSSTATE and JMSSTORE, are created automatically
when the JMS server boots. The DDL files used to create the tables are stored in
weblogic.jar in weblogic/jms/ddl. The example configuration below shows a JDBC store
for Oracle (client version 8.1.7 or later is needed to run with WLS 6.1 on JDK 1.3).
To manually create the tables (also deleting any existing tables), run java utils.Schema
as described in the previous question.
See the question, "How do I start WLS and configure JMS?" for a description
of how to configure JMS.
Here is a sample config.xml file resulting from configuring JMS. It should look
similar to yours. If you want JMS to use a file store instead of a database, just
change JDBCStore to FileStore in the JMSServer section.
<Server Name="myserver"
ListenPort="7001" DefaultProtocol="t3"
ThreadPoolSize="8" >
</Server>
<Security Realm="defaultRealm"
GuestDisabled="false" />
<Realm Name="defaultRealm"
FileRealm="defaultFileRealm" />
<FileRealm Name="defaultFileRealm"
/>
<JMSServer Name="TestJMSServer"
TemporaryTemplate="TestTemplate1"
Targets="myserver" Store="JDBCStore">
<JMSQueue Name="TestQueue1"
JNDIName="jms.queue.TestQueue1"
Template="TestTemplate1"
/>
</JMSServer>
<JMSTemplate Name="TestTemplate1"
/>
<JMSFileStore Name="FileStore"
Directory="myfilestore"
JMSServer="TestJMSServer"
/>
<JMSJDBCStore Name="JDBCStore"
ConnectionPool="testpool2"
JMSServer="TestJMSServer"
/>
<JDBCConnectionPool Name="testpool2"
Targets="myserver"
URL="jdbc:weblogic:oracle"
DriverName="weblogic.jdbc.oci.Driver"
InitialCapacity="0"
MaxCapacity="1"
CapacityIncrement="1"
Properties="user=SCOTT;password=tiger;server=bay816"
/>
</Domain>
The following is a sample class that sends
a Topic message on construction:
import javax.naming.*;
import javax.jms.*;
import java.util.Hashtable;
public class t
{
public final static String DESTINATION="jms.topic.TestTopic1";
private TopicConnectionFactory connectionFactory;
private TopicConnection connection;
private TopicSession session;
private TopicPublisher producer;
private TextMessage message;
private Topic destination;
public t()
{
try {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"weblogic.jndi.WLInitialContextFactory");
env.put(Context.PROVIDER_URL, "t3://localhost:7001");
InitialContext ctx = new InitialContext(env);
destination = (Topic) ctx.lookup(DESTINATION);
connectionFactory = (TopicConnectionFactory)
ctx.lookup("javax.jms.TopicConnectionFactory");
connection = (TopicConnection)
connectionFactory.createTopicConnection();
session = (TopicSession) connection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);
producer = (TopicPublisher) session.createPublisher(destination);
producer.setDeliveryMode(DeliveryMode.PERSISTENT);
message = (TextMessage) session.createTextMessage();
message.setText("hello world");
producer.publish(message);
} catch (Exception e) {
}
}
}
How do the WLS JMS 6.1 server/destination message maximum and threshold values work?
The byte and message maximum values are quotas - not flow control. Message quotas
prevent a WebLogic JMS server from filling up with messages and possibly running
out of memory, causing unexpected results. When you reach your quota, JMS prevents
further sends with a ResourceAllocationException (rather than blocking). You can
set quotas on individual destinations or on a server as a whole.
The thresholds are also not flow control - though they would be better suited to
that application than the quotas. The thresholds are simply settings that when exceeded
cause a message to be logged to the console to let you know that you are falling
behind.
Note that the messages maximum setting on a connection factory is not a quota. This
specifies the maximum numbers of outstanding messages that can exist after they
have been pushed from the server but before an asynchronous consumer has seen them;
it defaults to a value of 10.
Does WebLogic JMS support clustering?
WebLogic JMS supports cluster-wide, transparent access to destinations from any
server in the cluster. A system administrator can establish cluster-wide, transparent
access to destinations from any server in the cluster by configuring multiple connection
factories and using targets to assign them to WebLogic Servers. Each connection
factory can be deployed on multiple WebLogic Servers.
The application uses the Java Naming and Directory Interface (JNDI) to look up a
connection factory and create a connection to establish communication with a JMS
server. Each JMS server handles requests for a set of destinations. Requests for
destinations not handled by a JMS server are forwarded to the appropriate server.
You can configure multiple JMS servers on the various nodes in the cluster as long
as you give them different names. You can assign destinations to the various JMS
servers.
One problem to be aware of is the propagation delay in replicating entries in JNDI.
If you have an MDB deployed on one node but reference a destination on another node,
the deployment may fail with a javax.naming.NamingException exception. The problem
occurs because the server is not synced up to the JNDI from the remote server (JMS
server) yet, so the JNDI lookup of destination as part of MDB deployment will fail.
One workaround is for each MDB to reference a local destination. Another approach
is deploy the MDBs after the server boots (plus a delay for JNDI propagation). To
get around losing messages before the MDB is deployed, use durable subscribers.
This problem is fixed for MDBs in WLS 6.1, where the MDB will be deployed and reconnection
will be retried until the destination is available. Note that this is still a problem
for EJBs in general that try to reference a non-local JMS destination.
Which of the following statements are true regarding the identity of two EJBs?
a. Two stateful session beans are identical if their data attributes are identical.
b. Two stateful session beans are identical if their session contexts are equal.
c. Two stateless session beans are identical if they are of the same type.
d. Two stateless session beans are identical if their session contexts are equal.
e. Two entity beans are identical if they have same primary key but different home
interface.
f. Two entity beans are identical if they have different primary key but same home
interface.
B and C are correct. Since the stateful session beans maintain the conversational
state of the clients, they are identical when their session contexts are equal.
Two stateful session beans may have identical data attributes, but if the session
contexts are different they are not identical. Thus choice A is incorrect and B
is correct. Since stateless beans do not retain the conversational state, they are
considered identical if they are of the same type. Thus choice C is correct.
If two entity objects have the same home interface and primary key, they are considered
identical. The EJB specification does not mention object equality based on the =
= operator. Also, if you compare two object references using the Java API, Object.equals(Object
obj), the result is unspecified. The only way to compare object equality is through
the isIdentical (EJBObject) API. Thus choice E and F are incorrect.
In the WebLogic server, if stateless session bean instances are getting frequently
created and removed, performance can improved by setting a high value for which
of the following?
a. max-beans-in-free-pool
b. max-beans-in-cache
c. max-beans-in-memory
d. max-stateless-beans-in-cache
Choice A is correct. WebLogic Server maintains a free pool of EJBs for every stateless
session bean class. The max-beans-in-free-pool element defines the size of this
pool. By default, max-beans-in-free-pool has no limit; the maximum number of beans
in the free pool is limited only by the available memory.
When EJBs are created, the session bean instance is created and given an identity.
When the client removes a bean, the bean instance is placed in the free pool. When
you create a subsequent bean, you can avoid object allocation by reusing the previous
instance that is in the free pool. So the max-beans-in-free-pool element can improve
performance if EJBs are frequently created and removed. Keeping this parameter too
high uses extra memory and keeping it too low causes unnecessary object creation.
WebLogic Server allows you to configure the number of active beans that are present
in the EJB cache (the in-memory space where beans exist). The max-beans-in-cache
element specifies the maximum number of objects of this class that are allowed in
memory. When max-bean-in-cache is reached, WebLogic Server passivates some EJBs
that have not been recently used by a client. Choices C and D are not valid properties.
What happens if acknowledge() is called within a transaction?
As per the JMS specification, when you are in a transaction, the acknowledgeMode
is ignored. If acknowledge() is called within a transaction, it is ignored.
How should I use sorted queues?
Destination keys are used to define the sort order for a specific destination. Destination
keys can be message header or property fields. For a list of valid message header
and property fields, refer to the Programming WebLogic JMS.
Queues can be sorted in ascending or descending order based on the destination key.
A destination is considered to be first-in-first-out if a destination key is defined
as ascending for the JMSMessageID message header field, and last-in-first-out if
defined as descending. The key defined for the JMSMessageID header field, if specified,
must be the last key defined in the list of keys.
You can define multiple destination keys to sort a destination.
The MaxPostTimeSecs attribute set in the Administration console under Servers or
virtual hosts section corresponds to which of the following?
a. The amount of time that WebLogic Server waits between receiving chunks of data
in an HTTP POST.
b. The total amount of time that WebLogic Server spends receiving HTTP POST data.
c. The time spent by WebLogic server to post data to other servers in the cluster.
d. The number of bytes of data received in a POST from a single request.
Choice B is correct. Web servers may face denial-of-service attacks, which is usually
carried out by sending huge amounts of data in an HTTP POST method. You can set
three attributes in WebLogic Server that help prevent this type of attack. These
attributes are set in the console, under Servers or virtual hosts. You can limit
the amount of time that WebLogic Server waits between receiving chunks of data in
an HTTP POST by setting the attribute PostTimeoutSecs.
The MaxPostTimeSecs attribute limits the total amount of time that WebLogic Server
spends receiving post data. If this limit is triggered, a PostTimeoutException is
thrown and a message is sent to the server log. MaxPostSize attribute limits the
number of bytes of data received in a POST from a single request. If this limit
is triggered, a MaxPostSizeExceeded exception is thrown and a message is sent to
the server log.
How do I get a thread dump to help track down a problem?
Ways to get a thread dump:
* Try running this from the command line (after running the setEnv script in /bea/wlserver6.1/config/mydomain/):
java weblogic.Admin -url t3://localhost:7001 THREAD_DUMP
* On Windows, from the console window, enter Ctrl+Break.
* On UNIX, signal the server using kill -3.
Why do I get an exception when trying to find a connection factory?
The exception is usually something like java.io.InvalidClassException or java.lang.NoClassDefFoundError.
Make sure weblogic.jar is in the CLASSPATH of the client. Also make sure you have
the correct Java run-time jar files included (i.e., you might need rt.jar).
What is the NO_ACKNOWLEDGE acknowledge mode used for?
The NO_ACKNOWLEDGE acknowledge mode indicates that received messages do not need
to be specifically acknowledged which improves performance, but risks that messages
are lost. This mode is supported for applications that do not require the quality
of service provided by session acknowledge and that do not want to incur the associated
overhead. v Messages sent to a NO_ACKNOWLEDGE session are immediately deleted from
the server. Messages received in this mode are not recovered and, as a result, messages
may be lost and/or duplicate message may be delivered if an initial attempt to deliver
a message fails.
Note: You should avoid using this mode if your application cannot handle lost or
duplicate messages. Duplicate messages may be sent if an initial attempt to deliver
a message fails.
In addition, we do not recommend that this acknowledge mode be used with persistent
messaging, as it implies a quality of service that may be too low for persistent
messaging to be useful.
When should I use server session pools and connection consumers?
WebLogic JMS implements an optional JMS facility for defining a server-managed pool
of server sessions. This facility enables an application to process messages concurrently.
A ConnectionConsumer object uses a server session to process received messages.
If message traffic is heavy, the connection consumer can load each server session
with multiple messages to minimize thread context switching. Multiple connection
consumers can share server sessions in a server session pool.
To learn how to use the connection consumers within an application, see the section
Processing Messages Concurrently in Programming WebLogic JMS, or the javax.jms.ConnectionConsumer
javadoc.
Note: Server session pools can also be implemented using Message Driven Beans. Using
MDBs is preferable to using server session pools - see the answer to the question,
"How do server session pools and Message Driven Beans compare?" For information
on using message driven beans to implement server session pools, see Programming
WebLogic Enterprise JavaBeans.
How do I publish an XML message?
Follow these steps:
1. Generate XML from the DOM document tree.
2. Serialize the generated DOM document to a StringWriter.
3. Call toString on the StringWriter and pass it into message.setText.
4. Publish the message.
Is it possible to send or receive a message from within a message listener?
Yes. You can send to or receive from any queue or topic from within in a message
listener.
If it's not an MDB, you can use the same Connection or Session that the onMessage()
is part of to do this. When you create your message listener, you pass in a session
in your constructor. Then you have access to the session in your onMessage method
and you would be able to make synchronous, not asynchronous, calls from within the
onMessage method. Do not use another Session that is servicing another onMessage()
because that would multi-thread that Session and Sessions don't support multi-threading.
When things are done non-transactionally, there can be duplicates or lost messages
(assuming your onMessage() code is attempting to forward messages):
1. If you call acknowledge after the publish() and the acknowledge fails for whatever
reason (network/server failure), then you will see the message again and will end
up publishing twice (possible duplicate semantics). You can try to keep track of
sequence numbers to detect duplicates but this is not easy.
2. If you call acknowledge before the publish(), you get at-most-once semantics.
If the publish() fails, you don't know if the failure occurred before or after
the message reached the server.
If you want exactly once, transactional semantics using onMessage, you must use
transactional MDBs. The onMessage() for a transactional MDB starts the transaction,
includes the WebLogic Server JMS message received within that transaction and the
publish() would also be in the same transaction. The following code sends a response
to each message that it receives. It creates the connection, etc. in the ejbCreate
method so that it doesn't need to create it every time onMessage is called.
The QueueSender is anonymous (null Queue) since we don't know to whom we will
have to reply. The ejbRemove method cleans up by closing the connection. This same
approach can be used to create a receiver, subscriber or publisher.
import javax.ejb.CreateException;
import javax.ejb.EJBContext;
import javax.naming.*;
import javax.naming.directory.*;
import java.util.Hashtable;
import javax.ejb.MessageDrivenBean;
import javax.ejb.MessageDrivenContext;
import javax.jms.*;
public class MDB
implements MessageDrivenBean, MessageListener {
public static final String WLSqcf =
"javax.jms.QueueConnectionFactory";
public static final String WLSqname =
"jms.queue.TestQueue1";
public static final String WLSurl =
"t3://localhost:7001";
public static final String WLSJNDIfactory =
"weblogic.jndi.WLInitialContextFactory";
private MessageDrivenContext context;
private QueueSession session;
private QueueConnection connection = null;
private QueueConnectionFactory factory;
private InitialContext ctx;
private QueueSender QueueSender;
// Required - public constructor with no argument
public MDB() {}
// Required - ejbActivate
public void ejbActivate() {}
// Required - ejbRemove
public void ejbRemove() {
context = null;
if (connection != null) {
try {
connection.close();
} catch(Exception e) {}
connection = null;
}
}
// Required - ejbPassivate
public void ejbPassivate() {}
public void setMessageDrivenContext(
MessageDrivenContext mycontext) {
context = mycontext;
}
// Required - ejbCreate() with no arguments
public void ejbCreate () throws CreateException {
try {
// Get the initial context
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, WLSJNDIfactory);
env.put(Context.PROVIDER_URL, WLSurl);
env.put(Context.REFERRAL, "throw");
ctx = new InitialContext(env);
factory = (QueueConnectionFactory)ctx.lookup(WLSqcf);
// Create a QueueConnection, QueueSession, QueueSender
connection = factory.createQueueConnection();
session = connection.createQueueSession(false,
Session.AUTO_ACKNOWLEDGE);
queueSender = session.createSender(null);
connection.start();
} catch (Exception e) {
throw(new CreateException(e.toString()));
}
}
// Implementation of MessageListener
// Throws no exceptions
public void onMessage(Message msg) {
try {
System.out.println("MDB: " +
((TextMessage)msg).getText());
msg.clearBody();
((TextMessage)msg).setText("reply message");
queueSender.send((Queue)msg.getJMSReplyTo(), msg);
}
catch(Exception e) { // Catch any exception
e.printStackTrace();
}
}
}
This approach creates a connection per EJB/MDB instance, so you might want to create
a producer pool that is shared by the EJB instances. This is done by writing a class
that populates a static pool with producers (see the next question for a sample
producer pool). The onMessage call grabs a producer when needed. Since Sessions
must be single threaded, make sure there is only one producer per session within
the producer pool.
What are pending messages in the console?
Pending means the message could have been:
* sent in a transaction but not committed.
* received and not acknowledged.
* received and not committed.
* subject to a redelivery delay (as of WebLogic Server 6.1).
* subject to a delivery time (as of WebLogic Server 6.1).
A rolled back message remains pending until the transaction actually rolls back.
Rolling it back multiple times does not cause double counting, nor does an exception
that set a transaction as rollbackOnly followed by an actual rollback.
Current implies messages that are not pending.
Total implies total since server last started. The byte counts only consider the
payload of messages which includes the properties and the body but not the header.
Is it better to have more or fewer sessions for a given number of subscribers?
Using N sessions for N subscribers gives you concurrency up to N simultaneous threads
of execution provided you have as many threads to work with. Each Session gets its
own thread as long as there are enough threads available. Otherwise, the sessions
serially reuse the available threads.
One session for N subscribers serializes all subscribers through that one session.
If the load is heavy they may not be able to keep up without the extra threads.
If you are using CLIENT_ACKNOWLEDGE, N sessions gives you N separate message streams
that can be individually recovered. Having one session crosses the streams giving
you less control.
A client invokes a method on a stateful session bean instance deployed in the WebLogic
Server. While the method execution is in progress another method call arrives on
the server. What will be the result?
a. RemoteException is thrown if the value of concurrency-strategy property is false
b. EJBException is thrown if the value of concurrency-strategy property is false
c. The EJB container blocks the concurrent method call and allows it to proceed
when the previous call has completed if the value of allow-concurrent-calls is true
d. In all cases, RemoteException is thrown
Choice C is correct. By default, simultaneous access to a stateful session EJB results
in a RemoteException. However, you can set the allow-concurrent-calls option in
the WebLogic EJB deployment descriptor to specify that a stateful session bean instance
will allow concurrent method calls. This access restriction on stateful session
EJBs applies whether the EJB client is remote or internal to WebLogic Server. By
default, allows-concurrent-calls is false. However, when this value is set to true,
the EJB container blocks the concurrent method call and allows it to proceed when
the previous call has completed.
The concurrency-strategy element determines ejbLoad() and ejbStore() behavior for
entity EJB instances.
What is the standard way to create threads, do initialization, etc. within the application
server?
Threads should generally not be created by the user directly is because things may
not work correctly. User-created threads do not have some of the thread-local variables
pre-set by WebLogic when it creates it's own execute threads, the associated
transaction context, or the environment such as the proper class loader. The WebLogic-specific
way of doing this is with a startup class or using the WebLogic Time Services. The
portable way to do this is to define a load-on-startup servlet, doing the initialization
in the init() method and the cleanup in the destroy() method. The servlet itself
does nothing. This approach also allows for undeploy/redeploy of the application
without restarting the server, including proper cleanup/initialization each time.
It also providers more dynamic management of the dependent classes without restarting
the server.
What should an XPATH selector look like?
The following is an example of an XPATH selector. Pay careful attention to the use
of double and single quotes.
String selector =
"JMS_BEA_SELECT('xpath', '/recipient/transport/text()')
=
'email'";
tsubscriber = tsession.createSubscriber(topic, selector, false);
JMS_BEA_SELECT is a built-in function in WebLogic Server JMS SQL syntax. You put
it in your selector string when you create a consumer. Note the use of single quotes
around xpath, the XML tab, and the string value.
How do I put a message back on the queue for processing?
The following are several approaches:
* Use a transacted session, then rollback the session so the message will go back
to the queue.
* Use Session.CLIENT_ACKNOWLEDGE when creating a session, then recover the session
so the message will go back to the queue.
* Use a JTA transaction, then rollback the transaction so the message will go back
to the queue.
What can I do when I get java.lang.OutOfMemoryError because producers are faster
than consumers?
Quotas can be used to help this situation. Your sender will then receive ResourceAllocationExceptions
and the server will stay up. WLS 6.X does not support paging of messages out of
memory.
As of WLS 6.1 SP02 or later, you can use the Message Paging feature, which can free
up valuable virtual memory during peak message load periods by swapping out messages
from virtual memory to persistent storage when message loads reach a specified threshold.
How do I debug WebLogic Server using Visual Cafe 4.1?
You can install VisualCafe Enterprise Edition 4.1 and attach it to the server, pretty
much as it worked for 3.X.
The following are steps for debugging using VC 4.1. You may change the directory
names as necessary.
1. Install it under D:VisualCafeEE. No special options are needed.
2. Install the license under C:Program FilesCommon FilesWebGain Shared.
3. Start ddservices by selecting Start -> Programs -> WebGain Studio Professional
->Visual Cafe Enterprise Edition 4.1 -> Distributed Debugging Services ->
Start DD Services (Java2 - 1.3)
4. Start WebLogic Server using debugvm.exe instead of java.exe.
cd D:beawlserver6.1configmydomain
setEnv
edit startWebLogic.cmd
change "%JAVA_HOME%binjava" -hotspot -ms64m -mx64m to visualcafeEEjdk13bindebugvm.exe
5. Run startWebLogic. It prints out some debugging information.
6. Run VisualCafe - Start -> Programs -> WebGain Studio Professional ->
Visual Cafe Enterprise Edition 4.1 -> Visual Cafe Enterprise Edition 4.1
7. From the File menu, select Attach to Process. If everything is working correctly,
you should see your machine name.
8. Click the + sign to expand the tree and select your running WebLogic Server.
How does concurrency work for message-driven beans?
The way concurrency is achieved for Queues is by spawning one JMSSession per MDB
instance in the pool. Since JMSSessions are processed in parallel by JMS, concurrency
is obtained naturally this way and JMS takes care of delivering the message to,
at most, one listener. If an MDB is deployed to multiple servers in a cluster, JMSSessions
are created for each MDB instance on each server and load balancing will be done
across them.
For Topics in WebLogic JMS 6.1, there is one JMSSession per bean instance in the
pool. Because of the way Topics work, the session, and thus every bean instance,
receives a copy of each message published on that Topic. (There was also a problem
that caused parallel processing not to work correctly. This has been fixed for WLS
6.0 Service Pack 1.) Within a single server, one topic consumer is used to pass
out messages to multiple threads to get the concurrency while producing only a single
copy of each message. You can configure multiple MDBs to listen on the same topic
and each MDB will receive a copy of every message. When using multiple servers,
each server gets its own consumer and therefore its own copy of each message. It
is not currently possible to share a consumer across multiple servers. If you want
a message to be processed by exactly one MDB, use a queue.
One customer had an example where topic MDBs are needed in which there will be multiple
implementations of the MDBs listening on the same topic. In other words, more than
one MDB with a different implementation may be subscribing to the same topic. The
client has no advanced way of knowing how many different kinds of MDBs may be listening
on the same topic, but it is possible for there to be more than one listener, therefore
topics, not queues. For each kind of MDB listening on the topic, the message is
delivered exactly once (i.e., the message will be delivered exactly once to an instance
in each named MDB pool listening on the topic).
Can an MDB be a message producer or both a producer and consumer?
Yes. You have no JMS context inside the MDB so you will need to establish a connection,
session and producer yourself. One option is to do this every time you come into
the onMessage routine for the MDB. This is sufficient if the message rate is relatively
low. The second option is to establish the necessary objects in ejbActivate(). Note
that the objects are not serializable so they can't be passivated for a stateful
session bean or an entity bean. When the EJB deactivates, you need to close the
associated objects. The third option is that you could build up a JMS connection/sender
session pool within a startup class complete with your own synchronization and blocking
to get a connection. There is an example in the answer to the question "Is
it possible to send or receive a message from within a message listener?"
How do I use JTA transactions within an MDB?
In the ejb-jar.xml file, define the transaction type as Container and the trans-attribute
as Required, as in the following example:
<ejb-jar>
<enterprise-beans>
<message-driven>
<ejb-name>MDB</ejb-name>
<ejb-class>MDB</ejb-class>
<transaction-type>Container</transaction-type>
<message-driven-destination>
<destination-type>javax.jms.Queue</destination-type>
</message-driven-destination>
</message-driven>
</enterprise-beans>
<assembly-descriptor>
<container-transaction>
<method>
<ejb-name>MDB</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>
Required
</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>
To rollback a transaction, you can either use the WebLogic extension TXHelper or
you can use the MDB context as in the following code examples:
UserTransaction ut =
weblogic.transaction.TXHelper.getUserTransaction();
ut.setRollbackOnly();
or
private MessageDrivenContext context;
public void setMessageDrivenContext(
MessageDrivenContext mycontext) {
context = mycontext;
}
public void onMessage(Message msg) {
try { // some logic
}
catch(Exception e) {
System.out.println("MDB doing rollback");
context.setRollbackOnly();
}
Can the messaging bridge handle two-phase or global transactions between separate
WebLogic Server domains or between different releases?
Yes, as long as the communication is between source and target WebLogic domains
that are both running release 6.1 SP3 or later, and the bridge is configured to
use the Exactly-once quality of service.
Can I configure the messaging bridge to automatically downgrade the quality of service
if the Exactly-once service is not available on either the source or target bridge
destination?
Yes, just make sure to select the QOS Degradation Allowed check box on the Messaging
Bridge -> Configuration -> General administration console page.
Can the messaging bridge forward durable subscription messages between separate
WebLogic Server 6.1 and release 7.0 or later domains?
Yes, as long as the WebLogic 7.0 domain is using Service Pack 1 or later. To enable
durable messages across the messaging bridge using the Administration Console, select
the Durability Enabled attribute on the Messaging Bridge —> Configuration —>
General tab.
Which of the following is NOT true about the security implementation in the WebLogic
Server?
a. Servlets, JSPs, EJBs, RMI objects, and Java applications use the Java Authentication
and Authorization Service to authenticate WebLogic Server.
b. The default security realm in WebLogic Server is the File realm.
c. The default authentication scheme for WebLogic Server is two-way authentication.
d. An Administration Server may contain configuration information for one WebLogic
Server or a cluster of WebLogic servers.
Choice C is correct because it is not true about the security in WebLogic server.
A,B and D are true. Servlets, JSPs, EJBs, RMI objects, and Java applications use
the Java Authentication and Authorization Service to authenticate WebLogic Server.
JAAS is a standard extension to the Java 2 Software Development Kit. The authentication
component of JAAS provides the ability to reliably and securely maintain client
identity, regardless of whether the code is running as a Java application, a JSP,
an EJB, an RMI object or a servlet.
In WebLogic Server, JAAS is layered over the existing Security Service Provider
Interface (SPI) allowing the continued use of realm-based authorization. The default
security realm in WebLogic Server is the File realm. When WebLogic Server is started,
the File realm creates User, Group, and ACL objects from properties defined through
the Administration Console in WebLogic Server and stored in the fileRealm.properties
file. The File realm is designed for use with 1,000 or fewer users, for more no
of users, an alternate security realm should be used. In WebLogic Server, an Administration
Server is a WebLogic Server that functions as the central source of all configuration
information. An Administration Server may contain configuration information for
one WebLogic Server or a cluster of WebLogic servers.
Which of the following are true about the transaction support in the WebLogic server?
a. WebLogic Server allows transactions to be terminated only by the client that
created the transaction.
b. WebLogic Server does not support multithreaded transactional clients.
c. A client or a server object cannot invoke methods on an object that is participating
in another transaction.
d. WebLogic server supports Nested Transactions
Choices A and C are correct. WebLogic Server provides a Transaction Service that
supports transactions in EJB and RMI applications. WebLogic Server allows transactions
to be terminated only by the client that created the transaction. WebLogic Server
implements the flat transaction model. Nested transactions are not supported.
WebLogic Server supports multithreaded transactional clients. Clients can make transaction
requests concurrently in multiple threads. In WebLogic Server, a client or a server
object cannot invoke methods on an object that is infected with (or participating
in) another transaction. The method invocation issued by the client or the server
will return an exception. Also in WebLogic Server, clients using third-party implementations
of the Java Transaction API (for Java applications) are not supported.
How does WebLogic support CORBA and client communication via IIOP?
"CORBA" support means many things to many people. It often means simply
IIOP /ORB support and not much on CORBA services. WebLogic supports CORBA in multiple
ways.
First, Java clients can tunnel through a CORBA environment to WebLogic Server. We
call this "IIOP tunneling," and it is intended for use with applets coming
through an IIOP firewall, such as the IONA Wonderwall product. This is a Java-to-Java
model riding over an IIOP communications framework.
WebLogic RMI over IIOP provides RMI services for many clients (including CORBA clients)
over IIOP.
WebLogic Enterprise Connectivity enables you to create IIOP connection pools to
a BEA WebLogic Enterprise System, allowing you to execute WebLogic Enterprise CORBA
objects from WebLogic Server servlets and Enterprise JavaBeans.
Why
do I get NoClassDefFound/Too Many Open files messages on Solaris?
Why do I get "NoClassDefFound"/"Too Many Open files"messages
on Solaris?
Problem: When I am using WebLogic Server on Solaris and try to run my application,
I get a "NoClassDefFound" error, although the class causing the error
does exist and is in the right directory. In fact, there are other classes in the
same directory that are getting loaded. I also get a "Too many open files"
error.
We have seen this situation when the user account runs out of file descriptors.
On Solaris, each user account has a certain limited number of file descriptors.
You can find out how many file descriptors you have with the limit command in csh.
You can increase file descriptors if you have enough privileges with the ulimit
command in the csh. Otherwise, ask your system administrator to increase the file
descriptors available to your processes.
The home of a Product CMP entity bean has a finder method, which returns an Enumeration
of all the products whose price falls below a certain value, which is passed as
the method argument. If there are no products in the database to match the above
criteria what will be the result of a call to this finder method?
a. EJBException is thrown
b. ObjectNotFoundException is thrown
c. NoSuchEntityException is thrown
d. An empty enumeration is returned
Choice D is correct. Find methods that return a single remote reference throw a
FinderException if an application error occurs and a ObjectNotFoundException if
a matching bean cannot be found. The ObjectNotFoundException is a subtype of FinderException
and is only thrown by find methods, which return single remote references.
The findByPrimaryKey() method returns only one remote reference since there is a
one-to-one relationship between a primary key's value and an entity. Find methods
that return an Enumeration or Collection type return an empty collection or enumeration
if no matching beans can be found or throw a FinderException if an application error
occurs. NoSuchEntityException is a system exception thrown by the ejbLoad() method
of an entity bean when the database row to be loaded is not found and also by the
ejbStore() method when the database row to be updated cannot be found. It is a subclass
of EJBException.
In CORBA, which of the following files generated by the idltojava compiler must
be compiled before running the server application?
a. Only The Holder Classes
b. Only The Helper and Holder Classes
c. The implementation class(es) written by the user to provide body to the methods
defined in the interface class
d. All idltojava generated files (stubs, skeletons, helper, holder and interface
classes)
Choice C and D are correct. The Helper class (a final class) provides auxiliary
functionality, notably the narrow() method required to cast CORBA object references
to their proper types. The Holder class provides operations for out and inout arguments,
which CORBA has but which do not map easily to Java's semantics. The server
application cannot be compiled successfully until the implementation class(es) has/have
been written and compiled. All the other generated files however must be compiled
to form '.class' files from the '.java' files. Thus all the
implementation classes written by the user and all the "idltojava" generated
files must be complied to run the CORBA Server.
How do I increase WebLogic Server memory?
Increase the allocation of Java heap memory for WebLogic Server. (Set the minimum
and the maximum to the same size.) Start WebLogic Server with the -ms32m option
to increase the allocation, as in this example:
$ java ... -ms32m -mx32m ...
This allocates 32 megabytes of Java heap memory to WebLogic Server, which improves
performance and allows WebLogic Server to handle more simultaneous connections.
You can increase this value if necessary.
Java-CORBA integration: RMI-IIOP or Java IDL?
It is important to understand the distinction between these two ways of integrating
Java with CORBA.
RMI-IIOP is for Java programmers who want to program to the RMI interfaces but use
IIOP as the underlying transport. RMI-IIOP provides interoperability with other
CORBA objects implemented in various languages, but only if all the remote interfaces
are originally defined as Java RMI interfaces. It is of particular interest to programmers
using Enterprise JavaBeans (EJBs), because the remote object model for EJB is RMI-based.
Java IDL is for CORBA programmers who want to program in Java based on interfaces
defined in CORBA IDL. This is "business as usual" CORBA programming, supporting
Java in exactly the same way as other languages like C++ or COBOL.
What is the function of T3 in WebLogic Server?
T3 provides a framework for WebLogic Server messages that support for enhancements.
These enhancements include abbreviations and features, such as object replacement,
that work in the context of WebLogic Server clusters and HTTP and other product
tunneling.
T3 predates Java Object Serialization and RMI, while closely tracking and leveraging
these specifications. T3 is a superset of Java Object. Serialization or RMI; anything
you can do in Java Object Serialization and RMI can be done over T3.
T3 is mandated between WebLogic Servers and between programmatic clients and a WebLogic
Server cluster. HTTP and IIOP are optional protocols that can be used to communicate
between other processes and WebLogic Server. It depends on what you want to do.
For example, when you want to communicate between
* A browser and WebLogic Server-use HTTP
* An ORB and WebLogic Server-IIOP.
How do I call a servlet with parameters in the URL?
The usual format of a servlet parameter is a name=value pair that comes after a
question-mark (?) at the end of the URL. To access these parameters, call the getParameter()
method on the HttpServletRequest object, then write code to test the strings. For
example, if your URL parameters are "func=topic," where your URL appears
as:
http://www.myserver.com/myservlet?func=topic
then you could parse the parameter as follows, where "req" is the HttpServletRequest
object:
String func = req.getParameter("func");
if (func.equalsIgnoreCase("topic")) {
. . . do some work
}
Which of the statements below is true for a web application using session management?
a.) The session object is invalidated, when the session times out.
b.) The session object is invalidated, when sessionInvalidate() method of HttpSession
is invoked.
a. Both of the above statements are true.
b. Only statement a.) is true.
c. Only statement b.) is true.
d. None of the above statements is true.
B is the correct choice. The session object will become invalid in either of the
following scenarios:
a.) When the session times out.
b.) When invalidate() method of the HttpSession interface is invoked.
Please note that invalidate() and not sessionInvalidate() is the method of HttpSession
interface. Thus choice B is correct.
Why
ca not I boot WebLogic Server when using the LDAP Security Realm?
When using an alternative security realm or a custom security realm in WebLogic
Server, you must configure and enable the Caching realm.
When the LDAP server in Microsoft Site Server is installed and the root of the LDAP
directory is created, a number of organizational units are created by default. Under
Groups there is a default organization unit called NTGroups with a default group
called Administrators which is empty. By default, WebLogic Server also provides
a Group called Administrators that contains a member System which is the User under
which WebLogic Server is started. If you use the defaults in Microsoft Site Server
and start creating your own Groups under the default organizational units, WebLogic
Server will not start. You need to create your own organizational unit in the LDAP
directory and create your Groups under that organizational unit.
If you have two Groups in the LDAP directory with the same name, WebLogic Server
cannot properly authenticate the Users in the Groups. The LDAP security realm uses
the Group's DN (distinguished name) to locate Groups in the LDAP directory.
If you create more than one group with the same name, WebLogic Server only authenticates
the Users in the first Group it locates. You must use unique Group names when using
the LDAP security realm.
The LDAP realm V2 does not provide the following functionality provided in the LDAP
realm V1:
* Listing all Users
* Listing the members of a Group
* The AuthProtocol and User Authentication mechanisms for authenticating the LDAP
server.
The LDAP security realm needs to know where the Users and Groups are stored in the
LDAP directory used with the security realm. This is done by specifying the distinguished
names (DNs) of the LDAP directories containing the Users and Groups.
In LDAP, a DN starts with the leaf node and goes to the root node. The following
figure shows a branch of a LDAP directory.
root
|
|
o=acme.com
|
|
ou=Groups
The DN for this branch would be specified as ou=Groups, o=acme.com.
In LDAP realm V1, you specify DNs via the GroupDN and UserDN attributes on the LDAPRealm
MBean or through the Administration Console. However, you must reverse the DNs so
the example DN would be specified as:
groupDN="o=acme.com, ou=Groups"
In LDAP realm V2, you specify DNs by adding user.dn and group.dn properties to the
Configuration attribute of the CustomRealm MBean or through the Administration Console.
Unlike LDAP realm V1, you do not have to reverse the DN. For example, the user.dn
and group.dn properties for a LDAP realm V2 are specified as follows:
ConfigurationData="..., group.dn=ou=Groups, o=acme.com,..."
In short, the LDAP realm V1 requires reverse DNs and the LDAP realm V2 requires
normal DNs.
A common error customers make when switching between LDAP realm V1 and LDAP realm
V2 is copying over the reverse DNs thus causing the LDAP realm to stop working.
Check your DN specifications when migrating from LDAP realm V1 to LDAP realm V2.
How do I restrict access to servlets and JSPs?
The Java Servlet API Specification v2.2 allows you to declaratively restrict access
to specific Servlets and JSPs using the Web Application Deployment descriptor. Section
13.3.2 of the specification has an example deployment descriptor that uses declarative
security. For more information, see Programming WebLogic HTTP Servlets.
Which XML parser comes with WebLogic Server 6.1?
We bundle a parser, based on Apache's Xerces 1.3.1 parser, in WebLogic Server
6.1. In addition, we include a WebLogic proprietary high-performance non-validating
parser that you can use for small to medium sized XML documents. The WebLogic XML
Registry allows you to configure the parser you want to use for specific document
types.
How can I avoid ResourceExceptions when sending more requests for database connections
from the pool than are currently available?
The fundamental problem is too few resources (database connections in the connection
pool) for the work load. The correct response is to increase the maximum number
of connections in the connection pool. Optimally designed applications only require
the server to have one pool connection per execute thread.
The proper application response to a resource exception is not to retry the request
in a tight loop, which would tie up execute threads on the server.
You should design your application to gracefully fail if no connections are available.
Try to ensure that you get the connection as late as possible in your application
code and return them to the pool as early as possible so that you do not see as
many NoResource exceptions. It is better to have the connection as a method level
variable and close the connection in a finally block as in the following example:
try{
...
} catch(Exception handleEx) {
...
} finally {
try{ conn.close();
}catch (Exception ignore){} // always return the connection to pool
}
How do I bind string values in a PreparedStatement?
Suppose you are trying to tget the PreparedStatement class to bind Strings in a
statement. The setString() method doesn't seem to work. Here is how you have
set up the PreparedStatement:
String pstmt = "select n_name from n_table where n_name LIKE
'?%'";
PreparedStatement ps = conn.prepareStatement(pstmt);
ps.setString(1, "SMIT");
ResultSet rs = ps.executeQuery();
The preceding code does not work because the complete value needs to be specified
in a String (without using embedded quotes) and then bound to an unquoted question-mark
(?). Here is the corrected code:
String matchvalue = "smit%";
String pstmt = "select n_name from n_table where n_name LIKE ?";
PreparedStatement ps = conn.prepareStatement(pstmt);
ps.setString(1, matchvalue);
ResultSet rs = ps.executeQuery();
What is error ORA-6502?
The default length of a string bound to an OUTPUT parameter of a CallableStatement
is 128 characters. If the value you assign to the bound parameter exceeds that length,
you will get this error.
You can adjust the length of the value of the bound parameter by passing an explicit
length with the scale argument to the CallableStatement.registerOutputParameter()
method.
How do I use a startup class to initialize and later reference JMS objects?
You can use a shutdown class that does something like the following: JMSobject WLSobject
= null; try { WLSobject = JMSStartUp.getJMSobject(); WLSobject.JMSCleanup(); } catch(Exception
e) {} Servlets can provide a nice solution to provide both initialization and cleanup.
|