BlogJava-MikeChen专注电子商务-随笔分类-框架

框架-quartz

陈睿 — Tue, 03 Jul 2012 06:42:00 GMT

一：quartz简介
OpenSymphony 的Quartz提供了一个比较完美的任务调度解决方案。

Quartz 是个开源的作业调度框架，定时调度器，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。

Quartz中有两个基本概念：作业和触发器。作业是能够调度的可执行任务，触发器提供了对作业的调度

二：quartz spring配置详解

为什么不适用java.util.Timer结合java.util.TimerTask

1.主要的原因，适用不方便，特别是制定具体的年月日时分的时间，而quartz使用类似linux上的cron配置，很方便的配置每隔时间执行触发。

2.其次性能的原因，使用jdk自带的Timer不具备多线程，而quartz采用线程池，性能上比timer高出很多。

详解quartz在spring里面的配置

在spring里主要分为两种使用方式：第一种，也是目前使用最多的方式，spring提供的MethodInvokingJobDetailFactoryBean代理类，通过雷利类直接调用任务类的某个函数；第二种,程序里实现quartz接口，quartz通过该接口进行调度。

主要讲解通过spring提供的代理类MethodInvokingJobDetailFactoryBean

1.业务逻辑类:业务逻辑是独立的，本身就与quartz解耦的，并没有深入进去，这对业务来讲是很好的一个方式。

public class TestJobTask{

      /**
       *业务逻辑处理
       */
        public void   service(){
            /**业务逻辑*/
                ..
        }

}

2.增加一个线程池

3.定义业务逻辑类

4.增加quartz调用业务逻辑

5.增加调用的触发器，触发的时间，有两种方式：

第一种触发时间，采用类似linux的cron，配置时间的表示发出丰富
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">

Cron表达式“10 */1 * * * ?”意为：从10秒开始，每1分钟执行一次

第二种，采用比较简话的方式，申明延迟时间和间隔时间
<bean id="taskTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">

延迟10秒启动，然后每隔1分钟执行一次

6.开始调用

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
  <list>
   <ref bean="cronTrigger" />
  list>
property>
<property name="taskExecutor" ref="executor" />
bean>

7.结束：启动容器即可，已经将spring和quartz结合完毕。

Cron常用的表达式
"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触发

三：quartz原理

根据上面spring的配置，我们就比较清楚quartz的内部情况，下面我们主要详解配置涉及到的每个点
1.我们先从最后一个步骤看起，SchedulerFactoryBean ，scheduler的工厂实现，里面可以生产出对应的多个jobDetail和trigger，每个jobDetail对应trigger代表一个任务
Quartz的SchedulerFactory是标准的工厂类，不太适合在Spring环境下使用。此外，为了保证Scheduler能够感知 Spring容器的生命周期，完成自动启动和关闭的操作，必须让Scheduler和Spring容器的生命周期相关联。以便在Spring容器启动后， Scheduler自动开始工作，而在Spring容器关闭前，自动关闭Scheduler。为此，Spring提供 SchedulerFactoryBean，这个FactoryBean大致拥有以下的功能：

1)以更具Bean风格的方式为Scheduler提供配置信息；

2)让Scheduler和Spring容器的生命周期建立关联，相生相息；

3)通过属性配置部分或全部代替Quartz自身的配置文件。

2.jobDetail,表示一个可执行的业务调用

3.trigger:调度的时间计划，什么时候，每隔多少时间可执行等时间计划

4.ThreadPoolTaskExecutor，线程池，用来并行执行每个对应的job，提高效率，这也是上面提到不推荐使用jdk自身timer的一个很重要的原因

陈睿 2012-07-03 14:42 发表评论

框架-spring

陈睿 — Wed, 29 Feb 2012 06:45:00 GMT

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

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

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

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

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

