BlogJava-laoding-文章分类-spring

spring aop简单日志实例(2)

老丁 — Tue, 25 Nov 2008 10:27:00 GMT

上一篇中用XMLSchema配置方式介绍了简单日志实现，这里再用annotation来介绍(注意是spring2.0)

来看接口，这个接口简单的不能再简单了，嘻嘻。

public interface Hello {
String hello(String name);
}

实现类：

public class SayHello implements Hello {

    public String hello(String name) {
        String result = "---hello " + name;
        System.out.println(result);
        return result;
    }

}

切面，里面采用了annotation来注释，也说明了大概意思：

/*
* Create Date:2008-11-20 下午03:09:11
*
* Author:dingkm
*
* Version: V1.0
*
* Description：对进行修改的功能进行描述
*
*
*/
//首先这是注释这个类就是切面
@Aspect
public class MyAspect {
    //这里是注释要切入的方法，AfterReturning是表示方法返回以后进行切入，我这里
    //选这个的话是因为日志一般都是在方法执行完成后记录，当然你可以拿Before来试
    @AfterReturning("execution(* *.aspectJ.*.hello(..))")
    public void doLog(ProceedingJoinPoint joinpoint) throws Throwable{
        String result = (String)joinpoint.proceed();
        System.out.println("---doLog"+result);
    }
}

下面是spring配置文件，这里的配置文件就比较简单了：

这句很关键哦

再来看测试类：

public class Test {

