Java Application Development Internship

CHAPTER 1

COMPANY PROFILE

Infidata Technologies is a software development and training company. The foundation to

Infidata technologies is built on the key focus area of domain expertise in industry verticals,
customer focus by quickly aligning to client needs and company’s unique delivery model is
well executed through collaborative network of partners.

1.1 Introduction

Infidata Technologies is an ISO 9001: 2015 Certified Company and registered under MSME,
Government of India, headquartered in Bengaluru started in the year 2015. Company is
highly specialized in the design and development of website, software application
development, Mobile application development, E-Commerce solution and more. Company
has a team of expert’s professional works on the latest software tools and technologies to give
the best and promising services to the customers. Company is equipped with the state-of-art
work station in the software application development.

Vision

To become a leading performer and grow as a major IT service provider, in providing

quality Web application, Software Development solutions and corporate training in the
competitive global marketplace.

Mission

To ensure strategic planning with quality products and profitable growth through
customer service, innovation, quality and commitment.

1.2 Team

Infidata Technologies is a team of experienced professionals providing a wide range of

complex software and web application development services. The energetic professionals
with vast experience who are working in almost all technologies & spheres of IT.
Java Application Development Internship

1.3 Services

Infidata Technologies offer the services in the following areas:

● Enterprise Application Services

● Web designing and Development

● Mobile Application Development

● Internet of Things

● Training Services

1.3.1 Enterprise Application Services

An enterprise application is a software system platform designed to operate in a

corporate environment such as business or government. A software services include online
shopping and payment processing, interactive product catalogues, computerized billing
systems, security, content management, IT service management, content switching modules,
resource planning, business intelligence, human resource management, manufacturing,
application integration, forms automation, sales force automation, enterprise resource
planning and business process management. EA also includes news relevant to IT
compliance, business intelligence, office productivity suites, enterprise resource planning etc.

1.3.2 Web designing and Development

The web development process includes web design, web content development, client-
side/server-side scripting and network security configuration, among other tasks.

Web development ranges from creating plain text pages to complex web-based applications,
social network applications and electronic business applications.
Java Application Development Internship

The web development hierarchy is as follows:

● Client-side coding

● Server-side coding

● Database technology

1.3.3 Mobile Application Development

A mobile application, most commonly referred to as an app, is a type of application

software designed to run on a mobile device, such as a smartphone or tablet computer.

Mobile applications frequently serve to provide users with similar services to those accessed
on PCs. Apps are generally small, individual software units with limited function.

Vendors usually offer a mobile application platform to clients that want to go mobile or enter
the mobile market. The platform includes migration tools and resources that support a mobile
interface, or a development environment that allows creating new apps aimed at the Apple
and Android markets. A platform approach to mobile application development helps provide
a comprehensive model with tool suites that are accessible to developers and other users.

1.3.4 Internet of Things

Internet of things (IoT) is a computing concept that describes the idea of everyday
physical objects being connected to the internet and being able to identify themselves to other
devices. Most people think about being connected in terms of computers, tablets and
smartphones. IoT describes a world where just about anything can be connected and
communicate in an intelligent fashion. In other words, with the internet of things, the physical
world is becoming one big information system.

1.3.5 Training Services

The training programs that are organized by us are of the best standards. We have
some of the best trainers who conduct these programs. All these trainers have been in the
industry for a long period. They know the problems faced by the industries. They have the
total firsthand knowledge. Their rich experience is something that you would gain from. They
Java Application Development Internship

can train students/ employee step by step. We offers training on Full stack Java, Full Stack
Web, Python, Machine Learning and AI, Data Science, Data Analytics ,Mobile Application
Development, Software Testing and More.

1.4 Company Products

● Billing Software

● ERP Solutions

● Retail Store Application

1.5 Our Clients

 Streams Inc
 Vishnu Enterprises
 Deepthi Engineering
 JB Transport India
 BreakDQ
 SJCPU
 Rbits Technologies
Java Application Development Internship

ABOUT THE DEPARTMENT

Infidata Technologies provided an internship in the department of Java application

development division. The Objective is the development of new applications and technology
ensuring that the development of applications with the highest quality.

Java Application Development Department

Java Application Development Process organizes a practical procedure and approach
in application development. Infidata technologies want to streamline their internal
departments and functions, operations, sales and project management, etc. and want to take
advantage of a web based application's flexibility and versatility, by moving away from the
traditional desktop application platform to the web application platform and want to gain
more clients for better service their current clients by offering convenient services and
solutions online to build new web applications to offer innovative services or solutions to
online users and businesses
The structure helps produce best practice coding with consistent logic and coding
standards, and provides other developers the ability to become familiar with the code in a
short time. Builds are based on the module, libraries and tools, allowing programmers to
easily share libraries and implement complex functionalities and features in a fast and
efficient manner. Program actions and logic are separated from the HTML, CSS and design
files for the front end interface and embed java coding. This helps us to be able to edit the
interface and make design changes without help from a programmer.

