| Usage | Command |
|---|---|
| Check for the Version of Linux | uname -mrs or Open file using cat /proc/version or uname -a [All information] |
| Check for the Machine architecture | uname -mrs i386 and i686 = 32-bit; x86_64 = 64-bit |
| Check for the Server release details | lsb_release -a |
| Check the processes running | ps fuxxx , ps auxxx |
| Checking whether a port is open or not | telnet <ip_address> <port_no> |
| Updating access rights to execute a program | chmod +x ./<program_name> |
| Searching for specific text occurrences | grep <search_term> * |
| Checking top 100 lines of a file | tail -100f <file_name> |
| Running a program in back-ground | nohup ./<program_name> & |
| Checking ip address | /sbin/ifconfig or ip addr show |
| Checking which process is cosuming how much | top |
| Checking how much space is available in current drive | df -h |
| Killing a process | kill -9 |
| Clear the screen | clear screen |
Introduction to webMethods and CAF
Jar with dependencies using maven
In the earlier post, though we had dependencies for our jar, we just used them while compiling them. Hence, when we execute our jar, it is required that, they be included in the class-path while executing our jar.
Though, this sounds reasonable enough, there are situations when it becomes tedious to include the dependencies in the class-path every-time you want to run the jar,especially, when there are more than a few dependencies and multiple main-classes. A simpler way is to bundle the other dependent jars in our jar.
Hmmm. This may sound a little off the mark. It is true you cannot bundle the dependent jars in your jar. Albeit, you can include the classes of your dependent jars in your jar. This will solve the problem. Whoa!!! how do i do it?
This can be done pretty easily using Maven in tandem with an assembly.xml. Following are the key points:
a. Use Maven Assembly plugin to assemble the class files in a jar and include their dependencies as well
b. Maven Assembly plugin requires an additional assembly.xml which in turn specifies format e.g. jar and depndency-set
c. Configure the assembly.xml as part of same project and use it from pom.xml using maven assembly plugin
d. Generate one single jar with all dependencies
The sample pom.xml looks like below:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.schoudari.blog</groupId>
<artifactId>my-blog-reader</artifactId>
<packaging>jar</packaging>
<version>1.0.0-SNAPSHOT</version>
<name>My Blog Reader</name>
<properties>
<log4j.version>1.2.16</log4j.version>
</properties>
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId><!--1.Use Maven assembly plugin to assemble the jar-->
<configuration>
<attach>false</attach>
<descriptors>
<descriptor>src/assemble/assembly.xml</descriptor><!--2.Assembly configuration-->
</descriptors>
<archive>
<manifest>
<mainClass>com.schoudar.blog.MyBlogReader</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
</dependencies>
</project>
The sample assembly.xml is specified below:
<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
<id>jar-with-dependencies</id>
<formats>
<format>jar</format>
</formats>
<includeBaseDirectory>false</includeBaseDirectory>
<dependencySets>
<dependencySet>
<outputDirectory>/</outputDirectory>
<useProjectArtifact>true</useProjectArtifact>
<unpack>true</unpack>
<scope>runtime</scope>
</dependencySet>
</dependencySets>
</assembly>
Useful Links:
http://www.ibm.com/developerworks/java/library/j-5things13/index.html
Creating a Jar using Maven
In the earlier post, we had seen how to create a jar, in this post we will see how to create a jar using maven. Following are key points in creating the jar using maven.
1. Specify the packaging type e.g. jar.
2. Compile the source code. Use maven-compiler-plugin here.
3. Generate eclipse related files like .classpath, etc. Use maven-eclipse-plugin. [optional]
4. Bundle the java class files in a jar. Use maven-jar-plugin.
5. Provide the main-class[entry point] for your jar in the mainfest.
6. Execute the unit-tests of your jar before creating the jar. [optional]
Refer to the sample pom.xml below:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.schoudari.blog</groupId>
<artifactId>my-blog-reader</artifactId>
<packaging>jar</packaging> <!--1.Packaging Type -->
<version>1.0.0-SNAPSHOT</version>
<name>Blog Reader</name>
<properties>
<log4j.version>1.2.16</log4j.version>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId> <!--2.Compiles the source-code -->
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId> <!--3.Generates the eclipse-related files -->
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId><!--4.Creates a jar -->
<configuration>
<archive>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>com.schoudari.blog.BlogReader</mainClass><!--5.Add main class -->
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId><!--6.Executes the unit-test cases -->
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
</dependencies>
</project>
Basics of Jar
A few years back, i was asked why a class in jar was not running as expected from command prompt. The answer was quite simple, the dependencies of the class are not available.
There is a common misconception that you create a jar and everything runs out of the box for you when you run the main class. Now what is the main class in the jar. Let me give you some introduction to jars:
a. Jar – Java archive. As the name says, it archives a set of java files.
b. Common Jar Operations
| Operation | Command |
|---|---|
| To create a JAR file | jar cf jar-file input-file(s) |
| To view the contents of a JAR file | jar tf jar-file |
| To extract the contents of a JAR file | jar xf jar-file |
| To extract specific files from a JAR file | jar xf jar-file archived-file(s) |
| To run an application packaged as a JAR file (requires the Main-class manifest header) | java -jar app.jar |
c. In general, a java file uses some or the other open source libraries e.g. log4j.jar, etc. Hence, when we create a jar, it is required that it is available in the class-path when we are creating the jar, so the class files can be created and then, they can be bundled. The same principles applies when you execute the jar file as well.
d. Every jar should have at-least one Main-class. Main-class is a class, which is a public class, with the public static void main(String[] args) method. This is the entry-point for all the classes in your jar. P.S. There can be more than one main class as well. In such a case, it is preferable not to have a main-class specified in the manifest.
e. A jar generally comes with a MAINFEST file. This is like meta-information about a jar. e.g.
Manifest-Version: 1.0 Main-Class: MyClass Class-Path: MyUtils.jar Created-By: 1.6.0 (Sun Microsystems Inc.)
Useful links:
http://docs.oracle.com/javase/tutorial/deployment/jar/index.html
Difficult interview questions on Serialization in Java
This article is a follow-up to my article here
a. Are static variables serializable?
Ans: Static and transient variables of a class are not serializable.
b. Can a class implement both Serializable and Externalizable?
Ans: Yes, the class can implement both Serializable and Externalizable.
c. What happens to the non-serializable objects in a class while serializing which implements Serializable?
Ans: The class fails to serialize with exception java.io.NotSerializableException.
d. What happens to the non-serializable objects in a class while serializing which implements Serializable, Externalizable?
Ans: The class can be serialized and de-serialized successfully.
e. How do we deal with serialVersionUID when a class implements Serializable?
Ans: If we don’t provide a serialVersionUID, java compiler generates a serialVersionUID based on the properties defined in the class. Hence, if we have modified the class with a new property after a class has been serialized, then it will fail while de-serializing as a new serialVersionUID is generated by java compiler again. So, to get around this issue, we can fix the serialVersionUID of a class to be 1L. However, let me warn you that it might not be a good practice.
f. If we have a Serializable class “MyClass” which extends “MySuperClass”. What happens to the properties of “MySuperClass”, when we serialize/de-serialize “MyClass”?
Ans: If the properties inside the “MySuperClass” are serializable like primitives,serializable classes then all these will be available in the sub-class during/after serialization. However, if there are non-serializable properties, then there should be a default constructor in “MySuperClass” provided.
g. How do we serialize the non-serializable properties of a super-class[non-serializable] in a serializable sub-class?
Ans: We will have to over-ride the default private writeObject() and readObject() methods of sub-class and provide values for the non-serializable properties. Otherwise, ensure that the non-serializable properties are set with some default/specific values while creating the sub-class it-self. Refer below for sample code:
import java.io.*;
public class TestSerialization {
public static void main(String args[]) {
// Object serialization
try {
MyClass object1 = new MyClass("Hello");
System.out.println("object1: " + object1);
FileOutputStream fos = new FileOutputStream("serial");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
} catch (Exception e) {
System.out.println("Exception during serialization: " + e);
System.exit(0);
}
// Object deserialization
try {
MyClass object2;
FileInputStream fis = new FileInputStream("serial");
ObjectInputStream ois = new ObjectInputStream(fis);
object2 = (MyClass) ois.readObject();
ois.close();
System.out.println("object2: " + object2);
} catch (Exception e) {
System.out.println("Exception during deserialization: " + e);
System.exit(0);
}
}
}
class FailSerilization{
String y="fail serilization";
}
class MySuperClass{
String x="not super";
FailSerilization fs;
// MySuperClass(FailSerilization fs){
// this.fs=fs;
// }
MySuperClass(){
fs=new FailSerilization();
}
}
class MyClass extends MySuperClass implements Serializable {
String s;
public MyClass(String s) {
//super(new FailSerilization());
this.s = s;
}
public String toString() {
return "s=" + s + ";x= "+x+"; fs= "+fs.y;
}
}
More here:
class MyClass extends MyClass2 implements Serializable{
public MyClass(int quantity) {
setNonSerializableProperty(new NonSerializableClass(quantity));
}
private void writeObject(java.io.ObjectOutputStream out)
throws IOException{
// note, here we don't need out.defaultWriteObject(); because
// MyClass has no other state to serialize
out.writeInt(super.getNonSerializableProperty().getQuantity());
}
private void readObject(java.io.ObjectInputStream in)
throws IOException {
// note, here we don't need in.defaultReadObject();
// because MyClass has no other state to deserialize
super.setNonSerializableProperty(new NonSerializableClass(in.readInt()));
}
}
/* this class must have no-arg constructor accessible to MyClass */
class MyClass2 {
/* this property must be gettable/settable by MyClass. It cannot be final, therefore. */
private NonSerializableClass nonSerializableProperty;
public void setNonSerializableProperty(NonSerializableClass nonSerializableProperty) {
this.nonSerializableProperty = nonSerializableProperty;
}
public NonSerializableClass getNonSerializableProperty() {
return nonSerializableProperty;
}
}
class NonSerializableClass{
private final int quantity;
public NonSerializableClass(int quantity){
this.quantity = quantity;
}
public int getQuantity() {
return quantity;
}
}
Upload multiple files in Spring MVC 3
It was just another long day at office with the database not available and one of the team members lagging by a week now. So, we had to work as a team to get it delivered. In Spring 3, it looked straight forward to upload a file. However, there was little help on offer, to upload multiple files from a jsp file.
There are three basic things which need to be done to upload multiple files are:
a) The JSP needs to have the input[file] elements passed as an array.
<td><input name="fileData[0]" id="image0" type="file" /></td>
<td><input name="fileData[1]" id="image1" type="file" /></td>
b) The ModelAttribute/Model object in Spring MVC needs to have a list of MultipartFile.
import java.util.List;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
public class UploadItem {
private String filename;
private List<CommonsMultipartFile> fileData;
c) Configure Multipart Resolver bean in dispatcher-servlet.xml[applicationContext-servlet.xml]
<!-- Configure the multipart resolver -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
</bean>
d) Logic to read the files from the Model and store it in a file location in the Controller layer.
@RequestMapping(method = RequestMethod.POST)
public String create(UploadItem uploadItem, BindingResult result,
HttpServletRequest request, HttpServletResponse response,
HttpSession session) {
if (result.hasErrors()) {
for (ObjectError error : result.getAllErrors()) {
System.err.println("Error: " + error.getCode() + " - "
+ error.getDefaultMessage());
}
return "/uploadfile";
}
// Some type of file processing...
System.err.println("-------------------------------------------");
try {
for(MultipartFile file:uploadItem.getFileData()){
String fileName = null;
InputStream inputStream = null;
OutputStream outputStream = null;
if (file.getSize() > 0) {
inputStream = file.getInputStream();
if (file.getSize() > 20000) {
System.out.println("File Size exceeded:::" + file.getSize());
return "/uploadfile";
}
System.out.println("size::" + file.getSize());
fileName = request.getRealPath("") + "/images/"
+ file.getOriginalFilename();
outputStream = new FileOutputStream(fileName);
System.out.println("fileName:" + file.getOriginalFilename());
int readBytes = 0;
byte[] buffer = new byte[10000];
while ((readBytes = inputStream.read(buffer, 0, 10000)) != -1) {
outputStream.write(buffer, 0, readBytes);
}
outputStream.close();
inputStream.close();
// ..........................................
session.setAttribute("uploadFile", file.getOriginalFilename());
}
//MultipartFile file = uploadItem.getFileData();
}
} catch (Exception e) {
e.printStackTrace();
}
return "redirect:/forms/uploadfileindex";
}
I have extended the example which is found @ RoseIndia to dynamically create the file nodes and post them to the Controller.
Just download the source-code and replace the below jsp file and make other necessary changes:
Upload.jsp
<%@page contentType="text/html;charset=UTF-8"%>
<%@page pageEncoding="UTF-8"%>
<%@ page session="false"%>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>
<html>
<head>
<META http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>Upload Example</title>
<script language="JavaScript">
var count=0;
function add(type) {
//Create an input type dynamically.
var table = document.getElementById("fileUploadTable");
var tr = document.createElement("tr");
var td = document.createElement("td");
var element = document.createElement("input");
//Assign different attributes to the element.
element.setAttribute("type", "file");
element.setAttribute("value", "");
element.setAttribute("name", "fileData["+type+"]");
//Append the element in page (in span).
td.appendChild(element);
tr.appendChild(td);
table.appendChild(tr);
}
function Validate()
{
var image =document.getElementById("image").value;
if(image!=''){
var checkimg = image.toLowerCase();
if (!checkimg.match(/(\.jpg|\.png|\.JPG|\.PNG|\.jpeg|\.JPEG)$/)){
alert("Please enter Image File Extensions .jpg,.png,.jpeg");
document.getElementById("image").focus();
return false;
}
}
return true;
}
</script>
</head>
<body>
<form:form modelAttribute="uploadItem" name="frm" method="post"
enctype="multipart/form-data" onSubmit="return Validate();">
<fieldset><legend>Upload File</legend>
<table >
<tr>
<input type="button" name="Add Image" onclick="add(count++)" value="Add Image"/>
</tr>
<tr>
<table id="fileUploadTable">
<!--td><form:label for="fileData" path="fileData">File</form:label><br />
</td>
<td><input name="fileData[0]" id="image0" type="file" /></td>
<td><input name="fileData[1]" id="image1" type="file" /></td-->
</table>
</tr>
<tr>
<td><br />
</td>
<td><input type="submit" value="Upload" /></td>
</tr>
</table>
</fieldset>
</form:form>
</body>
</html>
UploadItem.java
Generate getter and setter methods for the private List fileData;
UploadFileController.java
Just copy and paste the create(…) mentioned in the blog above.
Note: If you are still facing issue with file upload in Spring MVC, please add a MultipartFilter. Refer here.
<filter>
<filter-name>multipartFilter</filter-name>
<filter-class>org.springframework.web.multipart.support.MultipartFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>multipartFilter</filter-name>
<url-pattern>/springrest/*</url-pattern>
</filter-mapping>
<bean id="filterMultipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize">
<value>10000000</value>
</property>
</bean>
