Advance Java

Jenkins

Jenkins WorkFlow

I. Introduction to Continuous Integration

Definition of Continuous Integration

Benefits of Continuous Integration

Continuous Integration (CI) is a software development practice that involves integrating code changes from multiple developers into a shared codebase frequently, typically multiple times a day. The goal of CI is to catch and resolve integration issues early in the development cycle, rather than waiting until later stages of development or testing.

Benefits of Continuous Integration include:

1. Early Detection of Integration Issues: By integrating and testing code changes frequently, developers can detect and resolve integration issues early in the development cycle, before they become more difficult and expensive to fix.

2. Faster Time to Market: Continuous Integration can help speed up the development process, allowing organizations to release new features and updates more quickly.

3. Improved Code Quality: By automating the process of building and testing code changes, Continuous Integration can help ensure that code changes meet established quality standards and do not introduce regressions or bugs.

4. Increased Collaboration: Continuous Integration promotes collaboration and communication between developers, as they work together to integrate code changes into a shared codebase.

5. More Efficient Development: Continuous Integration automates many of the repetitive and time-consuming tasks associated with software development, allowing developers to focus more on creating new features and solving complex problems.

II. Overview of Jenkins

What is Jenkins?

Key features of Jenkins

How Jenkins supports Continuous Integration

1. Extensibility: Jenkins has a large and active plugin ecosystem, which allows developers to extend and customize the functionality of Jenkins to meet their specific needs.

2. Easy Setup and Configuration: Jenkins is easy to set up and configure, and can be run on a variety of operating systems and cloud platforms.

3. Distributed Builds: Jenkins supports distributed builds, which allows developers to run build and test jobs across multiple machines or even in the cloud.

4. Pipeline Support: Jenkins provides support for creating and managing pipelines, which allow developers to define the entire software development workflow as a single, declarative script.

5. Integration with Other Tools: Jenkins integrates with a wide variety of other development tools and services, including version control systems like Git, build tools like Maven and Gradle, and continuous delivery services like Docker and Kubernetes

III. Jenkins Plugins

• Overview of Jenkins plugins

• Popular Jenkins plugins for Continuous Integration

1. Integration with external tools and services: Jenkins plugins allow developers to integrate Jenkins with other tools and services, including version control systems, build tools, and deployment platforms.

2. Customization and extensibility: Plugins can be used to customize and extend the functionality of Jenkins, allowing developers to create a tailored automation solution for their specific needs.

3. Easy installation and configuration: Plugins can be easily installed and configured through the Jenkins web interface, making it easy to add new functionality to Jenkins.

1. GitHub plugin: This plugin provides integration between Jenkins and GitHub, enabling Jenkins to automatically trigger builds and tests when code changes are pushed to a GitHub repository.

2. Maven plugin: This plugin provides integration with Maven, a popular build automation tool for Java projects.

3. Docker plugin: This plugin provides integration with Docker, a containerization platform that can be used for deployment and scaling of applications.

4. Pipeline plugin: This plugin provides support for creating and managing pipelines, which allow developers to define the entire software development workflow as a single, declarative script.

5. Slack Notification plugin: This plugin allows Jenkins to send notifications to Slack channels or users when build, test, and deployment jobs are executed.

Jenkins pipelines

Jenkinsfile & Jenkinsfile syntax

Example of a Jenkinsfile using Declarative syntax:

pipeline {
  agent any environment{MY_VAR = "some value"} stages {
    stage('Build') {
      steps { sh 'npm install' sh 'npm run build' }
    }
    stage('Test') {
      steps { sh 'npm run test' }
    }
    stage('Deploy') {
      when{branch 'master'} steps {
        sh 'docker build -t my-image .' withCredentials(
            [[$class:'UsernamePasswordMultiBinding',
                   credentialsId:'my-creds', usernameVariable:'DOCKER_USER',
                passwordVariable:'DOCKER_PASS']]) {
          sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS' sh 'docker push my-image'
        }
      }
    }
  }
  post {
    always{junit 'test-results.xml'}
    success{slackSend color : 'good', message : 'Build succeeded!'} failure {
      slackSend color : 'danger', message : 'Build failed!'
    }
  }
}

Here's an example of a Jenkinsfile using Scripted syntax:

node {
  stage('Build'){sh 'npm install' sh 'npm run build'} stage('Test'){
      sh 'npm run test'} stage('Deploy') {
    if (env.BRANCH_NAME == 'master') {
      sh 'docker build -t my-image .' withCredentials(
          [[$class:'UsernamePasswordMultiBinding',
                 credentialsId:'my-creds', usernameVariable:'DOCKER_USER',
              passwordVariable:'DOCKER_PASS']]) {
        sh 'docker login -u $DOCKER_USER -p $DOCKER_PASS' sh 'docker push my-image'
      }
    }
  }
  junit 'test-results.xml' currentBuild.result =
      currentBuild.result ?: 'SUCCESS' if (currentBuild.result == 'SUCCESS') {
    slackSend color : 'good', message : 'Build succeeded!'
  }
  else {
    slackSend color : 'danger', message : 'Build failed!'
  }
}

How to SetUp Jenkins on Tomcat ? Why should be run jenkins on Tomcat instead of running standalone?

1. Download the Jenkins WAR file from the Jenkins website.

2. Install Tomcat on your server, if it is not already installed.

3. Copy the Jenkins WAR file to the Tomcat webapps directory.

4. Start Tomcat and navigate to http://localhost:8080/jenkins to access the Jenkins web interface.

1. Scalability: Tomcat is designed to be scalable and can handle a large number of web applications, including Jenkins. Running Jenkins on Tomcat can help you scale your Jenkins environment as your needs grow.

2. Resource sharing: By running Jenkins on Tomcat, you can share resources such as CPU, memory, and network bandwidth with other web applications running on the same server.

3. Standardization: If you are already running Tomcat as your application server, running Jenkins on Tomcat can help you standardize your environment and simplify management.

4. Security: Tomcat has a built-in security framework that can be used to secure your Jenkins environment. By running Jenkins on Tomcat, you can take advantage of Tomcat's security features and reduce your security risks.

SonarQube

Servlet and JSP

1. JSP stands for JavaServer Pages, which is a technology used to create dynamic web pages.

2. JSP allows embedding Java code inside HTML pages by using special tags like <% %> and <%= %>.

3. JSP pages are translated into servlets at runtime by the web container and then compiled into bytecode.

4. JSP technology allows separation of business logic from presentation logic by using Javabeans and custom tags.

5. JSP pages can be reused and included in other pages using the JSP include directive.

1. Servlets are Java classes that can be dynamically loaded by a web server to process client requests.

2. Servlets are used to create dynamic web pages by generating HTML content on the server-side.

3. Servlets receive requests and send responses back to the client using the HTTP protocol.

4. Servlets can be used to handle different types of requests, like GET, POST, PUT, DELETE, etc.

5. Servlets are deployed in a web container like Apache Tomcat, which provides the runtime environment for servlets to run.

Introduction to Servlets:

Servlets are Java-based components that can dynamically process requests and responses from clients over HTTP. They can be thought of as server-side Java programs that can be used to generate dynamic web content. Servlets are built on top of the Java Servlet API, which defines a set of classes and interfaces for creating, deploying, and managing Servlets.

Servlet Lifecycle:

The Servlet lifecycle defines how a Servlet is loaded, instantiated, and destroyed. The lifecycle consists of three stages: initialization, service, and destruction. During initialization, the Servlet container loads and instantiates the Servlet. The Servlet's service() method is then called to process client requests. Finally, when the container shuts down or decides to unload the Servlet, the destroy() method is called to perform any necessary cleanup tasks.

Servlet Configuration:

Servlet configuration refers to the process of configuring Servlets using the web.xml file, which is an XML configuration file used by the Servlet container to configure Servlets. The web.xml file defines the Servlet's name, URL pattern, initialization parameters, security constraints, and other settings. Servlet configuration is essential for defining how the Servlet should be handled by the container and how it should behave at runtime.

HttpServletRequest:

The HttpServletRequest interface represents the client's request to the server and provides methods for accessing request parameters, headers, and other information. The HttpServletRequest interface extends the ServletRequest interface and adds additional methods for handling HTTP-specific features such as cookies, sessions, and HTTP methods. Some of the key methods in the HttpServletRequest interface include getParameter(), getHeader(), getCookies(), getSession(), and getMethod(). Understanding how to use the HttpServletRequest interface is essential for processing client requests and generating dynamic responses.

HttpServletResponse:

The HttpServletResponse interface represents the server's response to the client and provides methods for setting response headers, writing output to the response stream, and sending error codes. The HttpServletResponse interface extends the ServletResponse interface and adds additional methods for handling HTTP-specific features such as cookies, caching, and redirection. Some of the key methods in the HttpServletResponse interface include setHeader(), addCookie(), sendRedirect(), setStatus(), and getOutputStream(). Understanding how to use the HttpServletResponse interface is essential for generating dynamic responses to client requests