Java application development Process

The following list of procedures and documents provide a good outline for a Java
Application Lifecycle and Process:

 Roadmap Document: Defining Web Application, Purpose, Goals and Direction

 Researching and Defining Audience Scope and Security Documents
 Creating Functional Specifications or Feature Summary Document
 Team Collaboration and Project Management Document
Java Application Development Internship

 Technology Selection, Technical Specifications, Illustrative Diagram of Java Application

Architecture and Structure, Development Methodology, Versions Control, Backups,
Upgrades, Expansion and Growth Planning Document, Server Hardware / Software
Selection
 Third Party Vendors Analysis and Selection (Merchant Account and Payment Gateway,
SSL Certificate, Managed Server / Colocated Server Provider, Fulfillment Centers,
Website Visitor Analytics Software, Third Party Checkout Systems, etc.)
 Application Visual Guide, Design Layout, Interface Design, Wire Framing
 Database Structure Design and Web Application Development using Java
 Testing: Quality Assurance, Multiple Browser Compatibility, Security, Performance -
Load and Stress Testing, Usability
 Maintenance
Java Application Development Internship

CHAPTER 2
INTERNSHIP DOMAIN

2.1 Introduction

JAVA

Java is a small, simple, safe, object oriented, interpreted or dynamically optimized, byte
coded, architectural, garbage collected, multithreaded programming language with a strongly
typed exception-handling for writing distributed and dynamicaly extensible programs.

Java is an object oriented programming language. Java is a high-level, third generation

language like C, FORTRAN, Small talk, Pearl and many others. You can use java to write
computer applications that crunch numbers, process words, play games, store data or do any
of the thousands of other things computer software can do.

Special programs called applets that can be downloaded from the internet and played safely
within a web browser. Java a supports this application and the follow features make it one of
the best programming languages.

 It is simple and object oriented

 It helps to create user friendly interfaces.
 It is very dynamic.
 It supports multithreading.
 It is platform independent
 It is highly secure and robust.
 It supports internet programming

Java is a programming language originally developed by Sun Microsystems

and released in 1995 as a core component of Sun's Java platform. The language derives much
of its syntax from C and C++ but has a simpler object model and fewer low-level facilities.
Java applications are typically compiled to byte code which can run on any Java virtual
machine (JVM) regardless of computer architecture.
Java Application Development Internship

The original and reference implementation Java compilers, virtual machines, and class
libraries were developed by Sun from 1995. As of May 2007, in compliance with the
specifications of the Java Community Process, Sun made available most of their Java
technologies as free software under the GNU General Public License. Others have also
developed alternative implementations of these Sun technologies, such as the GNU Compiler
for Java and GNU Class path.

The Java language was created by James Gosling in June 1991 for use in a set top box
project. The language was initially called Oak, after an oak tree that stood outside Gosling's
office - and also went by the name Green - and ended up later being renamed to Java, from a
list of random words. Gosling's goals were to implement a virtual machine and a language
that had a familiar C/C++ style of notation.

Primary goals

There were five primary goals in the creation of the Java language:

1. It should use the object-oriented programming methodology.

2. It should allow the same program to be executed on multiple operating systems.
3. It should contain built-in support for using computer networks.
4. It should be designed to execute code from remote sources securely.
5. It should be easy to use by selecting what were considered the good parts of other
object-oriented languages.

The Java platform is the name for a bundle of related programs, or platform,
from Sun which allow for developing and running programs written in the Java programming
language. The platform is not specific to any one processor or operating system, but rather an
execution engine (called a virtual machine) and a compiler with a set of standard libraries
which are implemented for various hardware and operating systems so that Java programs
can run identically on all of them.

Different "editions" of the platform are available, including:

 Java ME (Micro Edition): Specifies several different sets of libraries (known as

profiles) for devices which are sufficiently limited that supplying the full set of Java
libraries would take up unacceptably large amounts of storage.
Java Application Development Internship

 Java SE (Standard Edition): For general purpose use on desktop PCs, servers and
similar devices.
 Java EE (Enterprise Edition): Java SE plus various APIs useful for multi-tier client-
server enterprise applications. The Java Platform consists of several programs, each of
which provides a distinct portion of its overall capabilities. For example, the Java
compiler, which converts Java source code into Java bytecode (an intermediate
language for the Java Virtual Machine (JVM)), is provided as part of the Java
Development Kit (JDK). The sophisticated Java Runtime Environment (JRE),
complementing the JVM with a just-in-time (JIT) compiler, converts intermediate
bytecode into native machine code on the fly. Also supplied are extensive libraries
(pre-compiled into Java bytecode) containing reusable code, as well as numerous
ways for Java applications to be deployed, including being embedded in a web page
as an applet.There are several other components, some available only in certain
editions.

