j2ee标准-web.xml中load-on-startup源码解析

查看tomcat 7.0 源码:

/**
 * Load and initialize all servlets marked "load on startup" in the
 * web application deployment descriptor.
 *
 * @param children Array of wrappers for all currently defined
 *                 servlets (including those not declared load on startup)
 */
/**
 * StandardContext类,代表webapps目录下的一个web应用
 * 方法会被startInternal调用(),也就是应用在启动的时候
 * @param children
 * @return
 */
public boolean loadOnStartup(Container children[]) {

    // Collect "load on startup" servlets that need to be initialized
    //用TreeMap来排序 默认为natural order,也就是按ascii码
    TreeMap<Integer, ArrayList<Wrapper>> map =
            new TreeMap<Integer, ArrayList<Wrapper>>();
    for (int i = 0; i < children.length; i++) {
        Wrapper wrapper = (Wrapper) children[i];
        //每个Wrapper对应一个Servlet,负责创建、初始化、销毁servlet,并为其提供ServletConfig
        int loadOnStartup = wrapper.getLoadOnStartup();
        if (loadOnStartup < 0) //如果loadOnStartup的配置参数小于0,则不添加到TreeMap中
            continue;
        Integer key = Integer.valueOf(loadOnStartup);
        ArrayList<Wrapper> list = map.get(key);
        if (list == null) {
            list = new ArrayList<Wrapper>();
            map.put(key, list);
        }
        list.add(wrapper);
    }

    // Load the collected "load on startup" servlets
    //按loadOnStartup 的natural order即升序,依次对servlet进行初始化
    for (ArrayList<Wrapper> list : map.values()) {
        for (Wrapper wrapper : list) {
            try {
                //此方法包含对servlet的实例化和init方法的调用
                wrapper.load();
            } catch (ServletException e) {
                getLogger().error(sm.getString("standardContext.loadOnStartup.loadException",
                        getName(), wrapper.getName()), StandardWrapper.getRootCause(e));
                // NOTE: load errors (including a servlet that throws
                // UnavailableException from the init() method) are NOT
                // fatal to application startup
                // unless failCtxIfServletStartFails="true" is specified
                if (getComputedFailCtxIfServletStartFails()) {
                    return false;
                }
            }
        }
    }
    return true;

}

代码和清晰

总结:如果web.xml中的servlet没有配置 <load-on-startup> 标签或者其值小于0,那么在容器启动时不会对其初始化;否则按照数字升序排列串行对其初始化(这也证实了 正数的值越小,启动该servlet的优先级越高 这句话)。

来自:https://blog.csdn.net/joenqc/article/details/73497804


自己动手 单独测试了一下:

一、创建最新的dynamic web project
二、在WebContent目录中(即网站根目录),创建 index.jsp   如下:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>







<h3> helleo  word</h3>







</body>
</html>
三、编辑web.xml  文件 如下:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
  <display-name>webXml</display-name>
  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
  <servlet>
    <servlet-name>S1</servlet-name>
    <servlet-class>com.web.servlet.S1</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>S2</servlet-name>
    <servlet-class>com.web.servlet.S2</servlet-class>
    <load-on-startup>2</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>S3</servlet-name>
    <servlet-class>com.web.servlet.S3</servlet-class>
    <load-on-startup>-1</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>S4</servlet-name>
    <servlet-class>com.web.servlet.S4</servlet-class>
    <load-on-startup>4</load-on-startup>
  </servlet>
  <servlet>
    <servlet-name>S5</servlet-name>
    <servlet-class>com.web.servlet.S5</servlet-class>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>S1</servlet-name>
    <url-pattern>/s1</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>S2</servlet-name>
    <url-pattern>/s2</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>S3</servlet-name>
    <url-pattern>/s3</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>S4</servlet-name>
    <url-pattern>/s4</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>S5</servlet-name>
    <url-pattern>/s5</url-pattern>
  </servlet-mapping>
</web-app>
四、创建 servlet 文件:

在 com.web.servlet 下面创建 5个 差不多的 servlet (eclipse 右键新建 servlet 即可) ,仅在 url ,构造函数 上进行了修改
S1 代码:

package com.web.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class S1
 */
@WebServlet(name = "S001", urlPatterns = { "/001" })
public class S1 extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public S1() {
        super();
        System.out.println("S1:init ready");
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

同理 S2代码如下:

package com.web.servlet;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Servlet implementation class S1
 */
@WebServlet(name = "S002", urlPatterns = { "/002" })
public class S2 extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public S2() {
        super();
        System.out.println("S2:init ready");
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		doGet(request, response);
	}

}

其他servlet代码 类似

五、测试结果总结:

1、load on startup 大于等于 0,服务器启动时,会加载servlet ,并调用servlet的init方法。当以后 用 url 再访问 servlet时,servlet 不会再创建了,直接回把之前创建好的,直接拿过来用了。

@Override
public void init() throws ServletException {
	// TODO Auto-generated method stub
	super.init();
}

如果load on startup 值小于0,那么服务器启动时不会加载,直达 调用时才会 加载。加载完成后,以后调用时,就直接拿来用了,不会再创建第二遍了。

2、servlet 3.0 加入了注解功能,我上面写的S1。。。都用了注解。url 可以用/S1访问,也可以用 /001 访问。因为 同一个 servlet 配置时取了两个名字,两个路径。服务器 启动时,会当做两个 servlet 来处理,每种 url 访问都会创建一次。

java入门概述-MANIFEST.MF文件详解及编写规范

参考百度百科的解释如下:

http://baike.baidu.com/item/MANIFEST.MF

MANIFEST.MF:这个 manifest 文件定义了与扩展和包相关的数据。单词“manifest”的意思是“显示”

打开Java的JAR文件我们经常可以看到文件中包含着一个META-INF目录,这个目录下会有一些文件,其中必有一个MANIFEST.MF,这个文件描述了该Jar文件的很多信息,下面将详细介绍MANIFEST.MF文件的内容,先来看struts.jar中包含的MANIFEST.MF文件内容:

Manifest-Version: 1.0

Created-By: Apache Ant 1.5.1

Extension-Name: Struts Framework

Specification-Title: Struts Framework

Specification-Vendor: Apache Software Foundation

Specification-Version: 1.1

Implementation-Title: Struts Framework

Implementation-Vendor: Apache Software Foundation

Implementation-Vendor-Id: org.apache

Implementation-Version: 1.1

Class-Path: commons-beanutils.jar commons-collections.jar commons-digester.jar commons-logging.jar commons-validator.jar jakarta-oro.jar struts-legacy.jar

如果我们把MANIFEST中的配置信息进行分类,可以归纳出下面几个大类:

一. 一般属性

1. Manifest-Version

用来定义manifest文件的版本,例如:Manifest-Version: 1.0