Servlet Collaboration:

Servlet collaboration refers to the process of two or more Servlets working together to process client requests. Servlet collaboration is achieved by sharing data between Servlets using the ServletContext object or by forwarding requests from one Servlet to another using the RequestDispatcher object. Servlet collaboration is essential for building complex web applications that require multiple components to work together to process client requests.

Servlet Context :

1. The Servlet context is represented by the ServletContext interface in the javax.servlet package.

2. The Servlet context is created by the Servlet container when a web application is deployed.

3. Each web application has its own Servlet context, which is isolated from other web applications running on the same server.

4. The Servlet context is shared by all Servlets running within a particular web application.

5. The Servlet context provides methods for storing and retrieving attributes, which are key/value pairs that can be used to store data for use by Servlets within the same web application.

6. The Servlet context also provides methods for accessing global resources such as database connections, JNDI resources, and context parameters.

7. The Servlet context is accessible from any Servlet within the same web application by calling the getServletContext() method of the ServletConfig object.

8. The Servlet context can be used to store data that needs to be accessed by multiple Servlets within the same web application, such as configuration information or shared resources.

public class MyServlet extends HttpServlet {
  protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    // Get the ServletContext object for the web application
    ServletContext context = getServletContext();
    // Set an attribute in the ServletContext object
    context.setAttribute("message", "Hello World!");
    // Retrieve an attribute from the ServletContext object
    String message = (String) context.getAttribute("message");
    // Output the message to the response
    response.getWriter().write(message);
  }
}

Servlet Session:

public class MyServlet extends HttpServlet {
  public void doGet(HttpServletRequest request, HttpServletResponse response)
      throws IOException {
    // Get the current session or create a new one if it doesn't exist
    HttpSession session = request.getSession(true);
    // Store data in the session
    session.setAttribute("username", "JohnDoe");
    // Retrieve data from the session
    String username = (String) session.getAttribute("username");
    // Set the maximum inactive interval (in seconds) for the session
    session.setMaxInactiveInterval(60); // 1 minute
    // Invalidate the session
    session.invalidate();
  }
}

init() and service()

Spring Framework

• Aspect-oriented programming (AOP)

• Dependency injection (DI)

• Plain Old Java Object (POJO)

What does Spring do for us?

Why do we need Spring?

What type of problem does Spring solve?

Spring - Some potential challenges and drawbacks associated with its use.

1. Complexity: Spring is a comprehensive framework with many different modules and features, which can make it challenging to learn and master.

2. Configuration: Because Spring provides so many configuration options, it can sometimes be difficult to determine the best approach for a given situation.

3. Performance: Some developers have noted that Spring's extensive use of reflection can lead to performance issues in certain scenarios.

4. Version compatibility: Spring is updated frequently, which can sometimes result in compatibility issues between different versions of the framework or between Spring and other libraries or tools.

<web-app>

<servlet-name>example</servlet-name>

<load-on-startup>1</load-on-startup>

<servlet-name>example</servlet-name>

</servlet-mapping>

</web-app>

Spring MVC

• Introduction to Spring MVC: Understanding the basic concepts of Spring MVC, its

• Configuration: Configuring Spring MVC using various approaches, such as XML configuration,Java-based configuration, and annotation-based configuration.

• Request Mapping: Understanding the Request Mapping feature of Spring MVC, which

• Controllers: Understanding controllers in Spring MVC, which handle incoming requests,

• Views: Understanding the views in Spring MVC, which generate a response to the user.

• Data Binding: Understanding data binding in Spring MVC, which binds incoming data to model objects.

• Validation: Validating user input using Spring MVC's validation framework.

• File Upload: Uploading files using Spring MVC's multipart file upload support.

• Exception Handling: Handling exceptions that occur during the processing of a request in Spring MVC.

• Interceptors: Understanding interceptors in Spring MVC, which can be used to intercept requests and responses.

• Security: Securing Spring MVC applications using Spring Security.

• Testing: Testing Spring MVC applications using various testing frameworks.

Introduction to Spring MVC

• Model: Represents the data and business logic of the application.

• View: Represents the presentation layer of the application.

• Controller: Handles user requests and performs operations on the model.

• Request mapping: Maps incoming requests to specific methods or controllers.

• Controllers: Handle incoming requests, process them, and return a response.

• Views: Generate a response to the user.

• Data binding: Bind incoming data to model objects.

• Validation: Validate user input using the validation framework.

• File upload: Upload files using multipart file upload support.

• Exception handling: Handle exceptions that occur during the processing of a request.