    /**
     *   @Description 方法实现功能描述
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        ApplicationContext act = new ClassPathXmlApplicationContext(
        "applicationContext21.xml");
        Hello h = (Hello)act.getBean("hello");
        h.hello("laoding");
    }

}

看看结果：

---hello laoding
---hello laoding
---doLog---hello laoding

---hello laoding这个与上一篇文章中提到的道理一样，因为记录日志要取得返回结果，所以执行了两次

最后的那句就是我们要的，这样就达到了记录日志的目的，哈哈，收工回去看PPS中韩魔兽对抗。

老丁 2008-11-25 18:27 发表评论

spring aop简单日志实例(1)

老丁 — Tue, 25 Nov 2008 10:14:00 GMT

一直就用spring的IOC，遗憾spring的另一重要组成部分AOP却没用过，所以近几天抽空研究了下AOP，学了些东西，在这里记录下spring2.0的aop配置，以一个简单的记录日志的实例来说明，先介绍下用XMLSchema来配置，下一篇介绍annotation配置，废话不多说，开始吧
先新建个web工程，将spring的包加进去，为方便就把全部的jar包加进去。

先来看个接口，很简单就两个方法

public interface Print {
public String print(String name);
public String sleep(String name);
}

接下来是实现类

public class SystemPrint implements Print{

    public String print(String name){
        String result="hello " + name;
        System.out.println(result);
        return result;
    }

    public String sleep(String name){
        String result=name+" is sleep now";
        System.out.println(result);
        return result;
    }
}

下面是所要织入的代码，也就是我们要用来记录日志的

public class GetLog {
    public void getLog(ProceedingJoinPoint joinpoint) throws Throwable {
        String reslut = (String)joinpoint.proceed();
        //这里是记录日志的
        System.out.println("result==="+reslut);
    }
}

再来看spring配置文件，没有注释的很清楚，可以去网上查查

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">


    <bean id="log" class="spring2aop.GetLog">bean>


    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="printMethods" expression="execution(* spring2aop.*.print*(..))"/>
            <aop:after-returning method="getLog" pointcut-ref="printMethods" returning="retVal"/>
        aop:aspect>
    aop:config>

    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="sleepMethods" expression="execution(* spring2aop.*.sle*(..))"/>
            <aop:after-returning method="getLog" pointcut-ref="sleepMethods" returning="retVal"/>
        aop:aspect>
    aop:config>


    <bean id="print" class="spring2aop.SystemPrint">bean>

beans>

测试类：

public class Test {

    /**
     *   @Description 方法实现功能描述
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        ApplicationContext act = new ClassPathXmlApplicationContext(
        "applicationContext20.xml");
        Print t =(Print)act.getBean("print");
        t.print("ding");
        System.out.println("-----------------");
        t.sleep("laoding");

    }

}

运行这个类，得到如下结果：
hello ding
hello ding
result===hello ding
-----------------
laoding is sleep now
laoding is sleep now
result===laoding is sleep now

这里的hello ding 打印了两次，不用担心，这是因为执行到getLog切面类的
String reslut = (String)joinpoint.proceed();这句代码的时候再执行了一次，这句代码是取回
返回结果的，可以设置个断点来测试下好了这里就输出的result就是记录的日志，当然
这里只是个很简单的实现，但是很简单的实现却很容易说清楚原理。

老丁 2008-11-25 18:14 发表评论

spring常见错误分析

老丁 — Sat, 01 Nov 2008 05:12:00 GMT

现象1：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''org.springframework.aop.support.DefaultPointcutAdvisor'' defined in null: Can''t resolve reference to bean ''txAdvice'' while setting property ''advice''; nested exception is
原因：缺少Spring开头的各种包，到Spring2.0 src中编译新的dist目录出来，拷贝全部的springxxx.jar到jpetstore/WEB-INF/lib下。OK。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象2：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''sessionFactory'' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Instantiation of bean failed; nested exception is java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
原因：缺少jta.jar，OK
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象3：
java.lang.NoClassDefFoundError: org/dom4j/Attribute缺dom4j.jar
java.lang.NoClassDefFoundError: net/sf/ehcache/CacheException
缺ehcache.jar
java.lang.NoClassDefFoundError: net/sf/cglib/core/KeyFactory
缺cglib-full.jar
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象4：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''sessionFactory'' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Initialization of bean failed; nested exception is net.sf.hibernate.MappingException: could not instantiate id generator
net.sf.hibernate.MappingException: could not instantiate id generator
原因：
hbm中id字段的定义为没有定义的sequesce,修改为inc
name="id"
type="string"
column="userid"
>
// 原来是sequence.
这样就可以了。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象6：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''/shop/addItemToCart.do'' defined in ServletContext resource [/WEB-INF/petstore-servlet.xml]: Can''t resolve reference to bean ''petStore'' while setting property ''petStore''; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ''petStore'' is defined
org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ''petStore'' is defined原因：
我使用Struts作为action,当然就不需要使用Spring WEB framework,因此也不需要与之配套的配置文件例如,petstore-servlet.xml,
还有remote-servlet.xml ,但是Spring仍旧加载此两个文件，没办法，只好将此两个文件挪动到别的地方，但是又出现找不到这两个
文件的IO异常，没办法，只好又拷贝回来，然后把文件内容晴空。
终于好用了。
原因就是，只要你在web.xml中定义了这个servlet，他就要去找此servlet名字对应的配置文件（servletname-servlet.xml）,找不到就出错。ok，现在注释掉web.xml中名字为petstore的servlet定义和影色，删除petstore-servlet.xml文件，哈哈，这下不报告错误了。
同理，注释名字为remote的servlet，删除remote-servlet.xml后，重新启动tomcat，这下不报告任何错误了。呵呵。原来如此啊。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象：
java.lang.NullPointerException
srx.test.testhibernate.UserDAO.getAll(UserDAO.java:9)
srx.test.struts.action.UserAction.execute(UserAction.java:20)原因：
Action原来
UserDAO // 这个类OK
public class UserDAO extends HibernateDaoSupport {
public List getAll() {
return this.getHibernateTemplate().find("select aa from Account aa");
}
}
//这个类需要修改
public class UserAction extends ActionSupport {
UserDAO dao = new UserDAO();
List accounts = dao.getAll();
。。。
}
修改：
//UserDAO dao = new UserDAO(); WebApplicationContext wac = this.getWebApplicationContext();
UserDAO dao = (UserDAO) wac.getBean("userDAO");

本文转自：http://main.blog.hexun.com/14227514_d.html

老丁 2008-11-01 13:12 发表评论

Spring自动装配(autowire)协作者

老丁 — Wed, 29 Oct 2008 01:44:00 GMT

在xml配置文件中，autowire有5种类型，可以在元素中使用autowire属性指定：

模式                        说明
no                       不使用自动装配，必须通过ref元素指定依赖，默认设置。
byName                    根据属性名自动装配。此选项将检查容器并根据名字查找与
                          属性完全一致的bean，并将其与属性自动装配。
byType                    如果容器中存在一个与指定属性类型相同的bean，那么将与
                          该属性自动装配；如果存在多个该类型bean，那么抛出异
                          常，并指出不能使用byType方式进行自动装配；如果没有找
                          到相匹配的bean，则什么事都不发生，也可以通过设置
                          dependency-check="objects"让Spring抛出异常。
constructor               与byType方式类似，不同之处在于它应用于构造器参数。如
                          果容器中没有找到与构造器参数类型一致的bean，那么抛出
                          异常。
autodetect                通过bean类的自省机制（introspection）来决定是使用
                          constructor还是byType方式进行自动装配。如果发现默认的
                          构造器，那么将使用byType方式。

可以设置bean使自动装配失效：
采用xml格式配置bean时，将元素的autowire-candidate属性设置为false，这样容器在查找自动装配对象时，将不考虑该bean，即它不会被考虑作为其它bean自动装配的候选者，但是该bean本身还是可以使用自动装配来注入其它bean的。

下面用实例来说明：准备3个类

public class Home {

    private String addr;

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

}

public class Person {

    private String name;
    private Home myHome;

    public Person(Home myHome){
        this.myHome = myHome;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Home getMyHome() {
        return myHome;
    }
    public void setMyHome(Home myHome) {
        this.myHome = myHome;
    }
}

public class Test {

    private Date time;
    private String str;

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

}

一.byName的装配方式
spring配置文件

xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<bean id="test" class="autowire.Test" autowire="byName">
    <property name="str">
        <value>dingvalue>
    property>
bean>
<bean id="time" class="java.util.Date"/>
beans>

测试类：

public class TestMain {

    public static void main(String[] args) {
    ApplicationContext at = new ClassPathXmlApplicationContext("applicationContext9.xml");
    Test t = (Test)at.getBean("test");
    /*
    代码若采用了byName的装配方式，也就是在配置文件中id为test的bean装入后，因为是byName装配，同时
    Test类中含有time属性，所以spring会自动查找id为time的bean来设置time的值。

    若在配置文件中把autowire="byName"去掉，则time的值为空

    */
    System.out.println(t.getStr());
    System.out.println(t.getTime());
    }

