A PROJECT REPORT ON

WEB BASED COLLABORATIVE BIG DATA ANALYTICS ON BIG DATA AS A SERVICE

 CHAPTER -1
1. INTRODUCTION
1.1 MOTIVATION

Right from the advent of computers, developers have been facing a lot of
problem maintaining and processing data. Varied formats and differing sizes have
made most of the data platform dependent. Frameworks like Hadoop and other
open source technologies have made dealing with big data easy and flexible.
Making cloud and Internet as platform of storage and analytics of data we have
drawn our motivation.

1.2 PROBLEM DEFINITION

The varied sizes and different types of data have made the processing and
maintenance of the data in a wide space like Internet far from flexible and
accessibility. Persons from various locations find it difficult to access data from
remote locations.

1.3 OBJECTIVE OF PROJECT

The primary purpose of the web application is to provide a platform where
different type of users with distinct privileges and authorities collaborate to deal
and perform analytics on the big data. This model serves as a prototype for the
real world big data analytics framework.

1.4 LIMITATIONS OF PROJECT

Security of the file is under stake when the data is worked on an
external Platform. The application carries the paradigm that of a real time big
data cloud applications but falls short in the efficiency of execution.
1
CHAPTER-2

2. LITERATURE SURVEY
2.1 INTRODUCTION

Data is always admired for its omnipresence and its accessibility. Right from the
generation of data, its maintenance has been a cause of issue. All of the data used in
social networking sites is stored and processed securely. One has to be very careful with
data stored or processed in public domains and social networking sites. Data is of various
kinds in existence and has its reach in different industries. Large amount of data requires
sophisticated approach in storing and performance.

As a model that serves on cloud, one of the basic concerns would be the security
of the data being shared. One does not really want to lose their data to an eavesdropper or
a professional hacker. This application being dealt on internet needs to be secure and
reliable such that no author or owner of a confidential information.

2.2 EXISTING SYSTEM

Literally, big data is a large volume of data so that it is difficult to collect, store,
and analyze. However, big data is not just about a large volume of data. It is a concept that
provides an opportunity to find useful knowledge into existing data.

2.2.1 DRAWBACKS IN EXISTING SYSTEM

Security of the file is under stake when the data is worked on an external platform.
The application carries the paradigm that of a real time big data cloud applications but
falls short in the efficiency of execution.

2.3 PROPOSED SYSTEM

Big data is characterized by 3Vs: Volume, Velocity, and Variety[4]. First of all,
there has been the exponential growth in the data storage as data format is diversifying.
We can find various data formats such as video, music, and large image files on the social
network service channels. It is common to have the storage system of which size is
Terabytes or Peta bytes. Secondly, velocity is often identified with real-time analytics.
 However, velocity is also about the rate of changes. There was a time when data had been
hardly changed or the rate of changes is very low.

Yet, today people reply on SNS (Social Network Service) to update their
messages. Sometimes, a few seconds’ old messages is discarded or updated because users
are not interested in any more. They often remove old messages and pay attention to
recent updates. This high velocity data illustrates big data. Lastly, data can be stored in
multiple formats. For example, the data would be stored in a simple text file or stored in
the form of video, SMS, pdf or user defined format. In this case, we should consider how
to process a variety formats of data. This variety of data describes big data.

2.4 FEASIBILITY STUDY

The feasibility of the project is analyzed in this phase and business proposal is put
forth with a very general plan for the project and some cost estimates. During system
analysis the feasibility study of the proposed system is to be carried out. This is to ensure
that the proposed system is not a burden to the company. For feasibility analysis, some
understanding of the major requirements for the system is essential.

Three key considerations involved in the feasibility analysis are

 ECONOMICAL FEASIBILITY

 TECHNICAL FEASIBILITY

 SOCIAL FEASIBILITY

ECONOMICAL FEASIBILITY

This study is carried out to check the economic impact that the system will have
on the organization. The amount of fund that the company can pour into the research and
development of the system is limited. The expenditures must be justified. Thus the
developed system as well within the budget and this was achieved because most of the
technologies used are freely available. Only the customized products had to be purchased.
TECHNICAL FEASIBILITY
This study is carried out to check the technical feasibility, that is, the technical
requirements of the system. Any system developed must not have a high demand on the
available technical resources. This will lead to high demands on the available technical
resources. This will lead to high demands being placed on the client. The developed
system must have a modest requirement, as only minimal or null changes are required for
implementing this system.

SOCIAL FEASIBILITY
The aspect of study is to check the level of acceptance of the system by the user.

This includes the process of training the user to use the system efficiently.

