Tomcat源码学习（六）--Tomcat_7.0.70 生命周期管理

最新推荐文章于 2018-10-21 11:20:01 发布
最新推荐文章于 2018-10-21 11:20:01 发布
阅读量147 收藏
点赞数
文章标签： java python 操作系统
原文链接：https://my.oschina.net/zhengweishan/blog/713984
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

想必大家都知道，从server.xml文件解析出来的各个对象都是容器，比如：Server、Service、Connector等。这些容器都具有新建、初始化完成、启动、停止、失败、销毁等状态。Tomcat的实现机制是通过实现org.apache.catalina.Lifecycle接口来管理。

Tomcat--Lifecycle接口

定义了容器生命周期、容器状态转换及容器状态迁移事件的监听器注册和移除等主要接口。代码清单：

	public interface Lifecycle {

    public static final String BEFORE_INIT_EVENT = "before_init";

    public static final String AFTER_INIT_EVENT = "after_init";

    public static final String START_EVENT = "start";

    public static final String BEFORE_START_EVENT = "before_start";

    public static final String AFTER_START_EVENT = "after_start";

    public static final String STOP_EVENT = "stop";

    public static final String BEFORE_STOP_EVENT = "before_stop";

    public static final String AFTER_STOP_EVENT = "after_stop";

    public static final String AFTER_DESTROY_EVENT = "after_destroy";

    public static final String BEFORE_DESTROY_EVENT = "before_destroy";

    public static final String PERIODIC_EVENT = "periodic";

    public static final String CONFIGURE_START_EVENT = "configure_start";

    public static final String CONFIGURE_STOP_EVENT = "configure_stop";

    public void addLifecycleListener(LifecycleListener listener);

    public LifecycleListener[] findLifecycleListeners();

    public void removeLifecycleListener(LifecycleListener listener);

    public void init() throws LifecycleException;

    public void start() throws LifecycleException;

    public void stop() throws LifecycleException;

    public void destroy() throws LifecycleException;

    public LifecycleState getState();

    public String getStateName();

    public interface SingleUse {
    }
}

其中，最重要的方法时start和stop方法。父组件通过这两个方法来启动/关闭该组件。addLifecycleListener，findLifecycleListeners，removeLifecycleListener三个方法用于向组件注册/查找/删除监听器。当事件发生时，会触发监听器。接口中还定义了相关事件。

下面从一幅图来了解Tomcat涉及生命周期管理的主要类：

  • Lifecycle：定义了容器生命周期、容器状态转换及容器状态迁移事件的监听器注册和移除等主要接口；
  • LifecycleBase：作为Lifecycle接口的抽象实现类，运用抽象模板模式将所有容器的生命周期及状态转换衔接起来，此外还提供了生成LifecycleEvent事件的接口；
  • LifecycleSupport：提供有关LifecycleEvent事件的监听器注册、移除，并且使用经典的监听器模式，实现事件生成后触打监听器的实现；
  • MBeanRegistration：Java jmx框架提供的注册MBean的接口，引入此接口是为了便于使用JMX提供的管理功能；
  • LifecycleMBeanBase：Tomcat提供的对MBeanRegistration的抽象实现类，运用抽象模板模式将所有容器统一注册到JMX；

从上图可以看出ContainerBase、StandardServer、StandardService、WebappLoader、Connector、StandardContext、StandardEngine、StandardHost、StandardWrapper等容器都继承了LifecycleMBeanBase，因此这些容器都具有了同样的生命周期并可以通过JMX进行管理。

什么是JMX?

JMX（Java Management Extensions，即Java管理扩展）是一个为应用程序、设备、系统等植入管理功能的框架。JMX可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议，灵活的开发无缝集成的系统、网络和服务管理应用。

JMX体系结构分为以下四个层次：

设备层

设备层（Instrumentation Level）：主要定义了信息模型。在JMX中，各种管理对象以管理构件的形式存在，需要管理时，向MBean服务器进行注册。该层还定义了通知机制以及一些辅助元数据类。

代理层

代理层（Agent Level）：主要定义了各种服务以及通信模型。该层的核心是一个MBean服务器，所有的管理构件都需要向它注册，才能被管理。注册在MBean服务器上管理构件并不直接和远程应用程序进行通信，它们通过协议适配器和连接器进行通信。而协议适配器和连接器也以管理构件的形式向MBean服务器注册才能提供相应的服务。

分布服务层