2. Created-By

声明该文件的生成者,一般该属性是由jar命令行工具生成的,例如:Created-By: Apache Ant 1.5.1

3. Signature-Version

定义jar文件的签名版本

4. Class-Path

应用程序或者类装载器使用该值来构建内部的类搜索路径

二. 应用程序相关属性

1. Main-Class

定义jar文件的入口类,该类必须是一个可执行的类,一旦定义了该属性即可通过 java -jar x.jar来运行该jar文件。

三. 小程序(Applet)相关属性

1. Extendsion-List

该属性指定了小程序需要的扩展信息列表,列表中的每个名字对应以下的属性

2. <extension>-Extension-Name

3. <extension>-Specification-Version

4. <extension>-Implementation-Version

5. <extension>-Implementation-Vendor-Id

5. <extension>-Implementation-URL

四. 扩展标识属性

1. Extension-Name

该属性定义了jar文件的标识,例如Extension-Name: Struts Framework

五. 包扩展属性

1. Implementation-Title 定义了扩展实现的标题

2. Implementation-Version 定义扩展实现的版本

3. Implementation-Vendor 定义扩展实现的组织

4. Implementation-Vendor-Id 定义扩展实现的组织的标识

5. Implementation-URL : 定义该扩展包的下载地址(URL)

6. Specification-Title 定义扩展规范的标题

7. Specification-Version 定义扩展规范的版本

8. Specification-Vendor 声明了维护该规范的组织

9. Sealed 定义jar文件是否封存,值可以是true或者false (这点我还不是很理解)

六. 签名相关属性

签名方面的属性我们可以来参照JavaMail所提供的mail.jar中的一段

Name: javax/mail/Address.class

Digest-Algorithms: SHA MD5

SHA-Digest: AjR7RqnN//cdYGouxbd06mSVfI4=

MD5-Digest: ZnTIQ2aQAtSNIOWXI1pQpw==

这段内容定义类签名的类名、计算摘要的算法名以及对应的摘要内容(使用BASE64方法进行编码)

七.自定义属性

除了前面提到的一些属性外,你也可以在MANIFEST.MF中增加自己的属性以及响应的值,例如J2ME程序jar包中就可能包含着如下信息

MicroEdition-Configuration: CLDC-1.0

MIDlet-Name: J2ME_MOBBER Midlet Suite

MIDlet-Info-URL: http://www.javayou.com/

MIDlet-Icon: /icon.png

MIDlet-Vendor: Midlet Suite Vendor

MIDlet-1: mobber,/icon.png,mobber

MIDlet-Version: 1.0.0

MicroEdition-Profile: MIDP-1.0

MIDlet-Description: Communicator

关键在于我们怎么来读取这些信息呢?其实很简单,JDK给我们提供了用于处理这些信息的API,详细的信息请见java.util.jar包中,我们可以通过给JarFile传递一个jar文件的路径,然后调用JarFile的getManifest方法来获取Manifest信息。

备注:更详细的说明,参考oracle提供的文档:http://docs.oracle.com/javase/1.5.0/docs/guide/jar/jar.html(这个地址其实是有规律的,试下后面的版本号更新到特定的)

 

编写MANIFEST.MF文件时的注意事项:

说明:一般编写MANIFEST.MF文件只需要用到Manifest-Version(MF文件版本号)、Main-Class(包含main方法的类)、Class-Path(执行这个jar包时的ClassPath,第三方依赖)

比如以下的例子:

Manifest-Version: 1.0 
Main-Class: test.Main 
Class-Path: ./ ./lib/commons-collections-3.2.jar ./lib/commons-dbcp-1.2.2.jar ./lib/commons-lang-2.3.jar ./lib/commons-logging-1.1.jar 

以下是需要注意的各个要点:

0. 最后一样一定要回车,空一行,不然无法识别最后一行的配置。

1. Manifest-Version、Main-Class和Class-Path后面跟着一个英文的冒号,冒号后面必须跟着一个空格,然后才是版本号、类和ClassPath。

2. Class-Path中的各项应使用空格分隔,不是逗号或分号。

3. Class-Path中如果有很多项,写成一行打包的时候会报错line too long,这时需要把Class-Path分多行写。注意:从第二行开始,必须以两个空格开头,三个以上我没试过,不过不用空格开头和一个空格开头都是不行的,我已经试过了。

4. Class-Path写完之后最后一定要有一个空行

5. jar包内有些配置文件想放在jar包外面,比如文件config.properties:如果这个文件是以路径方式载入的,比如new file(“./config/config.properties”),那么将config.properties放在jar包相同目录下的config目录下即可,也就是说“./”路径等价于jar包所在目录;如果这个文件是以ClassPath下的文件这种方式载入的,比如在Spring中载入classpath:config.properties,则在MF文件的配置文件的ClassPath中添加“./”,然后将这个配置文件与jar包放在同一个目录即可,当然也可以在MF文件的配置文件的ClassPath中添加“./config/”,然后把配置文件都放在jar包相同目录下的config目录下。

参考:http://www.cnblogs.com/gaoguofeng/p/5646442.html

来自:https://www.cnblogs.com/EasonJim/p/6485677.html

java入门概述-META-INF文件夹的含义

在java web 开发 和 安卓开发中,我们在打包文件的时候,经常能看到 META-INF文件夹。里面也存放了一些文件,那这个到底是干什么的呢。我们来了解一下:

首先查看 java 官方api 文档:
https://docs.oracle.com/javase/7/docs/technotes/guides/jar/jar.html#The_META-INF_directory

参考连接:

https://stackoverflow.com/questions/70216/whats-the-purpose-of-meta-inf


The META-INF directory
The following files/directories in the META-INF directory are recognized and interpreted by the Java 2 Platform to configure applications, extensions, class loaders and services:

MANIFEST.MF
The manifest file that is used to define extension and package related data.

INDEX.LIST
This file is generated by the new “-i” option of the jar tool, which contains location information for packages defined in an application or extension. It is part of the JarIndex implementation and used by class loaders to speed up their class loading process.

x.SF
The signature file for the JAR file. ‘x’ stands for the base file name.

x.DSA
The signature block file associated with the signature file with the same base file name. This file stores the digital signature of the corresponding signature file.

services/
This directory stores all the service provider configuration files.


百度知道解释:

常常在网上看到有人询问:如何把 java 程序编译成 .exe 文件。通常回答只有两种,一种是制作一个可执行的 JAR 文件包,然后就可以像.chm 文档一样双击运行了;而另一种是使用 JET 来进行 编译。但是 JET 是要用钱买的,而且据说 JET 也不是能把所有的 Java 程序都编译成执行文件,性能也要打些折扣。所以,使用制作可执行 JAR 文件包的方法就是最佳选择了,何况它还能保持 Java 的跨平台特性。