The user must not feel threatened by the system, instead must accept it as a
necessity. The level of acceptance by the users solely depends on the methods that are
employed to educate the user about the system and to make him familiar with it. His level
of confidence must be raised so that he is also able to make some constructive criticism,
which is welcomed, as he is the final user of the system.

2.2 FEATURES OF THE PROJECT

TECHNOLOGIES REQUIRED FOR THE IMPLEMENTATION
Overview of Java

Java is a programming language originally developed by James Gosling at Sun

Microsystems (now part of Oracle Corporation) and released in 1995 as a core component
of Sun Microsystems' Java platform. Java applications are typically compiled to byte
code (class file) that can run on any Java Virtual Machine (JVM) regardless of computer
architecture.It is intended to let application developers "write once, run anywhere." Java
is currently one of the most popular programming languages in use, particularly for
client-server web applications. Java technology is both a programming language and a
platform Independent.
Features of Java

Simple

Architecture neutral

Object oriented

Portable

Distributed

High performance

Interpreted

Multithreaded

Robust

Dynamic

Secure

Java Virtual Machine (JVM)

With most programming languages, you either compile or interpret a
program so that you can run it on your computer. The Java programming language
is unusual in that a program is both compiled and interpreted. With the compiler,
first you translate a program into an intermediate language called Java byte codes

—the platform-independent codes interpreted by the interpreter on the Java

platform. The interpreter parses and runs each Java byte code instruction on the
computer. Compilation happens just once; interpretation occurs each time the
program is executed.

The following figure illustrates how this works.

Figure 1: An Overview of the software development process

5
 Every Java interpreter, whether it’s a development tool or a Web browser that
can run applets, is an implementation of the Java VM. Java byte codes help make
“write once, run anywhere” possible. You can compile your program into byte
codes on any platform that has a Java compiler. The byte codes can then be run on
any implementation of the Java VM. That means that as long as a computer has a
Java VM, the same program written in the Java programming language can run on
Windows 2000, a Solaris workstation, or on an iMac.

Figure 2: Java Virtual machine

The Java Platform

A is the hardware or software environment in which a program runs. We’ve

already mentioned some of the most popular platforms like Windows 2000, Linux,
Solaris, and MacOS. Most platforms can be described as a combination of the
operating system and hardware. The Java platform differs from most other
platforms in that it’s a software-only platform that runs on top of other hardware-
based platforms.
 The Java platform has two components:

 The Java Virtual Machine


 The Java Application Programming Interface (Java API)

You’ve already been introduced to the Java VM.

It’s the base for the Java platform and is ported onto various hardware-based
platforms. The Java API is a large collection of ready-made software components that
provide many useful capabilities, such as graphical user interface (GUI) widgets. The
Java API is grouped into libraries of related classes and interfaces; these libraries are
known as

6
packages. The next section, What Can Java Technology Do? Highlights what
functionality some of the packages in the Java API provide.

The following figure depicts a program that’s running on the Java platform. As the figure
shows, the Java API and the virtual machine insulate the program from the hardware.

Fig: Java platform with API and JVM

Native code is code that after you compile it, the compiled code runs on a specific
hardware platform. As a platform-independent environment, the Java platform can be a
bit slower than native code. However, smart compilers, well-tuned interpreters, and just-
in-time byte code compilers can bring performance close to that of native code without
threatening portability.

Networking Classes in the JDK

Through the classes in java.net, Java programs can use TCP or UDP to
communicate over the Internet. The URL, URLConnection, Socket, and ServerSocket
classes all use TCP to communicate over the network. The Datagram Packet, Datagram
Socket, and MulticastSocket classes are for use with UDP. The TCP/IP stack is shorter
than the OSI one:
Fig: TCP/IP Architecture

7
TCP is a connection-oriented protocol; UDP (User Datagram Protocol) is a

connectionless protocol.

IP datagram’s

The IP layer provides a connectionless and unreliable delivery system. It

considers each datagram independently of the others. Any association between datagram
must be supplied by the higher layers.

The IP layer supplies a checksum that includes its own header. The header
includes the source and destination addresses. The IP layer handles routing through an
Internet. It is also responsible for breaking up large datagram into smaller ones for
transmission and reassembling them at the other end.

UDP

UDP is also connectionless and unreliable. What it adds to IP is a checksum for the
contents of the datagram and port numbers. These are used to give a client/server model -
see later.

TCP

TCP supplies logic to give a reliable connection-oriented protocol above IP. It provides a
virtual circuit that two processes can use to communicate.

Internet addresses

In order to use a service, you must be able to find it. The Internet uses an address scheme
for machines so that they can be located. The address is a 32 bit integer which gives the
IP address. This encodes a network ID and more addressing. The network ID falls into
various classes according to the size of the network address.
Network address