分布服务层（Distributed Service Level）：主要定义了能对代理层进行操作的管理接口和构件，这样管理者就可以操作代理。然而，当前的JMX规范并没有给出这一层的具体规范。

附加管理协议API

定义的API主要用来支持当前已经存在的网络管理协议，如SNMP、TMN、CIM/WBEM等。

Tomcat--事件、监听

每个容器由于继承自LifecycleBase，当容器状态发生变化时，都会调用fireLifecycleEvent方法，生成LifecycleEvent，并且交由此容器的事件监听器处理。

LifecycleBase的fireLifecycleEvent方法的实现：

protected void fireLifecycleEvent(String type, Object data) {
    lifecycle.fireLifecycleEvent(type, data);
}


//lifecycle定义
private LifecycleSupport lifecycle = new LifecycleSupport(this);


//LifecycleSupport的fireLifecycleEvent方法的实现
  public void fireLifecycleEvent(String type, Object data) {
    LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
    LifecycleListener interested[] = listeners;
    for (int i = 0; i < interested.length; i++)
        interested[i].lifecycleEvent(event);

}

然后将事件通知给所有监听当前容器的生命周期监听器LifecycleListener，并调用LifecycleListener的lifecycleEvent方法。

那么监听器LifecycleListener是何时注册进来的？其实每个容器在新建、初始化、启动，销毁，被添加到父容器的过程中都会调用父类LifecycleBase的addLifecycleListener方法：

 public void addLifecycleListener(LifecycleListener listener) {
    lifecycle.addLifecycleListener(listener);
}

LifecycleBase的addLifecycleListener方法实际是对LifecycleSupport的addLifecycleListener方法的简单代理，LifecycleSupport的addLifecycleListener方法的实现：

public void addLifecycleListener(LifecycleListener listener) {

  synchronized (listenersLock) {
      LifecycleListener results[] =
        new LifecycleListener[listeners.length + 1];
      for (int i = 0; i < listeners.length; i++)
          results[i] = listeners[i];
      results[listeners.length] = listener;
      listeners = results;
  }

}

容器会最终调用每个对此容器感兴趣的LifecycleListener的lifecycleEvent方法，那么LifecycleListener的lifecycleEvent方法会做些什么呢？为了简单起见，我们以监听器JasperListener为例，JasperListener的lifecycleEvent方法的实现：

  public void lifecycleEvent(LifecycleEvent event) {

    if (Lifecycle.BEFORE_INIT_EVENT.equals(event.getType())) {
        try {
            // Set JSP factory
            Class.forName("org.apache.jasper.compiler.JspRuntimeContext",
                          true,
                          this.getClass().getClassLoader());
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            // Should not occur, obviously
            log.warn("Couldn't initialize Jasper", t);
        }
        // Another possibility is to do directly:
        // JspFactory.setDefaultFactory(new JspFactoryImpl());
    }

}

Tomcat--容器生命周期

StandardServer、StandardService、Connector、StandardContext这些容器，彼此之间都有父子关系，每个容器都可能包含零个或者多个子容器，这些子容器可能存在不同类型或者相同类型的多个。在一个容器创建成功后，会有以下状态：

  • NEW：容器刚刚创建时，即在LifecycleBase实例构造完成时的状态。

  • INITIALIZED：容器初始化完成时的状态。

  • STARTING_PREP：容器启动前的状态。

  • STARTING：容器启动过程中的状态。

  • STARTED：容器启动完成的状态。

  • STOPPING_PREP：容器停止前的状态。

  • STOPPING：容器停止过程中的状态。

  • STOPPED：容器停止完成的状态。

  • DESTROYED：容器销毁后的状态。

  • FAILED：容器启动、停止过程中出现异常的状态。

  • MUST_STOP：此状态未使用。

  • MUST_DESTROY：此状态未使用。

这些状态都定义在枚举类LifecycleState中。代码详单：

