android update project -p <path_to_project_directory> -n <project_name> -t <android_sdk_version>You can also create a new project with:
android create project -p <path_to_project_directory> -n <project_name> -k <package_name> -a <activity_name> -t <android_sdk_version>The android version parameter looks like this: "android-18".
While I was working on a web application based on Wicket, I noticed that jQuery was not functioning in a way I expected. Using FireBug I noticed that a method call to a jQuery plugin failed, because it couldn't find the method. The HTML code I used in the <head>-element looks like this:
<script type="text/javascript" src="js/jquery-1.7.1.min.js"></script>
<script type="text/javascript" src="js/jquery-plugin.js"></script>
<script type="text/javascript">
function callbackToPlugin() {
return function () {
$('#plugin').callToPlugin();
};
}
</script>
The code-fragment includes the jQuery file and the custom plugin file. A function is defined below that returns a callback function that calls the plugin. The code in a Wicket web page class, decides if this callback is used or not. In the code below, the call is rendered in the <head>-element, when the boolean variable "callPlugin" is true.
@Override
public void renderHead(IHeaderResponse response) {
if (callPlugin) {
response.render(
OnDomReadyHeaderItem.forScript("$(document).ready(callbackToPlugin())"));
}
}
The problem with this code is that Wicket includes its embedded jQuery file in the HTML output automatically, when it detects certain JavaScript function provided by Wicket is used. In this case it includes the jQuery file AFTER the definition of the callback function. What happens is that the definition of the plugin method "callToPlugin" is lost, because the second inclusion of jQuery resets the "$" jQuery variable. This will make our call fail.
The easiest solution I found is to assign another variable to jQuery using the "jQuery.noConflict()" function.
<script type="text/javascript" src="js/jquery-1.7.1.min.js"></script>
<script type="text/javascript" src="js/jquery-plugin.js"></script>
<script type="text/javascript">
var $j = jQuery.noConflict();
function callbackToPlugin() {
return function () {
$j('#plugin').callToPlugin();
};
}
</script>
Now, the jQuery variable is "$j" instead of "$". Make sure you call the correct method from the Wicket page.
@Override
public void renderHead(IHeaderResponse response) {
if (callPlugin) {
response.render(
OnDomReadyHeaderItem.forScript("$j(document).ready(callbackToPlugin())"));
}
}
If you have a better solution for this, please let me know in the comments.
@Override
public boolean authenticate(String userName, String password) {
// Your authentication code here...
// Only reach this when authenticated...
if (isTemporary()) {
bind();
}
}
aTextField.add(new OnChangeAjaxBehavior() {
@Override
protected void onUpdate(AjaxRequestTarget target) {
target.add(aContainerThatIsRefreshed);
target.appendJavaScript("$('.jQueryPluginClass').initiatePlugin();");
}
});
Change the ".jQueryPluginClass" CSS class, and ".initiatePlugin()" plugin call for your specific project.
Looking for a Java Collection class for your project, but don't know which one to use or is available? The link below will take you to a Java Collection Matrix, which lists the summarized properties of the standard Java Collection implementations.
http://www.janeve.me/articles/which-java-collection-to-usepackage com.javaeenotes;
import org.apache.wicket.feedback.IFeedbackMessageFilter;
import org.apache.wicket.markup.html.panel.FeedbackPanel;
public class ErrorPanel extends FeedbackPanel {
private static final long serialVersionUID = 1L;
public ErrorPanel(String id, IFeedbackMessageFilter filter) {
super(id, filter);
}
public ErrorPanel(String id) {
super(id);
}
}
<wicket:panel>
<div class="feedbackPanel" wicket:id="feedbackul">
<b>Error</b>
<div class="errorlevel" wicket:id="messages">
<span class="errorlevel" wicket:id="message">A message</span>
</div>
</div>
</wicket:panel>
The HTML file is basically the same as the original file. I added an error header as an example.
In todays blog post, I'm showing how I implemented highly configurable, and modular classes with the help of annotations, and enumerations. From now on, let's call these modular classes "modules". Let's suppose we have the following architectural problem:
The module factory is responsible for creating a configured module. It takes the class name, and Properties object as parameters. I'm using a class name here instead of a class type, because the list of supported modules are stored in the database as names. The Properties object contains the configuration for the module to be created.
This enumeration is basically a list of supported types by the factory. When a new module is implemented, it should be added to this enumeration, otherwise the factory doesn't know how to translate the class name to the actual class. I tried to find a way to avoid the need of this enumeration, like searching in the class path for classes that correspond to the name. Unfortunately, this is too complex to achieve without adding a lot of boilerplate code. If you find a better way to solve this problem, please let me know in the comments.
This interface formalizes the methods implemented by all modules. Their parameters are defined in an enumeration of type ModuleParameter. Every module should have a corresponding ModuleParameter enumeration. An example implementation for this demo is called "ExampleModule", and it uses "ExampleModuleParameter" to define its configuration.
This interface specifies the required methods for every subclass enumeration implementation. The enumeration is basically a list of configuration parameters for a module. Per configuration parameter, it also defines: if the parameter is required, the default value, and a brief explanation. An example implementaton for this demo is called "ExampleModuleParameter", and it has two configuration parameters.
package com.javaeenotes.modules;
// This interface enforces required methods for the parameter enumerator.
public interface ModuleParameter {
boolean isRequired();
String getDefaultValue();
String getExplanation();
}
This interface defines the methods used to retrieve the properties of the configuration parameter.
package com.javaeenotes.modules;
// This enum class contains the parameters used to configure a module.
public enum ExampleModuleParameter implements ModuleParameter {
PARAM1("param1", true, "DEFAULT", "This is parameter 1."),
PARAM2("param2", false, null, "This is parameter 2.");
// Code below is boiler plate code. It is not possible to move the
// code to an abstract class, because enumerators are not allowed
// to extend classes.
private final String name;
private final boolean isRequired;
private final String defaultValue;
private final String explanation;
private ExampleModuleParameter(
String name,
boolean isRequired,
String defaultValue,
String explanation) {
this.name = name;
this.isRequired = isRequired;
this.defaultValue = defaultValue;
this.explanation = explanation;
}
@Override
public String toString() {
return name;
}
@Override
public boolean isRequired() {
return isRequired;
}
@Override
public String getDefaultValue() {
return defaultValue;
}
@Override
public String getExplanation() {
return explanation;
}
}
Everything you should know about the specific parameters is defined here, and nowhere else (high cohesion)! It forces the developer who is adding new parameters to define the extra properties as required.
I tried to eliminate the boiler plate code, by moving them to a shared abstract enumeration class, but that is not possible. Now we have to copy the same code for every new "ModuleParameter" implementation. Is there a better solution for this?
package com.javaeenotes.modules;
public interface Module {
void doBusinessStuff();
}
Just the interface of a module, containing a common method.
package com.javaeenotes.modules;
// Annotate this module with parameter class that contains the
// configurable parameters for this module.
@ParameterClass(parameterClass = ExampleModuleParameter.class)
public class ExampleModule implements Module {
private String param1;
private String param2;
@Override
public void doBusinessStuff() {
System.out.println("Hello, I am "
+ this.getClass().getSimpleName()
+ ". I am configured with param1='" + param1
+ "', and param2='" + param2 + "'.");
}
public void setParam1(String param1) {
this.param1 = param1;
}
public void setParam2(String param2) {
this.param2 = param2;
}
}
This is an example implementation of a module. As you can see, it's just a POJO, making it very easy to write new ones. The class is linked to its parameter class using the annotation placed just before the class definition. The attributes and setters are important here. The names must correspond with the names defined in the parameter class.
package com.javaeenotes.modules;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// Only usable on classes.
@Target(ElementType.TYPE)
// Annotation must be available during runtime.
@Retention(RetentionPolicy.RUNTIME)
public @interface ParameterClass {
Class<? extends ModuleParameter> parameterClass();
}
This is the annotation, which links the module to its parameter class. The factory uses this annotation to find out which configuration values to set.
package com.javaeenotes.modules;
// This is basically a list of supported modules by the factory.
public enum ModuleType {
EXAMPLE_MODULE(ExampleModule.class);
private Class<? extends Module> moduleClass;
private ModuleType(Class<? extends Module> moduleClass) {
this.moduleClass = moduleClass;
}
public Class<? extends Module> getModuleClass() {
return moduleClass;
}
}
This enumeration is a list of supported modules. The purpose of this enumeration is to map the name to its class type. This information is required by the module factory to instantiate the correct module class.
package com.javaeenotes.modules;
import java.util.Properties;
public interface ModuleFactory {
Module getModule(String moduleName, Properties configuration)
throws Exception;
}
The interface of the module factory. It requires the class name, and a "Properties" object containing the configuration of the module.
package com.javaeenotes.modules;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
public class ModuleFactoryImpl implements ModuleFactory {
private Map<String, ModuleType> nameToModuleType;
public ModuleFactoryImpl() {
// The Map contains all the supported module types.
nameToModuleType = new HashMap<String, ModuleType>();
for (ModuleType moduleType : ModuleType.values()) {
nameToModuleType.put(
moduleType.getModuleClass().getSimpleName(),
moduleType);
}
}
@Override
public Module getModule(String moduleName, Properties configuration)
throws Exception {
if (nameToModuleType.containsKey(moduleName)) {
ModuleType moduleType = nameToModuleType.get(moduleName);
Module module = moduleType.getModuleClass().newInstance();
configureModule(module, configuration);
return module;
}
throw new IllegalArgumentException(
"Class not supported: " + moduleName);
}
private void configureModule(
Module module, Properties configuration)
throws Exception {
if (module.getClass().isAnnotationPresent(ParameterClass.class)) {
Map<String, Method> methodNameToMethod =
getMethodNameToMethod(module);
for (ModuleParameter param : getModuleParameters(module)) {
String configValue = configuration.getProperty(
param.toString());
// Set default value if configuration value is empty.
if (configValue.isEmpty()) {
configValue = param.getDefaultValue();
}
// Check if value is required.
if ((configValue == null || configValue.isEmpty())
&& param.isRequired()) {
throw new IllegalArgumentException(
"Configuration value missing for: "
+ param.toString());
}
// Set configuration value in module.
invokeParameterSetter(methodNameToMethod, module,
param.toString(), configValue);
}
}
}
private Map<String, Method> getMethodNameToMethod(Module module) {
Map<String, Method> methodNameToMethod =
new HashMap<String, Method>();
for (Method method : module.getClass().getMethods()) {
methodNameToMethod.put(method.getName(), method);
}
return methodNameToMethod;
}
private ModuleParameter[] getModuleParameters(Module module) {
return module.getClass()
.getAnnotation(ParameterClass.class)
.parameterClass().getEnumConstants();
}
private void invokeParameterSetter(
Map<String, Method> methodNameToMethod,
Module module, String paramName, String configValue)
throws Exception {
String setterMethodName = getSetterMethodName(paramName);
if (methodNameToMethod.containsKey(setterMethodName)) {
methodNameToMethod.get(setterMethodName).invoke(
module, configValue);
} else {
throw new IllegalArgumentException(
"No setter found for: " + paramName);
}
}
private String getSetterMethodName(String paramName) {
return "set" + Character.toUpperCase(paramName.charAt(0))
+ paramName.substring(1);
}
}
Using the name of the module class, this factory instantiates the correct class with the help of the "ModuleType" enumeration class. Then it tries to find out if this module requires configuration, by detecting the annotation. The annotation specifies the use of the "ExampleModuleParameter" enumeration for configuration. Using the enumeration, and the "Properties" object, it calls the setters with the configuration values. It also checks if a required configuration value is present. The result is a module with all required configuration values set.
A drawback is that the method name of the setters is restricted. It must be the same as the name of the parameter (excluding the "set" string), which is defined in the enumeration. A solution for this is to use annotations in the setter method definition to specify which configuration parameter it corresponds to. Using string literals to tie things together makes the code brittle.
package com.javaeenotes.modules;
import java.util.Properties;
public class Main {
public static void main(String[] args) {
// Build the configuration properties.
Properties configuration = new Properties();
configuration.setProperty(
ExampleModuleParameter.PARAM1.toString(), "");
configuration.setProperty(
ExampleModuleParameter.PARAM2.toString(), "param2");
try {
// Get instance of configured module from factory.
Module module = new ModuleFactoryImpl()
.getModule("ExampleModule", configuration);
// Run the module.
module.doBusinessStuff();
} catch (Exception e) {
e.printStackTrace();
}
}
}
This class demonstrates the whole solution. If run, it prints: Hello, I am ExampleModule. I am configured with param1='DEFAULT', and param2='param2'.
As you can see, writing new modules is very easy by implementing just the two interfaces. All the configuration code is centralized in the factory implementation.
If you have ideas for improvements or better solutions, please don't hesitate to share them in the comments.
We're implementing a simple message service framework to demonstrate how we can implement a framework that uses annotations, like JAX-WS. Using annotations minimizes boilerplate code, and promotes high cohesion of classes. It also promotes decoupling, because it prevents forcing the use of framework classes on clients as much as possible.
The messaging framework has one interface with a register method, which is used to register custom objects that handle incoming messages. The framework does not know what the type is of this object. It uses the reflection API to check for annotated methods, which tell the messaging framework to call these methods when a message has to be handled.
The message service framework supports two types of messages, which we define in as an enum type in MessageType.java:
package com.javaeenotes;
public enum MessageType {
NORMAL,
URGENT
}
The interface of the message service framework has a method to register custom client objects that will handle incoming messages. The second method of the interface is only included, so we can send messages through this framework. The interface of the message service framework is defined in MessageService.java:
package com.javaeenotes;
public interface MessageService {
void registerMessageHandler(Object object);
void sendMessage(String message, MessageType messageType)
throws Exception;
}
Now, we define our annotation. This annotation can be used by the client application to mark methods that will handle incoming messages generated by the message service framework. It also has a message type enum parameter, so the framework will only call this method if the type of the message matches the specified type parameter. The annotation is defined in MessageMethod.java:
package com.javaeenotes;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
// Only usable on methods.
@Target(ElementType.METHOD)
// Annotation must be available during runtime.
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageMethod {
MessageType messageType() default MessageType.NORMAL;
}
A client object will use the annotation to mark callback methods for specified message types. The example client handler has one method for both message types. An example client message handler class for this demo is defined as ExampleMessageHandler.java:
package com.javaeenotes;
public class ExampleMessageHandler {
@MessageMethod(messageType = MessageType.NORMAL)
public void handleNormalMessage(String message) {
System.out.print("NORMAL MESSAGE: " + message + "\n");
}
@MessageMethod(messageType = MessageType.URGENT)
public void handleUrgentMessage(String message) {
System.out.println("URGENT MESSAGE: " + message + "\n");
}
}
The most important class of this tutorial is: MessageServiceImpl.java, which you can find below. This is the implementation of our message service framework interface. This class is responsible for determining callback methods provided by the client, and call them when messages arrive.
package com.javaeenotes;
import java.lang.reflect.Method;
public class MessageServiceImpl implements MessageService {
private Object messageHandler;
@Override
public void registerMessageHandler(Object messageHandlerObject) {
messageHandler = messageHandlerObject;
}
@Override
public void sendMessage(String message, MessageType messageType)
throws Exception {
for (Method method : messageHandler.getClass().getMethods()) {
if (method.isAnnotationPresent(MessageMethod.class)) {
MessageMethod messageMethod
= method.getAnnotation(MessageMethod.class);
if (messageMethod.messageType() == MessageType.NORMAL
&& messageType == MessageType.NORMAL) {
method.invoke(messageHandler, message);
} else if (messageMethod.messageType()
== MessageType.URGENT
&& messageType == MessageType.URGENT) {
method.invoke(messageHandler, message);
}
}
}
}
}
Now, we only need a Main class to get this demonstration working. The class will create the example client object, and register it in the framework. Then, it will create two example messages, and pass them to the framework, which then will call the annotated callback methods of the example client object. The Main class is defined in: Main.java.
package com.javaeenotes;
public class Main {
public static void main(String[] args) {
// Create message service and register message handler.
MessageService messageService = new MessageServiceImpl();
messageService.registerMessageHandler(
new ExampleMessageHandler());
try {
// Sending test messages through the message service.
messageService.sendMessage("This is a normal message.",
MessageType.NORMAL);
messageService.sendMessage("This is an urgent message!",
MessageType.URGENT);
} catch (Exception e) {
e.printStackTrace();
}
}
}
If we run the Main class, we should get the following output:
NORMAL MESSAGE: This is a normal message. URGENT MESSAGE: This is an urgent message!
If you're only using the web functionality provided by an application server, or you want to optimize HTTP performance, it would be a good idea to consider embedding the Jetty HTTP server inside your application. This way, you don't even have to generate a WAR-file and a web.xml file. The application is just a basic Java application, which you can run on any server with a Java VM.
If you're using a Maven project, add the following dependencies to the pom-file in the "dependencies"-element in order to start working right away:
<dependency> <groupId>org.mortbay.jetty</groupId> <artifactId>jetty-hightide</artifactId> <version>8.0.4.v20111024</version> </dependency> <dependency> <groupId>org.apache.wicket</groupId> <artifactId>wicket-core</artifactId> <version>1.5.3</version> </dependency>
For our example, we use a minimal Wicket application that consists of one page.
The ExampleWicketApplication.java file:
package com.javaeenotes;
import org.apache.wicket.Page;
import org.apache.wicket.protocol.http.WebApplication;
public class ExampleWicketApplication extends WebApplication {
@Override
public Class<? extends Page> getHomePage() {
return HomePage.class;
}
}
The HomePage.java file:
package com.javaeenotes;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
public class HomePage extends WebPage {
public HomePage() {
add(new Label("message", "Hello World!"));
}
}
The HomePage.html file:
<html> <body> <span wicket:id="message"></span> </body> </html>
The final class we need is a main class with the static main-method, in which we tie the Wicket servlet to the Jetty server.
The Main.java file:
package com.javaeenotes;
import org.apache.wicket.protocol.http.WicketFilter;
import org.apache.wicket.protocol.http.WicketServlet;
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.bio.SocketConnector;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.webapp.WebAppContext;
public class Main {
public static void main(String[] args) {
// Object that holds, and configures the WicketServlet.
ServletHolder servletHolder =
new ServletHolder(new WicketServlet());
servletHolder.setInitParameter(
"applicationClassName",
"com.javaeenotes.ExampleWicketApplication");
servletHolder.setInitParameter(
WicketFilter.FILTER_MAPPING_PARAM, "/*");
servletHolder.setInitOrder(1);
// Web context configuration.
WebAppContext context = new WebAppContext();
context.addServlet(servletHolder, "/*");
context.setResourceBase("."); // Web root directory.
// The HTTP-server on port 8080.
Server server = new Server();
SocketConnector connector = new SocketConnector();
connector.setPort(8080);
server.setConnectors(new Connector[]{connector});
server.setHandler(context);
try {
// Start HTTP-server.
server.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Run the main method in a VM, and connect to port 8080 with a browser to check that the application is working.
I like my library JAR-files to be managed by Maven 2. It makes life much easier. Sadly, due to the binary license there is no public Maven 2 repository with the Oracle JDBC driver. So we have to add the JDBC driver manually to our local Maven 2 repository.
First, download the latest Oracle JDBC driver here: http://www.oracle.com/technetwork/indexes/downloads/index.html. Do a search on "JDBC" to find the correct download link.
If you're using Maven inside Eclipse like I am, the "mvn" command will not work from the command prompt. We have to install Maven 2 on our system. You can download Maven 2 here: http://maven.apache.org/download.html. Simply unzip, and make sure the "bin" directory is in your command path.
Now, we can install the JAR file with the following command:
mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc6 -Dversion=11.2.0.3 -Dpackaging=jar -Dfile=ojdbc6.jar -DgeneratePom=trueBe sure to check the parameters, like the version number.
Finally, we can use the Oracle JDBC driver in our Maven 2 project by adding the following dependency to our "pom.xml" file:
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.2.0.3</version>
</dependency>
This post explains how to use Quartz 2 with Google Guice. Before you read any further, I assume you have some basic understanding about Guice and Quartz 2, and what problems they solve.
Normally, Quartz will instantiate job classes itself. You only need to supply the job class, so Quartz knows which class to instantiate when a job is ready to be executed. The job itself is pretty hidden (encapsulated) by Quartz.
In some cases, you want to let Google Guice inject references of (singleton) objects to the job. Such as a Data Access Object, so the job can access or store data.
The solution is to supply our own job factory to the Quartz class that is responsible for job instantiation. Our factory will use Guice to create instances for Quartz to use.
package com.javaeenotes.guicequartz;
import org.quartz.Job;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import com.google.inject.Inject;
import com.google.inject.Injector;
public class MyJobFactory implements JobFactory {
@Inject
private Injector injector;
@Override
public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler)
throws SchedulerException {
return (Job) injector.getInstance(
bundle.getJobDetail().getJobClass());
}
}
To complete this example, we need an example DAO class, and a Quartz job class that will hold the injected DAO object.
package com.javaeenotes;
public interface Dao {
public abstract String getData();
}
package com.javaeenotes;
import com.google.inject.Singleton;
@Singleton
public class DaoImpl implements Dao {
@Override
public String getData() {
return "Data from DAO.";
}
}
package com.javaeenotes;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import com.google.inject.Inject;
public class MyJob implements Job {
@Inject
private Dao dao;
@Override
public void execute(JobExecutionContext context)
throws JobExecutionException {
System.out.println(dao.getData());
}
}
Now, we need a Guice module that defines and maps the factory and DAO classes.
package com.javaeenotes;
import org.quartz.spi.JobFactory;
import com.google.inject.AbstractModule;
public class MyModule extends AbstractModule {
@Override
protected void configure() {
bind(JobFactory.class).to(MyJobFactory.class);
bind(Dao.class).to(DaoImpl.class);
}
}
Finally, a Main class to demonstrate the application:
package com.javaeenotes;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import com.google.inject.Guice;
import com.google.inject.Injector;
public class Main {
public void run() {
// The Guice injector used to create instances.
Injector injector = Guice.createInjector(new MyModule());
// Object that contains the job class.
JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
.withIdentity("jobId", "jobGroup").build();
// Create the trigger that will instantiate and execute the job.
// Execute the job with a 3 seconds interval.
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("triggerId")
.withSchedule(
SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(3).repeatForever())
.build();
try {
// Retrieve the Quartz scheduler to schedule the job.
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
// Here we tell the Quartz scheduler to use our factory.
scheduler.setJobFactory(injector.getInstance(MyJobFactory.class));
scheduler.scheduleJob(jobDetail, trigger);
// Start the scheduler.
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
new Main().run();
}
}
This will output the following every 3 seconds:
Data from DAO.
org.quartz-scheduler quartz 2.0.2 com.google.inject guice 3.0
package com.javaeenotes;
import java.io.Serializable;
public class JobContext implements Serializable {
private static final long serialVersionUID = 1L;
private String state = "Initial state.";
public String getState() {
synchronized (state) {
return state;
}
}
public void setState(String state) {
synchronized (state) {
this.state = state;
}
}
}
The next code is the job definition class, which implements the method called by the Quartz scheduler. It's recommended to wrap the whole body of the method in a try-block in order to catch any exceptions that might occur. Wrap the exception in the checked JobExecutionException before throwing it. The main thread can deal with the exception later.
package com.javaeenotes;
import java.util.Date;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
// Disallow running multiple jobs based on this class at the same time.
@DisallowConcurrentExecution
public class JobTask implements Job {
@Override
public void execute(JobExecutionContext executionContext)
throws JobExecutionException {
// It's a good idea to wrap the entire body in a try-block, in order to
// catch every exception thrown.
try {
// Retrieve the state object.
JobContext jobContext = (JobContext) executionContext
.getJobDetail().getJobDataMap().get("jobContext");
// Update state.
jobContext.setState(new Date().toString());
// This is just a simulation of something going wrong.
int number = 0;
number = 123 / number;
} catch (Exception e) {
throw new JobExecutionException(e);
}
}
}
The next class is responsible for monitoring the job. It's also responsible for dealing with exceptions thrown by the job.
package com.javaeenotes;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
public class JobTaskListener implements JobListener {
public static final String TRIGGER_NAME = "Trigger";
@Override
public String getName() {
return TRIGGER_NAME;
}
@Override
public void jobToBeExecuted(JobExecutionContext context) {
System.out.println("Job is going to be executed: "
+ context.getJobDetail().getKey().toString());
}
@Override
public void jobExecutionVetoed(JobExecutionContext context) {
System.out.println("Job is vetoed by trigger: "
+ context.getJobDetail().getKey().toString());
}
@Override
public void jobWasExecuted(
JobExecutionContext context,
JobExecutionException jobException) {
System.out.println("Exception thrown by: "
+ context.getJobDetail().getKey().toString()
+ " Exception: "
+ jobException.getMessage());
}
}
Now, we can use these classes to see how it runs. We use the Main-class for this purpose.
package com.javaeenotes;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.JobListener;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.KeyMatcher;
public class Main {
@SuppressWarnings("unchecked")
public void run() {
// The state of the job.
JobContext jobContext = new JobContext();
// The value or transfer object provided by Quartz that contains the
// state of the job. Save it in JobDetail or Trigger.
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put("jobContext", jobContext);
// Create an identifier for the job.
JobKey jobKey = new JobKey("jobId", "jobGroup");
// Object that contains the job class and transfer object.
JobDetail jobDetail = JobBuilder.newJob(JobTask.class)
.withIdentity(jobKey).usingJobData(jobDataMap).build();
// Create the trigger that will instantiate and execute the job.
// Execute the job with a 5 seconds interval.
Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity("triggerId")
.withSchedule(
SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(5).repeatForever())
.build();
// Setup a listener for the job.
JobListener jobListener = new JobTaskListener();
// Use the Quartz scheduler to schedule the job.
try {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.scheduleJob(jobDetail, trigger);
// Tell scheduler to listen for jobs with a particular key.
scheduler.getListenerManager().addJobListener(
jobListener,
KeyMatcher.keyEquals(jobKey));
// Start the scheduler after 5 seconds.
scheduler.startDelayed(5);
} catch (SchedulerException e) {
e.printStackTrace();
}
// Print the job state with a 3 seconds interval.
while (true) {
try {
System.out.println(jobContext.getState());
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
new Main().run();
}
}
The first thing we do is to create the state object, and wrap it in the transfer or value object provided by Quartz. The reason we do this, is because Quartz doesn't let us instantiate the job class ourselves.
The next step is to define and instantiate a JobKey object, which acts as the identifier for our job. This is also used together with the listener to tell the scheduler which jobs we want to monitor.
Then we create a JobDetail object, which contains details of the job. A trigger object is also needed to tell the scheduler when we want our job to be run. This provides a nice separation of the job and run schedule. Using multiple triggers we can run the same job at different times.
Next, we instantiate the listener class.
Finally, we retrieve an instance of the Quartz scheduler to schedule the job with the trigger. The listener class is also added, together with a matcher based on the job identifier. This way, the scheduler knows which jobs the listener is listening to. The scheduler is then started with a delay of 5 seconds.
The resulting output, when we run the Main class:
Initial state.
Initial state.
Job is going to be executed: jobGroup.jobId
Exception thrown by: jobGroup.jobId
Exception: java.lang.ArithmeticException: / by zero
Job is going to be executed: jobGroup.jobId
Exception thrown by: jobGroup.jobId
Exception: java.lang.ArithmeticException: / by zero
Thu Sep 08 18:07:03 CEST 2011
Thu Sep 08 18:07:03 CEST 2011
Job is going to be executed: jobGroup.jobId
Exception thrown by: jobGroup.jobId
Exception: java.lang.ArithmeticException: / by zero
org.quartz-scheduler quartz 2.0.2
package com.javaeenotes;
public abstract class AbstractStoppableThread extends Thread {
private volatile boolean stopThread = false;
@Override
public final void run() {
startUp();
while (!stopThread) {
runInLoop();
}
cleanUp();
}
public void stopThread() {
stopThread = true;
}
protected void startUp() {
;
}
protected abstract void runInLoop();
protected void cleanUp() {
;
}
}
A subclass of this class has to provide the actual overriding implementations of the last three methods. A class that demonstrates the use of the abstract class is shown next:
package com.javaeenotes;
public class ExampleThread extends AbstractStoppableThread {
@Override
protected void startUp() {
System.out.println("Thread started!");
}
@Override
protected void runInLoop() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
;
}
System.out.println("Running in a loop!");
}
@Override
protected void cleanUp() {
System.out.println("Cleaning up resources!");
}
public static void main(String[] args) {
ExampleThread exampleThread = new ExampleThread();
exampleThread.start();
try {
Thread.sleep(10000);
exampleThread.stopThread();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
When the example is class is run, the program will output the following:
Thread started! Running in a loop! Running in a loop! Running in a loop! Running in a loop! Running in a loop! Cleaning up resources!Other interesting links about stopping threads:
| Carbon Severity Enum | Commons Log | Log4J | JDK 1.4 Logger | LogKit |
|---|---|---|---|---|
| FATAL | FATAL | FATAL | SEVERE | FATAL_ERROR |
| ERROR | ERROR | ERROR | SEVERE | ERROR |
| WARN | WARN | WARN | WARNING | WARN |
| INFO | INFO | INFO | INFO | INFO |
| DEBUG | DEBUG | DEBUG | FINE | DEBUG |
| DEBUG | DEBUG | DEBUG | FINER | DEBUG |
| TRACE | TRACE | DEBUG | FINEST | DEBUG |
public void doSomething() throws ACheckedException {
if (someErrorCondition) {
String errorMessage = "Hey, some error occurred.";
logger.error(errorMessage);
throw new ACheckedException(errorMessage);
}
}
public void callerMethod() {
try {
doSomething();
} catch (ACheckedException exception) {
logger.error(exception.getMessage());
doSomethingElse();
}
}
logger.error("The error '" + errorMessage +
"' occurred in the " +
component.getName() + " component.");
if (logger.isEnabledFor(Level.ERROR) {
logger.error("The error '" + errorMessage +
"' occurred in the " +
component.getName() + " component.");
}
log.error("The error '{}' occurred in the {} component.",
errorMessage, component.getName());
01/02/2011 ERROR The user has a missing property.
java.lang.IllegalArgumentException:
com.javaeenotes.YourClass is not an interface.
context = new Mockery() {
{
setImposteriser(ClassImposteriser.INSTANCE);
}
};
package com.javaeenotes;
public class TestSubject {
private DependentClassInterface depObject;
public TestSubject(DependentClassInterface depObject) {
this.depObject = depObject;
}
public String method() {
return depObject.method();
}
}
package com.javaeenotes;
public interface DependentClassInterface {
public String method();
}
package com.javaeenotes;
import static org.junit.Assert.assertTrue;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.junit.Test;
public class TestSubjectTest {
@Test
public void testMethod() {
Mockery context = new Mockery();
// Create mock object.
final DependentClassInterface depObject = context
.mock(DependentClassInterface.class);
// Test object is instantiated with mock object.
TestSubject testSubject = new TestSubject(depObject);
// Configure expectation and behavior.
context.checking(new Expectations() {
{
oneOf(depObject).method();
will(returnValue("hello"));
}
});
// Test outcome.
assertTrue(testSubject.method().equals("hello"));
// Check if expectations are satisfied.
context.assertIsSatisfied();
}
}
java.lang.SecurityException:
class "org.hamcrest.TypeSafeMatcher"'s signer information
does not match signer information of other classes in the
same package
<html>
<head>
<title>Launch Page</title>
</head>
<body>
<div wicket:id="modal"></div>
<span wicket:id="passValueLabel">Value of passValue variable.</span>
<a wicket:id="showModalLink">Open modal window.</a>
</body>
</html>
package com.javaeenotes;
import org.apache.wicket.Page;
import org.apache.wicket.ajax.AjaxRequestTarget;
import org.apache.wicket.ajax.markup.html.AjaxLink;
import org.apache.wicket.extensions.ajax.markup.html.modal.ModalWindow;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.model.PropertyModel;
public class LaunchPage extends WebPage {
private String passValue;
@SuppressWarnings("serial")
public LaunchPage() {
passValue = "This value is passed to the modal window.";
// Display the current content of the passValue variable. The
// PropertyModel must be used, as the value can be changed.
final Label passValueLabel;
add(passValueLabel = new Label("passValueLabel",
new PropertyModel<String>(this, "passValue")));
passValueLabel.setOutputMarkupId(true);
// Create the modal window.
final ModalWindow modal;
add(modal = new ModalWindow("modal"));
modal.setCookieName("modal-1");
modal.setPageCreator(new ModalWindow.PageCreator() {
public Page createPage() {
// Use this constructor to pass a reference of this page.
return new ModalContentPage(LaunchPage.this.getPageReference(),
modal);
}
});
modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
public void onClose(AjaxRequestTarget target) {
// The variable passValue might be changed by the modal window.
// We need this to update the view of this page.
target.add(passValueLabel);
}
});
modal.setCloseButtonCallback(new ModalWindow.CloseButtonCallback() {
public boolean onCloseButtonClicked(AjaxRequestTarget target) {
// Change the passValue variable when modal window is closed.
setPassValue("Modal window is closed by user.");
return true;
}
});
// Add the link that opens the modal window.
add(new AjaxLink<Void>("showModalLink") {
@Override
public void onClick(AjaxRequestTarget target) {
modal.show(target);
}
});
}
public String getPassValue() {
return passValue;
}
public void setPassValue(String passValue) {
this.passValue = passValue;
}
}
<html>
<head>
<title>Modal Content Page</title>
</head>
<body>
<span wicket:id="passValueLabel">Current content of passValue variable.</span>
</body>
</html>
package com.javaeenotes;
import org.apache.wicket.PageReference;
import org.apache.wicket.extensions.ajax.markup.html.modal.ModalWindow;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
public class ModalContentPage extends WebPage {
public ModalContentPage(final PageReference modalWindowPage,
final ModalWindow window) {
// Retrieve the passValue content for display.
String passValue = ((LaunchPage) modalWindowPage.getPage())
.getPassValue();
add(new Label("passValueLabel", passValue));
// You can use the
// ((LaunchPage)modalWindowPage.getPage()).setPassValue() method to
// change the passValue variable of the launch/caller page.
}
}