Class A uses 8 bits for the network address with 24 bits left over for other addressing.

Class B uses 16 bit network addressing. Class C uses 24 bit network addressing and class

D uses all 32.

Subnet address

Internally, the UNIX network is divided into sub networks. Building 11 is currently on
one sub network and uses 10-bit addressing, allowing 1024 different hosts.

8
Host address

8 bits are finally used for host addresses within our subnet. This places a limit of 256
machines that can be on the subnet.

The 32 bit address is usually written as 4 integers separated by dots.

Read File Write File

Port addresses

A service exists on a host, and is identified by its port. This is a 16 bit number. To send a
message to a server, you send it to the port for that service of the host that it is running
on. This is not location transparency! Certain of these ports are "well known".

Sockets

A socket is a data structure maintained by the system to handle network connections.

A socket is created using the call socket. It returns an integer that is like a file descriptor.
In fact, under Windows, this handle can be used with and functions.
Remote Method Invocation (RMI)

The Java Remote Method Invocation (RMI) system allows an object running in
one Java Virtual Machine (JVM) to invoke methods on an object running in another Java
VM. RMI provides for remote communication between programs written in the Java
programming language. RMI can be used to develop distributed applications as has been
demonstrated by this project.

RMI provides the user with facilities to make method calls remotely. RMI is transparent to
the local modules of the application. Thus, there would be no difference between making a
call to a local method and making a remote method call to a method on a remote machine
using RMI. The user is provided with the same interface by the underlying layer.

9
 Awt

Swing's configurability is a result of a choice not to use the native host OS's GUI
controls for displaying itself. Swing "paints" its controls programmatically through the
use of Java 2D APIs, rather than calling into a native user interface toolkit. Thus, a Swing
component does not have a corresponding native OS GUI component, and is free to
render itself in any way that is possible with the underlying graphics APIs.