下面就来看看什么是 JAR 文件包吧:

1. JAR 文件包

JAR 文件就是 Java Archive File,顾名思意,它的应用是与 Java 息息相关的,是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件——准确的说,它就是 ZIP 文件,所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中,包含了一个 META-INF/MANIFEST.MF 文件,这个文件是在生成 JAR 文件的时候自动创建的。举个例子,如果我们具有如下目录结构的一些文件:

==

`– test

`– Test.class

把它压缩成 ZIP 文件 test.zip,则这个 ZIP 文件的内部目录结构为:

test.zip

`– test

`– Test.class

如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar,则这个 JAR 文件的内部目录结构为:

test.jar

|– META-INF

| `– MANIFEST.MF

`– test

`–Test.class

2. 创建可执行的 JAR 文件包

制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。

Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放;运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数;运行时还要到控制台下去使用 java 命令来运行,如果需要直接双击运行必须写 Windows 的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此,许多人说,Java 是一种方便开发者苦了用户的程序设计语言。

其实不然,如果开发者能够制作一个可执行的 JAR 文件包交给用户,那么用户使用起来就方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候,安装文件会将 .jar 文件映射给 javaw.exe 打开。那么,对于一个可执行的 JAR 文件包,用户只需要双击它就可以运行程序了,和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么,现在的关键,就是如何来创建这个可执行的 JAR 文件包。

创建可执行的 JAR 文件包,需要使用带 cvfm 参数的 jar 命令,同样以上述 test 目录为例,命令如下:

jar cvfm test.jar manifest.mf test

这里 test.jar 和 manifest.mf 两个文件,分别是对应的参数 f 和 m,其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包,光靠指定一个 manifest.mf 文件是不够的,因为 MANIFEST 是 JAR 文件包的特征,可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST,其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下:

Main-Class: 可执行主类全名(包含包名)

例如,假设上例中的 Test.class 是属于 test 包的,而且是可执行的类 (定义了 public static void main(String[]) 方法),那么这个 manifest.mf 可以编辑如下:

Main-Class: test.Test <回车>;

这个 manifest.mf 可以放在任何位置,也可以是其它的文件名,只需要有 Main-Class: test.Test 一行,且该行以一个回车符结束即可。创建了 manifest.mf 文件之后,我们的目录结构变为:

==

|– test

| `– Test.class

`– manifest.mf

这时候,需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用“==”表示的那个目录中,使用如下命令:

jar cvfm test.jar manifest.mf test

之后在“==”目录中创建了 test.jar,这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。

需要注意的是,创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构,就像上例一样。而 Main-Class 指定的类,也必须是完整的、包含包路径的类名,如上例的 test.Test;而且在没有打成 JAR 文件包之前可以使用 java <类名>; 来运行这个类,即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。

3. jar 命令详解

jar 是随 JDK 安装的,在 JDK 安装目录下的 bin 目录中,Windows 下文件名为 jar.exe,Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做,因为 SUN 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。

使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下:

jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 …

其中 {ctxu} 是 jar 命令的子命令,每次 jar 命令只能包含 ctxu 中的一个,它们分别表示:

-c 创建新的 JAR 文件包

-t 列出 JAR 文件包的内容列表

-x 展开 JAR 文件包的指定文件或者所有文件

-u 更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中)

[vfm0M] 中的选项可以任选,也可以不选,它们是 jar 命令的选项参数

-v 生成详细报告并打印到标准输出

-f 指定 JAR 文件名,通常这个参数是必须的

-m 指定需要包含的 MANIFEST 清单文件

-0 只存储,不压缩,这样产生的 JAR 文件包会比不用该参数产生的体积大,但速度更快

-M 不产生所有项的清单(MANIFEST〕文件,此参数会忽略 -m 参数

[jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包,它是 -f 参数的附属参数

[manifest-文件] 即 MANIFEST 清单文件,它是 -m 参数的附属参数

[-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令,它只能在创建和更新 JAR 文件包的时候可用。

文件名 … 指定一个文件/目录列表,这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录,那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。

下面举一些例子来说明 jar 命令的用法:

1) jar cf test.jar test

该命令没有执行过程的显示,执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar,那么该文件将被覆盖。

2) jar cvf test.jar test

该命令与上例中的结果相同,但是由于 v 参数的作用,显示出了打包过程,如下:

标明清单(manifest)

增加:test/(读入= 0) (写出= 0)(存储了 0%)

增加:test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

3) jar cvfM test.jar test

该命令与 2) 结果类似,但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件,打包过程的信息也略有差别:

增加:test/(读入= 0) (写出= 0)(存储了 0%)

增加:test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

4) jar cvfm test.jar manifest.mf test

运行结果与 2) 相似,显示信息也相同,只是生成 JAR 包中的 META-INF/MANIFEST 内容不同,是包含了 manifest.mf 的内容

5) jar tf test.jar

在 test.jar 已经存在的情况下,可以查看 test.jar 中的内容,如对于 2) 和 3) 生成的 test.jar 分别应该此命令,结果如下;

对于 2)

META-INF/

META-INF/MANIFEST.MF

test/

test/Test.class

对于 3)

test/

test/Test.class

6) jar tvf test.jar

除显示 5) 中显示的内容外,还包括包内文件的详细信息,如:

0 Wed Jun 19 15:39:06 GMT 2002 META-INF/

86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF

0 Wed Jun 19 15:33:04 GMT 2002 test/

7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class

7) jar xf test.jar

解开 test.jar 到当前目录,不显示任何信息,对于 2) 生成的 test.jar,解开后的目录结构如下:

==

|– META-INF

| `– MANIFEST

`– test

`–Test.class

8) jar xvf test.jar

运行结果与 7) 相同,对于解压过程有详细信息显示,如:

创建:META-INF/

展开:META-INF/MANIFEST.MF

创建:test/

展开:test/Test.class

9) jar uf test.jar manifest.mf

在 test.jar 中添加了文件 manifest.mf,此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下,如果使用 -m 参数并指定 manifest.mf 文件,那么 manifest.mf 是作为清单文件 MANIFEST 来使用的,它的内容会被添加到 MANIFEST 中;但是,如果作为一般文件添加到 JAR 文件包中,它跟一般文件无异。

10) jar uvf test.jar manifest.mf

与 9) 结果相同,同时有详细信息显示,如:

增加:manifest.mf(读入= 17) (写出= 19)(压缩了 -11%)

4. 关于 JAR 文件包的一些技巧

1) 使用 unzip 来解压 JAR 文件

在介绍 JAR 文件的时候就已经说过了,JAR 文件实际上就是 ZIP 文件,所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件,如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观,方便。而使用 unzip,则是因为它解压时可以使用 -d 参数指定目标目录。