• Interceptors: Intercepts requests and responses.

• Internationalization: Support internationalization in applications.

• Security: Secure applications using Spring Security.

Configuration

Request Mapping

Request Mapping is a process in Spring MVC that maps incoming requests to specific methods or controllers. It determines which controller and method should handle an incoming request based on the URL pattern specified in the request.

1. @RequestMapping annotation: This annotation is used to map a URL pattern to a controller method. It can be applied at the class level and/or method level to map requests to a specific handler method.
Example:

@Controller
@RequestMapping("/hello")
public class HelloController {
	@RequestMapping("/greet")
	public String greet() {
		return "hello";
	}
}

1. @GetMapping, @PostMapping , @PutMapping , @DeleteMapping annotations: These annotations are shortcuts for mapping HTTP GET, POST, PUT, and DELETE requests to controller methods.
Example:

@Controller
@RequestMapping("/users")
public class UserController {
  @GetMapping("/{id}")
  public String getUserById(@PathVariable Long id) {
    // code to get user by ID
  }
  @PostMapping("/")
  public String createUser(@RequestBody User user) {
    // code to create a new user
  }
  // other methods
}

• In this example, the `@GetMapping` annotation is used to map the HTTP GET request with the URL pattern `/users/{id}` to the `getUserById()` method, and the `@PostMapping` annotation is used to map the HTTP POST request with the URL pattern `/users/` to the `createUser()` method.

1. Ant-style path patterns: This approach uses Ant-style path patterns to map requests to specific methods or controllers. Ant-style path patterns support wildcards and placeholders.
Example:

@Controller
public class ProductController {
  @RequestMapping("/products/*/{id}")
  public String getProductById(@PathVariable Long id) {
    // code to get product by ID
  }
  // other methods
}

Controllers

@Controller
@RequestMapping("/book")
public class BookController {
	@Autowired
	private BookService bookService;
	@GetMapping("/{id}")
	public String getBook(@PathVariable Long id, Model model) {
		Book book = bookService.getBook(id);
		model.addAttribute("book", book);
		return "book-details";
	}
	@PostMapping("/")
	public String saveBook(@ModelAttribute("book") Book book) {
		bookService.saveBook(book);
		return "redirect:/book/" + book.getId();
	}
}

• getBook() method handles GET requests to `/book/{id}` and retrieves a book from the BookService. It adds the book object to the model and returns the view name "book-details".

• saveBook() method handles POST requests to `/book/` and saves a book using the BookService. It redirects the user to the book's details page.

Views

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>Book Details</title>
</head>
<body>
<h1>Book Details</h1>
<table>
<tr>
<th>Title</th>
<th>Author</th>
<th>ISBN</th>
</tr>
<tr>
<td>${book.title}</td>
<td>${book.author}</td>
<td>${book.isbn}</td>
</tr>
</table>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <!DOCTYPE html>
<html>
<head>
<title>Book Details</title>
</head>
<body>
<h1>Book Details</h1>
<table>
<tr>
<th>Title</th>
<th>Author</th>
<th>ISBN</th>
</tr>
<tr>
<td>${book.title}</td>
<td>${book.author}</td>
<td>${book.isbn}</td>
</tr>
</table>
</body>
</html>

@GetMapping("/{id}")
public String getBook(@PathVariable Long id, Model model) {
	Book book = bookService.getBook(id);
	model.addAttribute("book", book);
	return "book-details";
}

Data Binding

@PostMapping("/register")
public String registerUser(@ModelAttribute("user") User user) {
   // Save user to database
   return "redirect:/dashboard";
}

Validation: Spring MVC's validation framework.

1. @NotNull - ensures that a field is not null.

2. @Size - ensures that a field's length is within a specified range.

3. @Email - ensures that a field is a valid email address.

4. @Pattern - ensures that a field matches a regular expression pattern.

5. @Min and @Max - ensures that a field's value is within a specified range.
To use validation in Spring MVC, you need to create a validation rule set that specifies the validation constraints for a particular model object. This rule set is typically defined in a separate class that implements the Validator interface.

public class User {
  private String name;
  private String email;
  private String password;
  // getters and setters
}

public class UserValidator implements Validator {
  @Override
  public boolean supports(Class<?> clazz) {
    return User.class.equals(clazz);
  }
  @Override
  public void validate(Object target, Errors errors) {
    User user = (User) target;
    ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "name.required");
    ValidationUtils.rejectIfEmptyOrWhitespace(
        errors, "email", "email.required");
    ValidationUtils.rejectIfEmptyOrWhitespace(
        errors, "password", "password.required");
    if (!isValidEmail(user.getEmail())) {
      errors.rejectValue("email", "email.invalid");
    }
  }
  private boolean isValidEmail(String email) {
    // perform email validation
  }
}