However, at its core every Swing component relies on an AWT container, since (Swing's)
JComponent extends (AWT's) Container.

Swing component paints its rendition on the graphic device in response to a call to
component. paint (), which is defined in (AWT) Container. But unlike AWT components,
which delegated the painting to their OS-native "heavyweight" widget, Swing
components are responsible for their own rendering.

General Concepts of JFC-Swing

GUI programming with Java

 Java provides a set of user interface components



 The set is the same across Unix, Windows and the Macintos


 The user interface components can be used for applets and for applications


 The set allows cross-platformapplications and applets to be built

Evolution of Java GUI programming

 The AWT (Abstract Window Toolkit) has been present in all versions of Java


 The AWT objects are built above native code objects, giving a native look-and-
feel

  The AWT objects are a least common denominator of all platforms


 The Swing objects are a separate library for JDK 1.1



 The Swing objects are in pure Java, and have the same look-and-feel on all
platforms


 The L&F of Swing objects can be customized to particular styles



 In JDK 1.2, the Swing objects are part of the Java Foundation Classes


 The JFC objects will provide a superset of each platform's objects

10
 The AWT objects will decrease in importance over time Events may need to be
``blocked'' from reaching objects sometime in password entry, keystrokes need to be
caught by the application but not reach the Text object for display

File Dialog

Implemented by Motif File Selection Dialog

File Dialog has two constructors

File Dialog (Frame parent, String title);

File Dialog (Frame parent, String title, int mode);

The mode can be LOAD or SAVE - which affects the labeling of the dialog
Major methods are

Set Directory (String) // sets dirMask

Set File (String)

SetFilenameFilter (Filename Filter) - still does nothing

Lightweight Objects

 Lightweight objects are built purely in Java


 They have no native-code GUI object

 They have the same geometry model

 They have the same event handling model


 They are being used to develop the Java Foundation Classes


 The JFC objects mirror the AWT objects

  Eventually, much of the native code stuff will disappear

AWT Hierarchy

11
  ``Primitive'' objects are directly derived from Component

 Layout Manager is used for geometry management

 LayoutManager2 fixes some deficiencies in LayoutManager (from JDK 1.1 on)

 AWT Event encodes all the event information

 ComponentPeer objects are used to give the native implementation, and should be
ignored most of the time

 AWT Primitive Components

The main ``primitive'' objects derived from Component are

These are all in package java.awt.

Swing Primitive Components

These mirror the AWT components:

  There are additional components as well


 In general, to each AWT component is a Swing component

12
  As much as possible, each Swing component has the same methods and behavior
as its corresponding AWT component

 Container Components


 Container objects are derived from Component. The main ones derived from
that are


 Dialog


 File Dialog


 Frame


 Panel


 Window


 MenuComponents


 Menus are implemented by sub classing Menu Component which is derived from
Object

 CheckboxMenuItem


 Menu


 Menu Bar


 Menu Item

11

 Layout Objects


 Layout objects derive from Object and are used for geometry management


 BorderLayout


 CardLayout


 FlowLayout

13
  GridLayout


 GridBagLayouts


 Components


 Component Objects


 Component has a number of methods inherited by all objects derived from it.


 Some methods set state



 setEnabled() (replaces enable()/disable())



 setVisible() (replaces hide()/show())



 setBackground(Color)


 setFont(Font)


 Other methods are informational



 boolean isEnabled()


 boolean isShowing()


 Color getBackground()

Label

 Label is single-line only (stuff after \n ignored)



 It is left-to-right only


 There are three constructors for Label


  Label lab1 = new Label();


 Label lab2 = new Label("Hello", Label.RIGHT);

Label (2)

 Inherited methods allow



 label.setVisible(false);

14
  if (label.isShowing()) ...


 Major new methods are



 label.setText("Hello");


 label.setAlignment(Label.LEFT);


 String s = label.getText();

Label

Label is single-line only (stuff after \n ignored)

It is left-to-right only

There are three constructors for Label

Label lab1 = new Label ();

Label lab2 = new Label ("Hello World");

Label lab3 = new Label ("Hello", Label.RIGHT);

Label (2)

Inherited methods allow

label.setVisible (false);

if (label.isShowing()) ...

Major new methods are

label.setText("Hello");
 label.setAlignment(Label.LEFT);

String s = label.getText();

* Swing- Swing is a set of classes that provides more powerful and flexible
components that are possible with AWT. In addition to the familiar components, such
as button checkboxes and labels, swing supplies several exciting additions, including
tabbed panes, scroll panes, trees and tables.

Features of Swing components

 Swing buttons and labels can display images instead of, or in addition to text.

 User can easily add or change the borders drawn around most swing
components.

15
  Users can easily change the behavior or appearance of a swing component by
either invoking methods on it or creating a subclass of it.

 Swing components don’t have to be rectangular, buttons, for e.g., can be
round.

 Assistive technologies such as screen renders can get information from swing
components.

 Swing let’s to specify which look and feel a program’s GUI uses.

 Swing components are implemented with no native code and aren’t restricted
to the least common denominator.

Introduction to swing

This introduction to using Swing in Java will walk you through the basics of
Swing. This covers topics of how to create a window, add controls, position the controls,
and handle events of the control.

The main window almost all GUI applications have a main or top-level window.
In Swing, such window is usually instance of JFrame or JWindow. The difference
between those two classes is in simplicity – JWindow is much simpler than JFrame (most
noticeable are visual differences - JWindow does not have a title bar, and does not put a
button in the operating system task bar). So, your applications will almost always start
with a JFrame. Though you can instantiate a JFrame and add components to it, a good
practice is to encapsulate and group the code for a single visual frame in a separate class.
Usually, I subclass the JFrame and initialize all visual elements of that frame in the
constructor. Always pass a title to the parent class constructor – that String will be
displayed in the title bar and on the task bar. Also, remember to always initialize frame
size (by calling set Size (width, height)), or your frame will not be noticeable on the
screen. package com.neuri.handsonswing.ch1;

import javax.swing.JFrame;
 public class MainFrame extends JFrame

public MainFrame()

16
 super("My title");

setSize(300, 300);

}}

ss}

Now you have created your first frame, and it is time to display it. Main frame is
usually displayed from the main method – but resist the urge to put the main method in
the frame class. Always try to separate the code that deals with visual presentation from
the code that deals with application logic – starting and initializing the application is part
of application logic, not a part of visual presentation. A good practice is to create an
Application class that will contain initialization code.

package com.neuri.handsonswing.ch1;

public class Application

public static void main(String[] args)

//perform any initialization

MainFrame mf = new
MainFrame(); mf.show();

}
 If you run the code now, you will see an empty frame. When you close it,
something not quite obvious will happen (or better said, will not happen). The application
will not end. Remember that the Frame is just a visual part of application, not application
logic – if you do not request application termination when the window closes, your
program will still run in the background (look for it in the process list). To avoid this
problem, add the following line to the MainFrame constructor:

17
 Fig: JFrame

window listener and then act on the window closing event by stopping the application.
Since Java2 1.3, you can specify a simple action that will happen when a window is
closed with this shortcut. Other options are HIDE_ON_CLOSE (the default – window is
closed but application still runs) and DO_NOTHING_ON_CLOSE (rather strange option
that ignores a click on the X button in the upper right corner).

Adding Components

Now is the time to add some components to the window. In Swing (and the Swing
predecessor, AWT) all visual objects are subclasses of Component class. The Composite
pattern was applied here to group visual objects into Containers, special components that
can contain other components. Containers can specify the order, size and position of
embedded components (and this can all be automatically calculated, which is one of the
best features of Swing).
 JButton is a component class that represents a general purpose button – it can