The essential components in the platform are the Java language compiler, the libraries, and
the runtime environment in which Java intermediate bytecode "executes" according to the
rules laid out in the virtual machine specification.

Java Virtual Machine

Java Application Development Internship

The heart of the Java Platform is the concept of a "virtual machine" that executes
Java bytecode programs. This bytecode is the same no matter what hardware or operating
system the program is running under. There is a JIT compiler within the Java Virtual
Machine, or JVM. The JIT compiler translates the Java bytecode into native processor
instructions at run-time and caches the native code in memory during execution.

The use of bytecode as an intermediate language permits Java programs to run on any
platform that has a virtual machine available. The use of a JIT compiler means that Java
applications, after a short delay during loading and once they have "warmed up" by being all
or mostly JIT-compiled, tend to run about as fast as native programs and Every Operating
System has its own JVM.

Class libraries

In most modern operating systems, a large body of reusable code is provided to simplify the
programmer's job. This code is typically provided as a set of dynamically loadable libraries
that applications can call at runtime. Because the Java Platform is not dependent on any
specific operating system, applications cannot rely on any of the existing libraries. Instead,
the Java Platform provides a comprehensive set of standard class libraries, containing much
of the same reusable functions commonly found in modern operating systems.

The Java class libraries serve three purposes within the Java Platform. Like other standard
code libraries, they provide the programmer a well-known set of functions to perform
common tasks, such as maintaining lists of items or performing complex string parsing. In
addition, the class libraries provide an abstract interface to tasks that would normally depend
heavily on the hardware and operating system. Tasks such as network access and file access
are often heavily dependent on the native capabilities of the platform. The Java java.net and
java.io libraries implement the required native code internally, then provide a standard
interface for the Java applications to perform those tasks. Finally, when some underlying
platform does not support all of the features a Java application expects, the class libraries can
either emulate those features using whatever is available, or at least provide a consistent way
to check for the presence of a specific feature.
Java Application Development Internship

Platform independence

One characteristic, platform independence, means that programs written in the Java language
must run similarly on any supported hardware/operating-system platform. One should be able
to write a program once, compile it once, and run it anywhere.

This is achieved by most Java compilers by compiling the Java language code halfway (to
Java bytecode) – simplified machine instructions specific to the Java platform. The code is
then run on a virtual machine (VM), a program written in native code on the host hardware
that interprets and executes generic Java bytecode. (In some JVM versions, bytecode can also
be compiled to native code, either before or during program execution, resulting in faster
execution.) Further, standardized libraries are provided to allow access to features of the host
machines (such as graphics, threading and networking) in unified ways. Note that, although
there is an explicit compiling stage, at some point, the Java bytecode is interpreted or
converted to native machine code by the JIT compiler.

The first implementations of the language used an interpreted virtual machine to achieve
portability. These implementations produced programs that ran more slowly than programs
compiled to native executables, for instance written in C or C++, so the language suffered a
reputation for poor performance. More recent JVM implementations produce programs that
run significantly faster than before, using multiple techniques.

One technique, known as just-in-time compilation (JIT), translates the Java byte code into
native code at the time that the program is run, which results in a program that executes faster
than interpreted code but also incurs compilation overhead during execution. More
sophisticated VMs use dynamic recompilation, in which the VM can analyze the behavior of
the running program and selectively recompile and optimize critical parts of the program.
Dynamic recompilation can achieve optimizations superior to static compilation because the
dynamic compiler can base optimizations on knowledge about the runtime environment and
the set of loaded classes, and can identify the hot spots (parts of the program, often inner
Java Application Development Internship

loops, that take up the most execution time). JIT compilation and dynamic recompilation
allow Java programs to take advantage of the speed of native code without losing portability.

Another technique, commonly known as static compilation, is to compile directly into native
code like a more traditional compiler. Static Java compilers, such as GCJ, translate the Java
language code to native object code, removing the intermediate byte code stage. This
achieves good performance compared to interpretation, but at the expense of portability; the
output of these compilers can only be run on a single architecture. Some see avoiding the VM
in this manner as defeating the point of developing in Java; however it can be useful to
provide both a generic byte code version, as well as an optimized native code version of an
application.

Automatic memory management

