OCEJBCD -8.Using Timer Services

OCEJBCD (SCBCD) - 1Z0-895 - Enterprise JavaBeans Developer Certification

8.1. Describe timer services

Timer services is a service of scheduling notifications in the bean container.
(Available for all bean types except from stateful session beans).

Timers services can be created 
-Programmatically, using TimerService interface
-By annotations @Schedule

Functionality that a bean with timer services can perform:

• Create a timer notification callback
• Process a timer notification callback
• Manage timer objects (list notification, cancel timer etc...)

The timers can be classified as:

• Single notifications
• Interval (multiple notifications at specified interval)
• Calendar based schedule 
• second, minute, hour 
• dayOfWeek, dayOfMonth
• month
• year
• Expressions : wildcard (*), list(,), range(-),intervals(/)

8.2. Create a timer notification callback

• By timerService interface
• Single:

          Timer timer = timerService.createSingleActionTimer(data, new             TimerConfig());

• Calendar based: using javax.ejb.ScheduleExpression

          ScheduleExpression schedule = new ScheduleExpression();
          schedule.dayOfMonth("1,Last");//first and last day of the month
          Timer timer = timerService.createCalendarTimer(schedule);

       When a timer expires the container calls the bean's method annotated              with @Timeout (*Note: this method must return void and the argument is optional).

• By annotation

       Example : @Schedule(dayOfWeek="Mon", hour="0")

8.3. Process a timer notification callback 