public enum LifecycleState {
    NEW(false, null),
    INITIALIZING(false, Lifecycle.BEFORE_INIT_EVENT),
    INITIALIZED(false, Lifecycle.AFTER_INIT_EVENT),
    STARTING_PREP(false, Lifecycle.BEFORE_START_EVENT),
    STARTING(true, Lifecycle.START_EVENT),
    STARTED(true, Lifecycle.AFTER_START_EVENT),
    STOPPING_PREP(true, Lifecycle.BEFORE_STOP_EVENT),
    STOPPING(false, Lifecycle.STOP_EVENT),
    STOPPED(false, Lifecycle.AFTER_STOP_EVENT),
    DESTROYING(false, Lifecycle.BEFORE_DESTROY_EVENT),
    DESTROYED(false, Lifecycle.AFTER_DESTROY_EVENT),
    FAILED(false, null),
    /**
     * @deprecated Unused. Will be removed in Tomcat 9.0.x. The state transition
     *             checking in {[@link](http://my.oschina.net/u/393) org.apache.catalina.util.LifecycleBase}
     *             makes it impossible to use this state. The intended behaviour
     *             can be obtained by setting the state to
     *             {[@link](http://my.oschina.net/u/393) LifecycleState#FAILED} in
     *             <code>LifecycleBase.startInternal()</code>
     */
    @Deprecated
    MUST_STOP(true, null),
    /**
     * @deprecated Unused. Will be removed in Tomcat 9.0.x. The state transition
     *             checking in {@link org.apache.catalina.util.LifecycleBase}
     *             makes it impossible to use this state. The intended behaviour
     *             can be obtained by implementing {@link Lifecycle.SingleUse}.
     */
    @Deprecated
    MUST_DESTROY(false, null);

    private final boolean available;
    private final String lifecycleEvent;

    private LifecycleState(boolean available, String lifecycleEvent) {
        this.available = available;
        this.lifecycleEvent = lifecycleEvent;
    }

    /**
     * May the public methods other than property getters/setters and lifecycle
     * methods be called for a component in this state? It returns
     * <code>true</code> for any component in any of the following states:
     * <ul>
     * <li>{@link #STARTING}</li>
     * <li>{@link #STARTED}</li>
     * <li>{@link #STOPPING_PREP}</li>
     * <li>{@link #MUST_STOP}</li>
     * </ul>
     */
    public boolean isAvailable() {
        return available;
    }

    /**
     *
     */
    public String getLifecycleEvent() {
        return lifecycleEvent;
    }
}

每个容器都会有自身的生命周期，其中也涉及状态的迁移，以及伴随的事件生成。所有容器的状态转换（如新建、初始化、启动、停止等）都是由外到内，由上到下进行，即先执行父容器的状态转换及相关操作，然后再执行子容器的转态转换，这个过程是层层迭代执行的。

Tomcat容器生命周期----新建

所有容器在构造的过程中，都会首先对父类LifecycleBase进行构造。LifecycleBase中定义了所有容器的起始状态为LifecycleState.NEW。

private volatile LifecycleState state = LifecycleState.NEW;

Tomcat容器生命周期----初始化

每个容器的init方法是自身初始化的入口，其初始化过程如图所示：

  1. 调用方调用容器父类LifecycleBase的init方法，LifecycleBase的init方法主要完成一些所有容器公共抽象出来的动作；

  2. LifecycleBase的init方法调用具体容器的initInternal方法实现，此initInternal方法用于对容器本身真正的初始化；

  3. 具体容器的initInternal方法调用父类LifecycleMBeanBase的initInternal方法实现，此initInternal方法用于将容器托管到JMX，便于运维管理；

  4. LifecycleMBeanBase的initInternal方法调用自身的register方法，将容器作为MBean注册到MBeanServer；

  5. 容器如果有子容器，会调用子容器的init方法；

  6. 容器初始化完毕，LifecycleBase会将容器的状态更改为初始化完毕，即LifecycleState.INITIALIZED。

    init方法的实现

     public final synchronized void init() throws LifecycleException {
 if (!state.equals(LifecycleState.NEW)) {
     invalidTransition(Lifecycle.BEFORE_INIT_EVENT);
 }
 setStateInternal(LifecycleState.INITIALIZING, null, false);

 try {
     initInternal();//调用具体容器的initInternal方法实现
 } catch (Throwable t) {
     ExceptionUtils.handleThrowable(t);
     setStateInternal(LifecycleState.FAILED, null, false);
     throw new LifecycleException(
             sm.getString("lifecycleBase.initFail",toString()), t);
 }

 setStateInternal(LifecycleState.INITIALIZED, null, false);
 }

只有当前容器的状态处于LifecycleState.NEW的才可以被初始化，真正执行初始化的方法是initInternal，当初始化完毕，当前容器的状态会被更改为LifecycleState.INITIALIZED。以StandardService这个容器为例举例分析，StandardService容器的initInternal方法实现：

  protected void initInternal() throws LifecycleException {

    super.initInternal();
    
    if (container != null) {
        container.init();
    }

    // Initialize any Executors
    for (Executor executor : findExecutors()) {
        if (executor instanceof LifecycleMBeanBase) {
            ((LifecycleMBeanBase) executor).setDomain(getDomain());
        }
        executor.init();
    }

    // Initialize our defined Connectors
    synchronized (connectorsLock) {
        for (Connector connector : connectors) {
            try {
                connector.init();
            } catch (Exception e) {
                String message = sm.getString(
                        "standardService.connector.initFailed", connector);
                log.error(message, e);

                if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE"))
                    throw new LifecycleException(message);
            }
        }
    }
}