One of the ideas behind Java's automatic memory management model is that programmers be
spared the burden of having to perform manual memory management. In some languages the
programmer allocates memory for the creation of objects stored on the heap and the
responsibility of later deallocating that memory also resides with the programmer. If the
programmer forgets to deallocate memory or writes code that fails to do so, a memory leak
occurs and the program can consume an arbitrarily large amount of memory. Additionally, if
the program attempts to deallocate the region of memory more than once, the result is
undefined and the program may become unstable and may crash. Finally, in non garbage
collected environments, there is a certain degree of overhead and complexity of user-code to
track and finalize allocations. Often developers may box themselves into certain designs to
provide reasonable assurances that memory leaks will not occur.

In Java, this potential problem is avoided by automatic garbage collection. The programmer
determines when objects are created, and the Java runtime is responsible for managing the
object's lifecycle. The program or other objects can reference an object by holding a reference
to it (which, from a low-level point of view, is its address on the heap). When no references
to an object remain, the Java garbage collector automatically deletes the unreachable object,
freeing memory and preventing a memory leak. Memory leaks may still occur if a
programmer's code holds a reference to an object that is no longer needed—in other words,
they can still occur but at higher conceptual levels.
Java Application Development Internship

The use of garbage collection in a language can also affect programming paradigms. If, for
example, the developer assumes that the cost of memory allocation/recollection is low, they
may choose to more freely construct objects instead of pre-initializing, holding and reusing
them. With the small cost of potential performance penalties (inner-loop construction of
large/complex objects), this facilitates thread-isolation (no need to synchronize as different
threads work on different object instances) and data-hiding. The use of transient immutable
value-objects minimizes side-effect programming.

Comparing Java and C++, it is possible in C++ to implement similar functionality (for
example, a memory management model for specific classes can be designed in C++ to
improve speed and lower memory fragmentation considerably), with the possible cost of
adding comparable runtime overhead to that of Java's garbage collector, and of added
development time and application complexity if one favors manual implementation over
using an existing third-party library. In Java, garbage collection is built-in and virtually
invisible to the developer. That is, developers may have no notion of when garbage collection
will take place as it may not necessarily correlate with any actions being explicitly performed
by the code they write. Depending on intended application, this can be beneficial or
disadvantageous: the programmer is freed from performing low-level tasks, but at the same
time loses the option of writing lower level code. Additionally, the garbage collection
capability demands some attention to tuning the JVM, as large heaps will cause apparently
random stalls in performance.

Java does not support pointer arithmetic as is supported in, for example, C++. This is because
the garbage collector may relocate referenced objects, invalidating such pointers. Another
reason that Java forbids this is that type safety and security can no longer be guaranteed if
arbitrary manipulation of pointers is allowed.

Performance

Java's performance has improved substantially since the early versions, and
performance of JIT compilers relative to native compilers has in some tests been shown to be
quite similar. The performance of the compilers does not necessarily indicate the
performance of the compiled code; only careful testing can reveal the true performance issues
in any system.
Java Application Development Internship

Java Runtime Environment

The Java Runtime Environment, or JRE, is the software required to run any
application deployed on the Java Platform. End-users commonly use a JRE in software
packages and Web browser plug-in. Sun also distributes a superset of the JRE called the Java
2 SDK (more commonly known as the JDK), which includes development tools such as the
Java compiler, Java doc, Jar and debugger.

One of the unique advantages of the concept of a runtime engine is that errors
(exceptions) should not 'crash' the system. Moreover, in runtime engine environments such as
Java there exist tools that attach to the runtime engine and every time that an exception of
interest occurs they record debugging information that existed in memory at the time the
exception was thrown (stack and heap values). These Automated Exception Handling tools
provide 'root-cause' information for exceptions in Java programs that run in production,
testing or development environments.

2.2 Tools Used:

List of tools used during internship

 Eclipse IDE for Web Enterprise

 WAMP/XAMPP Server

2.3 Technologies Used

 Core Java
 HTML, CSS
Java Application Development Internship

 Java Server Pages(JSP)

 Java Servlets
 JDBC with Mysql

Core Java:

"Core Java" is a term often used to refer to the fundamentals and core features of the Java
programming language. It includes the basic concepts and libraries that are essential for any
Java developer to understand. Here are some of the core concepts and features of Java:

1. Object-Oriented Programming (OOP):

- Java is a pure object-oriented programming language, which means that everything in
Java is an object. OOP principles, such as classes, objects, inheritance, encapsulation, and
polymorphism, are fundamental to Java.

2. Platform Independence:
- Java is known for its "write once, run anywhere" capability. It achieves platform
independence through the use of the Java Virtual Machine (JVM), which allows Java code to
run on any platform that has a compatible JVM.

3. Syntax and Structure :

- Java has a C-like syntax and enforces a specific code structure, including the use of
classes, methods, and packages.

4. Data Types :
- Java supports a variety of data types, including primitive data types (e.g., int, boolean) and
reference data types (e.g., objects, arrays).

5. Variables and Constants :

- You can declare variables and constants in Java. Variables store data that can be modified,
while constants store values that cannot be changed.

6. Control Flow :
Java Application Development Internship

- Java supports conditional statements (if-else, switch) and looping constructs (for, while,
do-while) for controlling the flow of a program.

7. Methods :
- Methods are functions in Java that perform specific tasks. They can accept parameters and
return values. The `main` method is the entry point for a Java application.

8. Classes and Objects :

- Java programs are organized into classes, which serve as blueprints for creating objects.
Objects are instances of classes.

9. Inheritance :
- Java allows you to create new classes by inheriting properties and behaviors from existing
classes. This promotes code reusability.

10. Polymorphism :
- Polymorphism enables objects of different classes to be treated as objects of a common
superclass. This is achieved through method overriding and interfaces.

11. Encapsulation :
- Encapsulation is the concept of hiding an object's internal state and exposing it through
methods. Access modifiers like public, private, and protected are used to control access to
class members.

12. Abstraction :
- Abstraction allows you to define the essential features of an object while hiding the
implementation details. Abstract classes and methods are used to achieve this.

13. Exception Handling :

- Java provides mechanisms for handling exceptions that may occur during program
execution. This helps in writing robust and reliable code.

14. Collections Framework :

Java Application Development Internship

- Java includes a rich collections framework that provides classes and interfaces for
working with collections of objects, such as lists, sets, and maps.

15. Multithreading :
- Java supports multithreading, allowing multiple threads to run concurrently. This is
essential for building responsive and scalable applications.

16. File I/O :

- Java offers libraries for reading from and writing to files, making it possible to work with
external data.

17. Packages and Modules :

- Java code is organized into packages to facilitate code organization and reuse. Java 9 and
later versions also introduced modules for improved modularity.

18. Java Standard Library :

- Java comes with a vast standard library that includes classes and methods for common
tasks like networking, database access, and GUI development.

Core Java serves as the foundation for more advanced Java technologies and frameworks.
Developers typically start with core Java to gain a strong understanding of the language and
then move on to specific areas like web development, enterprise development, or mobile app
development using Java-based technologies and frameworks.
Java Application Development Internship

HTML and CSS

HTML (Hypertext Markup Language) and CSS (Cascading Style Sheets) are essential
technologies for web development. They work together to create the structure and visual
presentation of web pages. Here's an overview of HTML and CSS:
HTML is the standard markup language for creating web pages. It defines the structure and
content of a web page using a set of elements and tags.

1. Elements and Tags :

- HTML uses a variety of elements (e.g., `<p>`, `<h1>`, `<a>`) and tags (e.g., `<tagname>`)
to define different types of content, such as headings, paragraphs, links, images, and lists.

2. Document Structure :
- An HTML document is structured as a tree, with the `<html>` element at the root. It
includes the `<head>` section for metadata (title, links to stylesheets or scripts) and the
`<body>` section for the visible content of the web page.

3. Attributes :
- HTML elements often have attributes (e.g., `href`, `src`, `class`) that provide additional
information about the element or modify its behavior.

4. Hyperlinks :
- HTML allows you to create hyperlinks using the `<a>` element, enabling users to
navigate between web pages.

5. Forms :
- HTML provides form elements (e.g., `<form>`, `<input>`, `<button>`) for collecting user
input and sending data to a server.
Java Application Development Internship

CSS (Cascading Style Sheets):

CSS is a stylesheet language used for describing the presentation and layout of web pages. It
separates the content (HTML) from the visual design.

1. Selectors and Properties :

- CSS uses selectors to target HTML elements and apply styling rules. Properties (e.g.,
`color`, `font-size`, `margin`) specify how an element should be styled.

2. External and Internal Styles :

- CSS can be applied externally via linked stylesheets or internally within an HTML
document using the `<style>` element.

3. Cascading Style Sheets :

- CSS rules can cascade, which means that styles defined in different places (e.g., external
stylesheet, internal style block, inline styles) can interact to determine the final appearance of
an element.

4. Layout and Positioning :

- CSS is crucial for controlling the layout and positioning of elements on a web page. It
includes techniques for creating responsive designs and adapting to different screen sizes.

5. Box Model :
- Elements in CSS are treated as boxes with content, padding, borders, and margins.
Understanding the box model is essential for layout design.

6. Flexbox and Grid Layout :

- CSS offers advanced layout tools like Flexbox and CSS Grid, which simplify the design
of complex layouts.

7. Media Queries :
Java Application Development Internship

- Media queries in CSS allow you to apply different styles based on the characteristics of
the user's device, such as screen width and orientation.

8. Transitions and Animations :

- CSS can be used to create smooth transitions and animations, enhancing the user
experience.

9. CSS Frameworks :
- Developers often use CSS frameworks like Bootstrap or Foundation to accelerate web
development by providing pre-designed components and styles.

10. Responsive Web Design :

- CSS plays a critical role in responsive web design, ensuring that web pages adapt to
various devices and screen sizes.

HTML and CSS are the foundational technologies for web development. They are often used
in combination with JavaScript, a programming language that adds interactivity and dynamic
behavior to web pages. Together, HTML, CSS, and JavaScript form the core building blocks
of the World Wide Web, allowing developers to create engaging and interactive web
experiences.
Java Application Development Internship

Java Server Pages (JSP):

JSP (Java Server Pages) is a technology used for building dynamic web applications in Java.
JSP allows developers to embed Java code within HTML to create web pages that can
generate dynamic content. It's often used in conjunction with servlets to build Java-based web
applications. Here are some key points about JSP:

1. Dynamic Content : JSP enables the creation of web pages that can generate dynamic
content by embedding Java code within HTML templates.

2. Servlet-Based Technology : Under the hood, JSP is converted into servlets before
execution. It is part of the Java EE (Enterprise Edition) platform and is often used alongside
servlets to build web applications.

3. Tags and Scripting Elements :

- JSP provides custom tags for common tasks, such as displaying data, conditionals, and
looping. These custom tags are often used to simplify the page's structure and logic.
- JSP also allows the use of scripting elements, such as `<% %>` for scriptlet code, `<%=
%>` for expression language, and `<%! %>` for declarations.

4. Java Code Integration : Java code can be embedded within JSP pages using scripting
elements. This allows developers to execute Java logic and access Java objects, making JSP a
powerful tool for server-side processing.

5. Separation of Concerns : JSP encourages the separation of presentation logic (HTML)

from business logic (Java code). This separation makes it easier to maintain and scale web
applications.

6. Standard Actions :
- JSP includes standard actions for common tasks, such as conditionals (`<c:if>`), looping
(`<c:forEach>`), and working with JavaBeans (`<jsp:useBean>`).
- These standard actions can be used to create more maintainable and readable JSP code.
Java Application Development Internship

7. Use of Expression Language (EL) :

- JSP incorporates the Expression Language (EL) for accessing and manipulating data
stored in objects, such as JavaBeans. EL simplifies the retrieval of values and iteration over
collections.

8. Tag Libraries :
- JSP supports the use of custom tag libraries, such as JSTL (JavaServer Pages Standard
Tag Library) and Struts tags. These libraries provide additional tags and functionality to
simplify JSP development.

9. Servlet API Access : JSP pages have access to the Servlet API, allowing them to interact
with HTTP requests and responses, handle form submissions, and manage session data.

10. Deployment : JSP pages are typically compiled into servlets and are deployed on a web
server or application server. The compiled servlets are executed when clients request JSP
pages.

11. IDE Support : Integrated Development Environments (IDEs) like Eclipse, IntelliJ
IDEA, and NetBeans provide tools and features for JSP development, making it easier for
developers to work with JSP files.

JSP is commonly used for developing web applications in Java, and it is a versatile
technology for creating web pages with dynamic content. It is particularly useful for building
web applications with a Java backend, allowing developers to integrate business logic and
data with the presentation layer efficiently. However, in modern web development, there is a
trend toward using more lightweight and flexible front-end technologies like JavaScript
frameworks (e.g., React, Angular, Vue.js) in conjunction with RESTful APIs to create
dynamic web applications.
Java Application Development Internship

Java Servlets:

Java Servlets are server-side components used to extend the capabilities of web servers. They
allow developers to create dynamic and interactive web applications by handling requests,
processing data, and generating responses in Java. Here are some key points about Java
Servlets:

1. Server-Side Processing : Servlets run on the server and handle client requests, such as
HTTP requests, by processing data and generating dynamic responses.

2. Java-Based : Servlets are written in the Java programming language and are part of the
Java EE (Enterprise Edition) platform, which is now known as Jakarta EE.

3. Lifecycle : Servlets have a well-defined lifecycle, including methods like `init()`,

`service()`, and `destroy()`. These methods allow developers to set up resources, handle client
requests, and clean up resources when the servlet is no longer needed.

4. Extending HttpServlet : Most servlets extend the `HttpServlet` class, which provides
methods for handling HTTP-specific requests, such as `doGet()`, `doPost()`, and `doPut()`.
These methods allow developers to handle different types of HTTP requests.

5. Handling Requests and Responses : Servlets can access request parameters, headers, and
data, and they can generate HTML, XML, or other responses to be sent back to the client.

6. URL Mapping : Servlets are mapped to specific URLs, and when a client makes a
request to that URL, the servlet is invoked to process the request.

7. Session Management : Servlets can manage user sessions, allowing you to store and
retrieve session-specific data, such as user preferences or shopping cart contents.