执行这个类可以看到：
ding
Wed Oct 29 09:19:29 CST 2008

证明time已经被注入了
若在配置文件中把autowire="byName"去掉，则可以看到
ding
null

二.byName的装配方式

代码都不用改，只需要在spring配置文件里面把 autowire="byName"换成autowire="byType"就可以了
这种装配方式，则spring会自动查找与Test类中time属性类型相同的bean，不管这个
bean的id是什么（byName中的id必须与属性对应，而这里不要求），都可以用来设置time的值，随便改动
bean的名字都可以，比如的名字都可以，同样是对的
若存在多个这样的bean，则会抛出异常。
增加一个bean

运行可以看到异常：

Exception in thread "main" org.springframework.beans.factory.UnsatisfiedDependencyException:
     Error creating bean with name 'test' defined in class path resource [applicationContext9.xml]:
     Unsatisfied dependency expressed through bean property 'time': There are 2 beans of type [java.util.Date]
     available for autowiring by type: [ti252752, time2]. There should have been exactly 1 to be able to autowire
     property 'time' of bean 'test'. Consider using autowiring by name instead.

三.构造方法装载

spring配置文件

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <bean id="person" class="autowire.Person" autowire="constructor">
        <property name="name">
            <value>dingvalue>
        property>
    bean>
    <bean id="myHome" class="autowire.Home">
        <property name="addr">
            <value>江西value>
        property>
    bean>

beans>

测试类

public class TestMain2 {

    public static void main(String[] args) {
        ApplicationContext atx = new ClassPathXmlApplicationContext("applicationContext10.xml");
        Person p = (Person)atx.getBean("person");
        System.out.println(p.getName());
        System.out.println(p.getMyHome().getAddr());
        /*
         * 这段代码是通过构造方法装载的，配置文件里面有autowire="constructor"，Person类里面
         * 的构造方法含有参数myHome，spring会通过这个构造方法来查找与构造方法参数类型相同的bean，
         * 把它装载进来，如果出现两个类型一样的bean会抛出异常。
         * */
    }

}

若将Person类里面含有参数myHome的构造方法去掉则会报错

四.不使用自动装配

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    <bean id="person" class="autowire.Person">
        <property name="name">
            <value>dingvalue>
        property>
        <property name="myHome">
            <ref local="myHome"/>
        property>
    bean>

    <bean id="myHome" class="autowire.Home">
        <property name="addr">
            <value>江西value>
        property>
    bean>

beans>

public class TestMian3 {

    public static void main(String[] args) throws Exception {
// 默认的no装载模式
        ApplicationContext atx = new ClassPathXmlApplicationContext(
                "applicationContext11.xml");
        Person p = (Person) atx.getBean("person");
        System.out.println(p.getName());
        System.out.println(p.getMyHome().getAddr());
        // 若使用这个Person类的构造方法需是默认的，自己写的要去掉，否则抛出异常。��
    }
}

可以看到这里的配置文件里面用



注入了，否则得不到这个属性，同时Person类的构造方法需是默认的，其他的要去掉，否则抛出异常。

五.autodetect
通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
这个就不详细讲了。

老丁 2008-10-29 09:44 发表评论