其处理过程：

a、调用父类LifecycleBase的initInternal方法，为当前容器创建DynamicMBean，并注册到JMX中。

protected void initInternal() throws LifecycleException {
    
    // If oname is not null then registration has already happened via
    // preRegister().
    if (oname == null) {
        mserver = Registry.getRegistry(null, null).getMBeanServer();
        
        oname = register(this, getObjectNameKeyProperties());
    }
}

//getObjectNameKeyProperties()方法
public final String getObjectNameKeyProperties() {
    return "type=Service";
}

LifecycleBase的register方法会为当前容器创建对应的注册名称，以StandardService为例，getDomain默认返回Catalina，因此StandardService的JMX注册名称默认为Catalina:type=Service，真正的注册在registerComponent方法中实现。

//register方法
protected final ObjectName register(Object obj,
        String objectNameKeyProperties) {
    
    // Construct an object name with the right domain
    StringBuilder name = new StringBuilder(getDomain());
    name.append(':');
    name.append(objectNameKeyProperties);

    ObjectName on = null;

    try {
        on = new ObjectName(name.toString());
        
        Registry.getRegistry(null, null).registerComponent(obj, on, null);
    } catch (MalformedObjectNameException e) {
        log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),
                e);
    } catch (Exception e) {
        log.warn(sm.getString("lifecycleMBeanBase.registerFail", obj, name),
                e);
    }

    return on;
}

//registerComponent方法
public void registerComponent(Object bean, ObjectName oname, String type)
       throws Exception
{
    if( log.isDebugEnabled() ) {
        log.debug( "Managed= "+ oname);
    }

    if( bean ==null ) {
        log.error("Null component " + oname );
        return;
    }

    try {
        if( type==null ) {
            type=bean.getClass().getName();
        }

        ManagedBean managed = findManagedBean(bean.getClass(), type);

        // The real mbean is created and registered
        DynamicMBean mbean = managed.createMBean(bean);

        if(  getMBeanServer().isRegistered( oname )) {
            if( log.isDebugEnabled()) {
                log.debug("Unregistering existing component " + oname );
            }
            getMBeanServer().unregisterMBean( oname );
        }

        getMBeanServer().registerMBean( mbean, oname);
    } catch( Exception ex) {
        log.error("Error registering " + oname, ex );
        throw ex;
    }
}

Registry的registerComponent方法会为当前容器（如StandardService）创建DynamicMBean，并且注册到MBeanServer中。

b、将StringCache、MBeanFactory、globalNamingResources注册到JMX

其中StringCache的注册名为Catalina:type=StringCache，MBeanFactory的注册名为Catalina:type=MBeanFactory，globalNamingResources的注册名为Catalina:type=NamingResources（如StandardService则为：Catalina:type=Service）

c、初始化子容器

主要对Service子容器进行初始化，默认是StandardService。

注意：个别容器并不完全遵循以上的初始化过程，比如ProtocolHandler作为Connector的子容器，其初始化过程并不是由Connector的initInternal方法调用的，而是与启动过程一道被Connector的startInternal方法所调用。

Tomcat容器生命周期----容器启动

每个容器的start方法是自身启动的入口

  1. 调用方调用容器父类LifecycleBase的start方法，LifecycleBase的start方法主要完成一些所有容器公共抽象出来的动作；

  2. LifecycleBase的start方法先将容器状态改为LifecycleState.STARTING_PREP，然后调用具体容器的startInternal方法实现，此startInternal方法用于对容器本身真正的初始化；

  3. 具体容器的startInternal方法会将容器状态改为LifecycleState.STARTING，容器如果有子容器，会调用子容器的start方法启动子容器；

  4. 容器启动完毕，LifecycleBase会将容器的状态更改为启动完毕，即LifecycleState.STARTED。

     //LifecycleBase的start方法
 public final synchronized void start() throws LifecycleException {

     if (LifecycleState.STARTING_PREP.equals(state) || LifecycleState.STARTING.equals(state) ||
             LifecycleState.STARTED.equals(state)) {

         if (log.isDebugEnabled()) {
             Exception e = new LifecycleException();
             log.debug(sm.getString("lifecycleBase.alreadyStarted", toString()), e);
         } else if (log.isInfoEnabled()) {
             log.info(sm.getString("lifecycleBase.alreadyStarted", toString()));
         }

         return;
     }

     if (state.equals(LifecycleState.NEW)) {
         init();
     } else if (state.equals(LifecycleState.FAILED)) {
         stop();
     } else if (!state.equals(LifecycleState.INITIALIZED) &&
             !state.equals(LifecycleState.STOPPED)) {
         invalidTransition(Lifecycle.BEFORE_START_EVENT);
     }

     setStateInternal(LifecycleState.STARTING_PREP, null, false);

     try {
         startInternal();
     } catch (Throwable t) {
         // This is an 'uncontrolled' failure so put the component into the
         // FAILED state and throw an exception.
         ExceptionUtils.handleThrowable(t);
         setStateInternal(LifecycleState.FAILED, null, false);
         throw new LifecycleException(sm.getString("lifecycleBase.startFail", toString()), t);
     }

     if (state.equals(LifecycleState.FAILED)) {
         // This is a 'controlled' failure. The component put itself into the
         // FAILED state so call stop() to complete the clean-up.
         stop();
     } else if (!state.equals(LifecycleState.STARTING)) {
         // Shouldn't be necessary but acts as a check that sub-classes are
         // doing what they are supposed to.
         invalidTransition(Lifecycle.AFTER_START_EVENT);
     } else {
         setStateInternal(LifecycleState.STARTED, null, false);
     }
 }

在真正启动容器之前需要做2种检查：

如果当前容器已经处于启动过程（即容器状态为LifecycleState.STARTING_PREP、LifecycleState.STARTING、LifecycleState.STARTED）中，则会产生并且用日志记录LifecycleException异常并退出。 如果容器依然处于LifecycleState.NEW状态，则在启动之前，首先确保初始化完毕。

启动容器完毕后，需要做1种检查: 即如果容器启动异常导致容器进入LifecycleState.FAILED或者LifecycleState.MUST_STOP状态，则需要调用stop方法停止容器。

以StandardService为例，其startInternal的实现:

protected void startInternal() throws LifecycleException {

    if(log.isInfoEnabled())
        log.info(sm.getString("standardService.start.name", this.name));
    setState(LifecycleState.STARTING);//将自身状态更改为LifecycleState.STARTING；

    // Start our defined Container first
    if (container != null) {
        synchronized (container) {
            container.start();//调用子容器Service的start方法启动子容器。
        }
    }

    synchronized (executors) {
        for (Executor executor: executors) {
            executor.start();
        }
    }

    // Start our defined Connectors second
    synchronized (connectorsLock) {
        for (Connector connector: connectors) {
            try {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    connector.start();
                }
            } catch (Exception e) {
                log.error(sm.getString(
                        "standardService.connector.startFailed",
                        connector), e);
            }
        }
    }
}

除了初始化、启动外，各个容器还有停止和销毁的生命周期，其原理与初始化、启动类似。

总结

Tomcat通过将内部所有组件都抽象为容器，为容器提供统一的生命周期管理，各个子容器只需要关心各自的具体实现，这便于Tomcat以后扩展更多的容器。

转载于:https://my.oschina.net/zhengweishan/blog/713984