8. Stateful or Stateless : Servlets can be designed to be stateful or stateless, depending on

the needs of the application. Stateful servlets maintain information about the client's session,
while stateless servlets do not.
Java Application Development Internship

9. Use of JavaBeans : Servlets often interact with JavaBeans (Java objects) to encapsulate
and manage data and business logic. JavaBeans are often used to separate business logic from
presentation logic.

10. Integration with JSP : Servlets can work in conjunction with JSP (JavaServer Pages) to
create web applications. Servlets can handle business logic, while JSP pages handle the
presentation layer.

11. Thread Safety : Developers must ensure that servlets are thread-safe, as multiple clients
may access a servlet simultaneously. This is typically achieved by synchronizing critical
sections of the code.

12. Deployment : Servlets are typically packaged in web applications (WAR files) and
deployed on web servers or application servers, such as Apache Tomcat, WildFly, or Jetty.

13. IDE Support : Integrated Development Environments (IDEs) like Eclipse, IntelliJ
IDEA, and NetBeans provide tools and features for servlet development, making it easier for
developers to create and manage servlets.

Servlets are widely used in Java web development and are essential for building dynamic and
interactive web applications. They provide a server-side solution for handling HTTP requests
and generating dynamic content, making them a key component of many web applications
and APIs. In modern web development, servlets are often used in conjunction with other
technologies and frameworks, such as JSP, JavaBeans, and RESTful web services, to build
robust and scalable web applications.

JDBC with MySQL:

Java Application Development Internship

JDBC (Java Database Connectivity) is a Java-based API (Application Programming

Interface) that allows Java applications to interact with relational databases, including
MySQL. Using JDBC, you can perform various database operations such as connecting to a
database, executing SQL queries, and retrieving or modifying data. Here's a step-by-step
guide on how to use JDBC with MySQL:

Step 1: Set Up Your Development Environment

- Ensure you have Java installed on your system.
- Download and install MySQL or use an existing MySQL database server.

Step 2: Download MySQL Connector/J