在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的,因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下,再进行解压,比较麻烦。如果使用 unzip,就不需要这么麻烦了,只需要指定一个 -d 参数即可。如:

unzip test.jar -d dest/

2) 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件

上面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件,所以,只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包,再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况,只需要将这个 MANIFEST 按需要修改即可。

3) 使用 jar 命令创建 ZIP 文件

有些 Linux 下提供了 unzip 命令,但没有 zip 命令,所以需要可以对 ZIP 文件进行解压,即不能创建 ZIP 文件。如要创建一个 ZIP 文件,使用带 -M 参数的 jar 命令即可,因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单,那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名,创建的就是一个不折不扣的 ZIP 文件了,如将上一节的第 3) 个例子略作改动:

jar cvfM test.zip test

j2ee标准-web.xml文件的含义

每个javaEE工程中都有web.xml文件,那么它的作用是什么呢?它是每个web.xml工程都必须的吗?

一个web中可以没有web.xml文件,也就是说,web.xml文件并不是web工程必须的。

web.xml文件是用来初始化配置信息:比如Welcome页面、servlet、servlet-mapping、filter、listener、启动加载级别等。

当你的web工程没用到这些时,你可以不用web.xml文件来配置你的Application。

每个xml文件都有定义它书写规则的Schema文件,也就是说javaEE的定义web.xml所对应的xml Schema文件中定义了多少种标签元素,web.xml中就可以出现它所定义的标签元素,也就具备哪些特定的功能。web.xml的模式文件是由Sun 公司定义的,每个web.xml文件的根元素为<web-app>中,必须标明这个web.xml使用的是哪个模式文件。如:
<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app version=”2.5″
xmlns=”http://java.sun.com/xml/ns/javaee”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”>
</web-app>

web.xml的模式文件中定义的标签并不是定死的,模式文件也是可以改变的,一般来说,随着web.mxl模式文件的版本升级,里面定义的功能会越来越复杂,标签元素的种类肯定也会越来越多,但有些不是很常用的,我们只需记住一些常用的并知道怎么配置就可以了。

下面列出web.xml我们常用的一些标签元素及其功能:

1、指定欢迎页面,例如:
<welcome-file-list>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index1.jsp</welcome-file>
</welcome-file-list>
PS:指定了2个欢迎页面,显示时按顺序从第一个找起,如果第一个存在,就显示第一个,后面的不起作用。如果第一个不存在,就找第二个,以此类推。

关于欢迎页面:

访问一个网站时,默认看到的第一个页面就叫欢迎页,一般情况下是由首页来充当欢迎页的。一般情况下,我们会在web.xml中指定欢迎页。但 web.xml并不是一个Web的必要文件,没有web.xml,网站仍然是可以正常工作的。只不过网站的功能复杂起来后,web.xml的确有非常大用处,所以,默认创建的动态web工程在WEB-INF文件夹下面都有一个web.xml文件。

2、命名与定制URL。我们可以为Servlet和JSP文件命名并定制URL,其中定制URL是依赖命名的,命名必须在定制URL前。下面拿serlet来举例:
(1)、为Servlet命名:
<servlet>
<servlet-name>servlet1</servlet-name>
<servlet-class>org.whatisjava.TestServlet</servlet-class>
</servlet>

(2)、为Servlet定制URL、
<servlet-mapping>
<servlet-name>servlet1</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>

3、定制初始化参数:可以定制servlet、JSP、Context的初始化参数,然后可以再servlet、JSP、Context中获取这些参数值。

下面用servlet来举例:
<servlet>
<servlet-name>servlet1</servlet-name>
<servlet-class>org.whatisjava.TestServlet</servlet-class>
<init-param>
<param-name>userName</param-name>
<param-value>Daniel</param-value>
</init-param>
<init-param>
<param-name>E-mail</param-name>
<param-value>[email protected]</param-value>
</init-param>
</servlet>
经过上面的配置,在servlet中能够调用getServletConfig().getInitParameter(“param1”)获得参数名对应的值。

4、指定错误处理页面,可以通过“异常类型”或“错误码”来指定错误处理页面。
<error-page>
<error-code>404</error-code>
<location>/error404.jsp</location>
</error-page>
—————————–
<error-page>
<exception-type>java.lang.Exception<exception-type>
<location>/exception.jsp<location>
</error-page>

5、设置过滤器:比如设置一个编码过滤器,过滤所有资源
<filter>
<filter-name>XXXCharaSetFilter</filter-name>
<filter-class>net.test.CharSetFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>XXXCharaSetFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

6、设置监听器:
<listener>
<listener-class>net.test.XXXLisenet</listener-class>
</listener>

7、设置会话(Session)过期时间,其中时间以分钟为单位,假如设置60分钟超时:
<session-config>
<session-timeout>60</session-timeout>
</session-config>

除了这些标签元素之外,还可以往web.xml中添加很多标签元素,由于不常用省略。

来自:https://www.cnblogs.com/yqskj/articles/2233061.html

j2ee标准-web-inf文件夹的意义

写这篇文章的原因是看到了Tomcat下面的Webapps下面的,就想看一下。

总结一下这篇文章的内容:

WEB-INF下面的内容都是只能由服务器级别才能访问,客户端并不能访问。什么是客户端级别?什么是服务器级别呢?

转发就是服务器级别,浏览器的地址不会变,因为,客户端发送一个请求,服务器受理之后,发现要请求内容还要再去别的请求,那么转发就是服务器自己去处理完成。不麻烦客户端(浏览器)了,所以客户端上面的地址栏不会改变。

重定向:就是客户端级别的。服务器收到请求后,发现还要去请求别的内容,但是服务器自己不想处理,那么就告诉客户端,你自己去处理吧,那么客户端就去请求那个别的内容了。所以客户端(浏览器)地址栏就会改变了。


在web项目中,为了安全,可能需要把jsp文件放在WEB-INF目录下,这样如果我们的页面中出现超链接a标签或者js的location.href去直接转向到WEB-INF下的某一个jsp页面,那么就会引用不到,因为这样的请求方式是客户端的请求,而WEB-INF页面只对服务端开放,对客户端是不可见的。这时候我们可以使用action,来进行转向,我们先去请求一个action,然后由这个action分发到这个WEB-INF下的页面就可以了。我们可以自己定义一个类似struts1的DispatcherAction的一个action来分发页面。

由于WEB-INF下对客户端是不可见的,所以相关的资源文件,如css,javascript和图片等资源文件不能放在WEB-INF下,那么如何从WEB-INF下引用非WEB-INF下的文件,以及js,html的frame的框架如何去访问WEB-INF下的jsp呢?

下面对WEB-INF目录的一些问题进行详细说明:

以一个项目为例:

