Professional Documents
Culture Documents
Master of Science in Information Technology (MScIT-NEW) - Semester 3
Master of Science in Information Technology (MScIT-NEW) - Semester 3
Master of Science in Information Technology (MScIT-NEW) - Semester 3
Semester 3
MT0045 –: Java– 2 Credits
(Book ID: B0831)
Assignment Set – 2 (20 Marks)
Multithreaded
Distributed
Multithreaded
Multithreading allows two parts of the same program to run concurrently. This article
discusses how to pull off this performance-improving feat in J A program or process can
contain multiple threads that execute instructions according to program code. Like
multiple processes that can run on one computer, multiple threads appear to be doing
their work in parallel. Implemented on a multi-processor machine, they actually can work
in parallel. Unlike processes, threads share the same address space; that is, they can read
and write the same variables and data structuresava.
In a multithreaded program, threads are obtained from the pool of available ready-to-run
threads and run on the available system CPUs. The OS can move threads from the
processor to either a ready or blocking queue, in which case the thread is said to have
"yielded" the processor. Alternatively, the Java virtual machine (JVM) can manage thread
movement -- under either a cooperative or preemptive model -- from a ready queue onto
the processor, where the thread can begin executing its program code.
Cooperative threading allows the threads to decide when they should give up the
processor to other waiting threads. The application developer determines exactly when
threads will yield to other threads, allowing them to work very efficiently with one
another. A disadvantage is that a malicious or poorly written thread can starve other
threads while it consumes all available CPU time.
Under the preemptive threading model, the OS interrupts threads at any time, usually
after allowing them to run for a period of time (known as a time-slice). As a result, no
thread can ever unfairly hog the processor. However, interrupting threads at any time
poses problems for the program developer. Using our office example, consider what
would happen if a worker preempts another worker making copies halfway through her
copy job: the new worker would start his copy job on a machine that already has originals
on the glass or copies in the output tray. The preemptive threading model requires that
threads use shared resources appropriately, while the cooperative model requires threads
to share execution time. Because the JVM specification does not mandate a particular
threading model, Java developers must write programs for both models. We'll see how to
design programs for either model after looking a bit at threads and communication among
threads
Distributed
Java Distributed Computing offers a general introduction to distributed computing,
meaning programs that run on two or more systems. It focuses primarily on how to
structure and write distributed applications and discusses issues like designing protocols,
security, working with databases, and dealing with low bandwidth situations
2
Figure 3-1. General architecture for distributed object systems
With an object fully registered with a server, the client can now request an instance of the
class through the naming service. The runtime transactions involved in requesting and
using a remote object are shown in Figure 3-2. The naming service routes the client's
request to the server's object manager, which creates and initializes the new object using
the stored object skeleton. The new object is stored in the server's object storage area, and
an object handle is issued back to the client in the form of an object stub interface. This
stub is used by the client to interact with the remote object.
//Format string
if (b.indexOf(".") == 0){b = "0"+b;}
if(b.length() - b.indexOf(".") >= 4){ //More than 2 decimals
3
int unit = Integer.parseInt(b.substring(0, b.indexOf(".")));
int first = Integer.parseInt(b.substring(b.indexOf(".")+1, b.indexOf(".")+2));
int second = Integer.parseInt(b.substring(b.indexOf(".")+2, b.indexOf(".")+3));
int third = Integer.parseInt(b.substring(b.indexOf(".")+3, b.indexOf(".")+4));
if (third >= 5){ //Round
third = 0;second += 1;
if (second >= 10){
second = 0;first += 1;
if (first >= 10){
first = 0;unit += 1;
}
}
}
b = unit + "." + first + second;
}
else{
if (b.indexOf(".") == b.length()-1){b = b+"00";} //0 decimal
if (b.indexOf(".") == b.length()-2){b = b+"0";} //1 decimal
}
//Return result
return b;
}
An array is an ordered set of values grouped together under a single variable name
created by using an Array object constructor. You can create an Array literal by
specifying the name of the array and the values of all its elements. The following
example creates an array of three elements
The elements of an array are indexed using their ordinal number, starting with 0. You
could, therefore, refer to the second element in the above array ("Ford") as 'cars[1]'.
You can specify the number of elements in a new array by using a single numeric
parameter with the Array constructor.
4
If you create an array with a single numeric parameter, that number is stored in the
length property, and the array doesn't actually have any elements until some are
specifically assigned to it. If, however, the parameter is not a number, an array of 1
element is created and that value assigned to it. You can easily increase the size of an
array by assigning a value to an element higher than its current length.
NOTE:
PROPERTIES
constructor Property
The constructor property contains the function that created an object's prototype.
Syntax: object.constructor
index Property
The read-only index property for an array created by a regular expression match and
containing the zero-based index of that match.
Syntax: object.index
input Property
The read-only input property for an array created by a regular expression match and
containing the original string against which the match was made.
Syntax: object.input
length Property
The length property holds an unsigned 32 bit integer representing the length of the
array. It can be altered independently of the number of elements in the array.
Syntax: object.length
prototype Property
The prototype property allows the addition of properties to an array.
5
Syntax: object.prototype
METHODS
concat Method
The concat method joins two or more Array objects producing one new one. The
original Array objects are unaffected by this but, if one copy of a string or number is
altered, it is not reflected in the other, whereas a change to an object reference can be
seen in both copies.
join Method
The join method is used to join all the elements of an array into a single string
separated by a specified string separator (if none is specified, the default is a
comma).
Syntax: Array.join(separator)
pop Method
The pop method is used to remove and return the last element of an array. This
affects the length of the array.
Syntax: Array.pop()
push Method
The push method is used to add one or more elements to an array, returning the new
length of it. This affects the length of the array.
reverse Method
The reverse method, as the name implies, reverses the order of the elements in an
array making the first last and the last first. Syntax: Array.reverse()
shift Method
The shift method removes and returns the first element of an array. This affects the
length of the array.
Syntax: Array.shift()
6
slice Method
The slice method creates a new array from a selected section of an array.
Syntax: Array.slice(begin[,end])
splice Method
The splice method is used to add and/or remove elements of an array.
sort Method
The sort method sorts the elements of an array.
Syntax: Array.sort(compareFunction)
toSource Method
The toSource method is inherited from the Object object and returns the source code
of the array. For details see the Object.toSource method.
Syntax: Array.toSource()
toString Method
The toString method is inherited from the Object object and returns a string
representing the specified array and its elements. For more details see the
Object.toString method.
Syntax: Array.toString()
unshift Method
The unshift method adds one or more elements to the beginning of an array and
returns the new length.
valueOf Method
The valueOf method is inherited from the Object object and returns a primitive value
for a specified array. For details see the Object.valueOf method.
Syntax: Array.valueOf()
7
JavaScript Array
An array is a variable that can store many variables within it. Many programmers have
seen arrays in other languages, and they aren't that different in JavaScript.
The following points should always be remembered when using arrays in JavaScript:
JavaScript Code:
<script type="text/javascript">
<!—
myArray[0] = "Football";
myArray[1] = "Baseball";
myArray[2] = "Cricket";
//-->
8
</script>
Notice that you set values and get values from an array by specifying the position, in
brackets, of the value you want to use.
JavaScript Code:
<script type="text/javascript">
<!--
myArray2[0] = "Football";
myArray2[1] = "Baseball";
myArray2[2] = "Cricket";
myArray2.sort();
//-->
</script>
9
4. Write a program to explain the Exception Handling mechanisms in Java
using the keywords: try, catch and finally
The exception handling mechanisms in Java provide a clean way to check for errors
without cluttering code. Exceptions also provide a means to signal errors directly rather
than use flags or side effects such as fields that must be checked. Exceptions make the
error conditions that a method can signal an explicit part of the methods contract. The list
of exceptions can be seen by the programmer, checked by the compiler and preserved by
extended classes that override the method.
Exceptions in Java are objects. All exception types must extend the Java language class
Throwable or one of its subclasses. By convention, new exception types extend
Exception, a subclass of Throwable. Java exceptions are primarily checked exceptions i.e.
the compiler verifies that methods throw only exceptions that they have declared.
Java also avoids some of the problems with the exception handling mechanisms of C++,
by providing a finally clause. In C++, when an exception leaves the scope of a function,
all objects which are allocated on the stack are reclaimed, and their destructors are called.
Thus, if you want to free a resource or otherwise clean something up when an exception
passes by, you must put that code in the destructor of an object. This is artificial, error
prone, and inconvenient [4]. Every scope in Java can have a 'finally' clause. Any time a
scope is exited, regardless of the reason for that exit (e.g. the function could simply
return, or an exception could pass through it) the code in the finally clause is executed.
Thus, cleanup code does not have to be artificially put into some destructor. This makes
Java exceptions much easier to use than C++ exceptions.
Exceptions are thrown using a throw statement, which takes an object as a parameter [5].
An exception can also be generated by invoking a method that itself throws an exception.
The throws clause takes a comma separated list of exception types. The contract defined
10
by the throws clause is strictly enforced i.e. one can only throw an exception that has
been declared in the throws clause. This helps avoid bugs that result from not handling
errors since this states which exceptions are being thrown by methods and makes sure
they are dealt with in some way by the invoker.
Exceptions are caught by enclosing code in try blocks [5]. The body of the try statement
is executed until either an exception is thrown or it finishes successfully. If an exception
is thrown, each catch clause is examined in turn from first to last to see whether the type
of the exception object is assignable to the type declared in catch. Any number of catch
clauses can be associated with a particular try as long as each clause catches a different
type of exception.
If a finally clause is present in a try, its code is executed after all the processing in the try
is complete [5]. This happens regardless of how the completion was achieved i.e.
normally, through an exception or through a control flow statement like return or break.
Exception, that means exceptional errors. Actually exceptions are used for handling
errors in programs that occurs during the program execution. During the program
execution if any error occurs and you want to print your own message or the system
message about the error then you write the part of the program which generate the error
in the try{} block and catch the errors using catch() block. Exception turns the
direction of normal flow of the program control and send to the related catch() block.
Error that occurs during the program execution generate a specific object which has the
information about the errors occurred in the program.
In the following example code you will see that how the exception handling can be
done in java program. This example reads two integer numbers for the variables a and
b. If you enter any other character except number ( 0 - 9 ) then the error is caught by
NumberFormatException object. After that ex.getMessage() prints the information
about the error occurring causes.
11
Code of the program :
import java.io.*;
12
Master of Science in Information Technology (MScIT-NEW) –
Semester 3
MT0045 –: Java– 2 Credits
(Book ID: B0831)
Assignment Set – 2 (20 Marks)
DESCRIPTION
javah generates C header and source files that are needed to implement native methods.
The generated header and source files are used by C programs to reference an object's
instance variables from native source code. The .h file contains a struct definition whose
layout parallels the layout of the corresponding class. The fields in the struct correspond
to instance variables in the class.
The name of the header file and the structure declared within it are derived from the name
of the class. If the class passed to javah is inside a package, the package name is
prepended to both the header file name and the structure name. Underscores (_) are used
as name delimiters.
By default javah creates a header file for each class listed on the command line and puts
the files in the current directory. Use the -stubs option to create source files. Use the -o
option to concatenate the results for all listed classes into a single file.
The new native method interface, Java Native Interface (JNI), does not require header
information or stub files. javah can still be used to generate native method function
proptotypes needed for JNI-style native methods. javah produces JNI-style output by
default, and places the result in the .h file.
javah_g is a non-optimized version of javah suitable for use with debuggers like jdb.
OPTIONS
-o outputfile
Concatenates the resulting header or source files for all the classes listed on the
command line into outputfile. Only one of -o or -d may be used.
-d directory
13
Sets the directory where javah saves the header files or the stub files. Only one of
-d or -o may be used.
-stubs
Causes javah to generate C declarations from the Java object file.
-verbose
Indicates verbose output and causes javah to print a message to stdout concerning
the status of the generated files.
-help
Print help message for javah usage.
-version
Print out javah version information.
-jni
Causes javah to create an output file containing JNI-style native method function
prototypes. This is the default output, so use of -jni is optional.
-classpath path
Specifies the path javah uses to look up classes. Overrides the default or the
CLASSPATH environment variable if it is set. Directories are separated by semi-
colons. Thus the general format for path is:
.;<your_path>
For example:
.;C:\users\dac\classes;C:\tools\java\classes
For example, if directory foo contains a.jar and b.JAR, then the class path
element foo/* is expanded to a A.jar:b.JAR, except that the order of jar files is
unspecified. All jar files in the specified directory, even hidden ones, are included
in the list. A classpath entry consisting simply of * expands to a list of all the jar
files in the current directory. The CLASSPATH environment variable, where
defined, will be similarly expanded. Any classpath wildcard expansion occurs
before the Java virtual machine is started -- no Java program will ever see
unexpanded wildcards except by querying the environment. For example; by
invoking System.getenv("CLASSPATH").
-bootclasspath path
Specifies path from which to load bootstrap classes. By default, the bootstrap
classes are the classes implementing the core Java platform located in
jre\lib\rt.jar and several other jar files.
-old
14
Specifies that old JDK1.0-style header files should be generated.
-force
Specifies that output files should always be written.
-Joption
Pass option to the Java virtual machine, where option is one of the options
described on the reference page for the java application launcher. For example,
-J-Xms48m sets the startup memory to 48 megabytes.
ENVIRONMENT VARIABLES
CLASSPATH
Used to provide the system a path to user-defined classes. Directories are
separated by semi-colons, for example,
.;C:\users\dac\classes;C:\tools\java\classes
2. Interface Skeleton
Deprecated. no replacement. Skeletons are no longer required for remote method calls
in the Java 2 platform v1.2 and greater.
public interface Skeleton
TestRemote.java
/**
* This code is provided "AS IS", without warranty of any kind.
* This is a sample code, might be not completely error free.
* This site or author of this code doesn't take any responsibility
* what so ever resulting out of usage of this code.
*/
import java.rmi.*;
TestRemoteObj.java
/**
* This code is provided "AS IS", without warranty of any kind.
* This is a sample code, might be not completely error free.
* This site or author of this code doesn't take any responsibility
* what so ever resulting out of usage of this code.
*/
import java.rmi.*;
import java.rmi.server.*;
I2WRemoteServer.java
/**
* This code is provided "AS IS", without warranty of any kind.
* This is a sample code, might be not completely error free.
* This site or author of this code doesn't take any responsibility
* what so ever resulting out of usage of this code.
*/
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
rmic.exe TestRemoteObject
rmiregistry 9999
18
Primitive data type
• a basic type is a data type provided by a programming language as a basic
building block. Most languages allow more complicated composite types to be
recursively constructed starting from basic types.
• a built-in type is a data type for which the programming language provides built-
in support.
In most programming languages, all basic data types are built-in. In addition, many
languages also provide a set of composite data types. Opinions vary as to whether a built-
in type that is not basic should be considered "primitive".[citation needed]
Depending on the language and its implementation, primitive data types may or may not
have a one-to-one correspondence with objects in the computer's memory. However, one
usually expects operations on basic primitive data types to be the fastest language
constructs there are.[citation needed] Integer addition, for example, can be performed as a
single machine instruction, and some processors offer specific instructions to process
sequences of characters with a single instruction. In particular, the C standard mentions
that "a 'plain' int object has the natural size suggested by the architecture of the execution
environment". This means that int is likely to be 32 bits long on a 32-bit architecture.
Basic primitive types are almost always value types.
Most languages do not allow the behavior or capabilities of primitive (either built-in or
basic) data types to be modified by programs. Exceptions include Smalltalk, which
permits all data types to be extended within a program, adding to the operations that can
be performed on them or even redefining the built-in operations.
Overview
Almost all programming languages explicitly include the notion of data type, though
different languages may use different terminology. Most programming languages also
allow the programmer to define additional data types, usually by combining multiple
elements of other types and defining the valid operations of the new data type. For
example, a programmer might create a new data type named "Person" that specifies that
data interpreted as Person would include a name and a date of birth. Common data types
may include:
• integers,
• floating-point numbers (decimals), and
• alphanumeric strings.
19
Primitive Data Types
The Java programming language is statically-typed, which means that all variables must
first be declared before they can be used. This involves stating the variable's type and
name, as you've already seen:
int gear = 1;
Doing so tells your program that a field named "gear" exists, holds numerical data, and
has an initial value of "1". A variable's data type determines the values it may contain,
plus the operations that may be performed on it. In addition to int, the Java programming
language supports seven other primitive data types. A primitive type is predefined by the
language and is named by a reserved keyword. Primitive values do not share state with
other primitive values. The eight primitive data types supported by the Java programming
language are:
• byte: The byte data type is an 8-bit signed two's complement integer. It has a
minimum value of -128 and a maximum value of 127 (inclusive). The byte data
type can be useful for saving memory in large arrays, where the memory savings
actually matters. They can also be used in place of int where their limits help to
clarify your code; the fact that a variable's range is limited can serve as a form of
documentation.
• short: The short data type is a 16-bit signed two's complement integer. It has a
minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with
byte, the same guidelines apply: you can use a short to save memory in large
arrays, in situations where the memory savings actually matters.
• int: The int data type is a 32-bit signed two's complement integer. It has a
minimum value of -2,147,483,648 and a maximum value of 2,147,483,647
(inclusive). For integral values, this data type is generally the default choice
unless there is a reason (like the above) to choose something else. This data type
will most likely be large enough for the numbers your program will use, but if you
need a wider range of values, use long instead.
• long: The long data type is a 64-bit signed two's complement integer. It has a
minimum value of -9,223,372,036,854,775,808 and a maximum value of
9,223,372,036,854,775,807 (inclusive). Use this data type when you need a range
of values wider than those provided by int.
• float: The float data type is a single-precision 32-bit IEEE 754 floating point. Its
range of values is beyond the scope of this discussion, but is specified in section
4.2.3 of the Java Language Specification. As with the recommendations for byte
and short, use a float (instead of double) if you need to save memory in large
arrays of floating point numbers. This data type should never be used for precise
values, such as currency. For that, you will need to use the java.math.BigDecimal
20
class instead. Numbers and Strings covers BigDecimal and other useful classes
provided by the Java platform.
• double: The double data type is a double-precision 64-bit IEEE 754 floating
point. Its range of values is beyond the scope of this discussion, but is specified in
section 4.2.3 of the Java Language Specification. For decimal values, this data
type is generally the default choice. As mentioned above, this data type should
never be used for precise values, such as currency.
• boolean: The boolean data type has only two possible values: true and false.
Use this data type for simple flags that track true/false conditions. This data type
represents one bit of information, but its "size" isn't something that's precisely
defined.
• char: The char data type is a single 16-bit Unicode character. It has a minimum
value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535
inclusive).
with their appropriate arithmetic and relational operators and mathematical standard
functions. All predefined arithmetic operators deliver results with an accuracy of at least
1 ulp (unit in the last place). Thus, they are of maximum accuracy in the sense of
scientific computing. The rounding of the arithmetic operators may be controlled using
the data types interval and cinterval. Type casting functions are available for all
mathematically useful combinations. Literal constants may be converted with maximum
accuracy. All mathematical standard functions for the simple numerical data types may
be called by their generic names and deliver results with guaranteed high accuracy for
arbitrary permissible arguments. The standard functions for the data types interval and
cinterval provide range inclusions which are sharp bounds.
21
Table 1: Mathematical Standard Functions
For the scalar data types presented above, vector and matrix types are available:
...
int n, m;
cout << "Enter the dimensions n, m:";
cin >> n >> m;
Defining a vector or a matrix without explicitly indicating the index bounds results in a
vector of length 1 or in a 1x1 matrix. The storage for the object is not allocated until run
time. Here, we use the Resize statement (see example above) to allocate an object of the
desired size. Alternatively, the index bounds may be determined when defining the vector
or matrix as we did in the example above with matrix A.
The size of a vector or a matrix may be determined at any time by calling the functions
Lb() and Ub() for the lower and upper index bounds, respectively.
Introduction:
There are lost of discussion on the internet about the Interface vs Abstract class. Also, as
base class whether we have to use interface, abstract class or normal class.
I am trying to point out few considerations on which we can take decision about
Interface vs Abstract class vs Class.
24
//Abstarct Class
public abstract class Vehicles
{
private int noOfWheel;
private string color;
public abstract string Engine
{
get;
set;
}
public abstract void Accelerator();
}
//Interface
public interface Vehicles
{
string Engine
{
get;
set;
}
void Accelerator();
}
We can see abstract class contains private members also we can put some methods with
implementation also. But in case of interface only methods and properties allowed.
We use abstract class and Interface for the base class in our application.
This is all about the language defination. Now million doller question:
How can we take decision about when we have to use Interface and when Abstract Class.
Basicly abstact class is a abstract view of any realword entity and interface is more
abstract one. When we thinking about the entity there are two things one is intention and
one is implemntation. Intention means I know about the entity and also may have idea
about its state as well as behaviour but don’t know about how its looks or works or may
know partially. Implementation means actual state and behaviour of entity.
Enough theory lets take an example.
I am trying to make a Content Management System where content is a genralize form of
article, reviews, blogs etc.
25
So content is our base class now how we make a decision whether content class should be
Abstract class, Interface or normal class.
First normal class vs other type (abstract and interface). If content is not a core entity
of my application means as per the business logic if content is nothing in my application
only Article, Blogs, Review are the core part of business logic then content class should
not be a normal class because I’ll never make instance of that class. So if you will never
make instance of base class then Abstract class and Interface are the more appropriate
choice.
As you can see content having behavior named “Publish”. If according to my business
logic Publish having some default behavior which apply to all I’ll prefer content class as
an Abstract class. If there is no default behavior for the “Publish” and every drive class
makes their own implementation then there is no need to implement “Publish” behavior
in the base case I’ll prefer Interface.
These are the in general idea of taking decision between abstract class, interface and
normal class. But there is one catch. As we all know there is one constant in software that
is “CHANGE”. If I made content class as Interface then it is difficult to make changes in
base class because if I add new method or property in content interface then I have to
implement new method in every drive class. These problems will over come if you are
using abstract class for content class and new method is not an abstract type. So we can
replace interface with abstract class except multiple inheritance.
CAN-DO and IS-A relationship is also define the deference between Interface and
abstract class. As we already discuss Interface can be use for multiple inheritance for
example we have another interface named “ICopy” which having behavior copy and
every drive class have to implements its own implementation of Copy. If “Article” class
drive from abstract class Content as well as ICopy then article “CAN-DO” copy also.
IS-A is for “generalization” and “specialization” means content is a generalize form of
Article, Blogs, Review and Article, Blogs, Review are a specialize form of Content.
So, abstract class defines core identity. If we are thinking in term of speed then
abstract is fast then interface because interface requires extra in-direction.
So as per my view Abstract class having upper-hand in compare to interface. Using
interface having only advantage of multiple inheritance. If you don’t understand the
things then don’t worry because it’s my mistake because I am not able to describe the
topic.
26
4. explain the procedure for connecting to the database
Use
This procedure enables you to connect to a remote database and display an installed AS
Java configuration.
Procedure
...
Start the Config Tool by double clicking the configtool script file in
<SAP_install_dir>/<system_name>/<instance_name>/j2ee/configtool directory.
In the Connection settings dialog window, choose “Yes” if you want to connect to the default
database, or “No” to connect to a different one.
The default database connecting is via the Secure Store.
1. If you set the “Do not ask me again” indicator, the next time you start the Config
Tool, it will automatically connect to the default database.
The other way to reset the startup options is when you delete the
visual.propertiesfile. Then, start the Config Tool.
In the Connect dialog window, choose whether to connect via secure store or via direct login
and enter the required data in the relevant fields.
Connection Settings
27
System Displays the name of the CE1
Name system to which this data
applies.
Secure Specifies the security C:/usr/sap/CE1/SYS/global/security/lib
Store directory. It contains IAIK
Lib JAR files you need to use
to open the Secure Store.
RDBMS A property key, by which jdbc/pool/CE1
Connecti the value contains the DB
ons connection settings.
Direct Description Example
Login
Settings
RDBMS Specifies the URL for the jdbc:sapdb://sofD60163517A/CE1?
URL database connection in the timeout=0&spaceoption=true&unicode=true
correct format for the
corresponding driver.
Driver Specifies the class name of com.sap.dbtech.jdbc.DriverSapDB
name the JDBC driver to be used
for database connections.
RDBMS Specifies the user name for SAPCE1DB
user this database connection.
RDBMS Specifies the password for <Instalation SAP NetWeaver AS Java
password the user of this database password>
connection.
IAIK Specifies the IAIK JAR files ;
Library directory. It enables the C:\usr\sap\CE1\SYS\global\security\lib\
encrypting and decrypting tools\iaik_jce.jar;
of the properties file. C:\usr\sap\CE1\SYS\global\security\lib\
tools\iaik_jsse.jar;
C:\usr\sap\CE1\SYS\global\security\lib\
tools\iaik_smime.jar;
C:\usr\sap\CE1\SYS\global\security\lib\
tools\iaik_ssl.jar
General Description Example
Settings
RDBMS Contains the path to the C://sapdb/programs/runtime/jar/sapdbc.j
Driver RDBMS driver. ar
Location
RDBMS Specifies the number of 1
Initial database connections to be
Connecti created initially in the
ons connection pool.
28
RDBMS Specifies the maximum 10
Maximum number of database
Connecti connections to be kept in
ons the connection pool.
After filling the connection fields, you have the following options:
1. Directly connect to the relevant database. Choose Connect to DB.
2. Save the connection properties you have just set:
Choose Save Connection As.
Enter a file name with the extension “properties”, for example
user.properties.
Choose Save.
1. Open a previously saved “.properties” file to connect to a particular
database. Choose Load Connection Set
29