- Download the MySQL Connector/J JDBC driver from the official MySQL website
(https://dev.mysql.com/downloads/connector/j/).
- Add the JAR file to your Java project's classpath.

Step 3: Import Required Packages

- In your Java code, import the necessary JDBC packages:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.SQLException;

Step 4: Establish a Database Connection

- Use the following code to establish a connection to your MySQL database:

Connection connection = null;

try {
String jdbcUrl = "jdbc:mysql://localhost:3306/your_database_name";
String username = "your_username";
String password = "your_password";

connection = DriverManager.getConnection(jdbcUrl, username, password);

Java Application Development Internship

if (connection != null) {
System.out.println("Connected to the database!");
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
try {
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}

Step 5: Create and Execute SQL Queries

- You can create SQL queries using `Statement` or `PreparedStatement`. Here's an example
using `Statement`:

Statement statement = connection.createStatement();

String sql = "SELECT * FROM your_table_name";

ResultSet resultSet = statement.executeQuery(sql);

while (resultSet.next()) {
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
// Process data as needed
}
```

Step 6: Perform Updates

- To execute insert, update, or delete statements, you can use `executeUpdate`:
Java Application Development Internship

String insertSQL = "INSERT INTO your_table_name (name, age) VALUES ('John', 30)";
int rowsAffected = statement.executeUpdate(insertSQL);

if (rowsAffected > 0) {
System.out.println("Insert successful.");
}

Step 7: Handle Exceptions and Close Resources

- Always handle exceptions appropriately and close database resources in a `finally` block to
ensure proper resource management.

finally {
try {
if (resultSet != null) {
resultSet.close();
}
if (statement != null) {
statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}

Step 8: Error Handling and Exception Management

- Implement robust error handling and exception management in your application to handle
database-related errors.

That's a basic overview of how to use JDBC with MySQL. You can build upon these
concepts to create more complex database interactions in your Java applications. Remember
Java Application Development Internship

to handle exceptions, close resources properly, and ensure secure and efficient database
operations in your applications.

CHAPTER 3

TASK PERFORMED
Java Application Development Internship

Note: Explain about your Project Work

Example:

Project Tile: “Design of Email Integration using Swing Designer Framework

Introduction

The main objective of my internship work was to integrate SMTP setting for a gmail account.
The e-mail address here will be displayed as sender in the out-going e-mail message. We
need to put this file under the application’s directory. The application needs JavaMail API to
work and we need to put the javax.mail.jar file under project’s classpath.

The application consists of four main classes:

EmailUtility.java: implements a function for sending an e-mail message including

attachments. details.

ConfigUtility.java: implements two functions for reading and writing SMTP settings
from/to thesmtp.properties file as described above.

SettingsDialog.java: implements a user interface that allows the user to update

SMTP settings.

SwingEmailSender.java: is the main entry of the application, it builds the main user
interface that displays e-mail sending form and connects all the above pieces together.
To allow the user to add a file as attachment, this class uses the JFilePicker class
which is introduced in this article: File picker component in Swing.

In my project I am using SMTP (Simple Mail Transfer Protocol). It provides a

mechanism to deliver the email. We can use Apache James server, Postcast server, cmail
server etc. as an SMTP server. But if we purchase the host space, an SMTP server is
bydefault provided by the host provider. For example, my smtp server is
mail.javatpoint.com. If we use the SMTP server provided by the host provider,
authentication is required for sending and receiving emails.
Java Application Development Internship

CHAPTER 4

REFLECTION NOTES
Java Application Development Internship

(Here’s what past students had to say about the internship experience...)

Note: write your own internship experience

Sample for reference

"I thoroughly enjoyed my internship this summer and now have very valuable experience
under my belt. I know this will help when looking for jobs and needing references. I was
dreading it in the beginning, but now I am so happy it was required. As much as the
curriculum changes, I hope that class remains constant."

"We all know that practical experience is the best, and internships give students that hands-on
experience they need. I feel that quality internships are essential to develop key skills that
you can't get in a classroom. Skills such as multitasking, communicating, learning to deal
with diversity, and dealing with deadlines are different when you are working for someone
else, not yourself like you do in college. Internships are also a great way to network with
people in the industry. My boss and co-workers were great about giving me contacts and
referring me to open positions in the industry."

"I learned that customer service is hard. You can not please everyone. There are people in
this world that are simply difficult. I have learned that stressing over little things will not get
me anywhere. I have learned to work well as a team and that without my counterparts the
work would not get done. Another aspect that I learned throughout my internship is to never
be afraid to ask lots of questions. By asking questions I got answers."

"I learned more than I ever expected. I felt in the beginning that I would really have a head
start being that I am a senior and have taken all my classes already but I realized that I don’t
think any amount of classes will ever prepare you for all the world has to offer. Don’t get me
wrong, I feel that Auburn did a wonderful job teaching me but I feel that it is most valuable if
combined with first hand work . I feel that during my time interning my most challenging
part of my work was having to share my tasks and coordinate my work with others. I have
always been kind of a perfectionist and liked to have things done my way so working with
others and sharing duties was a slight change I must say. It took me a couple of weeks to
really feel comfortable allowing someone else to share my work but eventually I learned it
was ok and that two heads were better than one."
Java Application Development Internship

ACTIVATES DURING INTERNSHIP

Week 1 Activities
 Domain Training
Java Application Development Internship

 Training on Core Java Fundamentals and Assignment work

 Training on SDLC, Handling Runtime errors using Exception Handling

 Task on Inheritance & Interfaces

 Case Study Activities
 Weekly Assignment Task

Week 2 Activities
 Working with HTML, CSS
 Working with Java Server Pages (JSP)
 Task on Designing Web Pages Using HTML CSS
 Task on Java Server Pages
 Weekly Assignment Task

Week 3 Activities
 Training on Java Servlets, JDBC with MySQL Database
 Working with Web Templates
 Project Analysis & Design
 Project Based Activities with team

 Working with Java Servlets Program

 Weekly Assignment Task
 Project Work

Week 4 Activities
 Project Based Activities with team

 Activities on JDBC with Mysql

Java Application Development Internship

 Weekly Assignment Task

 Assessment Test
 Internship Project Work Presentation
 Internship Report Preparation

CHAPTER 5

RESULTS AND INTERNSHIP OUTCOMES

Note: Add your project Snapshots

Java Application Development Internship

Figure 1: Email Window

Figure 2: File Attachment Window

Java Application Development Internship

Figure 3: Email Sender Window

CHAPTER 6

CONCLUSION

Note: Write conclusion on your internship and project work

The main objective of my internship work was to integrate SMTP setting for a gmail account
for one of the internal application at Infidata Technologies, The project email integration
module contains all the basic operation with attachement of files, subject line and email body
and I have tested this email integration module with the internal application at Infidata
Technologies
Java Application Development Internship

REFERENCES

BOOKS:
 Charles Hampfed (2000) ‘Instant Java Server Pages’ University of Toronto
 Herbert Schildt (2000) ‘Java Complete Reference’ Tata McGraw Hill
 John Zukowski (2000) ‘Mastering Java2’ BPB Publications
 Jamie Jaworsky ‘J2EE Bible’ Techmedia
 Ian Somerville ‘Software engineering’ and Rajeev mall ‘Software engineering
 Elmasri Navathe ‘Fundamentals of database systems’
ONLINE REFERENCE:

 www.java.sun.com
 www.w3schools.com