Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
1. How will you call a Web server from a stand alone Java
application?
Using the java.net.URLConnection and its subclasses like
HttpURLConnection and JarURLConnection.
URLConnection
Supports HEAD, GET, POST,
PUT, DELETE, TRACE and
OPTIONS
Does not support cookies.
Can handle protocols other than
http like ftp, gopher, mailto and
file.
HttpClient (browser)
Supports HEAD, GET, POST,
PUT, DELETE, TRACE and
OPTIONS
Does support cookies.
Handles only http.
memory allocation.
SAX Parser example: Xerces,
Crimson etc.
Use JAXP (Java API for XML
Parsing) which enables
applications to parse and
transform XML documents
independent of the particular
XML parser. Code can be
developed with one SAX parser
in mind and later on can be
changed to another SAX parser
without changing the
application code.
<xs:complexType>
<xs:sequence>
<xs:element name="to" type="xs:string"/>
<xs:element name="from" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="content" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:attribute name="language" type=xs:string
use=Required />
</xs:element>
</xs:schema>
XSL
XSL stands for eXtensible Stylesheet Language. The XSL
consists of 3 parts:
XSLT: Language for transforming XML documents from
one to another.
XPath: Language for defining the parts of an XML
document.
XSL-FO: Language for formatting XML documents. For
example to convert an XML document to a PDF document
etc.
XSL can be thought of as a set of languages that can :
Define parts of an XML
Transform an XML document to XHTML (eXtensible Hyper
Text Markup Language) document.
Convert an XML document to a PDF document.
Filter and sort XML data.
XSLT processor example: Xalan (From Apache)
PDF Processor example: FOP (Formatting Objects Processor
from Apache)
To convert the Sample.xml file to a XHTML file let us apply the
following Sample.xsl through XALAN parser.
Sample.xsl
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<xsl:apply-templates select="note " /></xsl:template>
<xsl:template match="note">
<html><head><title><xsl:value-of
select="content/@language">
</title></head></html>
</xsl:template>
</xsl:stylesheet>
You get the following output XHTML file:
Sample.xhtml
<html><head><title>English</title></head></html>
Now to convert the Sample.xml into a PDF file apply the
following FO (Formatting Objects) file Through the FOP
processor.
Sample.fo
<?xml version="1.0" encoding="ISO-8859-1"?>
<fo:root xmlns:fo="http://www.w3.org/1999/XSL/Format">
<fo:layout-master-set>
<fo:simple-page-master master-name="A4">
</fo:simple-page-master>
</fo:layout-master-set>
<fo:page-sequence master-reference="A4">
<fo:flow flow-name="xsl-region-body">
<fo:block>
<xsl:value-of select="content[@language='English']">
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
which gives a basic Sample.pdf which has the following line
Not Much
XPath
Xml Path Language, a language for addressing parts of an
XML document, designed to be used by both XSLT and
XPointer. We can write both the patterns (context-free) and
expressions using the XPATH Syntax. XPATH is also used in
XQuery.
As per Sample.xsl
<xsl:template match=content[@language=English]>
JAXP
JAXP Stands for Java API for XML Processing. This provides a
common interface for creating and using SAX, DOM, and XSLT
APIs in Java regardless of which vendors implementation is
actually being used (just like the JDBC, JNDI interfaces). JAXP
has the following packages:
javax.xml.parsers : common interface for different
vendors of SAX, DOM parsers).
org.xml.sax : Defines basic SAX API.
org.w3c.dom : Defines Document Object Model and its
components.
javax.xml.transform : Defines the XSLT API which allows
you to transform XML into other forms like PDF, XHTML etc.
Required JAR files are jaxp.jar, dom.jar, xalan.jar,
xercesImpl.jar.
DOM example using JAXP:
DocumentBuilderFactory dbf =
DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new File("xml/Test.xml"));
NodeList nl = doc.getElementsByTagName("to");
Node n = nl.item(0);
System.out.println(n.getFirstChild().getNodeValue());
SAX example using JAXP:
SAXParserFactory spf =SAXParserFactory.newInstance();
SAXParser sp = spf.newSAXParser();
SAXExample se = new SAXExample();
sp.parse(new File("xml/Sample.xml"),se);
where SAXExample.Java code snippet
public class SAXExample extends DefaultHandler {
public void startElement(String uri,String localName,String
qName,Attributes attr)throws SAXException {
System.out.println("--->" + qName);
}
...
}
The DefaultHandler implements ContentHandler, DTDHandler,
EntityResolver, ErrorHandler.
XSLT example using JAXP:
what a system does rather than how it does it. A use case
is a summary of scenarios for a single task or goal. An actor is
responsible for initiating a task. The connection between actor
and use case is a communication association.
When to use use case diagrams?
Determining user requirements. New use cases often
generate new requirements.
Communicating with clients. The simplicity of the
diagram makes use case diagrams a good way for
designers and developers to communicate with clients.
Generating test cases. Each scenario for the use case
may suggest a suite of test cases.
Class diagrams: Class diagram technique is vital within Object
Oriented methods. Class diagrams describe the types of objects
in the system and the various static relationships among them.
Class diagrams also show the attributes and the methods.
Class diagrams have the following possible relationships:
Association: A relationship between instances of 2
classes.
In this relationship the object of one instance perform an
action on behalf of the other class. The typical behaviour
can be invoking the method of other class and using the
member of the other class.
In other words, association defines the multiplicity
between objects. You may be aware of one-to-one, one-tomany, many-to-one, many-to-many all these words define
an association between objects. Aggregation is a special
form of association.
Composition is a special form of aggregation.
Example: A Student and a Faculty are having an
association.
Aggregation:
Aggregation is a special case of association.
A directional association between objects. When an object
has-a another object, then you have got an aggregation
between them. Direction between them specified which
object contains the other object. Aggregation is also called
a Has-a relationship.
Realization :
Realization is a relationship between the blueprint class
and the object containing its respective implementation
level details. This object is said to realize the blueprint
class.
In other words, you can understand this as the
relationship between the interface and the implementing
class.
Dependency: A dependency is a weak relationship where
one class requires another class. The dependency
Youre heavily reliant upon a plan, which you can/will often follow
to the detriment of the
end result
Youre heavily reliant upon a project manager driving the way
the power of one
Iterative Waterfall Development
This approach carries less risk than a traditional Waterfall approach
but is still far more risky and less efficient than a more Agile
approaches.
The focus is on delivering a sprint of work as opposed to a series of
valuable/shippable features.
The most commonly occurring issue in this type of scenario (in my
experience) is bottle necking.
For example, you deliver loads of code a little bit behind schedule
(?) and you leave it until the last minute to test everything. One
issue takes longer than expected to resolve, you miss your sprint
deadline and you deliver nothing.
Another common symptom of this type of approach is overcommitment. Its really difficult to estimate the total effort
associated with a particular User Story/Feature when approaching
delivery in this phased way.
Youre more or less forced to estimate each phase separately (e.g.
estimate development separately to testing in this instance) this
doesnt work as the phases are not separate, theyre totally
intertwined.
For example, if you find an issue with the test, you must return to
development. The whole team must remain focused on delivering
the end goal, not the separate phases.
Its also worth noting that velocity and burn downs are far less (if at
all) useful in this type of environment you dont benefit from
early-warning-signs as you dont find out whether youre on track
until the end of the sprint.
Scrum Development
This approach carries far less risk than Waterfall approaches.
We focus on delivering fully-tested, independent, valuable, small
features. As such, we diversify our risk if one feature goes wrong,
it should not impact another feature.
With that said, we still plan our work in iterations and we will still
release at the end of each iteration.
Lean Development
Lean is very similar to Scrum in the sense that we focus on features
as opposed to groups of features however Lean takes this one
step further again.
In Lean Development, you select, plan develop, test and deploy one
feature (in its simplest form) before you select, plan, develop, test
and deploy the next feature. By doing this, you further isolate risk
to a feature-level.
In these environments, you aim to eliminate waste wherever
possible you therefore do nothing until you know its necessary or
relevant.
17.
How would you go about determining the enterprise
security requirements for your Java/J2EE application?
It really pays to understand basic security terminology and J2EE
security features. Lets look at them:
Some of the key security concepts are:
Authentication
Authorization ((J2EE declarative & programmatic)
Data Integrity
Confidentiality and privacy
Non-repudiation and auditing
Authentication
Authentication is basically an identification process. Do I know
who you are?
Terminology used for J2EE security:
hash) of the user id, password, the nonce and some other
data. The server creates the same checksum from the user
parameters available in the user registry. If both the
checksums match then it is assumed that the user knows
the correct password.
Form-based authentication: Most Web applications use
the form-based authentication since it allows applications
to customize the authentication interface. Uses base64
encoding which can expose username and password unless
all connections are over SSL. (Since this is the most
common let us look at in greater detail together ie
authentication & authorization under Authorization).
Certificate based authentication: Uses PKI and SSL.
This is by far the most secured authentication method. A
user must provide x509 certificate to authenticate with
the server.
Authorization
Authorization is the process by which a program determines
whether a given identity is permitted to access a resource such
as a file or an application component. Now that you are
authenticated, I know who you are? But are you allowed to
access the resource or component you are requesting?
Terminology used for J2EE security:
Authorization: Process of determining what type of
access (if any) the security policy allows to a resource by a
principal.
Security role: A logical grouping of users who share a
level of access permissions.
Security domain: A scope that defines where a set of
security policies are maintained and enforced. Also known
as security policy domain or realm.
J2EE uses the concept of security roles for both declarative and
programmatic access controls. This is different from the
traditional model, which is permission-based (for example UNIX
file system security where resources like files are associated with
a user or group who might have permission to read the file
but not execute).
Let us look at some differences between Permission-based
authorization: Typically the permission-based security both users
and resources are defined in a security database and the
<realm classname="org.apache.catalina.realm.JDBCRealm"
debug="99"
drivername="org.gjt.mm.mysql.Driver"
connectionurl="jdbc:mysql://localhost/tomcatusers?
user=test;password=test"
usertable="users" usernamecol="user_name"
usercredcol="user_pass"
userroletable="user_roles" rolenamecol="role_name"/>
You have to create necessary tables and columns created in the
database.
STEP: 4 Set up the security constraints in the web.xml for
authorization.
<security-constraint>
<web-resource-collection>
<web-resourcename>PrivateAndSensitive</web-resourcename>
<url-pattern>/private/*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>executive</role-name>
<role-name>admin</role-name>
</auth-constraint>
</security-constraint>
The Web containers perform the following steps to implement
security when a protected Web resource is accessed:
Step 1: Determine whether the user has been authenticated.
Step 2: If the user has not been already authenticated, request
the user to provide security credentials by redirecting the user to
the login page defined in the web.xml as per Step-1 & Step-2
described above.
Step 3: Validate the user credentials against the security realm
set up for the container.
Step 4: Determine whether the authenticated user is authorized
to access the Web resource defined in the deployment descriptor
web.xml. Web containers enforce authorization on a page level.
For fine grained control programmatic security can be employed
using request.getRemoteUser(), request.isUserInRole(),
request.getUserPrincipal() etc
Note: The Web containers can also propagate the authentication
information to EJB containers.
Data integrity
Data integrity helps to make sure if something is intact and not
tampered with during transmission.
Checksums: Simply add up the bytes within file or request
message. If the checksums match the integrity is maintained.
The weakness with this approach is that some times junks can
be added to make sums equal like ABCDE == EDCBA
Cryptography hashes: This uses a mathematical function to
create small result called message digest from the input
message. Difficult to create false positives. Common hash
functions are MD5, SHA etc.
Data [e.g. Name is Peter] MD5 iterative hash function
Digest [e.g. f31d120d3] It is not possible to change the message
digest back to its original data. You can only compare two
message digests i.e. one came with the clients message and the
other is recomputed by the server from sent message. If both
the message digests are equal then the message is intact and
has not been tampered with.
Confidentiality and Privacy
The confidentiality and privacy can be accomplished through
encryption. Encryption can be:
Symmetric or private-key: This is based on a single key. This
requires the sender and the receiver to share the same key. Both
must have the key. The sender encrypts his message with a
private key and the receiver decrypts the message with his own
private key. This system is not suitable for large number of users
because it requires a key for every pair of individuals who need
to communicate privately. As the number of participant increases
then number of private keys required also increases. So a
company which wants to talk to 1000 of its customers should
have 1000 private keys. Also the private keys need to be
transmitted to all the participants, which have the vulnerability
to theft. The advantages of the symmetric encryption are its
computational efficiency and its security.
Asymmetric or public-key infrastructure (PKI): This is
based on a pair of mathematically related keys.
One is a public key, which is distributed to all the users, and the
other key is a private key, which is kept secretly on the server.
So this requires only two keys to talk to 1000 customers. This is
also called Asymmetric encryption because the message
encrypted by public key can only be decrypted by the private key
MIIBJTCB0AIBADBtMQswCQYDVQQGEwJVUzEQMA4GA1UEChs4lB
MHQXJpem9uYTEN
A1UEBxMETWVzYTEfMB0GA1UEChMWTWVs3XbnzYSBDb21tdW5
pdHkgQ29sbGVnZTE
A1UEAxMTd3d3Lm1jLm1hcmljb3BhLmVkdTBaMA0GCSqGSIb3DQ
EBAQUAA0kAMEYC
QQDRNU6xslWjG41163gArsj/P108sFmjkjzMuUUFYbmtZX4RFxf/U
7cZZdMagz4I
MmY0F9cdpDLTAutULTsZKDcLAgEDoAAwDQYJKoZIhvcNAQEEBQA
DQQAjIFpTLgfm
BVhc9SQaip5SFNXtzAmhYzvJkt5JJ4X2r7VJYG3J0vauJ5VkjXz9aev
J8dzx37ir
3P4XpZ+NFxK1R=
-----END NEW CERTIFICATE REQUEST----STEP 2: The CA takes the owners certificate request and
creates a message m from the request and signs the message
m with CAs private key to create a separate signature sig. The
message m and the signature sig form the certificate, which
gets sent to the owner.
STEP 3: The owner then distributes both parts of the certificate
(message and signature) to his customers (or recipients) after
signing the certificate with owners private key.
STEP 4: The recipient of the certificate (i.e. the customer)
extracts the certificate with owners public key and subsequently
verifies the signature sig using CAs public-key. If the signature
proves valid, then the recipient accepts the public key in the
certificate as the owners key.
Non-repudiation and auditing
Proof that the sender actually sent the message. It also prohibits
the author of the message from falsely denying that he sent the
message. This is achieved by record keeping the exact time of
the message transmission, the public key used to decrypt the
message, and the encrypted message itself. Record keeping can
be complicated but critical for non-repudiation.
Secure Socket Layer
Secure Socket Layer (SSL) uses a combination of symmetric and
asymmetric (public-key) encryption to accomplish confidentiality,
integrity, authentication and non-repudiation for Internet
communication. In a nutshell SSL uses public key encryption to
SOAP
SOAP stands for Simple Object Access Protocol. It is an XML
based lightweight protocol, which allows software components
soap:encodingStyle="http://www.w3.org/2001/12/soapencoding">
<soap:Body>
<m:GetPrice xmlns:m="http://www.mysite.com/prices">
<m:Item>PlasmaTV</m:Item>
</m:GetPrice>
</soap:Body>
</soap:Envelope>
SOAP Response:
HTTP/1.1 200 OK
Content-Type: application/soap; charset=utf-8
Content-Length: 200
<?xml version="1.0"?>
<soap:Envelope
xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
soap:encodingStyle="http://www.w3.org/2001/12/soapencoding">
<soap:Body>
<m:GetPriceResponse
xmlns:m="http://www.mysite.com/prices">
<m:Price>3500.00</m:Price>
</m:GetPriceResponse>
</soap:Body>
</soap:Envelope>
Lets look at a HTTP header:
POST /Price HTTP/1.1
Host: www.mysite.com
Content-Type: text/plain
Content-Length: 200
SOAP HTTP Binding
A SOAP method is an HTTP request/response that complies with
the SOAP encoding rules.
HTTP + XML = SOAP
Lets look at a HTTP header containing a soap message:
POST /Price HTTP/1.1
Host: www.mysite.com
Content-Type: application/soap+xml; charset=utf-8
Content-Length: 200
WSDL
WSDL stands for Web Service Description Language. A WSDL
document is an XML document that describes how the messages
are exchanged. Lets say we have created a Web service. Who is
going to use that and how does the client know which method to
invoke and what parameters to pass? There are tools that can
generate WSDL from the Web service. Also there are tools that
can read a WSDL document and create the necessary code to
invoke the Web service. So the WSDL is the Interface
Definition Language (IDL) for Web services.
UDDI
UDDI stands for Universal Description Discovery and Integration.
UDDI provides a way to publish and discover information about
Web services. UDDI is like a registry rather than a repository. A
registry contains only reference information like the JNDI, which
stores the EJB stub references. UDDI has white pages, yellow
pages and green pages. If the retail industry published a UDDI
for a price check standard then all the retailers can register their
services into this UDDI directory. Shoppers will search the UDDI
directory to find the retailer interface. Once the interface is
found then the shoppers can communicate with the services
immediately. The Web services can be registered for public use
at http://www.uddi.org. Once the Web service is selected
through the UDDI then it can be located using the discovery
process.
Before UDDI, there was no Internet standard for businesses to
reach their customers and partners with information about their
products and services. Neither was there a method of how to
integrate businesses into each other's systems and processes.
UDDI uses WSDL to describe interfaces to Web services.
21.
HTML
Content driven
Format driven
22.
Component of SOAP
An envelope, a set of encoding rules, and a convention for
representing remote procedure calls.
23.
What is the difference between Schema and DTD?
Schema might outphase DTD. XML schemas are in XML. XML
Schema has a lot of built-in data types including
xs:string,xs:decimal,xs:integer,xs:boolean,xs:date,xs:time. XML
schemas can be edited with Schema files, parsed with XML
parser, manipulated with XML DOM, and transformed with XSLT.
The building blocks of DTD include elements, attributes, entities,
PCDATA, and CDATA.
24.
What is SGML?
SGML is the Standard Generalized Markup Language (ISO
8879:1986), the international standard for defining descriptions
of the structure of different types of electronic document. SGML
is very large, powerful, and complex. It has been in heavy
industrial and commercial use for nearly two decades, and there
is a significant body of expertise and software to go with it. XML
is a lightweight cut-down version of SGML, which keeps enough
of its functionality to make it useful, but removes all the optional
features, which made SGML too complex to program for in a Web
environment.
25.
What software development processes/principles
are you familiar with?
Agile (i.e. lightweight) software development process is gaining
popularity and momentum across organizations.
Highest priority is to satisfy the customer.
Welcome requirement changes even late in development
life cycle.
Business people and developers should work
collaboratively.
Form teams with motivated individuals who produce best
designs and architectures.
This means that the change made on an LDAP server will take
effect on every directory service based application that uses this
piece of user information. The variety of information about a new
user can be added through a single interface which will be made
available to Unix account, NT account, e-mail server, Web Server,
Job specific news groups etc. When the user leaves his account
can be disabled to all the services in a single operation. So LDAP
is most useful to provide white pages (e.g. names, phone
numbers, roles etc) and yellow pages (e.g.
location of printers, application servers etc) like services.
Typically in a J2EE application environment it will be used to
authenticate and authorize users.
Why use LDAP when you can do the same with relational
database (RDBMS)?
In general LDAP servers and RDBMS are designed to provide
different types of services. LDAP is an open standard access
mechanism, so an RDBMS can talk LDAP. However the servers,
which are built on LDAP, are optimized for read access so likely
to be much faster than RDBMS in providing read access. So in a
nutshell, LDAP is more useful when the information is often
searched but rarely modified. (Another difference is that RDBMS
systems store information in rows of tables whereas LDAP uses
object-oriented hierarchies of entries.) .
Key LDAP Terms:
DIT: Directory Information Tree. Hierarchical structure of
entries, those make up a directory.
DN: Distinguished Name. This uniquely identifies an entry in the
directory. A DN is made up of relative DNs of the entry and each
of entrys parent entries up to the root of the tree. DN is read
from right to left and commas separate these names. For
example cn=Peter Smith, o=ACME, c=AUS.
objectClass: An objectClass is a formal definition of a specific
kind of objects that can be stored in the directory. An
ObjectClass is a distinct, named set of attributes that represent
something concrete such as a user, a computer, or an
application.
LDAP URL: This is a string that specifies the location of an LDAP
resource. An LDAP URL consists of a server host and a port,
search scope, baseDN, filter, attributes and extensions. Refer to
diagram below:
Step 2: The client process will look up the remote object from
the RMI registry.
Step 3: The lookup will return the stub to the client process
from the server process.
Step 4: The client process will invoke method calls on the stub.
The stub calls the skeleton on the server process through the
RMI reference manager.
Step 5: The skeleton will execute the actual method call on the
remote object and return the result or an exception to the client
process via the RMI reference manager and the stub.
30.
What is a remote object? Why should we extend
UnicastRemoteObject?
A remote object is one whose methods can be invoked from
another JVM (or process). A remote object class must implement
the Remote interface. A RMI Server is an application that creates
a number of remote objects.
An RMI Server is responsible for
Creating an instance of the remote object (e.g. CarImpl
instance = new CarImpl()).
Exporting the remote object.
Binding the instance of the remote object to the RMI
registry.
By exporting a remote object you make it available to accept
incoming calls from the client. You can export the remote object
by either extending the java.rmi.server.UnicastRemoteObject or
if your class is already extending another class then you can use
the static method UnicastRemoteObject.exportObject (this);If
the UnicastRemoteObject is not extended (ie if you use
UnicastRemoteObject.exportObject () then the implementation
class is responsible for the correct implementations of the
hashCode(), equals() and toString() methods. A remote object is
registered in the RMI registry using: Naming.rebind(String
serviceName, Remote remoteObj);
31.
What is the difference between RMI and CORBA?
RMI
CORBA
Java only solution. The
CORBA was made specifically
interfaces, implementations
for interoperability among
and the clients are all written in various languages. For example
Java.
the server could be written in
C++ and the business logic can
be in Java and the client can be
written in COBOL.
RMI allows dynamic loading of
In a CORBA environment with
classes at runtime.
multi-language support it is not
possible to have dynamic
loading.
32.
What is HTTP tunneling or how do you make RMI
calls across firewalls?
RMI transport layer generally opens direct sockets to the server.
Many Intranets have firewalls that do not allow this. To get
2. XML mappings
Hibernate and iBatis both use XML based mapping and are quite
intuitive to implement. Tools are available to create and edit
these file. e.g. Abator for iBatis and Hibernate tools.
3. Project from Scratch with new Database or Existing
Database Hibernate works well when you control the data
model, iBATIS works well when you need to integrate with an
existing database. In the projects where the Project is being
developed from scratch and developer has to come up with
database design along with the Java object model then Hibernate
is a good option as it becomes easy to develop and mappings
becomes intuitive. Hibernate also provides ways to generate
database from mappings files itself. This may reduce your
deployment script generation efforts.
Using iBatis for a project which is developed from scratch is also
very simple and does not involve lot of efforts.
4. Data centric project
A project which has database intensive operations to be done
and needs to utilize lot of existing implementations which are
available in Database layer then iBatis provides easier way to
leverage on it. Hibernate also provides way to handle such
situations but it gets complex as your application becomes more
and more complex. The hibernate developer need to start
understanding lot of complex things to accomplish it.
5. Hibernate Query Language (HQL) vs Structured Query
Language (SQL)
Its another choice which you may want to take in case you
application involves lot of complex database intensive operations
then in Hibernate you may want to go for Hibernate Query
Language (HQL) which will have following aspects
- Learning curve for developers
- You will not be able to see the actual SQL because Hibernate
generates it internally, though there is a way to see what is
being generated but you lose the direct control over it.
- Abstraction of SQL makes it difficult for the developers visualize
what is happening at that layer.
Where as in case of iBatis you have same SQL available to you in
the XML mapping file and you can play around with it as you
wish, which gives you lot of freedom to tune in performance of
queries.
6. Simple Applications
In case your application is simple with not lot of complex data
processing then Hibernate could be a decent option. Also if a
developer does not like SQL much then it could be a good option
too.
35.
What is apache lucene ?
Apache Lucene is an open source, a high-performance, fullfeatured text search engine library written entirely in Java. It is a
technology suitable for nearly any application that requires fulltext search, especially cross-platform