二：spring的整个生命周期
   首先说一下spring的整个初始化过程，web应用中创建spring容器有两种方式：
   第一种：在web.xml里直接配置spring容器，servletcontextlistener
   第二种：通过load-on-startup servlet实现。
   主要就说一下第一种方式：
   spring提供了ServletContextListener的实现类ContextLoaderListener,该类作为listener使用，在创建时自动查找WEB-INF目录下的applicationContext.xml,该文件是默认查找的，如果只有一个就不需要配置初始化xml参数，如果需要配置，设置contextConfigLocation为application的xml文件即可。可以好好阅读一下ContextLoaderListener的源代码，就可以很清楚的知道spring的整个加载过程。
   spring容器的初始化代码如下：
   /**

     * Initialize the root web application context.
     */
    public void contextInitialized(ServletContextEvent event) {
        this.contextLoader = createContextLoader();
        if (this.contextLoader == null) {
            this.contextLoader = this;
        }
        this.contextLoader.initWebApplicationContext(event.getServletContext());//contextLoader初始化web应用容器

    }

继续分析initWebApplicationContext做了什么事情：

    /**
     * Initialize Spring's web application context for the given servlet context,
     * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
     * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
     * @param servletContext current servlet context
     * @return the new WebApplicationContext
     * @see #CONTEXT_CLASS_PARAM
     * @see #CONFIG_LOCATION_PARAM
     */
    public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
   //首先创建一个spring的父容器，类似根节点root容器，而且只能是一个，如果已经创建，抛出对应的异常
        if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
            throw new IllegalStateException(
                    "Cannot initialize context because there is already a root application context present - " +
                    "check whether you have multiple ContextLoader* definitions in your web.xml!");
        }

        Log logger = LogFactory.getLog(ContextLoader.class);
        servletContext.log("Initializing Spring root WebApplicationContext");
        if (logger.isInfoEnabled()) {
            logger.info("Root WebApplicationContext: initialization started");
        }
        long startTime = System.currentTimeMillis();

        try {
            // Determine parent for root web application context, if any.
            ApplicationContext parent = loadParentContext(servletContext);//创建通过web.xml配置的父容器
具体里面的代码是怎么实现的，就不在这里进行详解了
// Store context in local instance variable, to guarantee that
            // it is available on ServletContext shutdown.
            this.context = createWebApplicationContext(servletContext, parent);//主要的创建过程都在改方法内，可以自己去看源代码
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
   //把spring初始好的容器加载到servletcontext内，相当于servletcontext包含webapplicationcontext
            ClassLoader ccl = Thread.currentThread().getContextClassLoader();
            if (ccl == ContextLoader.class.getClassLoader()) {
                currentContext = this.context;
            }
            else if (ccl != null) {
                currentContextPerThread.put(ccl, this.context);
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                        WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
            }
            if (logger.isInfoEnabled()) {
                long elapsedTime = System.currentTimeMillis() - startTime;
                logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
            }

            return this.context;
        }
        catch (RuntimeException ex) {
            logger.error("Context initialization failed", ex);
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
            throw ex;
        }
        catch (Error err) {
            logger.error("Context initialization failed", err);
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
            throw err;
        }
    }

   看到这里基本已经清楚了整个spring容器的加载过程，如果还想了解更加深入，请查看我红色标注的方法体。

   其次再说一下spring的IOC和AOP使用的场景，由于原理大家都很清楚了，那就说一下它们使用到的地方：

   IOC使用的场景：
   管理bean的依赖关系，目前主流的电子商务网站基本都采用spring管理业务层代码的依赖关系，包括:淘宝，支付宝，阿里巴巴，百度等公司。

陈睿 2012-02-29 14:45 发表评论

框架-struts2

陈睿 — Mon, 27 Feb 2012 09:07:00 GMT

一：struts2概要
   以WebWork优秀设计思想为核心，吸收了struts1的部分优点。

二：struts2详解
   主要就是详解struts2与struts1之间的区别，以及为什么要采用webwork重新设计新框架，以及吸收了struts1的哪部分优点。
   首先将区别：

最大的区别是与servlet成功解耦，不在依赖容器来初始化HttpServletRequest和HttpServletResponse