如下这样一个代码目录:我们把除index.jsp外其他的jsp文件放在WEB-INF下,把css,javascript,图片放在了webRoot(WebContent)目录下,然后main.jsp是一个frame的html框架,包含了main1.jsp和main2.jsp两个文件。

1、index.jsp页面访问css,js,图片等文件的时候,自然不用说,因为它不在WEB-INF下,正常的访问即可:

<link href="css/login_css.css" rel="stylesheet" type="text/css">

<script type="text/javascript" src="js/login_js.js"></script>

<img alt="" src="image/1.jpg">

2、register.jsp页面去访问css,js和图片的时候,也是不需要添加WEB-INF目录的,也就是忽略WEB-INF目录,访问的时候和index.jsp页面所在的路径访问资源文件是一样的:

<link href="css/register_css.css" rel="stylesheet" type="text/css">

<script type="text/javascript" src="js/register_js.js"></script>

<img alt="" src="image/2.jpg">

3、register.jsp页面去转向index.jsp页面,即注册页面有一个链接,转向到登录界面,由于index.jsp页面没有在WEB-INF下,所以可以直接访问index.jsp页面的路径,

 register.jsp:

<tr>

    <td></td>

    <td colspan="2" style="float: left; ">

        <button type="button" >注册</button>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

        <button type="button"  onclick="goLogin()">去登录</button>

    </td>

</tr>

在register.jsp页面中定义了一个botton,然后响应一个onclick事件,

我们在register_js.js中定义这个goRegister ()的js事件:

regitster_js.js:

function goLogin(){

    location.href="index.jsp";

}

这样就可以访问到WebContent目录中的index.jsp页面了。

 

4、index.jsp(登录页面)有一个链接,指向register页面,如果点击链接,就跳转到register.jsp中进行注册,因为register.jsp在WEB-INF下,所以不可以直接使用a标签去访问WEB-INF路径下的文件:

<a href="WEB-INF/register/register.jsp">去注册</a>

或者js的location.href去访问:

function goRegister(){  

    location.href="WEB-INF/register/register.jsp";

}

这样两种方式都是直接请求了WEB-INF路径,都是无法跳转的。

我们可以建立一个action,struts的action中没有DispatcherAction,但是我们可以通过通配符来让一个action的不同方法返回不同的页面,然后我们去请求这个action中的相应方法即可由这个action从服务器端请求到WEB-INF下的页面了:

下面详细说明如果进行自定义的分发action来进行页面的分发:

DispatcherAction.java:

package com.yun.test.webinf.action;

import com.opensymphony.xwork2.ActionSupport;
publicclass DispatcherAction extends ActionSupport{
    public String goRegister(){

        return"goRegister";

    }
}

这个action中,我们定义了一个goRegister的方法,这个方法没有任何逻辑代码,只是返回一个字符串,然后在struts.xml中我们让这个字符串指向我们要访问的WEB-INF下的register.jsp页面:

struts.xml:

<action name ="dispatcher" class="com.yun.test.webinf.action.DispatcherAction" >

    <result name ="goRegister">WEB-INF/register/register.jsp</result >

    <result name ="input">/index.jsp</result >

</action >

然后我们可以在页面中进行请求DispatcherAction的goRegister方法,然后这个action的goRegister方法就会把页面转向到WEB-INF下的register.jsp页面了:

我们在index.jsp中定义了一个botton,然后给这个botton注册一个点击事件:

index.jsp:

<tr>

    <td></td>

    <td colspan="2" style="float: left; ">

        <button onclick="checkValues()">登录</button>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

        <button type="button" id="button1" onclick="goRegister()">去注册</button>

    </td>

</tr>

在index_js.js中定义这个点击事件为location.href到定义的action的goRegister.action方法中:

login_js.js:

function goRegister(){

    location.href="dispatcher!goRegister.action";

}

当然,也可以直接在页面中使用a标签来请求这个action的goRegister方法:

    <a href="dispatcher!goRegister.action">去注册</a>

这样我们就可以通过action的转发,成功的请求道WEB-INF下的jsp文件了。

注意请求action的方式,dispatcher!goRegister.action  这个!是一个分发字符,!之前的部分是action的名字,!之后的部分是这个action的某个我们要请求的方法的名字。然后这个action中必须要定义一个同名的方法,就不需要使用execute方法了。然后这个同名方法,返回的是一个String字符串,这个字符串在struts.xml中指向为我们想要跳转的路径。这就是一个请求分发的action。

我们还可以自己定义分发的分隔符,可以是下划线等,分发action详见Struts2实现分发的action一节

5、jsp页面中的frame框架中想把多个WEB-INF下的页面设置为框架的内容的时候,即使main.jsp和main1.jsp,main2.jsp同在WEB-INF目录下,也不可以直接去指定WEB-INF路径,如:

<frameset cols="30%,70%">

    <frame src="main/main1.jsp">

    <frame src="main/main1.jsp">

</frameset>

这样还是不能访问,也必须使用服务端的action分发的方式进行指定jsp文件的路径。

代码如下:

main.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>main</title>
</head>
<frameset cols="30%,70%">

    <frame src="dispatcher!goMain1.action">

    <frame src="dispatcher!goMain2.action">

</frameset>
</html>

struts.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC

    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

    "http://struts.apache.org/dtds/struts-2.0.dtd">

    

<struts >

    <package name ="test" extends ="struts-default" >

        <action name ="dispatcher" class ="com.yun.test.webinf.action.DispatcherAction" >

            <result name ="goRegister">WEB-INF/register/register.jsp</result >

            <result name ="goMain1">WEB-INF/main/main1.jsp</result >

            <result name ="goMain2">WEB-INF/main/main2.jsp</result >

            <result name ="input">/index.jsp</result >

        </action >

        <action name ="login" class ="com.yun.test.webinf.action.LoginAction" >

            <result name ="success">WEB-INF/main.jsp</result >

            <result name ="input">/index.jsp</result >

        </action >

        <action name ="register" class ="com.yun.test.webinf.action.RegisterAction" >

            <result name ="success">WEB-INF/main.jsp</result >

            <result name ="input">WEB-INF/register/register.jsp</result >

        </action >
  </package>
<!-- 定义struts标签为无默认样式 -->

    <constant name="struts.ui.theme" value="simple" />

</struts>

DispatcherAction.java:

package com.yun.test.webinf.action;

import com.opensymphony.xwork2.ActionSupport;

publicclass DispatcherAction extends ActionSupport{
    public String goRegister(){
        return"goRegister";

    }

    public String goMain1(){
        return"goMain1";
    }

    public String goMain2(){

        return"goMain2";

    }
}

这样,这个main页面就可以通过action分发使用frame框架了。

 

