`
adamed
  • 浏览: 183883 次
社区版块
存档分类
最新评论

Quartz Job Scheduling Framework第10章翻译初稿

quartzEJBJ2SE应用服务器Weblogic 
阅读更多
Chapter 10. Using Quartz with J2EE
第10章 在J2EE中使用Quartz
 
The Java 2 Platform, Enterprise Edition (J2EE) defines the standards for developing component-based enterprise applications. Whether you are inclined to use one of the open source J2EE servers, such as JBoss or Geronimo, or whether you prefer the comfort and safety of commercial support with ones such as WebSphere and WebLogic, Quartz can be used in several different deployment arrangements with all of them. This chapter demonstrates the various strategies for deploying Quartz with a J2EE application server and increasing the richness of J2EE with the Quartz framework.
 
Java 2 Platform, Enterprise Edition (J2EE) 定义了基于组件的企业级开发标准。无论你使用开源的J2EE服务器如Jboss、Geronimo，或者使用舒适安全的商用服务器如WebSphere、WebLogic。Quartz支持在以上所有服务器中进行多个部署方案的使用。这一章展示了在一个J2EE应用服务器中使用多种策略配置Quartz并且展示了如何使用Quartz使J2EE更加丰富。
 
If I Have J2EE, Why Do I Need Quartz?
如果我已经使用了J2EE，为什么我还需要Quartz？
 
Since J2EE first came on the scene in the late 1990s, developers have been perplexed by some of the specification decisions and some of the seemingly obvious missing features. This is not necessarily a criticism of the specification writers, but more indicative of the problem that arises when many separate groups, all with differing opinions and agendas, try to agree on a single set of priorities sort of like the United Nations, but not as nice. Many of the needed features showed up, but a few of the key ones were left out, to be added later. One of the key features that was deferred from the early specifications was a timer service.
自从90年代后期J2EE出现以来，开发人员一直被一些规范决策和一些看视明显的缺点所困扰。这不是对规范定制人员的批评而是说明当问题出现时许多许多独立团体，各具有不同的意见和议程，试图对单一的一套标准达成共识，这有点像联合国。（原文是：try to agree on a single set of priorities sort of like the United Nations, but not as nice.）许多必须的特征被展示出来一些被遗漏则等待以后添加上。其中一个从早期规范中被遗漏的特征就是定时服务器。
 
I Need a Timer Service
我需要定时服务器
Many business processes require asynchronous job scheduling. For example, Web sites usually need to send e-mails to registered users to alert them to new features or the latest specials. Medical claimprocessing companies typically need to download medical data at night and do something with that data. A company that sells some type of product might have reports generated each night that show sales and commission information. All of these scenarios could benefit from a timer service that executes asynchronous jobs.
许多业务过程需要一步的作业调度。例如，网站通常需要给注册用户发送E-MAIL通知他们新特征或最新专辑。处理医疗事故的公司通常需要在夜间下载医疗数据并对这些数据进行处理。销售某种类型产品的公司可能每天晚上生成一张报告展示销售业绩。所有这些情况都收益于一个时间服务器异步执行工作（job）。
 
The Java/J2EE community has produced several attempts at solving the timer problem. Early on, vendors added propriety solutions within their J2EE servers. (For this chapter, the terms J2EE server and J2EE container are used interchangeably.) For example, the WebLogic product had some custom extensions, as did the IBM J2EE server. Unfortunately, they were not exactly compatible for moving components from one to another. Later, these vendors and others tried to develop a common set of timer components.
 
java/j2ee社区对试图解决计时器的问题进行了多次尝试。在早期，厂商在他们的J2EE服务器中添加一些特征来解决这个问题。（这一章中J2EE服务器和J2EE容器可以交替使用。）例如，WebLogic和IBM服务器提供一些自定义拓展。不幸的是，当组件从一个服务器移植到另一个的时候发现他们并不兼容。后期，这些厂商视图开发一套通用的定时器控件。
 
Starting with Java 1.3, Sun added the java.util.Timer and java.util.TimerTask classes to help add basic Timer functionality to the core language. Although the Timer and TimerTask can work for simple requirements, there is much more to true job scheduling than can be solved by two concrete classes. Hopefully, that's a point that you already understand.
 
从Java1.3开始，Sun在核心包中增加java.util.Timer 和 java.util.TimerTask这2个类帮助添加基本的定时函数。虽然Timer 和 TimerTask可以满足基本需求，但实际上工作调度无法用这2个类来完成。希望你能明白这一点。
Quartz/J2EE Deployment Models
Quartz/J2EE配置模型
Two basic strategies exist for architecting and deploying Quartz with J2EE. With one strategy, you can design Quartz to work outside the J2EE container as a standard J2SE client. As you'll see shortly, this is the simplest approach. The second strategy is to deploy Quartz as a J2EE client that resides within the J2EE container. In this scenario, the J2EE client is a Web Archive (WAR) file and is deployed like any other Web application. The strategy you choose depends on your exact needs. Each comes with a set of pros and cons.
 
现在有2个基本策略在J2EE中构建部署Quartz。一种方式是你可以在J2EE容器外设计Quartz作为一个标准的J2SE客户端。正如你将看到在短期内，这是最简单的方法。另一种方式是使Quartz作为J2EE客户端部署到J2EE容器中。这种方案中J2EE客户端就是部署一个与其他Web应用一样的WAR文件。策略的选择取决于你的实际需要。2种策略都有各有利弊。
 
Running Quartz as a J2SE Client
使Quartz作为J2SE客户端运行
If you just need to invoke services on Enterprise JavaBeans (EJBs) or put messages inside a JMS queue or topic, the easiest way to configure Quartz with J2EE is to run Quartz outside the J2EE container as a stand-alone J2SE application. It then would function like any other Java application that lives outside the container but needs to call methods on distributed components within the container.
 
如果你仅仅需要调用EJB中的服务或者调用JMS队列或topic种的信息，J2EE环境下最简单的配置方式就是将Quartz作为一个标准独立的J2SE应用运行在J2EE容器之外。此时就想其他容器外的Java应用程序只需要调用容器内的分布式组件内的方法来执行Quartz。
 
We've essentially been practicing this approach in the previous chapters, minus the part about calling EJBs. You can create a Quartz application that contains the Quartz libraries and job-scheduling information and connects to the J2EE server through the home and remote interfaces. You can then invoke methods on EJBs like any other distributed client. You can also create and insert JMS messages and have them processed by message-driven beans (MDB) running within the container. This approach is shown in Figure 10.1.
 
我们已经在以前的章节种实践了这种方法（除了调用EJB那部分）。你可以创建一个包含Quartz库与工作调度信息的Quartz应用，通过主页或远程接口与J2EE服务器进行连接。你可以像任何其他分布式客户端那样在EJB中调用方法。你也可以创建、插入JMS消息并在容器中通过message-driven beans （MDB）对其进行调用。如图10.1：
图 10.1 Quartz can work with J2EE as a stand-alone J2SE client.
图 10.1 Quartz在J2EE中可以作为一个独立的标准J2SE客户端。
 
This approach works nicely if you have existing J2EE components that you want Quartz to interoperate with, and you don't want to or can't make any changes to the server. To implement this approach, you just need to build a Quartz application, as we've done in previous chapters, and use the EJBInvokerJob that ships with Quartz. We discuss the EJBInvokerJob shortly.
 
这种方法适用于现阶段已经存在一些预与Quartz交互操作的J2EE组件，并且你不想或者不能对服务器做任何改变。实现方式就是你只需要建立一个Quartz应用（就想我们前几章所作的那样）并且使用Quartz所附带的EJBInvokerJob。关于EJBInvokerJob我们会在稍后进行讨论。
Deploying Quartz Within the J2EE Server
在J2EE服务器中部署Quartz
Quartz can also be deployed directly within the container to do away with the external Quartz application. This is commonly referred to as using a J2EE client. You might choose this approach over the previous one for several reasons. One reason is that there's only one application to maintain, compared with two in the other approach. If the external Quartz client shuts down, the job-scheduling information is temporarily lost, and the business owners will not be thrilled. In other words, it's one failure point versus two. Another reason for deploying Quartz within the container is to have Quartz use some of the other resources that the container offers, such as mail sessions, data sources, and other resource adapters. If you are using the J2EE server in a clustered environment, it also makes sense to deploy Quartz within the container to make the clustering easier and more manageable. Figure 10.2 illustrates how Quartz can be deployed with the J2EE application.
Quartz也可以不在容器外部而直接部署到容器中。通常这被称为J2EE客户端。你选择这种方式可能有好多理由。其中之一是这种方式你只需维护一个应用服务，而不是二个。如果外部Quartz客户端停掉那么工作调度信息只是暂时丢失，你的业务主管不会被吓的发抖。（老外的幽默偶们还是难以接受啊。。。^_^）。换句话说，与前一种方式相比这种方式故障点只有一个。另一个将Quartz部署到容器的理由是让Quartz使用容器内的共享资源比如mail会话（mail sessions）、数据源和其他资源适配器的资源。如果你的J2EE服务器实在集群环境下使用那么将Quartz部署到容器中将使集群更简单更易于管理。图10.2阐明Quartz如何部署到J2EE应用中的。
Figure 10.2. Quartz can be deployed within a J2EE application.
图10.2 Quartz可以部署在J2EE应用中
 
When Quartz is deployed within a J2EE container, you must understand and deal with some complications. Before we get into those, let's talk about how to deploy Quartz as a J2SE client and access the container from outside the container.
 
如果将Quartz部署到J2EE容器中，你必须理解并且处理一些复杂信息。在我们谈论这方面问题前我们先谈一下如何将Quartz作为一个J2SE客户端在容器外访问容器的。
 
Running Quartz as a J2SE Client
使Quartz作为J2SE客户端运行
By far the easiest and simplest way to use Quartz with J2EE is to deploy it outside the container. What makes this approach easier is that you don't have to deal with many of the issues that will surface as Quartz attempts to create threads and execute within the container. It's also easier because deploying applications into a J2EE container can be frustrating, even with all of the latest tools and technologies such as XDoclet and administrative consoles.
 
到目前为止，在J2EE中使用Quartz最容易也是最简单的方法就是将Quartz部署在容器外面。这是因为你不用处理大量问题，因为Quartz会尝试在容器内建立、执行线程。说它简单也是因为即使使用最新的工具和技术（比如Xdoclet、控制台）将应用部署到J2EE容器中也是一件令人沮丧的事(frustrating)。
 
Using the Quartz EJBInvokerJob to Call an EJB
使用Quartz的EJBInvokerJob调用EJB
 
The Quartz framework includes the org.quartz.jobs.ee.ejb.EJBInvokerJob, which enables you to schedule a job that can invoke an EJB method when triggered. The job is easy to set up and can be used regardless of which deployment scenario you've chosen with Quartz. Suppose, for example, that you have a Stateless Session Bean (SLSB) like the one in Listing 10.1.
 
Quartz框架包含org.quartz.jobs.ee.ejb.EJBInvokerJob类，这个类的作用是当调度作业被触发时可以调用EJB中的方法。作业可以非常简单的建立并且可以使用在任何你选择的Quartz部署方案中。例如你有一个类似于列表10.1这样的无状态会话Bean（Stateless Session Bean SLSB）。
 

Listing 10.1. An Example Stateless Session Bean<o:p></o:p>

列表10.1 一个无状态会话Bean的例子<o:p></o:p>

java 代码
  1. import java.rmi.RemoteException;   
  2.   
  3.     
  4.   
  5. import javax.ejb.EJBException;   
  6.   
  7. import javax.ejb.SessionBean;   
  8.   
  9. import javax.ejb.SessionContext;   
  10.   
  11.     
  12.   
  13. public class TestBean implements SessionBean {   
  14.   
  15. /** The session context */  
  16.   
  17.      /** session上下文*/  
  18.   
  19.      private SessionContext context;   
  20.   
  21.     
  22.   
  23.      public TestBean() {   
  24.   
  25.           super();   
  26.   
  27.      }   
  28.   
  29.     
  30.   
  31.      // EJB Lifecycle Methods not shown for brevity   
  32.   
  33.      //为了简洁起见不显示EJB的生命周期方法   
  34.   
  35.     
  36.   
  37.      public void helloWorld() throws EJBException {   
  38.   
  39.           System.out.println("Hello World");   
  40.   
  41.      }   
  42.   
  43.     
  44.   
  45.      public void helloWorld(String msg) throws EJBException {   
  46.   
  47.           System.out.println("Hello World - " + msg);   
  48.   
  49.      }   
  50.   
  51. }   
  52.     

With this EJB deployed and ready in your J2EE application server of choice, you can use the EJBInvokerJob to invoke one of the helloWorld() methods available to remote clients.

将这个EJB部署到你准备好的J2EE容器中，你就可以使用EJBInvokerJob调用一个helloWorld()方法发送给远程客户端。

<o:p> </o:p>

You set up the EJBInvokerJob just as you would for any other job. Listing 10.2 shows an example of using the EJBInvokerJob to invoke the helloWorld() on the SLSB.

你可以像配置其他Job一样配置EJBInvokerJob。列表10.2显示一个在SLSB使用EJBInvokerJob调用helloWorld()方法的例子。

<o:p> </o:p>

Listing 10.2. A Simple Example Using the EJBInvokerJob<o:p></o:p>

列表10.2 一个使用EJBInvokerJob的简单例子<o:p></o:p>

java 代码
  1. package org.cavaness.quartzbook.chapter10;   
  2.   
  3.     
  4.   
  5. import java.util.Date;   
  6.   
  7.     
  8.   
  9. import org.apache.commons.logging.Log;   
  10.   
  11. import org.apache.commons.logging.LogFactory;   
  12.   
  13. import org.quartz.JobDetail;   
  14.   
  15. import org.quartz.Scheduler;   
  16.   
  17. import org.quartz.SchedulerException;   
  18.   
  19. import org.quartz.Trigger;   
  20.   
  21. import org.quartz.TriggerUtils;   
  22.   
  23. import org.quartz.impl.StdSchedulerFactory;   
  24.   
  25. import org.quartz.jobs.ee.ejb.EJBInvokerJob;   
  26.   
  27.     
  28.   
  29. public class Listing_10_2 {   
  30.   
  31.      static Log logger = LogFactory.getLog(Listing_10_2.class);   
  32.   
  33.     
  34.   
  35.      public static void main(String[] args) {   
  36.   
  37.           Listing_10_2 example = new Listing_10_2();   
  38.   
  39.     
  40.   
  41.           try {   
  42.   
  43.                // Create a Scheduler and schedule the Job   
  44.   
  45.                //建立Scheduler并且调度Job   
  46.   
  47.                Scheduler scheduler = example.createScheduler();   
  48.   
  49.                example.scheduleJob(scheduler);   
  50.   
  51.     
  52.   
  53.                // Start the Scheduler running   
  54.   
  55.                //执行Scheduler   
  56.   
  57.                scheduler.start();   
  58.   
  59.     
  60.   
  61.                logger.info("Scheduler started at " + new Date());   
  62.   
  63.     
  64.   
  65.     
  66.   
  67.           } catch (SchedulerException ex) {   
  68.   
  69.                logger.error(ex);   
  70.   
  71.           }   
  72.   
  73.      }   
  74.   
  75.     
  76.   
  77.      // Schedule the EJBInvokerJob   
  78.   
  79.      private void scheduleJob(Scheduler scheduler) throws SchedulerException {   
  80.   
  81.     
  82.   
  83.           // Create a JobDetail for the Job   
  84.   
  85.           JobDetail jobDetail = new JobDetail("HelloWorldJob",   
  86.   
  87.                     Scheduler.DEFAULT_GROUP,   
  88.   
  89.                     org.quartz.jobs.ee.ejb.EJBInvokerJob.class);   
  90.   
  91.     
  92.   
  93.           loadJobDataMap(jobDetail);   
  94.   
  95.     
  96.   
  97.           // Create a trigger that fires every 10 seconds, forever   
  98.   
  99.           //建立一个每隔10秒运行一次且无限循环的触发器。   
  100.   
  101.           Trigger trigger = TriggerUtils.makeSecondlyTrigger(10);   
  102.   
  103.           trigger.setName("helloWorldTrigger");   
  104.   
  105.           // Start the trigger firing from now   
  106.   
  107.           //现在开始执行触发器   
  108.   
  109.           trigger.setStartTime(new Date())   
  110.   
  111.     
  112.   
  113.           // Associate the trigger with the job in the scheduler   
  114.   
  115.           //在scheduler中关联触发器与作业   
  116.   
  117.     
  118.   
  119.              scheduler.scheduleJob(jobDetail, trigger);   
  120.   
  121.          }   
  122.   
  123.     
  124.   
  125.          /*  
  126.  
  127.           * Configure the EJB parameters in the JobDataMap  
  128.  
  129.           * 在JobDataMap中配置EJB参数  
  130.  
  131.           */  
  132.   
  133.          public JobDetail loadJobDataMap(JobDetail jobDetail) {   
  134.   
  135.               jobDetail.getJobDataMap().put(EJBInvokerJob.EJB_JNDI_NAME_KEY,   
  136.   
  137.                         "ejb/HelloWorldSession");   
  138.   
  139.     
  140.   
  141.               jobDetail.getJobDataMap().put(EJBInvokerJob.EJB_METHOD_KEY,   
  142.   
  143.                         "helloWorld");   
  144.   
  145.     
  146.   
  147.               jobDetail.getJobDataMap().put(EJBInvokerJob.PROVIDER_URL,   
  148.   
  149.                         "t3://localhost:7001");   
  150.   
  151.     
  152.   
  153.               jobDetail.getJobDataMap().put(   
  154.   
  155.                    EJBInvokerJob.INITIAL_CONTEXT_FACTORY,   
  156.   
  157.                         "weblogic.jndi.WLInitialContextFactory");   
  158.   
  159.     
  160.   
  161.               return jobDetail;   
  162.   
  163.     
  164.   
  165.          }   
  166.   
  167.     
  168.   
  169.          /*  
  170.  
  171.           * return an instance of the Scheduler from the factory  
  172.  
  173.           * 从工厂中返回一个Scheduler实例  
  174.  
  175.           */  
  176.   
  177.          public Scheduler createScheduler() throws SchedulerException {   
  178.   
  179.               return StdSchedulerFactory.getDefaultScheduler();   
  180.   
  181.          }   
  182.   
  183. }   
  184.   
  185.     

As you can see from Listing 10.2, the EJBInvokerJob is configured like any other job. A JobDetail and trigger are created and registered with the Scheduler. Several JobDataMap parameters can be used for the job to function properly with various J2EE containers. Table 10.1 lists the JobDataMap parameters that the job supports.

正如你在列表10.2看到的那样，EJBInvokerJob配置余其他job配置一样都是创建一个JobDetail和触发器并在Scheduler中注册。许多JobDataMap参数传递给Job使其恰当的在多种J2EE容器种执行。表10.1列出了Job支持的JobDataMap参数。
 

The parameters you add to the JobDataMap depend on which J2EE server you're using and what its requirements are. For example, if you're using BEA WebLogic, you would need to specify at least the ones from Listing 10.1, obviously substituting values for your specific environment. If you were using WebSphere, most of the values would be different.

<o:p> </o:p>

传入JobDataMap中的参数依赖于你使用的容器的需要。例如：如果你使用BEA 的WebLogic你需要指定至少从列表10.1中定义的参数，当然如果你指定了其他环境则需要使用其他参数。如果你使用WebSphere，大部分的值都是不一样的。

<o:p> </o:p>

When we set up and run Listing 10.2 within our external Quartz application, every 10 seconds the helloWorld() method on the EJB is invoked. This approach is nice because we don't have to worry about deploying the Quartz application within the J2EE container. It enforces a separation of job information from business processing logic.

<o:p> </o:p>

当我们定义并运行外部Quartz应用程序（列表10.2中定义的），每隔10秒EJB都会调用helloWord()方法。这种方法的好处在于我们不用考虑如何将Quartz应用部署到J2EE容器中。它分离了job信息与业务处理逻辑。

<o:p> </o:p>

Table 10.1. The EJBInvokerJob Uses Several Parameters, Depending on Your Specific J2EE Server<o:p></o:p>

表10.1 依赖与不同的J2EE服务器EJBInvokerJob使用的参数<o:p></o:p>

Static Constant<o:p></o:p>

静态常数<o:p></o:p>

String Value<o:p></o:p>

字符串值<o:p></o:p>

EJB_JNDI_NAME_KEY

ejb

Notes: JNDI name of the bean's home interface

PROVIDER_URL

java.naming.provider.url

Notes: Vendor-specific URL that specifies where the server can be found

INITIAL_CONTEXT_FACTORY

java.naming.factory.initial

Notes: Vendor-specific context factory that is used to look up resources

EJB_METHOD_KEY

method

Notes: Name of the method to invoke on the EJB

EJB_ARGS_KEY

args

Notes: Object[] of the args to pass to the method (optional, if left out, there are no arguments)

EJB_ARG_TYPES_KEY

argType

Notes: Class[] of the args to pass to the method (optionalif left out, the types will be derived by calling getClass() on each of the arguments)

PRINCIPAL

java.naming.security.principal

Notes: The principal (user) to be used for the EJB method call

CREDENTIALS

java.naming.security.credentials

Notes: The credentials to be used for the EJB method call

<o:p> </o:p>

 

  • 大小: 6.4 KB
分享到：
| 今日开博
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics