Blog

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

一、简单情境下

1、配置文件概述

2、注册转发器

在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>

3、配置转发器

转发配置文件–>【前面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.handlers"></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>

4、编写控制器

在dispatcherServlet-servlet.xml中,因为标明了自定义扫描包路径,来寻找控制器。于是我们就用代码来实现控制器。在包名 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>

6、url请求测试结果

下面两个都能 正常访问
http://localhost:5858/springmvc-1/
http://localhost:5858/springmvc-1/index.jsp

WEB-INF只允许服务器访问,外部无法访问,所以 下面的 请求 无法访问。
http://localhost:5858/springmvc-1/WEB-INF/views/success.jsp

springmvc页面 能正常访问
http://localhost:5858/springmvc-1/helloworld

在index.jsp文件后面又新建了一个测试文件test1.jsp,发现能够正常访问。
http://localhost:5858/springmvc-1/test1.jsp

总结:在此web.xml配置的转发器的拦截域是:
经测试发现,先判断请求是不是 网站根目录/零层或多层路径/xxx.jsp,
如果是,查找是不是存在,存在的话就OK。不存在的就返回404
如果不是,那么再查看控制器,判断是否有匹配的映射名,如果仍没有就返回 404


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

在配置转发器中,需要添加的注解映射器和注解适配器:
在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中,有兴趣的同学可以自行查看。


二、非注解情况配置

与注解情况的区别就是:1、修改handle     2、配置转发器文件

1、在springmvc.xml中的配置,如下:{也就是前面提到的dispatcherServlet-servlet.xml,因为配置文件可以随意取名}

<?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">

	
     
<!-- 配置视图解析器【多个函数可选择】: 此解析器默认生成InternalResourceView,如果项目添加了jstl.jar包的话就会自动改为生成JstlView; 即如何把 handler 方法返回值解析为实际的物理视图,handler的返回值也可以具体是 /WEB-INF/XXXX/XXX.jsp,这样下面的试图解析器就不需要添加前缀和后缀了 -->	

	<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<!-- 配置jsp路径的前缀 -->
		<property name="prefix" value="/WEB-INF/views/"></property>
	    <!-- 配置jsp路径的后缀 -->
		<property name="suffix" value=".jsp"></property>
	</bean>
	
    <!-- 配置handler -->
     <bean id="helloController" name="/hello" class="com.test.springmvc.handlers.HelloController"></bean> 
    <!-- 处理器映射器  根据bean的name进行查找Handler 将controller 的url配置在bean的name中-->
     <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean> 
    <!-- 处理器适配器  通过查看源码,可知此适配器能执行实现Controller接口的handler:-->
     <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean> 

	
</beans>

所有的映射器都实现HandlerMapping接口,所有的适配器都实现HandlerAdapter接口,还有另外一个非注解的适配器:org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,另外一个映射器:org.springframework.web.servlet.handler.SimpleUrlHandlerMapping,如果这些都不配置的话,仍然能够使用,因为MVC有默认配置在核心中的/org/springframework/web/servlet/DispatcherServlet.properties中,有兴趣的同学可以自行查看。

2、配置handler【又叫controller】

package com.test.springmvc.handlers;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

//HelloController类必须实现Controller接口,查看映射文件:
//这样,springmvc 才能识别它

public class HelloController  implements Controller {

	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
		
	//返回ModelAndView
        ModelAndView modelAndView =  new ModelAndView();
        //相当 于request的setAttribut,在jsp页面中通过itemsList取数据
        //在当前的实验中, 我没有在网页中进行获取信息测试,所以设置了空值
        modelAndView.addObject("itemsList", "");
        
        //指定视图 下面这句有错误 (正确做法是在 转发配置页中  删除视图解析器的前缀和后缀)
        modelAndView.setViewName("/WEB-INF/views/success.jsp");    
        //或者另一种正确的做法 上面这句返回"success";保留 转发配置页中的视图解析器的前缀和后缀

        //modelAndView.setViewName("success");
        
        System.out.println("hello world" + request.toString());
		request.toString();

        return modelAndView;
	}

}

j2ee标准-servlet3.0引入的新特性

来自:http://www.blogjava.net/freeman1984/archive/2012/11/16/391444.html