6、同在WEB-INF目录下的register.jsp和main.jsp中怎么跳转呢?我们会在register.jsp中提交表单,然后在action中进行处理,如果注册成功,会跳转到main页面,这时的跳转也会涉及到WEB-INF目录,因为目标路径main.jsp也在WEB-INF下,所以我们在跳转的时候也必须写上WEB-INF的目录路径才可以,而且必须是请求分发,而不能是redirct的方式。

如代码:

register.jsp:

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>register</title>

<link href="css/register_css.css" rel="stylesheet" type="text/css">

<script type="text/javascript" src="js/register_js.js"></script>

</head>

<body>
    <div id="content" >

    <form action="register.action" id="registerForm"  method="post">
        <table>

            <tr>

                <td width="150px;" style="text-align:center; ">注册名</td>

                <td width="80px;" style="text-align: left;"><input type="text" name="user.username"  id="username" ></td>

                <td width="400px;" style="text-align: left;"><font color="red">* 请输入用户名</font></td>

            </tr>

            <tr>

                <td width="100px;" style="text-align:center; ">注册密码</td>

                <td width="80px;" style="text-align: left;"><input type="password" name="user.password" size="22" id="password"></td>

                <td width="400px;" style="text-align: left;"><font color="red">* 请输入密码</font></td>

            </tr>

            <tr>

                <td></td>

                <td colspan="2" style="float: left; ">

                    <button type="button"  onclick="checkValues()">注册</button>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;

                    <button type="button"  onclick="goLogin()">去登录</button>

                </td>

            </tr>

        </table>

 

     </form>

    </div>

    <img alt="" src="image/2.jpg">

</body>

</html>

struts.xml:

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC

    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts >

    <package name ="test" extends ="struts-default" >

        <action name ="dispatcher" class ="com.yun.test.webinf.action.DispatcherAction" >

            <result name ="goRegister">WEB-INF/register/register.jsp</result >

            <result name ="goMain1">WEB-INF/main/main1.jsp</result >

            <result name ="goMain2">WEB-INF/main/main2.jsp</result >

            <result name ="input">/index.jsp</result >

        </action >

        <action name ="login" class ="com.yun.test.webinf.action.LoginAction" >

            <result name ="success">WEB-INF/main.jsp</result >

            <result name ="input">/index.jsp</result >

        </action >

        <action name ="register" class ="com.yun.test.webinf.action.RegisterAction" >

            <result name ="success">WEB-INF/main.jsp</result >

           <result name ="input">WEB-INF/register/register.jsp</result >

        </action >

 

    </package>

 

    <!-- 定义struts标签为无默认样式 -->

    <constant name="struts.ui.theme" value="simple" />

</struts>

RegisterAction.java:

package com.yun.test.webinf.action;

import com.opensymphony.xwork2.ActionSupport;

import com.yun.test.webinf.entity.User;
public class RegisterAction extends ActionSupport{
         private User user;
         public void setUser(User user) {
                   this.user = user;

         }

         public User getUser() {
                   return user;

         }

         @Override

         public String execute() throws Exception {

                   if("lisi".equals(user.getUsername())&&"lisi".equals(user.getPassword())){

                            return SUCCESS;

                   }

                   return INPUT;

         }

         

}

 

接下来对WEB-INF页面中的注意事项进行说明:

1、把页面资源文件只能放在WebContent目录内,,如CSS,JS,image等.不能放在WEB-INF下,因为WEB-INF是对客户端隐藏的,所以放在WEB-INF下会造成页面的布局等文件引用不到的情况。
2、页面文件一般放在WEB-INF目录下面,这样可以限制访问,提高安全性.如JSP,html文件,放在WEB-INF目录下就可以避免客户端直接在地址栏上输入路径进行访问了。基于不同的功能,把JSP 放置在WEB-INF下的不同的目录中。
3、只能用转向方式来访问WEB-INF目录下的JSP,不用采用重定向的方式请求该目录里面的任何资源。
4、转向方式:

4.1、请求转发:

如struts.xml文件中配置

<result name ="goMain2">WEB-INF/main/main2.jsp</result >

或在Action中写

request.getRequestDispatcher(“/WEB-INF/main/main2.jsp”).forward(request, response);

的方式都是服务器读取了该页面内容,并发送到客户端的,客户端的地址不变,然后内容跳转了。这样的方式是可以访问到WEB-INF目录下的jsp文件的。

4.2、重定向方式:

如struts.xml文件中配置

<result name ="goMain2" type="redirect">WEB-INF/main/main2.jsp</result >

 或在action中

response.sendRedirect(“WEB-INF/main/main2.jsp “);

都属于重定向的方式,重定向的含义就是服务器把地址发给客户端,让客户端去访问,这样还是在客户端访问的WEB-INF目录,所以是无法访问到WEB-INF目录下的jsp文件的。

5、有一些标签,也是可以访问到WEB-INF目录中的文件的,如果符合要求的情况下也可以使用,如:

<jsp:forward page = "/WEB-INF/jsp/test/test.jsp" />

<a href="javascript:<jsp:forward page='WEB-INF/xxxx.jsp'/>"></a>

<jsp:include page="WEB-INF/xxx.jsp">

都是可以访问WEB-INF下的jsp文件的。但是局限性很大,还是建议使用action分发的方式。

来自:https://www.cnblogs.com/shenxiaoquan/p/5819359.html

j2ee标准-j2ee简介

人们平常说的Java一般指JavaSE,也就是Java Standard Edition,Java的标准版,一般用来开发桌面应用程序,但是在开发桌面应用程序上相对VB,Delphi,VC++并没有什么优势。

而JavaWeb则到了JavaEE(J2EE)领域了,也就是Java Enterprise Edition,Java的企业版,看那个web就应该想到是与Internet有关的,其实开发JavaWeb应用程序,初级的一般是用JSP(Java Server Pages)+servlet+Javabean来开发的,对大型的网站一般是使用框架来开发的,例如struts,hibernate,spring,例如校内,你在登陆的时候会在地址栏看见Login.do,登陆以后会看见Home.do这样的请求,典型的struts框架结构。

J2EE核心是一组技术规范与指南,其中所包含的各类组件、服务架构及技术层次,均有共同的标准及规格,让各种依循J2EE架构的不同平台之间,存在良好的兼容性,解决过去企业后端使用的信息产品彼此之间无法兼容,企业内部或外部难以互通的窘境。

Java还有一个版本是JavaME,Java Micro Edition,Java的微型版,诺基亚手机上运行的Java程序就是指用这个版本开发的程序。

 

 

springmvc基础-配置开发环境

一、从官网下载  spring  jar包

http://repo.spring.io/release/org/springframework/

楼主选的是spring 4 版本,开发要用到的 基本jar包如下:

-javadoc 其实里面就是 html,用于介绍 api 的说明文档
-sources 里面是源代码,用于查看 框架的 设计和实现