have a text caption or an icon, and can be pressed to invoke an action. Let’s add the
button to the frame (note: add imports for javax.swing.* and java.awt.* to the MainFrame
source code so that you can use all the components).

When you work with JFrame, you want to put objects into it’s content pane – special
container intended to hold the window contents. Obtain the reference to that container
with the getContentPane() method.

Container content = getContentPane

18
content.add(new JButton("Button 1"));

If you try to add more buttons to the frame, most likely only the last one added
will be displayed. That is because the default behavior of JFrame content pane is to
display a single component, resized to cover the entire area.

Fig: Button widget on JFrame

Grouping Componets

To put more than one component into a place intended for a single component,
group them into a container. JPanel is a general purpose container, that is perfect for
grouping a set of components into a “larger” component. So, let’s put the buttons into a
JPanel:
JPanel panel=new JPanel();

panel.add(new JButton("Button 1"));

panel.add(new JButton("Button 2"));

panel.add(new JButton("Button 3"));

content.add(panel)

19
 Fig: Mulltiple buttons widget on JFrame

Layout Management Basics

One of the best features of Swing is automatic component positioning and

resizing. That is implemented trough a mechanism known as Layout management.
Special objects – layout managers – are responsible for sizing, aligning and positioning
components. Each container can have a layout manager, and the type of layout manager
determines the layout of components in that container. There are several types of layout
managers, but the two you will most frequently use are FlowLayout (orders components
one after another, without resizing) and BorderLayout (has a central part and four edge
areas – component in the central part is resized to take as much space as possible, and
components in edge areas are not resized). In the previous examples, you have used both
of them. FlowLayout is the default for a JPanel (that is why all three buttons are displayed
without resizing), and BorderLayout is default for JFrame content panes

Layout for a container is defined using the setLayout method (or usually in
the constructor). So, you could change the layout of content pane to FlowLayout and add
several components, to see them all on the screen.

20
 The best choice for the window content pane is usually a BorderLayout with a
central content part and a bottom status (or button) part. The top part can contain a
toolbar, optionally.

Now, let’s combine several components and layouts, and introduce a new
component – JTextArea. JTextArea is basically a multiline editor. Initialize the frame
content pane explicitly to BorderLayout, put a new JTextArea into the central part and
move the button panel below.

Fig: JText Area

package com.neuri.handsonswing.ch1;

import java.awt.*;

import javax.swing.*;
public class MainFrame extends JFrame

public MainFrame()

super("My title");

setSize(300,300);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Container content = getContentPane();

content.setLayout(new BorderLayout());
JPanel panel = new JPanel(new FlowLayout());
panel.add(new JButton("Button 1"));

21
 panel.add(new JButton("Button 2"));

panel.add(new JButton("Button 3"));

content.add(panel, BorderLayout.SOUTH);
content.add(new JTextArea(), BorderLayout.CENTER);

Scrolling

Now, type a few lines of text into the text area – once you type enough lines (or
press Enter enough times), the cursor will disappear from the screen. Swing is different
from other GUI toolkits, and visual components do not support scrolling unless you tell
them to – but, on the other hand, this way you can put scrollbar around almost anything.
To enable scrolling, just put the component (or a container with other components) into a
JScrollPane – this is a special container that adds scrollbars to it’s content. Change the
last line of the previous class to content.add(new JScrollPane(new JTextArea()),
BorderLayout.CENTER);to see a scrolling text area inside your window.
Fig: Frame with scrolling option

22
 Fig:JFrame with drop-down options

panel=new JPanel(new FlowLayout());

panel.add(new JLabel("Enter your name"));

panel.add(new JTextField(10));
 String options[] = new String[]{ "Option 1","Option 2","Option 2"
}; panel.add(new JComboBox(options)); content.add(panel,
BorderLayout.NORTH);

Handling Actions and Events

Now that you have learned how to put components on the screen, you will learn
how to react to user actions with those components. The central mechanism for this is
the Observer pattern, implemented in Swing with event listeners. Components publish
notifications about events, and event listeners receive these notifications.For example, to
execute a code when user presses a button, you should define a listener for the button
pressing event and register it with that button.

23
 Fig: JFrame with onClick event Listener

package com.neuri.handsonswing.ch1;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.*;

public class MainFrame extends JFrame