weixin_34128411
关注
tomcat9+tomcat-cluster-redis-session-manager_4.0.zip
07-16
"tomcat9+tomcat-cluster-redis-session-manager_4.0.zip"这个文件组合涉及到的是在Tomcat 9上实现负载均衡以及使用Redis作为Session管理器的高级配置。 首先，Tomcat 9是Apache Tomcat服务器的一个版本，它是Java ...
Could not initialize class org.apache.jasper.compiler.JspUtil
LawrenceUyi31的博客
09-06 1003
有效解决：Could not initialize class org.apache.jasper.compiler.JspUtil
Tomcat7启动分析（五）Lifecycle机制和实现原理
预流
08-06 425
在上篇文章分析Tomcat7的各组件的init、start方法时经常会看到有一个setStateInternal方法的调用，在查看LifecycleBase类及其它各组件的源码时会在多处看到这个方法的调用，这篇文章就来说说这方法，以及与这个方法相关的Tomcat的Lifecycle机制和实现原理。   上篇文章里谈到Tomcat7的各组件的父类LifecycleBase类，该类实现了接口o...
Tomcat源码学习（二）--Tomcat_7.0.70 启动分析
weixin_34008784的博客
07-01 157
2019独角兽企业重金招聘Python工程师标准>>> ...
Tomcat启动一半闪退问题解决
热门推荐
IT小白
07-22 3万+
最近刚刚接触Tomcat，对其还不是很了解。在这几天，遇到一个Tomcat启动闪退的问题，通过查阅各种资料，算是完美解决。在此分享给朋友们。         首先，确定你的问题在哪里。有两个方法，你可以通过日志去查询，也可以直接去一般处理程序中启动。         1.查询错误：win+R 输入cmd，进入一般处理程序。通过cd 找到你Tomcat的bin文件夹，在bin下面输入st
tomcat-connectors-1.2.40-windows-x86_64-httpd-2.4.x
10-31
标题中的"tomcat-connectors-1.2.40-windows-x86_64-httpd-2.4.x"指的是Tomcat服务器与Apache HTTPD服务器之间的连接器版本1.2.40，专为64位Windows系统设计，并且兼容HTTPD服务器的2.4.x版本。这个连接器，也被称为...
tomcat-7.0.76-16.el7_9.noarch.rpm
12-24
官方离线安装包，测试可用。使用rpm -ivh [rpm完整包名] 进行安装
eclipse-jee-mars-R-win32-x86_64位官方绿色版.zip
06-30
2. **Web和Java EE支持**：该版本强化了对Web和Java EE应用程序的支持，内建了诸如Tomcat、Jetty等服务器的集成，便于开发者部署和测试应用程序。同时，提供了用于创建、编辑和管理Java EE项目所需的工具。 3. **...
apache-tomcat-6.0.44.zip_O5QT_apache-tomcat-6_du_tomcat6
09-24
其中，"apache-tomcat-6.0.44"是解压后的目录，包含了服务器的核心文件，如bin、conf、lib、logs、temp、webapps和work等子目录。 - **bin** 目录：包含启动和停止Tomcat的脚本，如startup.sh或startup.bat（根据...
apache-tomcat-7.0.70
11-13
apache-tomcat-7.0.70
apache-tomcat-7.0.70.zip
11-21
apache-tomcat-7.0.70
tomcat7.0.70
07-19
tomcat7免安装版tomcat7免安装版tomcat7免安装版tomcat7免安装版tomcat7免安装版
jasper异常解决办法
海浪博客|技术|游戏|生活|随心
02-19 1585
NoClassDefFoundError: org/apache/commons/digester/Rule add    commons-digester.jar 自己用的是1.8版本的 NoClassDefFoundError: org/codehaus/groovy/control/CompilationFailedException add groovy-all.jar
java.lang.NoClassDefFoundError: Could not initialize class org.apache.jasper.el.ELContextImpl
面向学姐编程
10-21 9005
需要在家里把一个小web项目收尾，但家里的电脑没有intellij，需要在命令行手动编译，嫌在命令行输入classpath麻烦，所以直接把servlet-api.jar和jsp-api.jar放到了%JAVA_HOME%\jre\lib\ext文件夹，编译时倒是方便了一点点，但是运行有些JSP时一直报文章标题这个错误，真烦，搜了一下，StackOverflow上面有人说这可能是因为类冲突导致的，在...
Tomcat8–模板配置记录
tianjinsong的专栏
08-25 2578
http://71.oopspy.com/?p=2230 参考：http://tomcat.apache.org/tomcat-8.5-doc/config/http.html 连接器选择： cat catalina.sh #!/bin/sh JAVA_HOME="/opt/programs/jdk_1.8.0_111" CPU_N=`cat /proc/cpuin
${jrebel_args:jre1.8.0_192} -Dcatalina.base="D:\Software\tomcat\apache-tomcat-7.0.70_psmis_ws" -Dcatalina.home="D:\Software\tomcat\apache-tomcat-7.0.70_psmis_ws" -Dwtp.deploy="D:\Software\tomcat\apache-tomcat-7.0.70_psmis_ws\webapps" -Djava.library.path="D:\Program Files\Java\jre1.8.0_192\bin;D:\Software\tomcat\apache-tomcat-7.0.70_psmis_ws\bin"。解释
最新发布
06-03
2. `-Dcatalina.base="D:\Software\tomcat\apache-tomcat-7.0.70_psmis_ws"`：这是Tomcat的基础路径，表示Tomcat的配置信息和运行时数据存储在该路径下。 3. `-Dcatalina.home="D:\Software\tomcat\apache-tomcat-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值