Servlet3.0规范的新特性主要是为了3个目的:
1.简化开发
2.便于布署
3.支持Web2.0原则
为了简化开发流程,Servlet3.0引入了注解(annotation),这使得web布署描述符web.xml不在是必须的选择。
Pluggability可插入性
当使用任何第三方的框架,如Struts,JSF或Spring,我们都需要在web.xml中添加对应的Servlet的入口。这使得web描述符笨重而难以维护。Servlet3.0的新的可插入特性使得web应用程序模块化而易于维护。通过web fragment实现的可插入性减轻了开发人员的负担,不需要再在web.xml中配置很多的Servlet入口。
Asynchronous Processing 异步处理
另外一个显著的改变就是Servlet3.0支持异步处理,这对AJAX应用程序非常有用。当一个Servlet创建一个线程来创建某些请求的时候,如查询数据库或消息连接,这个线程要等待直到获得所需要的资源才能够执行其他的操作。异步处理通过运行线程执行其他的操作来避免了这种阻塞。
Apart from the features mentioned here, several other enhancements have been made to the existing API. The sections towards the end of the article will explore these features one by one in detail.
除了这些新特性之外, Servlet3.0对已有的API也做了一些改进,在本文的最后我们会做介绍。
Annotations in Servlet Servlet中使用注解
Servlet3.0的一个主要的改变就是支持注解。使用注解来定义Servlet和filter使得我们不用在web.xml中定义相应的入口。
@WebServlet
@WebServlet用来定义web应用程序中的一个Servlet。这个注解可以应用于继承了HttpServlet。这个注解有多个属性,例如name,urlPattern, initParams,我们可以使用者的属性来定义Servlet的行为。urlPattern属性是必须指定的。
例如我们可以象下面的例子这样定义:

1. @WebServlet(name = “GetQuoteServlet”,  urlPatterns = {“/getquote”} )