Spring简介

老丁 — Tue, 28 Oct 2008 01:25:00 GMT

转自：www.java114.com

Spring作为实现J2EE的一个全方位应用程序框架，为我们开发企业级应用提供了一个健壮、高效的解决方案。所谓全方位，不得不说以下几个特点：

1 非侵入式：对于写代码从来不考虑复用和移植的程序员来说，这一点根本就没有吸引力，那么请跳过。所谓非侵入式是指Spring框架的API不会在业务逻辑上出现，也就是说我们的业务逻辑应该是纯净的，不能出现与业务逻辑无关的代码。首先针对应用而言，这样我们才能将业务逻辑从当前应用中剥离出来，从而在其他的应用中实现复用；其次针对框架而言，由于业务逻辑中没有Spring的API，所以业务逻辑也可以从Spring框架快速的移植到其他框架。

2 容器：Spring提供容器功能，容器可以管理对象的生命周期，对象与对象之间的依赖关系。你可以写一个配置文件（通常是xml文件），在上面定义对象的名字，是否是单例，以及设置与其他对象的依赖关系。那么在容器启动之后，这些对象就被实例化好了，你直接去用就好了，而且依赖关系也建立好了。

3 IOC：控制反转，谓之“依赖关系的转移”，如果以前都是依赖于实现，那么现在反转为依赖于抽象吧，其实它的核心思想就是要面向接口编程，至于何谓接口何谓抽象，以及它们的好处，多看看设计模式吧，这里就不费口舌了。

4 依赖注入：建立对象与对象之间依赖关系的实现，包括接口注入、构造注入、set注入，在Spring中只支持后两种

5 AOP：面向方面编程，我们可以把日志、安全、事务管理等服务（或功能）理解成一个“方面”，那么以前这些服务一直是直接写在业务逻辑的代码当中的，这有两点不好；首先业务逻辑不纯净，其次这些服务被很多业务逻辑反复使用，完全可以剥离出来做到复用。那么AOP就是这些问题的解决方案，我们可以把这些服务剥离出来形成一个“方面”，以期做到复用；然后将“方面”动态的插入到业务逻辑中让业务逻辑能够享受到此“方面”的服务

其他还有一些特点不是Spring的核心，这里只做简单陈述，如：对JDBC的封装与简化，提供事务管理功能，对O/R mapping工具（hibernate、iBATIS）的整合；提供MVC解决方案，也可以与其他web框架（Struts、JSF）进行整合；还有对JNDI、mail等服务进行封装。

老丁 2008-10-28 09:25 发表评论

spring功能简单介绍

老丁 — Fri, 05 Sep 2008 01:15:00 GMT

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

•         目的：解决企业应用开发的复杂性

•         功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

•         范围：任何Java应用

简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

■         轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

■         控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

■         面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

■         容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

■         框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

老丁 2008-09-05 09:15 发表评论

spring quartz定时执行任务

老丁 — Thu, 04 Sep 2008 11:39:00 GMT

首先是spring配置文件

xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">








            timeTask




            class="org.springframework.scheduling.quartz.CronTriggerBean">





            0 0 23 * * ?




            class="org.springframework.scheduling.quartz.SchedulerFactoryBean">







执行的那个类和方法我就不写了，自己随便写个简单的测试就可以了

下面是执行主方法

public class TestTimer {

/**
*   @Description 方法实现功能描述
*   @param args
*   void
*   @throws 抛出异常说明
*/
public static void main(String[] args) {
//这里的spring配置文件的路径自己修改
  ApplicationContext context = new FileSystemXmlApplicationContext("/WebRoot/WEB-INF/application*.xml");

  System.out.println("*****完毕******");

}

这个方法的作用就是将spring跑起来
OK啦
就是这么简单

欢迎讨论！！

以下是网上摘抄的一些说明：
字段允许值允许的特殊字符
秒 0-59 , - * /
分 0-59 , - * /
小时 0-23 , - * /
日期 1-31 , - * ? / L W C
月份 1-12 或者 JAN-DEC , - * /
星期 1-7 或者 SUN-SAT , - * ? / L C #
年（可选）留空, 1970-2099 , - * /

表达式意义
"0 0 12 * * ?" 每天中午12点触发
"0 15 10 ? * *" 每天上午10:15触发
"0 15 10 * * ?" 每天上午10:15触发
"0 15 10 * * ? *" 每天上午10:15触发
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
"0 15 10 15 * ?" 每月15日上午10:15触发
"0 15 10 L * ?" 每月最后一日的上午10:15触发
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

老丁 2008-09-04 19:39 发表评论