{
public MainFrame()

super("My title");

setSize(300,300);

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Container content = getContentPane();

content.setLayout(new BorderLayout());
JPanel panel = new JPanel(new FlowLayout());
JButton button1 = new JButton("Button 1");
panel.add(button1);

button1.addActionListener( new
MyButtonListener(this)); panel.add(new JButton("Button
2")); panel.add(new JButton("Button 3"));

content.add(panel, BorderLayout.SOUTH);

content.add(new JScrollPane(new JTextArea()), BorderLayout.CENTER);

24
 panel = new JPanel(new FlowLayout());

panel.add(new JLabel("Enter your name"));

panel.add(new JTextField(10));

String options[] = new String[]{"Option 1","Option 2","Option 2"};

panel.add(new JComboBox(options)); content.add(panel, BorderLayout.NORTH);
}

private class MyButtonListener implements

ActionListener {

private JFrame parentComponent;

MyButtonListener(JFrame parentComponent)

this.parentComponent=parentComponent;

public void actionPerformed(ActionEvent e)

JOptionPane.showMessageDialog(parentComponent, "BUTTON PRESSED!");

}
}

In this example, we created an ActionListener and attached it to a button.

ActionListener interface has just one method: actionPerformed. That method is called
when an action occurs. The event type ActionEvent is the most common in Swing - most
components produce an ActionEvent. Components may also produce other events - such
as change of the current selection, text or size. For now, you should be most concerned
with ActionEvent. In any case, in an IDE that can display methods of a class and look for
methods that begin with add and end with Listener (for example, addFocusListener) to
see what listener/event types a component supports. One more interesting thing in this
example is usage of class JOptionPane. That class has many utility methods that help you
display standardised input dialogs and message dialogs. This being said, it is time to note
that the above example is not written in the style usual for Swing. Since the only usage of
a listener is to call a method, it is ofter written as an anonymous inner class.

25
button1.addActionListener( new ActionListener()

public void actionPerformed(ActionEvent e)

JOptionPane.showMessageDialog(MainFrame.this,"BUTTON PRESSED!");

})

For now, just note that there are also other ways of receiving event notification
then installing a listener for every object on the screen. For example, the following few
lines installs a global listener for the F1 key pressing:

KeyStroke ks=KeyStroke.getKeyStroke(KeyEvent.VK_F1,0);

topComponent.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMP

ONENT).put(ks,"HELP");

topComponent.getActionMap().put("HELP",

new AbstractAction()

public void actionPerformed(ActionEvent evt)

{
 // do something here, display a dialog or whatever

});

JDBC

In an effort to set an independent database standard API for Java, Sun

Microsystems developed Java Database Connectivity, or JDBC. JDBC offers a generic
SQL database access mechanism that provides a consistent interface to a variety of
RDBMSs. This consistent interface is achieved through the use of “plug-in” database
connectivity modules, or drivers. If a database vendor wishes to have JDBC support, he
or she must provide the driver for each platform that the database and Java run on.

26
 3. ANALYSIS

3.1 INTRODUCTION

A Software Requirements Specification (SRS) is a description of a particular

software product, program or set of programs that performs a set of functions in a target
environment (IEEE Std. 830-1993).

3.2 REQUIREMENT SPECIFICATION

3.2.1 USER REQUIREMENTS

3.2.1.1 FUNCTIONAL REQUIREMENTS

Functional Requirement defines a function of a software system and how the

system must be have when presented with specific inputs or conditions. These may
include calculations, data manipulation and processing and other specific functionality. In
this system following are the functional requirements Data owner will login to the
corresponding cloud server he got registered.

 Data owner encrypt will upload file to the cloud server



 Data owner verifies the file he uploaded either it is safe or not.



 Data owner can view, how many file has been uploaded to the
corresponding cloud servers

3.2.1.2 NON-FUNCTIONAL REQUIREMENTS

The major non-functional Requirements of the system are as follows

1. Usability
 The system is designed with completely automated process hence there is
no or less user intervention.

2. Reliability

The system is more reliable because of the qualities that are inherited
from the chosen platform java (JSP). The code built by using java is more reliable.

3. Performance

This system is developing in the high level languages and using the
advanced front-end and back-end technologies it will be responsive and execute in
very less time.

27
 4. Supportability

The system is designed to be the cross platform supportable. The system

is supported on a wide range of hardware and any software platform, which is
having JVM, built into the system.

5. Implementation

The system is implemented with Java environment. The java software

development kit and net beans used as software and windows 10 is used as the
platform.

3.2.2 SOFTWARE AND HARDWARE REQUIREMENTS

HARDWARE REQUIREMENTS:

 Processor - Pentium –III


 RAM - 256 MB (min)

 Hard Disk - 20 GB

 Key Board - Standard Windows Keyboard

 Mouse - Two or Three Button Mouse

 Monitor – SVGA

SOFTWARE REQUIREMENTS:
  Operating System : Windows95/98/2000/XP

 Front End : HTML, JSP

 Scripts: JavaScript.

 Server side Script :AWT, swings.

 Database : MySQL 5.0

 DatabaseConnectivity : JDBC

28

5. IMPLEMENTATION
5.1 INTRODUCTION

The most crucial phase of any project is the implementation. This includes
all those activities that take place to convert from the old system to the new system. It
involves setting up of the system for use by the concerned end user. A successful
implementation involves a high level of interaction between the analyst, programmers
and the end user. The most common method of implementation is the phased approach,
which involves installation of the system concurrently with the existing system. This has
its advantage in that the normal activity carried out, as part of the existing system is
anyway hampered. The end users are provided with sufficient documentation and
adequate training in the form of demonstration/presentation in order to familiarize with
the system.

5.2 KEY FUNCTIONS

Data Owner- Uploads data

Data Scientist – Verifies the data whether it is of the right type

Bdaas – Grants permission to the service developer to execute on external ide.

Service Developer – Executes and uses data on other platforms.

5.3 SAMPLE CODE

<HTML XMLNS="HTTP://WWW.W3.ORG/1999/XHTML">
<HEAD>

<TITLE>WEB BASED COLLABORATIVE</TITLE>

<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="TEXT/HTML; CHARSET=ISO-

8859-1" />

<LINK REL="STYLESHEET" HREF="LAYOUT/STYLES/LAYOUT.CSS"

TYPE="TEXT/CSS" />

<SCRIPT TYPE="TEXT/JAVASCRIPT"

43
SRC="LAYOUT/SCRIPTS/JQUERY.MIN.JS"></SCRIPT>

<SCRIPT TYPE="TEXT/JAVASCRIPT"

SRC="LAYOUT/SCRIPTS/JQUERY.JCAROUSEL.PACK.JS"></SCRIPT>

<SCRIPT TYPE="TEXT/JAVASCRIPT"

SRC="LAYOUT/SCRIPTS/JQUERY.JCAROUSEL.SETUP.JS"></SCRIPT>

</HEAD>

<BODY ID="TOP">

<DIV CLASS="WRAPPER COL1">

<DIV ID="HEADER">

<DIV ID="LOGO">

<H1><A HREF="INDEX.HTML">WEB-BASED COLLABORATIVE</A></H1>

<P>BIG DATA ANALYTICS ON BIG DATA AS A SERVICE PLATFORM</P>

</DIV>

<DIV ID="TOPNAV">

<UL>

<LI CLASS="ACTIVE"><A HREF="INDEX.HTML">HOME</A></LI>

<LI><A HREF="DATAOWNER.JSP">DATA OWNER</A></LI>

<LI><A HREF="DATASCIENTIT.JSP">DATA SCIENTISTS</A></LI>

 <LI><A HREF="SERVICEDEVELOPER.JSP">SERVICE DEVELOPERS</A>

<LI><A HREF="BDAAS.JSP">BDAAS</A>

</LI>

</UL>

</DIV>

<BR CLASS="CLEAR" />

</DIV>

</DIV>

5.4 OUTPUT SCREENS

44
HOME PAGE
DATA OWNER LOGIN PAGE

45
DATA OWNER REGISTRATION PAGE
DATA LIST PAGE WITH ALL FILES

46
DATA MODIFICATION PAGE
.DATA MONITORING PAGE

47
DATA SCIENTIST HOME PAGE
DATA SCIENTIST VERIFICATION PAGE

48
PAGE FOR CHECKING ALL VERIFIED FILES
SERVICE DEVELOPER LOGIN PAGE

49
.PAGE WITH LIST OF FILES THAT ARE VERIFIED
.BDAAS HOME PAGE

50
REQUEST VALIDATION PAGE
GRANTED REQUEST PAGE

51
 6. TESTING, VALIDATION AND RESULTS

6.1 INTRODUCTION

The purpose of testing is to discover errors. Testing is the process of trying to

discover every conceivable fault or weakness in a work product. It provides a way to
check the functionality of components, subassemblies, assemblies and/or a finished
product It is the process of exercising software with the intent of ensuring that the

Software system meets its requirements and user expectations and does not fail in an
unacceptable manner. There are various types of test. Each test type addresses a specific
testing requirement.

6.2 TESTING METHODOLOGIES

Unit testing

Unit testing involves the design of test cases that validate that the internal program
logic is functioning properly, and that program inputs produce valid outputs. All decision
branches and internal code flow should be validated. It is the testing of individual
software units of the application .it is done after the completion of an individual unit
before integration. This is a structural testing, that relies on knowledge of its construction
and is invasive. Unit tests perform basic tests at component level and test a specific
business process, application, and/or system configuration. Unit tests ensure that each
unique path of a business process performs accurately to the documented specifications
and contains clearly defined inputs and expected results.