二、 eclipse 新建 dynamic web 项目

记得勾选自动生成 web.xml文件啊。。。

三、编辑web.xml文件,创建springmvc文件

先了解一下web.xml文件

web.xml文件进行配置:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
	
	<!-- 配置 DispatcherServlet -->
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<!-- 配置 DispatcherServlet 的一个初始化参数: 配置 SpringMVC 配置文件的位置和名称 -->
		<!-- 
			实际上也可以不通过 contextConfigLocation 来配置 SpringMVC 的配置文件, 而使用默认的.
			默认的配置文件为: /WEB-INF/<servlet-name>-servlet.xml
		-->
		<!--  
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		-->
		<load-on-startup>1</load-on-startup>
        <!-- load on starup 大于、等于0代表随系统启动后加载 ,数字越小优先级越高 ; 数值为负数时,启动时不加载,调用时再加载 -->
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
     <!-- 
              第一种:*.action 或者 *.do,访问以.action或*.do结尾 由DispatcherServlet进行解析
              第二种:/,所以访问的地址都由DispatcherServlet进行解析,对于静态文件的解析需要配置不让DispatcherServlet进行解析
              使用此种方式可以实现 RESTful风格的url
              第三种:/*,这样配置不对,使用这种配置,最终要转发到一个jsp页面时,
              仍然会由DispatcherServlet解析jsp地址,不能根据jsp页面找到handler,会报错。
       -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

<!-- 下面这个没有写不要紧,因为tomcat服务器默认 index为首页 --> 
<welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>

</web-app>

可以参考一下:
j2ee标准-web.xml中load-on-startup源码解析

四、编辑 spring mvc 配置文件

根据 web.xml 中 已经配置好的 org.springframework.web.servlet.DispatcherServlet 的类,加载这个类时需要 转发配置文件。

转发配置文件–>【前面web.xml配置的是在src下, 取名springmvc.xml文件。如果是默认配置应该在WEB-INF下即和web.xml同目录,取名dispatcherServlet-servlet.xml文件】,其中 配置自定扫描的包 ,是为了扫描指定包文件中,有@Controller ,@Component等注解的类文件。

转发配置文件 的基本配置 如下:

<?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:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 对于注解的Handler可以单个配置 实际开发中建议使用组件扫描 -->
    <!-- <bean class="com.test.springmvc.handlers.HelloWorld" />  -->
    <!-- 可以扫描controller、service、...这里让扫描controller,指定controller的包,但是view的包下面的注解类就扫描不到了,
    所以 com.test.springmvc.handlers 改成 com.test.springmvc就行啦,子目录都能扫描得到  -->
	<!--下面是 配置扫描  指定目录包 中的 java文件 -->
	<context:component-scan base-package="com.test.springmvc"></context:component-scan>
    
	<!-- 配置视图解析器【多个函数可选择】: 此解析器默认生成InternalResourceView,如果项目添加了jstl.jar包的话就会自动改为生成JstlView; 即如何把 handler 方法返回值解析为实际的物理视图,handler的返回值也可以具体是 /WEB-INF/XXXX/XXX.jsp,这样下面的试图解析器就不需要添加前缀和后缀了 -->
	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
	
</beans>

1、自定义扫描目录范围表示 扫描指定文件,查看是否 存在 注解。
2、springmvc 配置文件的 视图解析器,告诉了 控制器 返回结果时,应该将页面跳转到 哪里。比如 控制器【第五节介绍】 返回结果 success ,那么跳转页面 应该到 /WEB-INF/views/success.jsp 文件中

四、配置 控制器

在包名 com.test.springmvc.handlers 下
创建 HelloWorld.java

[java]
package com.test.springmvc.handlers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller // spring里面 又名handler 处理器
public class HelloWorld {

/**
* 1、使用RequestMapping 注解来映射 请求的url
* 2、返回值会通过视图解析器解析为实际的物理视图,
* 对于org.springframework.web.servlet.view.InternalResourceViewResolver
* 会做如下解析,prefix + returnVal + suffix 得到实际的物理视图。然后做转发操作。
* 即 WEB-INF/views/success.jsp
*/
@RequestMapping("/helloworld")
public String hello(){
System.out.println("hello world");
return "success";
}

}

[/java]

上面的请求路径为:projectname/helloworld
也可以在类上面多加一个 @RequestMapping 注解,比如 xxx
那么请求路径为 projectname/xxx/helloworld

五、配置 返回结果 页

/WEB-INF/views/success.jsp 编辑如下:

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>


<h4> Success page </h4>


</body>
</html>
六、启动服务器,输入地址

在配置控制器时,已经 在类HelloWorld 使用了@RequestMapping(“/helloworld”)注解
所以 浏览器 直接输入 ” http://localhost:端口号/工程名/helloworld” 就能看到结果啦

七、补充:配置注解映射器和注解适配器

在配置转发器中,需要添加的注解映射器和注解适配器:
在spring3.1之前使用org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping注解映射器。

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping注解映射器。

在spring3.1之前使用org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter注解适配器。

在spring3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter注解适配器。

下面是在 配置转发器【即前面提到的dispatcherServlet-servlet.xml】 中,进行编辑的内容:

<!-- 注解映射器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <!-- 注解的适配器 -->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
    <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置
        mvc:annotation-driven默认加载很多的参数绑定方法,
        比如json转换解析器就默认加载了,如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
        实际开发时使用mvc:annotation-driven
     -->
    <!-- <mvc:annotation-driven></mvc:annotation-driven> -->

在实际使用时,不配置注解映射器和注解适配器,也能正常运行。因为MVC有默认配置在核心中的/org/springframework/web/servlet/DispatcherServlet.properties中,有兴趣的同学可以自行查看。

八、非注解方式配置方法

参考springmvc基础-注解方式编程和非注解方式编程

九、国际化配置方法

1、新建i18n文件,存放于src文件夹下面:

i18n.username=Username
i18n.password=Password
i18n.username=\u7528\u6237\u540D
i18n.password=\u5BC6\u7801
i18n.username=Username
i18n.password=Password

2、在转发配置文件中添加:

<!-- 配置国际化资源文件 -->
<bean id="messageSource"
	class="org.springframework.context.support.ResourceBundleMessageSource">
	<property name="basename" value="i18n"></property>	
</bean>

3、在请求页面jsp中:添加

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<body>
	<fmt:message key="i18n.username" ></fmt:message>
	<fmt:message key="i18n.password" ></fmt:message>
</body>

国际化问题特别注意点:<fmt:message>标签只能出现在转发页面中,不能出现在请求页面中【请求页面我测试了一下,出现乱码】原因是在转发配置页中,指定了国际化配置文件啊,必须在转发过程中才会生效啊 !!!

十、配置无控制器直接转发