2. public class GetQuoteServlet extends HttpServlet {

3.     @Override

4.     protected void doGet(HttpServletRequest request, HttpServletResponse response)

5.             throws ServletException, IOException {

6.         PrintWriter out = response.getWriter();

7.         try {

8.             String symbol = request.getParameter(“symbol”);

9.             out.println(“<h1>Stock Price is</h1>” + StockQuoteBean.getPrice(symbol);

10.         } finally {

11.             out.close();

12.         }

13.     }

14. }

15.

16. public class StockQuoteBean {

17. private StockQuoteServiceEntity serviceEntity = new StockQuoteServiceEntity();

18.     public double getPrice(String symbol) {

19.         if(symbol !=null )  {

20. return serviceEntity.getPrice(symbol);

21.          } else {

22.             return 0.0;

23.         }

24.     }

25. }

复制代码

在上面的例子中,一个Servlet只对应了一个urlPattern。实际上一个Servlet可以对应多个urlPattern,我们可以这样定义:

1. @WebServlet(name = “GetQuoteServlet”,  urlPatterns = {“/getquote”,  “/stockquote”} )

2. public class GetQuoteServlet extends HttpServlet {

3.     @Override

4.     protected void doGet(HttpServletRequest request, HttpServletResponse response)

5.             throws ServletException, IOException {

6.         PrintWriter out = response.getWriter();

7.         try {

8.             String symbol = request.getParameter(“symbol”);

9.             out.println(“<h1>Stock Price is</h1>” + StockQuoteBean.getPrice(symbol);

10.         } finally {

11.             out.close();

12.         }

13.     }

14. }

复制代码

@WebFilter
我们可以使用@WebFilter注解来定义filter。这个注解可以被应用在实现了javax.servlet.Filter接口的类上。同样的,urlPattern属性是必须指定的。下面就是一个例子。

1. @WebFilter(filterName = “AuthenticateFilter”, urlPatterns = {“/stock.jsp”, “/getquote”})

2. public class AuthenticateFilter implements Filter {

3.

4.     public void doFilter(ServletRequest request, ServletResponse response,

5.             FilterChain chain)     throws IOException, ServletException {

6.         String username = ((HttpServletRequest) request).getParameter(“uname”);

7.         String password = ((HttpServletRequest) request).getParameter(“password”);

8.           if (username == null || password == null) {

9.                  ((HttpServletResponse) response).sendRedirect(“index.jsp”);            }

10. if (username.equals(“admin”) && password.equals(“admin”)) {

11.                 chain.doFilter(request, response);      }

12. else {

13.                 ((HttpServletResponse) response).sendRedirect(“index.jsp”);         }

14.          }

15.

16.     public void destroy() {

17.     }

18.     public void init(FilterConfig filterConfig) {

19.     }

20. }

复制代码

@WebInitParam
可以使用@WebInitParam注解来制定Servlet或filter的初始参数。当然我们也可以使用@WebServlet或@WebFileter的initParam属性来指定初始参数。下面是使用@WebInitParam的例子:

1. @WebServlet(name = “GetQuoteServlet”, urlPatterns = {“/getquote”})

2. @WebInitParam(name = “default_market”, value = “NASDAQ”)

3. public class GetQuoteServlet extends HttpServlet {

4.     @Override

5.     protected void doGet(HttpServletRequest request, HttpServletResponse response)

6.             throws ServletException, IOException {

7.         response.setContentType(“text/html;charset=UTF-8”);

8.         PrintWriter out = response.getWriter();

9.         try {

10.             String market = getInitParameter(“default_market”);

11.             String symbol = request.getParameter(“symbol”);

12.             out.println(“<h1>Stock Price in ” + market + ” is</h1>” + StockQuoteBean.getPrice(symbol, market));

13.         } finally {

14.             out.close();

15.         }

16.     }

17. }

复制代码

下面是使用initParam属性的例子:

1. @WebServlet(name = “GetQuoteServlet”,

2.             urlPatterns = {“/getquote”},

3.             initParams={@WebInitParam(name=”default_market”,  value=”NASDAQ”)}

4.            )

5. public class GetQuoteServlet extends HttpServlet {

6.     @Override

7.     protected void doGet(HttpServletRequest request, HttpServletResponse response)

8.             throws ServletException, IOException {

9.         response.setContentType(“text/html;charset=UTF-8”);

10.         PrintWriter out = response.getWriter();

11.         try {

12.             String market = getInitParameter(“default_market”);

13.             String symbol = request.getParameter(“symbol”);

14.             out.println(“<h1>Stock Price in ” + market + ” is</h1>” + StockQuoteBean.getPrice(symbol, market));

15.         } finally {

16.             out.close();

17.         }

18.     }

19. }

复制代码

@WebListener
@WebListener注解被应用在作为listener监听web应用程序事件的类上,所以@WebListener能够被应用在实现了ServletContextListener,ServletContextAttributeListener,ServletRequestListener,ServletRequestAttributeListener,HttpSessionListener和HttpSessionAttributeListener接口的类上。在下面的例子中,该类实现了ServletContextListener接口。

1. @WebListener

2. public class QuoteServletContextListener implements ServletContextListener {

3.    public void contextInitialized(ServletContextEvent sce) {

4.    ServletContext context = sce.getServletContext();

5. context.setInitParameter(“default_market”, “NASDAQ”);

6. }

7. public void contextDestroyed(ServletContextEvent sce) {

8. }

9. }

复制代码

@MultipartConfig
使用@MultipartConfig注解来指定Servlet要求的multipart MIME类型。这种类型的MIME附件将从request对象中读取。
The Metadata and Common Annotations元数据与通用的注解
除了以上的Servlet特定的注解之外,Servlet3.0还支持JSR175(Java元数据规范)和JSR250(Java平台通用注解)所规定的注解,包括:
* 安全相关的注解,如 @DeclareRoles 和 @RolesAllowed
* 使用EJB的注解,如 @EJB 和 @EJBs
* 资源注入相关的注解,如 @Resource 和 @Resources
* 使用JPA的注解,如 @PersistenceContext, @PersistenceContexts, @PersistenceUnit, 和 @PersistenceUnits
* 生命周期的注解,如 @PostConstruct和 @PreDestroy
* 提供WebService引用的注解,如 @WebServiceRef and @WebServiceRefs
注解和web.xml哪个会生效
注解的引入使得web.xml变成可选的了。但是,我们还是可以使用web.xml。容器会根据web.xml中的metadata-complete元素的值来决定使用web.xml还是使用注解。如果该元素的值是true,那么容器不处理注解,web.xml是所有信息的来源。如果该元素不存在或者其值不为true,容器才会处理注解。
Web框架的可插入性
我们前面说过了Servlet3.0的改进之一就是使得我们能够将框架和库插入到web应用程序中。这种可插入性减少了配置,并且提高了web应用程序的模块化。Servlet3.0是通过web模块布署描述片段(简称web片段)来实现插入性的。
一个web片段就是web.xml文件的一部分,被包含在框架特定的Jar包的META-INF目录中。Web片段使得该框架组件逻辑上就是web应用程序的一部分,不需要编辑web布署描述文件。
Web片段中使用的元素和布署文件中使用的元素基本相同,除了根元素不一样。Web片段的根元素是<web-fragment>,而且文件名必须叫做web-fragment.xml。容器只会在放在WEB-INF\lib目录下的Jar包中查找web-fragment.xml文件。如果这些Jar包含有web-fragment.xml文件,容器就会装载需要的类来处理他们。
在web.xml中,我们要求Servlet的name必须唯一。同样的,在web.xml和所有的web片段中,Servlet的name也必须唯一。
下面就是一个web-fragment的例子:
web-fragment.xml

1. <web-fragment>

2. <servlet>

3. <servlet-name>ControllerServlet</servlet-name>

4. <servlet-class>com.app.control.ControllerServlet</servlet-class>

5. </servlet>

6. <listener>

7. <listener-class>com.listener.AppServletContextListener</listener-class>

8. </listener>

9. </web-fragment>

复制代码

框架的Jar包是放在WEB-INF\lib目录下的,但是Servlet3.0提供两种方法指定多个web片段之间的顺序:
1. 绝对顺序
2. 相对顺序
我们通过web.xml文件中的<absolute-ordering>元素来指定绝对顺序。这个元素有之元素name,name的值是各个web片段的name元素的值。这样就指定了web片段的顺序。如果多个web片段有相同的名字,容器会忽略后出现的web片段。下面是一个指定绝对顺序的例子:
web.xml

1. <web-app>

2. <name>DemoApp</name>

3. <absolute-ordering>

4. <name>WebFragment1</name>

5. <name>WebFragment2</name>

6. </absolute-ordering>

7. …

8. </web-app>

复制代码

相对顺序通过web-fragment.xml中的<ordering>元素来确定。Web片段的顺序由<ordering>的子元素<before>,<after>和<others>来决定。当前的web片段会放在所有的<before>元素中的片段之前。同样的,会放在所有的<after>元素中的片段之后。<others>用来代替所有的其他片段。注意只有当web.xml中没有<absolute-ordering>时,容器才会使用web片段中定义的相对顺序。
下面是一个帮助理解相对顺序的例子:
web-fragment.xml

1. <web-fragment>

2. <name>WebFragment1</name>

3. <ordering><after>WebFragment2</after></ordering>

4. …

5. </web-fragment>

复制代码

web-fragment.xml

1. <web-fragment>

2. <name>WebFragment2</name>

3. ..

4. </web-fragment>

复制代码

web-fragment.xml

1. <web-fragment>

2. <name>WebFragment3</name>

3. <ordering><before><others/></before></ordering>

复制代码

..
</web-fragment>
这些文件将会按照下面的顺序被处理:
1. WebFragment3
2. WebFragment2
3. WebFragment1
包含WebFragment3的Jar文件被最先处理,包含WebFragment2的文件被第二个处理,包含WebFragment1的文件被最后处理。
如果既没有定义绝对顺序,也没有定义相对顺序,那么容器就认为所有的web片段间没有顺序上的依赖关系。
Servlet中的异步处理
很多时候Servlet要和其他的资源进行互动,例如访问数据库,调用web service。在和这些资源互动的时候,Servlet不得不等待数据返回,然后才能够继续执行。这使得Servlet调用这些资源的时候阻塞。Servlet3.0通过引入异步处理解决了这个问题。异步处理允许线程调用资源的时候不被阻塞,而是直接返回。AsyncContext负责管理从资源来的回应。AsyncContext决定该回应是应该被原来的线程处理还是应该分发给容器中其他的资源。AsyncContext有一些方法如start,dispatch和complete来执行异步处理。
要想使用Servlet3.0的异步处理,我们需要设置@Webservlet和@WebFilter注解的asyncSupport属性。这个属性是布尔值,缺省值是false。
Servlet3.0的异步处理可以很好的和AJAX配合。在Servlet的init方法中,我们能够访问数据库或从JMS读取消息。在doGet或doPost方法中,我们能够启动异步处理,AsyncContext会通过AsyncEvent和AsyncListener来管理线程和数据库操作/JMS操作自己的关系。
已有API的改进
除了这些新特性之外,Servlet3.0还对以往已经存在的API做了一些改进。
HttpServletRequest
To support the multipart/form-data MIME type, the following methods have been added to the HttpServletRequest interface:
为了支持multipart/form-data MIME类型,在HttpServletRequest接口中添加了项目的方法:
* Iterable<Part> getParts()
* Part getPart(String name)
Cookies
为了避免一些跨站点攻击,Servlet3.0支持HttpOnly的cookie。HttpOnly cookie不想客户端暴露script代码。Servlet3.0在Cookie类中添加了如下的方法来支持HttpOnly cookie:
* void setHttpOnly(boolean isHttpOnly)
* boolean isHttpOnly()
ServletContext
通过在ServletContext中添加下面的方法,Servlet3.0允许Servlet或filter被编程的加入到context中:
* addServlet(String servletName, String className)
* addServlet(String servletName, Servlet servlet)
* addServlet(String servletName, Class<? extends Servlet> servletClass)
* addFilter(String filterName, String className)
* addFilter(String filterName, Filter filter)
* addFilter(String filterName, Class<? extends Filter>filterClass)
* setInitParameter (String name, String Value)

Servlet3.0新功能: 异步处理

J2EE 6和Glassfish 3V正式发布了,J2EE 6正式发布了Servlet3.0, 为了能更好的对WEB2.0提供支持, 3.0添加了异步处理的机制.

 

HTTP1.1相对于HTTP1.0的影响.

 

HTTP1.1最大的一个改变就是提供了长连接,这样HTTP不再是一次请求,一次连接的协议了,只要HTTP的connection不关闭,一次HTTP连接可以支持任意多次request/reponse处理. 当WEB Client与WEB Server建立连接时,客户端可以采用长连接,也就是说Client会一直保持对WEB Server的连接(例如:Browser对一个网站保持当连接,知道Browser关闭或最终退出该网站). 旧的WEB Server会为每一个Http连接分配一个active的Thread,这样当Client的数量增大时,Server端Thread Pool的最大容量也需要相应增大,但Thread是相当耗内存的,一个不小心就会导致Server端NotEnoughMemory…

 

基于HTTP1.1,大部分支持Servlet2.X的WEB容器都采用的NIO去接收和处理请求. 当Client和Server端建立连接时,Server端并不分配一个Thread给HTTP连接.直到Server端收到Client端发送的Request时, Server才开始为该Request分配Thread(注意:这里不是为HTTP连接分配Thread).

 

这样当大量的Client建立长连接与Server进行交互时,Server无需维持一个Thread给inactive的HTTP长连接, 每个Servlet在doReceived()时其实对应的是一个active Request,而不是HTTPConnection本身. 这样Server端所需的最大Thread数大大地减少了.

 

AJAX的影响

 

1. Request的数量爆炸性增加增加

 

过去WEB Browser打开一个Web page,只需要和Web Server端建立一个HTTP连接.但AJAX技术出现以后,一个Web page上可能有多个与Web Server的连接,而且Ajax request通常是十分频繁的,Server接收到的Request数量大大增长了, 这样原先NIO的技术已经不能很好的支持基于Ajax的服务了.

 

Servlet 3.0的异步处理就能够解决上面的问题.

 

Servlet3.0的solution:

当request发送到Server端时,servlet的doReceived()将request放进一个queue里,然后doReceived结束.这个时候server并没有关闭response,Client端一直在等server端response的内容. Server端维护自己的ThreadPool,当ThreadPool里有idle的Thread,就从queue里取出一个request,分配idle的Thread给request,并进行处理.

 

Java代码 
  1.    @WebServlet(“/test” asyncSupported=true)
  2.    public class MyServlet extends HttpServlet {
  3.        ScheduledThreadPoolExecutor executor = null;
  4.         public void init(ServletConfig arg0) throws ServletException {
  5.                    executor = new ThreadPoolExecutor(10);//独立的线程池处理请求
  6.         }
  7.         public void doGet(HttpServletRequest req, HttpServletResponse res) {
  8.             …
  9.             AsyncContext aCtx = request.startAsync(req, res);
  10.             executor.execute(new AsyncWebService(aCtx));//异步处理
  11.         }
  12.    }
  13.    public class AsyncWebService implements Runnable {
  14.         AsyncContext ctx;
  15.         public AsyncWebService(AsyncContext ctx) {
  16.             this.ctx = ctx;
  17.         }
  18.         public void run() {//处理请求
  19.             //Do something here …
  20.             // Dispatch the request to render the result to a JSP.
  21.             ctx.dispatch(“/render.jsp”);
  22.    }
  23. }
   @WebServlet("/test" asyncSupported=true)   public class MyServlet extends HttpServlet {       ScheduledThreadPoolExecutor executor = null;        public void init(ServletConfig arg0) throws ServletException {                   executor = new ThreadPoolExecutor(10);//独立的线程池处理请求        }        public void doGet(HttpServletRequest req, HttpServletResponse res) {            ...            AsyncContext aCtx = request.startAsync(req, res);            executor.execute(new AsyncWebService(aCtx));//异步处理        }   }   public class AsyncWebService implements Runnable {        AsyncContext ctx;        public AsyncWebService(AsyncContext ctx) {            this.ctx = ctx;        }        public void run() {//处理请求            //Do something here ...            // Dispatch the request to render the result to a JSP.            ctx.dispatch("/render.jsp");   }}

以上的例子可以用于处理对Ajax的请求,因为通常Ajax的请求多,但对响应速度的要求并不太高. 对于正常的页面请求,要求一定的响应速度,可以沿用以前Servlet同步的实现.

 

2. Server端推送信息

在Web2.0的应用中, Ajax可用通过不断的发送Request来获取Server端某种信息的变化,但这种实现会产生大量的Client请求. 当前推荐的方法是,让Server端自己推送信息变化给Client.

 

因为Servlet3.0提供了异步处理的方式, Request提交给Server以后, Server可以为Request注册一个Listener,由Listener去monitor信息的变化,当信息发生变化时,由Listener负责把信息变化发送给Cient(Listener关闭HTTP response).

j2ee标准-web.xml中的web-app标签分析

当用eclipse创建 dynamic web project 时,创建过程中  需要选择一个 dynamic web module version 。当前可选择的取值有 2.2    2.3   2.4   2.5   3.0   3.1  取值完毕时  ,项目中的   web.xml  里面的   web-app 版本 就是   dynamic web module version 值。  这个值 其实 就是 servlet 版本值。(servlet 版本升级,都会带来一些新的功能)

每个tomcat版本对应的标准servlet版本,如下:

The XSD version is preferred since JSP 2.0 / Servlets 2.4 (eg: Tomcat 5.5). Note that the XML encoding can be specified as ISO-8859-1, UTF-8, or any other valid encoding in either version, and should match the actual encoding of your text file.

注意 servlet 2.4、3.1之后xsi的变化。

Servlet 3.1 deployment descriptor

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
		 http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">
</web-app>

XSD example for JSP 2.2 / Servlets 3.0 (Tomcat 7.0):

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app 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_3_0.xsd"
      version="3.0">

</web-app>

XSD example for JSP 2.1 / Servlets 2.5 (Tomcat 6.0):

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
     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"
     version="2.5">

</web-app>

XSD example for JSP 2.0 / Servlets 2.4 (Tomcat 5.5):

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
     version="2.4">

</web-app>

DTD example for JSP 1.2 / Servlets 2.3 (Tomcat 5):

<?xml version="1.0" encoding="ISO-8859-1"?> 
<!DOCTYPE web-app
   PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
   "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

</web-app>&nbsp;

官方参考可见http://www.oracle.com/webfolder/technetwork/jsc/xml/ns/javaee/index.html。

对于spring,对应关系如下:
  • 4.0 最低要求JDK 6,支持websocket, Servlet 3.0+
  • 3.0 最低要求JDK 1.5,基于注解的配置,servlet 2.4,完全支持REST,包从spring.jar拆分为按模块进行组织
  • 2.5 最低要求JDK 1.4.2,Servlet 2.3, JSP 1.2
========================================================================
十余年金融IT行业团队管理,系统架构,数据库架构与优化经验
擅长于大规模高并发j2ee soa体系系统架构设计与实现,精通j2ee系统性能分析与优化
精通oltp&dss oracle&mysql数据库设计、性能分析与优化、HA、分库分表应用架构设计与实现
我的开源项目io.spider,mysqlawr,logpool。https://git.oschina.net/zhjh256
来自:https://www.cnblogs.com/zhjh256/p/6118158.html

 


Servlet 3十二月2009开发平台标准版6,6可插性,易于开发,异步ser vlet,安全,文件上传
Servlet 2.5九月2005开发平台标准版5,5需要平台标准版5,支持注释
Servlet 2.4十一月2003中1.4,1.3 web.xml新解
Servlet 2.1十一月1998未正式规范,添加Dispatcher,Ser vlet Cont ext
Servlet 2类1.1部分程序开发工具包2
Servlet 1六月1997定义

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包,添加了就行。