Integration testing
 Integration tests are designed to test integrated software components to determine
if they actually run as one program. Testing is event driven and is more concerned with
the basic outcome of screens or fields. Integration tests demonstrate that although the
components were individually satisfaction, as shown by successfully unit testing, the
combination of components is correct and consistent. Integration testing is specifically
aimed at exposing the problems that arise from the combination of components.

52
Functional test

Functional tests provide systematic demonstrations that functions tested are

available as specified by the business and technical requirements, system documentation,
and user manuals.

Functional testing is centered on the following items:

Valid Input
: identified classes of valid input must be accepted.

Invalid Input
: identified classes of invalid input must be rejected.

Functions
: identified functions must be exercised.

Output
: identified classes of application outputs must be exercised.

Systems/Procedures: interfacing systems or procedures must be invoked.

Organization and preparation of functional tests is focused on requirements, key

functions, or special test cases. In addition, systematic coverage pertaining to identify
Business process flows; data fields, predefined processes, and successive processes must
be considered for testing. Before functional testing is complete, additional tests are
identified and the effective value of current tests is determined.
System Test

System testing ensures that the entire integrated software system meets
requirements. It tests a configuration to ensure known and predictable results. An
example of system testing is the configuration oriented system integration test. System
testing is based on process descriptions and flows, emphasizing pre-driven process
links and integration points.

White Box Testing

White Box Testing is a testing in which in which the software tester has
knowledge of the inner workings, structure and language of the software, or at least its

53
purpose. It is purpose. It is used to test areas that cannot be reached from a black box
level.

Black Box Testing

Black Box Testing is testing the software without any knowledge of the inner
workings, structure or language of the module being tested. Black box tests, as most other
kinds of tests, must be written from a definitive source document, such as specification or
requirements document, such as specification or requirements document. It is a testing in
which the software under test is treated, as a black box .you cannot “see” into it. The test
provides inputs and responds to outputs without considering how the software works.

6.3 DESIGN OF TEST CASES AND SCENARIOS

Unit Testing:

Unit testing is usually conducted as part of a combined code and unit test phase of
the software lifecycle, although it is not uncommon for coding and unit testing to be
conducted as two distinct phases.

Test strategy and approach

Field testing will be performed manually and functional tests will be written in

detail.
 Test objectives

 All field entries must work properly.


 Pages must be activated from the identified link.

 The entry screen, messages and responses must not be delayed.

54
 Features to be tested

 Verify that the entries are of the correct format


 No duplicate entries should be allowed


 All links should take the user to the correct page.

Integration Testing

Software integration testing is the incremental integration testing of two or more

integrated software components on a single platform to produce failures caused by
interface defects.

The task of the integration test is to check that components or software

applications, e.g. components in a software system or – one step up – software
applications at the company level – interact without error.

Test Results: All the test cases mentioned above passed successfully. No defects
encountered.

Acceptance Testing

User Acceptance Testing is a critical phase of any project and requires significant
participation by the end user. It also ensures that the system meets the functional
requirements.
55
 7. CONCLUSION

7.1 CONCLUSION

The most crucial phase of any project is the implementation. This includes
all those activities that take place to convert from the old system to the new system. It
involves setting up of the system for use by the concerned end user. A successful
implementation involves a high level of interaction between the analyst, programmers
and the end user. The most common method of implementation is the phased approach,
which involves installation of the system concurrently with the existing system. This has
its advantage in that the normal activity carried out, as part of the existing system is
anyway hampered. The end users are provided with sufficient documentation and
adequate training in the form of demonstration/presentation in order to familiarize with
the system.

7.2 FUTURE ENHANCEMENT

Being a prototype it would not promise much but the module can be trained with
algorithms of machine learning such that the application will become good enough to deal
with the type of data it gets from a new user. This way we can expect minimum errors
and exceptions.
56
 8. BIBLIOGRAPHY

REFERENCES

1. Kyounghyun Park, Minh Chau Nguyen, HeesunWon, “Web-based Collaborative

Big Data Analytics on Big Data as a Service Platform,” vol. 03, 2015.

2. M. A. Beyer and D. Laney, “The importance of ‘big data’: A definition,” Gartner,

Tech. Rep., 2012.

3. S. Lohr, “The age of big data, “ New York Times, vol. 11, 2012.

4. “Big data-as-a-service: A market and technology perspective,” EMC Solution

Group, Tech. Rep., 2012.

5. Z. Zheng, J. Zhu, and M. R. Lyu, "Service-generated big data and big data-as-A-
service: An overview," pp. 403-410, 2013.
57