一般情况下,请求页需要由控制器处理后,才能转发到目标页面。但是也可以编辑转发配置文件,实现不经过控制器而直接转发到目标页面。【本质上就是在这里配置了一个默认控制器,path代表控制器的@RequestMaping  ,view-name代表 控制器的返回值】

<!-- 配置直接转发的页面 -->
	<!-- 可以直接相应转发的页面, 而无需再经过 Handler 的方法.  -->
	<mvc:view-controller path="/success" view-name="success"/>

但是上面的配置会造成,那些所有需要经过控制器转发的url请求,全部失效无法访问。为了解决这个问题,需要在转发配置页  继续配置如下:

<mvc:annotation-driven></mvc:annotation-driven>

十一、请求静态资源问题

因为前面测试过了,如果请求路径是xxx.jsp是可以直接显示的。如果是XXX,就会交由handler处理。

为了能够在网页中,加载js和css,请求静态资源,所以需要  编辑   转发配置器。

 <!--  
		default-servlet-handler 将在 SpringMVC 上下文中定义一个 DefaultServletHttpRequestHandler,
		它会对进入 DispatcherServlet 的请求进行筛查, 如果发现是没有经过映射的请求, 就将该请求交由 WEB 应用服务器默认的 
		Servlet 处理. 如果不是静态资源的请求,才由 DispatcherServlet 继续处理

		一般 WEB 应用服务器默认的 Servlet 的名称都是 default.
		若所使用的 WEB 服务器的默认 Servlet 名称不是 default,则需要通过 default-servlet-name 属性显式指定
		
	-->
	<mvc:default-servlet-handler/>
	<!-- 前面的 mvc:default-servlet-handler 可以解决静态资源了,但是让其他经过handler的请求,又失效了,所以配置了下面的 mvc:annotation-driven 来解决问题 -->
	<mvc:annotation-driven></mvc:annotation-driven>	
	

出现过的问题小结:之前在项目中添加了entity文件,里面有@NotEmpty注解等。这些注解用到了校验jar包,比如 hibernate-validator-5.0.0.CR2.jar

在没有添加这句话  <mvc:annotation-driven></mvc:annotation-driven> 前,一直没有报错,后来加了这句话后报错了。

Caused by: java.lang.NoClassDefFoundError: org/jboss/logging/BasicLogger
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at org.apache.catalina.loader.WebappClassLoaderBase.findClassInternal(WebappClassLoaderBase.java:2541)
	at org.apache.catalina.loader.WebappClassLoaderBase.findClass(WebappClassLoaderBase.java:858)
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1301)
	at org.apache.catalina.loader.WebappClassLoaderBase.loadClass(WebappClassLoaderBase.java:1166)
	at org.hibernate.validator.internal.util.logging.LoggerFactory.make(LoggerFactory.java:29)
	at org.hibernate.validator.internal.util.Version.<clinit>(Version.java:27)
	at org.hibernate.validator.internal.engine.ConfigurationImpl.<clinit>(ConfigurationImpl.java:65)
	at org.hibernate.validator.HibernateValidator.createGenericConfiguration(HibernateValidator.java:41)
	at javax.validation.Validation$GenericBootstrapImpl.configure(Validation.java:276)
	at org.springframework.validation.beanvalidation.LocalValidatorFactoryBean.afterPropertiesSet(LocalValidatorFactoryBean.java:250)
	at org.springframework.validation.beanvalidation.OptionalValidatorFactoryBean.afterPropertiesSet(OptionalValidatorFactoryBean.java:40)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1687)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1624)
	... 28 more

发现是缺少了  jboss-logging的jar包,添加了就行。


springmvc概述-知识大纲整理

Spring基础-springmvc知识大纲归纳整理

一、原理

1.用户发出HTTP请求

2-3.DispatchServlet通过请求URL到HandlerMapping中去寻找相对应的Handler并返回给DispatchServlet。

4.找到Handler之后,通过Handler获得Controller类对象并调用。

5.Controller 去调用业务处理的xxxService并返回ModelAndView。

6.DispatchServlet把获得的ModelAndView交给ViewResovler进行处理,然后将处理的结果封装成View返回给DispatchServlet。

7.将View视图解析

8.发送给浏览器进行显示。


二、结构

spring-webmvc-版本号.jar 是springmvc的 核心包,springmvc框架中 有jstl的jar包,因为SpringMVC默认使用的标签就是jstl标签。

 

centos7初装系统-启动级别分类

在Linux中有7种启动级别:修改系统启动级别:修改系统默认启动到3多用户状态,在Linux中有7种启动级别,默认是X-Window,像是Windows的窗口模式,而Linux的操作和配置一般都采用输入命令的方式来完成,需要更改默认启动级别才可以实现。
第1步:以管理员身份进入Linux,修改文件:/etc/inittab文件。
第2步:找到“id:5:initdefault:”,其中的5就是X-Window,为默认运行级别,把5改为3即可。
7总运行级别介绍如下:
# 0 - halt (Do NOT set initdefault to this)
# 1 - Single user mode
# 2 - Multiuser, without NFS (The same as 3, if you do not have networking)
# 3 - Full multiuser mode
# 4 - unused
# 5 - X11
# 6 - reboot (Do NOT set initdefault to this)
各个运行级的详细解释:
0 为停机,机器关闭。
1 为单用户模式,就像Win9x下的安全模式类似。
2 为多用户模式,但是没有NFS支持。
3 为完整的多用户模式,是标准的运行级。
4 一般不用,在一些特殊情况下可以用它来做一些事情。例如在笔记本电脑的电池用尽时,可以切换到这个模式来做一些设置。
5 就是X11,进到X Window系统了。
6 为重启,运行init 6机器就会重启。
0和6一般不用;
运行startx可启动到级别5。

最新的 centos7 中,配置 文档 里面有 说明,需要 用 命令行 配置:
systemctl set-default graphical.target

centos7初装系统-cannot find a valid baseurl for repo:base/7/x86_64

安装CentOS7文字界面版后,无法联网,用yum安装软件提示 cannot find a valid baseurl for repo:base/7/x86_64 的解决方法

*无法联网的明显表现会有:

1、yum install出现 Error: cannot find a valid baseurl or repo:base

2、ping host会提示unknown host

 

方法一、

1、打开 vi /etc/sysconfig/network-scripts/ifcfg-eth0(每个机子都可能不一样,但格式会是“ifcfg-eth数字”),把ONBOOT=no,改为ONBOOT=yes

2、重启网络:service network restart

方法二、

1、打开 vi /etc/resolv.conf,增加 nameserver 8.8.8.8

2、重启网络: service network restart

来自:https://www.cnblogs.com/hopkings/p/6140654.html

 

我这边的文件名字是     /etc/sysconfig/network-scripts/ifcfg-enp0s3