@PostMapping("/register")
public String registerUser(@Valid @ModelAttribute("user") User user, BindingResult result) {
  if (result.hasErrors()) {
    return "register";
  }
  // Save user to database
  return "redirect:/dashboard";
}

File Upload

<form action="/upload" method="post" enctype="multipart/form-data">
<div>
<label for="file">File:</label>
<input type="file" id="file" name="file">
</div>
<div>
<label for="name">Name:</label>
<input type="text" id="name" name="name">
</div>
<div>
<label for="description">Description:</label>
<textarea id="description" name="description"></textarea>
</div>
<button type="submit">Upload</button>
</form>

@PostMapping("/upload")
public String handleFileUpload(@RequestParam("file") MultipartFile file,
    @RequestParam("name") String name,
    @RequestParam("description") String description) {
  // Save file to disk or database
  return "redirect:/files";
}

Spring Boot

• The dependency injection approach is used in Spring Boot.

• It contains powerful database transaction management capabilities.

• It simplifies integration with other Java frameworks like JPA/Hibernate ORM, Struts, etc.

• It reduces the cost and development time of the application.

RESTful Web Services

What is a Resource?

1. Client-Server: Separates the concerns of the client and server, allowing them to evolve independently.

2. Statelessness: Each request must contain all the information necessary to complete it, with no client context stored on the server between requests.

3. Cacheability: The server indicates to the client whether a response can be cached, reducing the number of requests made to the server.

4. Layered System: Allows for intermediaries like load balancers and proxies to be added or removed without affecting the overall system.

5. Uniform Interface: Defines a uniform way of interacting with resources using standard HTTP methods and resource identifiers.

6. Code on Demand (optional): Allows the server to send code to the client to be executed, enabling a more dynamic and interactive user experience.

Advantages of Statelessness

1. Web services can treat each method request independently.

2. Web services need not maintain the client's previous interactions. It simplifies the application design.

3. As HTTP is itself a statelessness protocol, RESTful Web Services work seamlessly with the HTTP protocols.

• Verb − Indicates the HTTP methods such as GET, POST, DELETE, PUT, etc.

• URI − Uniform Resource Identifier (URI) to identify the resource on the server.

• HTTP Version − Indicates the HTTP version. For example, HTTP v1.1.

• Request Header − Contains metadata for the HTTP Request message as key-value pairs. For example, client (or browser) type, format supported by the client, format of the message body, cache settings, etc.

• Request Body − Message content or Resource representation.

• Status/Response Code − Indicates the Server status for the requested resource. For example, 404 means resource not found and 200 means response is ok.

• HTTP Version − Indicates the HTTP version. For example HTTP v1.1.

• Response Header − Contains metadata for the HTTP Response message as key value pairs. For example, content length, content type, response date, server type, etc.

• Response Body − Response message content or Resource representation

@GetMapping("/books")
public List<Book> getAllBooks() {
// code to retrieve all books from a database or other source
	return bookList;
}

SOAP

What is SOAP?

• SOAP stands for Simple Object Access Protocol

• SOAP is an application communication protocol

• SOAP is a format for sending and receiving messages

• SOAP is platform independent

• SOAP is based on XML

• SOAP is a W3C recommendation

• SOAP is a light-weight protocol that is used for data interchange between applications. Note the keyword ‘light.’ SOAP programming is based on the XML language, which itself is a lightweight data interchange language, hence SOAP as a protocol that also falls in the same category.

• SOAP is designed to be platform independent and is also designed to be operating system independent. So the SOAP protocol can work with any programming language based applications on both Windows and Linux platforms.

• It works on the HTTP protocol –SOAP works on the HTTP protocol, which is the default protocol used by all web applications. Hence, there is no sort of customization which is required to run the web services built on the SOAP protocol to work on the World Wide Web.

SOAP Building Blocks

1. SOAP envelope: The SOAP envelope defines the structure of the message and contains information about how the message should be processed. It includes an optional header and a mandatory body that contains the actual data being sent.

2. SOAP header: The SOAP header contains optional metadata about the message, such as authentication and encryption information.

3. SOAP body: The SOAP body contains the actual data being sent as part of the message, such as XML data.

4. SOAP fault: The SOAP fault is used to report errors and exceptions that occur during message processing. It includes information about the error, such as the error code and message, to help diagnose and resolve the issue.

SOAP Message Structure