JAR files support a wide range of functionality, including electronic signing, version control, package sealing, and others. What gives a JAR file this versatility? The answer is the JAR file’s manifest.
The manifest is a special file that can contain information about the files packaged in a JAR file. By tailoring this “meta” information that the manifest contains, you enable the JAR file to serve a variety of purposes.
This example will explain the contents of the manifest file and show you how to work with it, with examples for the basic features.
try {
// Open the JAR file
JarFile jarfile = new JarFile("filename.jar");
// Get the manifest
Manifest manifest = jarfile.getManifest();
// Get the manifest entries
Map map = manifest.getEntries();
// Enumerate each entry
for (Iterator it=map.keySet().iterator(); it.hasNext(); ) {
// Get entry name
String entryName = (String)it.next();
// Get all attributes for the entry
Attributes attrs = (Attributes)map.get(entryName);
// Enumerate each attribute
for (Iterator it2=attrs.keySet().iterator(); it2.hasNext(); ) {
// Get attribute name
Attributes.Name attrName = (Attributes.Name)it2.next();
// Get attribute value
String attrValue = attrs.getValue(attrName);
}
}
} catch (IOException e) {
}
The implicit HttpServlet interface comes with two methods which must be implemented. These are doGet(HttpServletRequest req, HttpServletResponse res) and doPost(HttpServletRequest req, HttpServletResponse res). The example below shows how to get both.
// See also The HttpServlet
// This method is called by the servlet container to process a GET request.
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
doGetOrPost(req, resp);
}
// This method is called by the servlet container to process a POST request.
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
doGetOrPost(req, resp);
}
// This method handles both GET and POST requests.
private void doGetOrPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
// Get the value of a request parameter; the name is case-sensitive
String name = "param";
String value = req.getParameter(name);
if (value == null) {
// The request parameter 'param' was not present in the query string
// e.g. http://hostname.com?a=b
} else if ("".equals(value)) {
// The request parameter 'param' was
// present in the query string but has no
// value
// e.g. http://hostname.com?param=&a=b
}
// The following generates a page showing all
// the request parameters
PrintWriter out = resp.getWriter();
resp.setContentType("text/plain");
// Get the values of all request parameters
Enumeration enum = req.getParameterNames();
for (; enum.hasMoreElements(); ) {
// Get the name of the request parameter
name = (String)enum.nextElement();
out.println(name);
// Get the value of the request parameter
value = req.getParameter(name);
// If the request parameter can appear
// more than once in the query string,
// get all values
String[] values =
req.getParameterValues(name);
for (int i=0; i<values.length; i++) {
out.println(" "+values[i]);
}
}
out.close();
}
In Java it’s simply done by the InetAddress Object as follows:
try {
// Get hostname by textual representation of
// IP address
InetAddress addr =
InetAddress.getByName("127.0.0.1");
// Get hostname by a byte array containing
the IP address
byte[] ipAddr = new byte[]{127, 0, 0, 1};
addr = InetAddress.getByAddress(ipAddr);
// Get the host name
String hostname = addr.getHostName();
// Get canonical host name
String hostnameCanonical = addr.getCanonicalHostName();
} catch (UnknownHostException e) {
}
Java code can throw exceptions. This comes in the form of the Stacktrace. When this happens you want to be able to get some more details. The example below shows how this can be achieved.
try {
// My code
} catch (Throwable e) {
// Get the stack trace
StackTraceElement stack[] =
e.getStackTrace();
// stack[0] contains the method that created
// the exception.
// stack[stack.length-1] contains the oldest
// method call.
// Enumerate each stack element.
for (int i=0; i<stack.length; i++) {
String filename = stack[i].getFileName();
if (filename == null) {
// The source filename is not
// available
}
String className =
stack[i].getClassName();
String methodName =
stack[i].getMethodName();
boolean isNativeMethod =
stack[i].isNativeMethod();
int line = stack[i].getLineNumber();
}
}
Sometimes you want to use system native libraries (dll on Windows or .so on Linux, UNIX or Mac). This example shows how to load them. After you loaded the library you can call them from your Java Applications.
This example shows how text can be HiLighted in the text of a JTextPane.
JTextPane textPane = new JTextPane();
StyledDocument doc = textPane.getStyledDocument();
// Makes text red
Style style = textPane.addStyle("Red", null);
StyleConstants.setForeground(style, Color.red);
// Inherits from "Red"; makes text red and underlined
style = textPane.addStyle("Red Underline", style);
StyleConstants.setUnderline(style, true);
// Makes text 24pts
style = textPane.addStyle("24pts", null);
StyleConstants.setFontSize(style, 24);
// Makes text 12pts
style = textPane.addStyle("12pts", null);
StyleConstants.setFontSize(style, 12);
// Makes text italicized
style = textPane.addStyle("Italic", null);
StyleConstants.setItalic(style, true);
// A style can have multiple attributes; this one makes text bold and italic
style = textPane.addStyle("Bold Italic", null);
StyleConstants.setBold(style, true);
StyleConstants.setItalic(style, true);
// Set text in the range [5, 7) red
doc.setCharacterAttributes(5, 2, textPane.getStyle("Red"), true);
// Italicize the entire paragraph containing the position 12
doc.setParagraphAttributes(12, 1, textPane.getStyle("Italic"), true);
This example shows how a Swing Window Object can be centered on the screen. Note that the Window Object doesn’t have a CENTER method of its own so you need to implement the logic yourself.
// Get the size of the screen
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
// Determine the new location of the window
int w = window.getSize().width;
int h = window.getSize().height;
int x = (dim.width-w)/2;
int y = (dim.height-h)/2;
// Move the window
window.setLocation(x, y);