struts1里依赖的核心控制器为ActionServlet而struts2依赖ServletDispatcher,一个是servlet一个是filter,正是采用了filter才不至于和servlet耦合，所有的数据都是通过拦截器来实现，如下图显示：

web层表现层的丰富，struts2已经可以使用jsp、velocity、freemarker
线程模式方面：struts1的action是单例模式而且必须是线程安全或同步的，是struts2的action对每一个请求都产生一个新的实例，因此没有线程安全问题。
封装请求参数：是struts1采用ActionForm封装请求参数，都必须继承ActionForm基类，而struts2通过bean的属性封装，大大降低了耦合。
类型转换：struts1封装的ActionForm都是String类型，采用Commons- Beanutils进行类型转换，每个类一个转换器；struts2采用OGNL进行类型转换，支持基本数据类型和封装类型的自动转换。
数据校验：struts1在ActionForm中重写validate方法；struts2直接重写validate方法，直接在action里面重写即可，不需要继承任何基类，实际的调用顺序是，validate()-->execute()，会在执行execute之前调用validate,也支持xwork校验框架来校验。

   其次，讲一下为什么要采用webwork来重新设计struts2
   首先的从核心控制器谈起，struts2的FilterDispatcher，这里我们知道是一个filter而不是一个servlet,讲到这里很多人还不是很清楚web.xml里它们之间的联系，先简短讲一下它们的加载顺序，context-param(应用范围的初始化参数)-->listener(监听应用端的任何修改通知)-->filter(过滤)-->servlet。
   filter在执行servlet之间就以及调用了，所以才有可能解脱完全依赖servlet的局面，那我们来看看这个filter做了什么事情：
   /**

* Process an action or handle a request a static resource.
*

     * The filter tries to match the request to an action mapping.
     * If mapping is found, the action processes is delegated to the dispatcher's serviceAction method.
     * If action processing fails, doFilter will try to create an error page via the dispatcher.
     *

     * Otherwise, if the request is for a static resource,
     * the resource is copied directly to the response, with the appropriate caching headers set.
     *

     * If the request does not match an action mapping, or a static resource page,
     * then it passes through.
     *
     * @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)
     */
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
        ServletContext servletContext = getServletContext();

        String timerKey = "FilterDispatcher_doFilter: ";
        try {

            // FIXME: this should be refactored better to not duplicate work with the action invocation
            ValueStack stack = dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
            ActionContext ctx = new ActionContext(stack.getContext());
            ActionContext.setContext(ctx);

            UtilTimerStack.push(timerKey);
            request = prepareDispatcherAndWrapRequest(request, response);
            ActionMapping mapping;
            try {
                mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());
            } catch (Exception ex) {
                log.error("error getting ActionMapping", ex);
                dispatcher.sendError(request, response, servletContext, HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex);
                return;
            }

            if (mapping == null) {
                // there is no action in this request, should we look for a static resource?
                String resourcePath = RequestUtils.getServletPath(request);

                if ("".equals(resourcePath) && null != request.getPathInfo()) {
                    resourcePath = request.getPathInfo();
                }

                if (staticResourceLoader.canHandle(resourcePath)) {
                    staticResourceLoader.findStaticResource(resourcePath, request, response);
                } else {
                    // this is a normal request, let it pass through
                    chain.doFilter(request, response);
                }
                // The framework did its job here
                return;
            }

            dispatcher.serviceAction(request, response, servletContext, mapping);//过滤用户请求，拦截器执行，把对应的action请求转到业务action执行        }

finally {
            try {
                ActionContextCleanUp.cleanUp(req);
            } finally {
                UtilTimerStack.pop(timerKey);
            }
        }
    }
   对应的action参数由拦截器获取。
   解耦servlet是struts2采用webwork思路的最重要的一个原因，也迎合了整个技术的一个发展方向，解耦一直贯穿于整个框架。

陈睿 2012-02-27 17:07 发表评论