Example with timerService interface

	package example;
	import java.util.Date;
	import java.util.logging.Logger;
	import javax.annotation.Resource;
	import javax.ejb.LocalBean;
	import javax.ejb.Stateless;
	import javax.ejb.Timeout;
	import javax.ejb.Timer;
	import javax.ejb.TimerService;
	/**
	* Session Bean implementation class ScheduleBean
	*/
	@Stateless
	@LocalBean
	public class ScheduleBean{
	@Resource
	TimerService timerService;
	private Logger logger = Logger.getLogger("ScheduleBean.java");
	/**
	* Default constructor.
	*/
	public ScheduleBean() {
	}
	public void setTimer(long intervalDuration) {
	Timer timer = timerService.createTimer(intervalDuration,
	"Created new programmatic timer every 30 seconds");
	Long duration = timer.getTimeRemaining();
	Date date = timer.getNextTimeout();
	logger.info("the next timeout is programed " + date + " happening in " + duration + " milliseconds");
	}
	@Timeout
	public void programmaticTimeout(Timer timer) {
	logger.info("Timeout occurred");
	}

view raw ScheduleBean2.java hosted with ❤ by GitHub

To execute this bean we need to make a call from a client (for example a servlet class) to the method setTimer that indicates the milliseconds after the timeout will happen: scheduleBean.setTimer(30000);

Results in server console:
2016-03-26T11:58:33.313+0000|Info: TestBean was successfully deployed in 362 milliseconds.
2016-03-26T12:00:26.816+0000|Info: the next timeout is programed Sat Mar 26 12:00:56 GMT 2016 happening in 29968 milliseconds

2016-03-26T12:00:56.787+0000|Info: Timeout occurred

Example with schedule annotation
The following example is a stateless session bean, with a timer scheduled every 1 min.
When it is deployed in the server, after 1 minute the timeout method is called:

	package example;
	import java.util.Date;
	import javax.ejb.LocalBean;
	import javax.ejb.Schedule;
	import javax.ejb.Stateless;
	import javax.ejb.Timeout;
	import javax.ejb.Timer;
	/**
	* Session Bean implementation class ScheduleBean
	*/
	@Stateless
	@LocalBean
	public class ScheduleBean implements ScheduleBeanLocal {
	/**
	* Default constructor.
	*/
	public ScheduleBean() {
	}
	/**
	* Scheduled every minute
	*/
	@Schedule(minute="*/1", hour="*")
	public void automaticTimeout() {
	System.out.println("Automatic timeout occured");
	}
	}

view raw ScheduleBean.java hosted with ❤ by GitHub

Results in server console:
2016-03-26T10:03:00.001+0000|Info: Automatic timeout occured
2016-03-26T10:04:00.002+0000|Info: Automatic timeout occured
2016-03-26T10:05:00.001+0000|Info: Automatic timeout occured
2016-03-26T10:06:00.002+0000|Info: Automatic timeout occured
2016-03-26T10:07:00.002+0000|Info: Automatic timeout occured

8.4. Manage timer objects

-Cancel() - cancel a timer
-getHandle() - obtain a serializable object
-getTimeRemaining()
-getNextTimeout()
-getInfo()

When using container-managed transactions @Timeout can use attributes: Required or RequiredNew to preserve transaction integrity, which means that in case of rollback the timeout will be reset.

OCEJBCD (SCBCD) - 1Z0-895 - Enterprise JavaBeans Developer Certification

How to upload files using Servlet technology

This time, the aim of this post is to describe how to upload files to a server using servlet technology.

Upload files with Java technology is easy, we only need to create a JSP page and a servlet class, but we have to take into account this form will be a bit different than usual:

• Method POST 
• multipart/form-data 

Form declaration in the JSP:

<form action="upload" method="post" enctype="multipart/form-data">

Annotations in the servlet declaration:

@WebServlet("/UploadServlet")

@MultipartConfig

public class UploadServlet extends HttpServlet {

JSP code:

	<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
	pageEncoding="ISO-8859-1"%>
	<!DOCTYPE html>
	<html>
	<head>
	<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
	<title>JavaWithBreakfast</title>
	<style>
	p {
	border: 1px solid grey;
	padding: 10px;
	margin: 30px;
	}
	</style>
	</head>
	<body>
	<form action="myUpload" method="post" enctype="multipart/form-data">
	<p>
	<input type="file" name="file" />
	<input type="submit" value="click here to upload"/>
	</p>
	</form>
	</body>
	</html>

view raw uploadPage.jsp hosted with ❤ by GitHub

Servlet code:

* This example project is using servlet library version 3.0 or above.

	package test;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import javax.servlet.ServletException;
	import javax.servlet.annotation.MultipartConfig;
	import javax.servlet.annotation.WebServlet;
	import javax.servlet.http.HttpServlet;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;
	import javax.servlet.http.Part;
	/**
	* Servlet implementation class UploadServlet
	*/
	@WebServlet("/myUpload")
	@MultipartConfig
	public class UploadServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	/**
	* @see HttpServlet#HttpServlet()
	*/
	public UploadServlet() {
	super();
	// TODO Auto-generated constructor stub
	}
	/**
	* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
	* response)
	*/
	protected void doGet(HttpServletRequest request,
	HttpServletResponse response) throws ServletException, IOException {
	// TODO Auto-generated method stub
	}
	/**
	* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
	* response)
	*/
	protected void doPost(HttpServletRequest request,
	HttpServletResponse response) throws ServletException, IOException {
	Part filePart = request.getPart("file");
	// obtain file name from header
	String content = filePart.getHeader("content-disposition");
	String filename = "";
	for (String token : content.split(";")) {
	if (token.trim().startsWith("filename")) {
	System.out.println(token);
	filename = token.substring(token.indexOf("=") + 2,
	token.length() - 1);
	System.out.println(filename);
	}
	}
	// path where the file will be placed:
	String path = "C:\\uploads";
	System.out.println(path);
	// obtain file content
	InputStream fileContent = filePart.getInputStream();
	OutputStream out = new FileOutputStream(new File(path + File.separator
	+ filename));
	int read = 0;
	final byte[] bytes = new byte[1024];
	while ((read = fileContent.read(bytes)) != -1) {
	out.write(bytes, 0, read);
	}
	}
	}

view raw UploadServlet.java hosted with ❤ by GitHub

Method post - summary:

1) Getting the file attribute from the request object. file attribute corresponds
with the name of the input type ="file" in the JSP. The object obtained is Part type.

2) Obtain the name of the file uploaded:
using filePart.getHeader to obtain the value of the property filename.

3) Defining an object OutputStream with the destination path, plus the file name).

4) Read the content of the object filepart obtained in point 1, and writing the bytes into the ouputStream (in the destination).


Running the application:  
http://localhost:8080/UploadWeb/

 Select a file from the local disk and click the button to submit the request:

The server logs will display this message:

INFO: Reloading Context with name [/UploadWeb] is completed

Checking the execution result (the path selected in the example is also a local directory C:/uploads), we can verify the file has been uploaded successfully to the selected destination.