gmv

你好，两者的压缩机不同。你可以根据自己实际需要去选择购买。

springmvc回显float类型失败是数据回显。pojo的数据回显Springmvc会把形参中pojo参数，放到request域中，key为pojo参数的类型首字母小写，也就是如果pojo参数为Items。

你可以把springmvc当成struts2，大概就明白了。以下内容来自网络，请认真看一遍。Spring是一个轻型容器(light-weight container)，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model)。在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其他流行的Web框架进行集成。1)开源框架2)IoC（控制反转）,将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合3)AOP 将安全，事务等于程序逻辑相对独立的功能抽取出来，利用spring的配置文件将这些功能插进去，实现了按照方面编程，提高了复用性前言最近在看Spring MVC的源码,就把自己对MVC模式和对各种框架的实现的认识写出来给大家看看,算是一个总结.所以,恳请大家用怀疑的眼光来看待这篇文章,假如有认识不对的地方,麻烦指出.MVC与WEB应用MVC是什么就不用我多说了.对于现有较成熟的Model-View-Control(MVC)框架而言,其注意的主要问题无外乎下面这些:Model:模型应该包含由视图显示的数据.在J2EE Web应用中,数据通常应该由普通的javabean组成.一旦一个控制器选择了视图,模型就要包含视图相应的数据.模型本身不应该进一步的访问数据,也不应该和业务对象相联系.模型要解决的问题包括:l 封装要显示的数据l 我不认为模型要依赖于特定的框架l 不一定非得是javabeanView:视图负责显示出模型包含的信息,视图不必了解控制器或是底层业务对象的具体实现视图要解决的问题包括:l 在显示给定数据模型的情况下显示内容l 不应该包含有业务逻辑l 可能需要执行显示逻辑,比如颜色交替的显示某个数组的各行l 视图最好不处理验证的错误,数据的验证应该在由其他组件完成l 视图不应该处理参数,参数应该交由控制器集中处理Control:控制器就好像MVC里的中枢神经,它也许会需要一些助手来帮助它比如解析视图,解析参数等.控制器可以访问到业务对象或者是它的代理是很重要的,比如Struts里的Action.控制器要解决的问题包括:l 检查和抽取请求参数l 调用业务对象,传递从请求中获取的参数l 创建模型,视图讲显示对应的模型l 选择一个合适的视图发送给客户端l 控制器有时不会只有一个现有的框架现在已经有很多的MVC的框架实现.比较流行的应该就是Struts和Webwork了Struts这是最流行的web框架,几乎成为了实际上的工业标准.除了上面讨论的MVC模式应该有的优点以外.它还有如下一些缺点:l 每个Action只生成一次,然后就被缓存起来,再次请求这个Action的时候就不会生成新的对象,而是重复使用第一次生成的对象,这就意味着每个Action必须是线程安全的l 采用ActionForm封装了表单数据,但是却只能对应String类型的数据, 虽然它可以使用工具Commons Beanutils进行类型转化,但是仅仅是提供了对象级别的支持l 严重的依赖于Servlet API, 测试比较困难(不过下一版Struts里的Action.execute的方法签名讲会换成execute(ActionContext actionContext),依赖也许不会那么严重)l 框架本身的验证规则比较简单,一般都是依赖于Commons Validation进行验证l 想在Action前后做些处理很困难.有时甚至不得不自己去写专门的控制器l 由于Struts都是具体的类继承,这样很容易打破封装?l 提供各式各样的自定义的标签,但是数据绑定太原始了,这样就使页面代码依赖于Struts这个特定的框架,而它却不是规范,我觉得这是很致命的l 它太面向JSP了,尽管使用其他视图技术是有可能的,但是使用的时候却不是很方便Webwork这个框架虽然我没使用过,但是却一直在关注它的发展 Webwork的设计思想采用了比Struts更为聪明的一种方式,就技术角度上说比Struts要高出不少.它以Command模式为基础.分为Xwork和Webwork,而且框架并不依赖于Servlet API. Xwork提供了很多核心功能:拦截器（Interceptor）,运行时表单验证,类型转换,IoC容器等. WebWork建立在Xwork之上,用于处理基于HTTP的响应和请求.用Map和ActionContext封装了Session,Application等这些Servlet对象.从而解除了和Servlet API的耦合. 但是它仍然不是完美的:l 为每一个请求都创建一个Action可能有些浪费.(但是Servlet引擎也是为每个请求创建多个对象,但是也没看出来对性能有多大的影响?)l 当项目越来越大的时候,配置文件可能会很零乱.好像它不支持多个配置文件l 异常处理是Command模式里值得注意的问题:我们不知道某一特定命令可能会抛出什么特定的异常,所以execute()被迫抛出异常,而不论异常是运行时异常,还是已检查异常 Spring MVC Framework的目标上面说了一些MVC的原理,以及现在主流框架的一些问题,现在来看Spring是如何处理的. Spring MVC框架根据不同的角色定义了很多接口,但是它最大的问题也是依赖于Servlet APISpring MVC Framework有这样一些特点:l 它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件.并且和Spring提供的其他基础结构紧密集成.l 不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)l 可以任意使用各种视图技术,而不仅仅局限于JSPl 支持各种请求资源的映射策略l 它应是易于扩展的我认为评价一个框架,应该有几个原则l 它应该是易于使用的,易于测试的Spring 易于使用吗?我不这么觉得,尤其是它的配置文件.在最恐怖的情况下,各种业务逻辑,基础设施也许会拥挤在一个配置文件里.而如事务处理这些基础设施应该是由容器管理而不是开发人员,就算把这些分开到几个配置文件里,逻辑上虽然清晰了,但是基础设置却还是暴露在外边Spring易于测试吗?对Spring进行单元测试很容易,测试起来很方便l 应该在多个层次上提供接口Spring提供了很多接口,而几乎每个接口都有默认的抽象实现,每个抽象实现都有一些具体实现,所以在可扩展性这点上Spring无疑是很优秀的l 框架内部和框架外部应该被区别对待框架内部可以很复杂,但是使用起来一定要简单,Spring的内部比较麻烦,但是它很好的隐藏了这种复杂性,使用起来很舒服,比如设置一个bean的属性.仅仅是setPropertyValue(String propertyName, Object value)就完成,至于怎么去设置,Spring完全隐藏了这种复杂性l 完善的文档和测试集这个就不用说了,老外的东西,都很完善 Spring Web框架基本流程知道了Spring MVC框架,现在来看看它的流程Spring MVC Framework大至流程如下:当web程序启动的时候,ContextLoaderServlet会把对应的配置文件信息读取出来,通过注射去初始化控制器DispatchServlet. 而当接受到一个HTTP请求的时候, DispatchServlet会让HandlerMapping去处理这个请求.HandlerMapping根据请求URL(不一定非要是URL,完全可以自定义,非常灵活)来选择一个Controller. 然后DispatchServlet会在调用选定的Controller的handlerRequest方法,并且在这个方法前后调用这个Controller的interceptor(假如有配置的话),然后返回一个视图和模型的集合ModelAndView.框架通过ViewResolver来解析视图并且返回一个View对象,最后调用View的render方法返回到客户端DispatcherServlet这是框架的控制器,是一个具体类,它通过运行时的上下文对象来初始化.控制器本身并不去控制流程,而只是是Controller的”控制器”,他只是把处理请求的责任委托给了对应的Controller. 控制器继承自抽象基类FrameworkServlet,它的属性webApplicationContext就代表着这个web程序上下文,而这个上下文对象默认实现就是从一个XML文件读取配置信息(当然也可以是其他文件格式). WebApplicationContext其实是beans包的东西,这个包提供了这个Spring整个框架的基础结构,以后我会分析这个包的内容.但是现在仅仅需要知道WebApplicationContext代表一个web应用的上下文对象. 现在来看看DispatchServlet是如何工作的:DispatchServlet由于继承自抽象基类FrameworkServlet,而FrameworkServlet里的doGet(),doPost()方法里有调用serviceWrapper(),跳到serviceWrapper()里去看,结果发现它有把具体实现委托给了doService(request, response); 方法.所以现在已经很清楚了, DispatchServlet真正实现功能的是doService() 这个方法. 特别的, FrameworkServlet的initFrameworkServlet()这个方法是控制器的初始化方法,用来初始化HandlerMappings之类的对象,这也是延迟到子类实现的.其实就是一个Template模式的实现.don"t call us, we will call u.总的看来,Spring就是通过这样来实现它的控制反转的:用框架来控制流程,而不是用户 跳到doService()一看究竟,就会发现真正工作的又是另一个助手函数doDispatch(request, response),没办法,继续看下去,发现这样两行代码HandlerExecutionChain mappedHandler = null; mappedHandler = getHandler(processedRequest, false);看HandlerExecutionChain源码就发现它其实就是对Controller和它的Interceptors的进行了包装; getHandler()就是从HandlerMappings(这是一个List,存放的handlerMapping对象)中取出对应的handlerMapping对象, 每个HandlerMapping对象代表一个Controller和URL的映射(其实在运行的时候是一个HandlerExecutionChain和URL的映射,而HandlerExecutionChain对象其实就是对Controller和它interceptors的一个包装器,可以把HandlerMapping看成Controller和URL的映射).而这个HandlerMapping是通过配置文件在运行时注射进来的,一般是SimpleUrlHandlerMapping这个子类 取得了HandlerMapping对象,继续向下看,发现: if (mappedHandler.getInterceptors() != null) { for (int i = 0; i < mappedHandler.getInterceptors().length; i++) { HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i]; if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) { triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null); return; } interceptorIndex = i; } }这里就是在调用Controller的拦截器,原理就是这句了: interceptor.preHandle(processedRequest, response, mappedHandler.getHandler(), mv);preHandle方法传入了mappedHandler.getHandler()这个参数来实现递归调用!而interceptor.postHandle方法如此一般.只不过这个方法是在handleRequest方法后调用 继续看下去: HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); mv = ha.handle(processedRequest, response, mappedHandler.getHandler());发现Controller的handleRequest真正的操作又被代理给了HandlerAdapter的handle方法,并且返回一个ModelAndView,我想这里增加一层的意义应该是为了解除Controller和DispatchServlet的耦合吧. 接着就很简单了,调用render()方法,在这个方法里面由ViewResoler解析出视图名,再调用视图对象的render方法把合适的视图展现给用户 到此,控制器的流程就OVER了HandlerMapping通过使用HandlerMapping,控制器可以用URL和某一个Controller进行标准的映射,而实现URL映射的具体子类的UrlHandlerMapping. Spring还允许我们自定义映射,比如通过Session,cookie或者用户状态来映射.而这一切仅仅只需要实现HandlerMapping接口而已.不过URL映射已经能满足大部分的要求ControllerController 类似Structs的Action, Controller接口只有一个方法handleRequest(),放回一个ModelAndView对象,如同设计目标所说的那样,每个Controller都是一个java组件,所以它可以在上下文环境中任意配置,组件属性都会在初始化的时候被配置.Spring自己提供了几个具体的实现.方便我们使用ViewResolverController通常返回包含视图名字而不是视图对象的ModelAndView对象.从而彻底的解除了控制器和视图之间的耦合关系,并且在这里还可以提供国际化的支持.在你的配置文件中你可以:welcomeView.class = org.springframework.web.servlet.view. InternalResourceViewwelcomeView.url=/welcome.jsp也可以welcomeView.class = org.springframework.web.servlet.view.xslt. XsltViewwelcomeView.url=/xslt/default.xslt View这也是一个java组件,它不做任何请求处理或是业务逻辑,它仅仅获取模型传递的数据,并把数据显示出来.它里面的 render方法按照如下流程工作:l 设置模型的数据到request作用域l 取得视图的URLl 转发到对应的URL总结:Spring的web框架是一个很优秀的框架,在这里只是走马观花的分析了Spring的工作流程和一些关键的类,但是并没有去深入的去探讨它背后所体现的思想,还有它的优缺点等东西.这些都等下次再说吧

struts1Struts1 工作流程1 ActionServlet接收由浏览器发出的请求后，检索和请求匹配的ActionMapping对象。如果不存在，返回请求无效的信息。2 检索和请求匹配的ActionForm对象。如果不存在，就创建一个。把提交的表单中的数据保存在ActionForm对象中3 根据配置信息决定是否进行校验。如果是，就进行校验。如果通过校验，进行下一步4 ActionServlet根据ActionMapping对象包含的信息决定把请求转发给哪个Action。如果这个Action的对象不存在，就创建一个，然后调用它的excute方法5 Action的excute方法返回一个ActionForward对象。ActionServlet把请求转发给ActionForward指定的JSP。6 ActionFoward对象指定的JSP生成动态网页，返回给浏览器struts2struts2是webwork升级版，跟struts1没有关系。struts1和servlet耦合度高，各层之间耦合度高，单元测试困难，表示层技术单一，而struts2没有和servlet耦合，更容易测试，支持更多表示层技术。struts2工作流程1） 客户端初始化一个指向Servlet容器（例如Tomcat）的请求。2） 这个请求经过一系列的过滤器（Filter）。3） 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action。4） 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy。5） ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类。6） ActionProxy创建一个ActionInvocation的实例。7） ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。8） 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。Struts2的核心就是拦截器。Struts.xml中所有的package都要extends="struts-default"。同理与所有的Java类都要extends自Object一样。struts-default.xml里面就是要做以上事情。springmvc1.spring mvc将所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作。2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.3.DispatcherServlet将请求提交到目标Controller4.Controller进行业务逻辑处理后，会返回一个ModelAndView5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象6.视图对象负责渲染返回给客户端。struts1与struts2的比较1、struts1要求Action类继承一个抽象基类，而不是接口，struts2继承ActionSupport类或者实现Action接口。2、struts1是单例模式的，Action资源必须是线程安全的或同步的，会有线程安全问题，struts2为每一个请求都实例化一个对象，不存在线程安全问题。3、struts1依赖servlet API 因为execute方法的参数有httpservletrequest和httpservletresponse对象，而struts2不用依赖servlet。4、struts1依赖servlet API，所以测试要依赖web容器，测试难，struts2不依赖于容器，允许Action脱离容器单独被测试。 5、ActionForm，普通的JavaBean不能用作ActionForm，因此，开发者必须创建大量的ActionForm类封装用户请求参数，Struts 2直接使用Action属性来封装用户请求属性，避免了开发者需要大量开发ActionForm类的烦琐。Struts 2提供了ModelDriven模式，可以让开发者使用单独的Model对象来封装用户请求参数，但该Model对象无需继承任何Struts 2基类，是一个POJO，从而降低了代码污染。 6、struts1 支持jsp作为表现层技术，struts2支持velocity、freemarker等表现层技术。7、Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。 Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言OGNL8、Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。 Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期struts2与springmvc比较1、spring mvc的入口是servlet，而struts2是filter2、struts2是类级别的拦截， 一个类对应一个request上下文，springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应3、spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。而struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入；struts2实际上是通过setter getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。4、spring3mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ，然后直接返回响应文本即可。

原理都是一样的，责任链设计模式。区别就是用的地方不一样，拦截的位置不一样。过滤器是web标准，一般配置在web.xml中，在遇到符合规则的请求时处理。struts2拦截器，是struts提供的，配置在struts.xml中，拦截struts的Action请求并处理，如果你的请求不符合struts要求未被struts处理，则拦截器同样不会触发。spring跟struts一样，只是由spring框架提供，未被spring管理的对象方法是不会被拦截的。

MVC是web开发常用的模式，M即模型层（Model）：主要由javabean来实现。V即视图层（View）：主要由jsp、velocity、freemarker等。C即控制层（Controller）：主要由servlet、strtus、springmvc来实现。struts1Struts1 工作流程1 ActionServlet接收由浏览器发出的请求后，检索和请求匹配的ActionMapping对象。如果不存在，返回请求无效的信息。2 检索和请求匹配的ActionForm对象。如果不存在，就创建一个。把提交的表单中的数据保存在ActionForm对象中3 根据配置信息决定是否进行校验。如果是，就进行校验。如果通过校验，进行下一步4 ActionServlet根据ActionMapping对象包含的信息决定把请求转发给哪个Action。如果这个Action的对象不存在，就创建一个，然后调用它的excute方法5 Action的excute方法返回一个ActionForward对象。ActionServlet把请求转发给ActionForward指定的JSP。6 ActionFoward对象指定的JSP生成动态网页，返回给浏览器struts2struts2是webwork升级版，跟struts1没有关系。struts1和servlet耦合度高，各层之间耦合度高，单元测试困难，表示层技术单一，而struts2没有和servlet耦合，更容易测试，支持更多表示层技术。struts2工作流程1） 客户端初始化一个指向Servlet容器（例如Tomcat）的请求。2） 这个请求经过一系列的过滤器（Filter）。3） 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action。4） 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy。5） ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类。6） ActionProxy创建一个ActionInvocation的实例。7） ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。8） 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。Struts2的核心就是拦截器。Struts.xml中所有的package都要extends="struts-default"。同理与所有的Java类都要extends自Object一样。struts-default.xml里面就是要做以上事情。springmvc1.spring mvc将所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责对请求进行真正的处理工作。2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.3.DispatcherServlet将请求提交到目标Controller4.Controller进行业务逻辑处理后，会返回一个ModelAndView5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象6.视图对象负责渲染返回给客户端。struts1与struts2的比较1、struts1要求Action类继承一个抽象基类，而不是接口，struts2继承ActionSupport类或者实现Action接口。2、struts1是单例模式的，Action资源必须是线程安全的或同步的，会有线程安全问题，struts2为每一个请求都实例化一个对象，不存在线程安全问题。3、struts1依赖servlet API 因为execute方法的参数有httpservletrequest和httpservletresponse对象，而struts2不用依赖servlet。4、struts1依赖servlet API，所以测试要依赖web容器，测试难，struts2不依赖于容器，允许Action脱离容器单独被测试。 5、ActionForm，普通的JavaBean不能用作ActionForm，因此，开发者必须创建大量的ActionForm类封装用户请求参数，Struts 2直接使用Action属性来封装用户请求属性，避免了开发者需要大量开发ActionForm类的烦琐。Struts 2提供了ModelDriven模式，可以让开发者使用单独的Model对象来封装用户请求参数，但该Model对象无需继承任何Struts 2基类，是一个POJO，从而降低了代码污染。 6、struts1 支持jsp作为表现层技术，struts2支持velocity、freemarker等表现层技术。7、Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。 Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言OGNL8、Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。 Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期struts2与springmvc比较1、spring mvc的入口是servlet，而struts2是filter2、struts2是类级别的拦截， 一个类对应一个request上下文，springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应3、spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性，而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。而struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter getter方法把request中的数据注入；struts2实际上是通过setter getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。4、spring3mvc的验证也是一个亮点，支持JSR303，处理ajax的请求更是方便，只需一个注解@ResponseBody ，然后直接返回响应文本即可。

基于Spring实现的MVC框架。不能不使用Spring，单独使用SpringMVC，因为其需要依赖Ioc容器等。但是如果单独为了更好的理解SpringMVC这种MVC框架，就把它和Struts/Struts2。。。一系列的MVC框架，只是基于DispatcherServlet或者Filter做一个前端分发器，最终把这个框架引导起来，进行其自己的逻辑处理。没有什么特殊的地方。每个MVC框架都有自己的特点，互相比较一下，就理解原理了。

不会。在使用springmv此注解之后不会再走json视图解析器，而是直接将数据写入到输出流中，效果等同于使用response对象输出指定格式的数据。SpringWebMVC是一种基于Java的实现了MVC设计模式的、请求驱动类型的、轻量级Web框架。

依赖注入(IoC)，又称控制反转。 不用显示的在一个类里用new关键字来生成你想要的对象而只需在xml配置文件里添加相应节点即可，这样就让你整个程序的组成变得灵活多样。

Spring工作流程描述 1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获； 2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回； 3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法） 4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作： HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

springMVC工作原理：整个处理过程从一个HTTP请求开始： 1）DispatcherServlet接收到请求后，根据对应配置文件中配置的处理器映射，找到对应的处理器映射项（HandlerMapping），根据配置的映射规则，找到对应的处理器（Handler）。 2）调用相应处理器中的处理方法，处理该请求，处理器处理结束后会将一个ModelAndView类型的数据传给DispatcherServlet，这其中包含了处理结果的视图和视图中要使用的数据。 3）DispatcherServlet根据得到的ModelAndView中的视图对象，找到一个合适的ViewResolver（视图解析器），根据视图解析器的配置，DispatcherServlet将视图要显示的数据传给对应的视图，最后给浏览器构造一个HTTP响应。 DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求组织协调Spring MVC的各个组成部分。其主要工作有以下三项： 1）截获符合特定格式的URL请求。 2）初始化DispatcherServlet上下文对应的WebApplicationContext，并将其与业务层、持久化层的WebApplicationContext建立关联。 3）初始化Spring MVC的各个组成组件，并装配到DispatcherServlet中。

Spingmvc 基于MVC的设计思想更高效servlet 手写代码但是更灵活

1、首先要明确什么是拦截器、什么是过滤器1.1 什么是拦截器： 拦截器，在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。 在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。 谈到拦截器，还有一个词大家应该知道——拦截器链（Interceptor Chain，在Struts2中称为拦截器栈 Interceptor Stack）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。 1.2. 拦截器的实现原理： 大部分时候，拦截器方法都是通过代理的方式来调用的。Struts2的拦截器实现相对简单。当请求到达Struts2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器。1.3 什么是过滤器过滤器是一个程序，它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息。在这之后，过滤器可以作如下的选择：①以常规的方式调用资源（即，调用servlet或JSP页面）。②利用修改过的请求信息调用资源。③调用资源，但在发送响应到客户机前对其进行修改。④阻止该资源调用，代之以转到其他的资源，返回一个特定的状态代码或生成替换输出。1.4 Servlet过滤器的基本原理在Servlet作为过滤器使用时，它可以对客户的请求进行处理。处理完成后，它会交给下一个过滤器处理，这样，客户的请求在过滤链里逐个处理，直到请求发送到目标为止。例如，某网站里有提交“修改的注册信息”的网页，当用户填写完修改信息并提交后，服务器在进行处理时需要做两项工作：判断客户端的会话是否有效；对提交的数据进行统一编码。这两项工作可以在由两个过滤器组成的过滤链里进行处理。当过滤器处理成功后，把提交的数据发送到最终目标；如果过滤器处理不成功，将把视图派发到指定的错误页面。2、拦截器与过滤器的区别 ： 1. 拦截器是基于java的反射机制的，而过滤器是基于函数回调。2. 拦截器不依赖与servlet容器，过滤器依赖与servlet容器。 3. 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。4. 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。 5. 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次拦截器的代码实现(以struts2为例)：1、在xml文件中如何定义拦截器<interceptors><interceptor name="filterIPInterceptor"class="com.xxxx.web.FilterIPActionInterceptor" /><interceptor-stack name="filterIPStack"><interceptor-ref name="defaultStack" /><interceptor-ref name="filterIPInterceptor" /></interceptor-stack></interceptors>2、怎么遍别写自定义拦截器 public class FilterIPActionInterceptor extends AbstractInterceptor{/** 日志控制. */private final Log log = LogFactory.getLog(getClass());/*** @see com.opensymphony.xwork2.interceptor.AbstractInterceptor#intercept(com.opensymphony.xwork2.ActionInvocation)*/@Override@SuppressWarnings("unchecked")public String intercept(ActionInvocation invocation) throws Exception{String result = null;// 获得当前方法名.String methodName = invocation.getInvocationContext().getName();String currIp = null;try{if (invocation.getAction() instanceof PortletAction){PortletAction action = (PortletAction) invocation.getAction();currIp = action.getRequest().getRemoteAddr();}String ip = ApplicationResource.getHotValue("ALLOW_CACHE_IP");if (StringUtils.isBlank(ip) || StringUtils.isBlank(currIp)){log.error("允许刷新的IP不存在或当前请求的IP非法.");throw new NoAllowIPException();}else{String[] ips = ip.split(",");boolean errorIp = true;for (String s : ips){if (s.equals(currIp))errorIp = false;}// 判断IPif (errorIp)throw new NoAllowIPException();}result = invocation.invoke();//调用被拦截的方法}catch (Exception e){log.error("异常类名:" + invocation.getAction().getClass());log.error("异常方法:" + methodName, e);throw e;}return result;}}3、怎么编写过滤器1、在web.xml里面配置自定义的拦截器<filter><filter-name>Redirect Filter</filter-name><filter-class>com.xx.filter.RedirectFilter</filter-class></filter><filter-mapping><filter-name>Redirect Filter</filter-name><url-pattern>/xx/xx/*</url-pattern></filter-mapping>2、如何编写自定义的拦截器public class RedirectFilter implements Filter {public void doFilter(ServletRequest request, ServletResponse response,FilterChain filterChain) throws IOException, ServletException {// 获取URLLong startTime = null;if (log.isDebugEnabled()){startTime = System.currentTimeMillis();}HttpServletRequest httpRequest = (HttpServletRequest) request;String url = httpRequest.getRequestURL().toString();if (url == null || url.trim().length() == 0) {return;}if (url.indexOf(luceneCreateMapping) != -1|| url.indexOf(luceneSearchMapping) != -1) {doFilterForxxx(request, response, url);} else {doxxxx(request, response, url);}if (log.isDebugEnabled()){long endTime = System.currentTimeMillis();Thread currentThread = Thread.currentThread();String threadName = currentThread.getName();log.debug("[" + threadName + "]" + "< "+ this.getClass().getName() + " " + url + " "+ (endTime - startTime) + " ms");}// 激活下一个FilterfilterChain.doFilter(request, response);}}

这个是你需要的吗？如果满意请采纳，谢谢。

前面一篇文章我们已经分析过了SpringMVC的初始化流程( https://www.jianshu.com/p/b254a45612e8 ),现在我们继续探究一下SpringMVC的请求处理过程; 首先复习一下,Spring基于Servlet实现的类的继承结构,有了继承结构图,我们就能更好的分析其原理 如你所知,HttpServlet类中有处理请求的doGet(), doPost(), service()等方法,如下图所示 有了HttpServlet的成员,我们再来看看它具体的实现,下面是HttpServlet接口的部分源码 关键部分都已经在源码中给出说明 从源码可知,FrameworkServlet对部分不同类型的请求进行了实现,那么就来看看FrameworkServlet的源码 从FrameworkServlet源码可知, doGet(), doPost(),doDelete(), doPut()等方法都调用了该类的processRequest()方法;而这个processRequest()方法最重要的就是doService()方法, 而doService()方法是由其子类DispatcherServlet实现的,所以我们不得不去看看DispatcherServlet的源码了; 至此,我们才到了DispatcherServlet处理请求的核心方法了, 至于doDispatch()方法,究竟是怎么处理的呢? 我们继续探究,先贴出doDispatch()的源码 这里借用松哥大佬的一张流程图，来详细总结一下doDispatch的流程， 原文链接： https://blog.csdn.net/u012702547/article/details/115176519?spm=1001.2014.3001.5501 未完待续

SpringMvc是spring的一个模块 基于MVC的一个框架 无需中间整合层来整合 SpringMvc整个的执行流程：1、发起请求到前端控制器（DispatcherServlet ）2、前端控制器请求HandlerMapping查找Handler（可以根据xml、注解进行查找）3、处理器映射器HandlerMapping向前端控制器DispatcherServlet 返回Handler4、前端控制器DispatcherServlet 调用处理器适配器HandlerAdapter 执行Handler5、处理器适配器HandlerAdapter 执行Handler6、Handler执行完给处理器适配器返回ModelAndView7、处理器适配器向前端控制器返回ModelAndView （ModelAndView 是SpringMvc的底层对象 包括model和view）8、前端控制器请求视图解析器去解析视图根据逻辑视图名解析成真正的视图（jsp）9、视图解析器向前端控制器返回view10、前端控制器进行视图渲染视图渲染将模型数据（模型数据在ModelAndView对象中）填充到request域11、前端控制器向用户响应结果

在Spring框架中，Spring MVC是基于Servlet API的MVC框架。Spring MVC的核心思想是将应用程序分成三个部分：模型（Model）、视图（View）和控制器（Controller）。在Spring MVC中，控制器负责处理HTTP请求并返回HTTP响应。控制器通过模型将数据传递给视图，然后视图负责将数据渲染成HTML响应。Spring框架提供了一个DispatcherServlet，它是一个Servlet，作为Spring MVC的前端控制器，用于管理控制器的生命周期和处理HTTP请求的分发。当客户端发送请求时，请求首先到达DispatcherServlet，然后DispatcherServlet将请求分派给适当的控制器。控制器处理请求并返回ModelAndView对象，该对象包含要渲染的视图名称和模型数据。然后DispatcherServlet根据视图名称调用视图解析器，解析器将找到视图并渲染响应。Spring框架使用了许多注解和XML配置来管理Spring MVC。在注解方面，@Controller和@RestController注解用于标记控制器类，@RequestMapping注解用于映射请求路径和处理方法。在XML配置方面，可以使用Spring的XML配置文件来配置DispatcherServlet、视图解析器和其他Spring MVC组件。

SpringMVC和spring是两个概念，不要搞混了

参见 http://www.blogjava.net/fiele/archive/2014/08/24/417283.html

网页链接

1、springmvc基于方法开发的，struts2基于类开发的。2、单例和多例的区别：springmvc在映射的时候，通过形参来接收参数的，是将url和controller方法映射，映射成功后，springmvc生成一个handlers对象，对象中只包括一个method，方法执行结束的时候，形参的数据就销毁，所以springmvc可以进行单例开发，并且建议使用。但是structs接收的参数是通过类的成员变量来接收的，这些变量在多线程访问中，是共享的，而不是像springmvc那样，方法结束之后，形参自动销毁，且无法使用单例，只能使用多例。3、structs速度慢，在与使用structs标签，如果使用structs建议使用jstl。4、机制：spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。5、设计思想上：struts更加符合oop(面向对象编程)的编程思想， spring就比较谨慎，在servlet上扩展。

spring 是是一个开源框架，是为了解决企业应用程序开发，功能如下◆目的：解决企业应用开发的复杂性◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能◆范围：任何Java应用简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。Spring的两大核心AOP与IOC，可以单独用于任何应用，包括与Struts等MVC框架与Hibernate等ORM框架的集成，目前很多公司所谓的轻量级开发就是用 Spring + Struts(2)+Hibernate。 Spring MVC就是一个MVC框架，个人觉得Spring MVC annotation式的开发比Struts2方便，可以直接代替上面的Struts（当然Struts的做为一个非常成熟的MVC，功能上感觉还是比Spring强一点，不过Spring MVC已经足够用了）。当然spring mvc的执行效率比struts高，是因为struts的值栈影响效率spring mvc类似于struts的一个MVC开框架，其实都是属于spring，spring mvc需要有spring的架包作为支撑才能跑起来如果有人问你什么事控制反转（spring的核心面试常问道）：你就回答，本来程序是由我们new 出来的嘛，后来交给程序控制进行new出来了嘛，这就是控制反转嘛，打了那么多手都麻了，看在我那么辛苦的份上给分吧

springmvc常用注解标签详解1、@Controller在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMVC 中提供了一个非常简便的定义Controller 的方法，你无需继承特定的类或实现特定的接口，只需使用@Controller 标记一个类是Controller ，然后使用@RequestMapping 和@RequestParam 等一些注解用以定义URL 请求和Controller 方法之间的映射，这样的Controller 就能被外界访问到。此外Controller 不会直接依赖于HttpServletRequest 和HttpServletResponse 等HttpServlet 对象，它们可以通过Controller 的方法参数灵活的获取到。@Controller 用于标记在一个类上，使用它标记的类就是一个SpringMVC Controller 对象。分发处理器将会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping 注解。@Controller 只是定义了一个控制器类，而使用@RequestMapping 注解的方法才是真正处理请求的处理器。单单使用@Controller 标记在一个类上还不能真正意义上的说它就是SpringMVC 的一个控制器类，因为这个时候Spring 还不认识它。那么要如何做Spring 才能认识它呢？这个时候就需要我们把这个控制器类交给Spring 来管理。有两种方式：（1）在SpringMVC 的配置文件中定义MyController 的bean 对象。（2）在SpringMVC 的配置文件中告诉Spring 该到哪里去找标记为@Controller 的Controller 控制器。2、@RequestMappingRequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。3、@Resource和@Autowired@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。4、@ModelAttribute和 @SessionAttributes代表的是：该Controller的所有方法在调用前，先执行此@ModelAttribute方法，可用于注解和方法参数中，可以把这个@ModelAttribute特性，应用在BaseController当中，所有的Controller继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。@SessionAttributes即将值放到session作用域中，写在class上面。具体示例参见下面：使用 @ModelAttribute 和 @SessionAttributes 传递和保存数据5、@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数。6、@requestParam@requestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter("name")，它有三个常用参数：defaultValue = "0", required = false, value = "isApp"；defaultValue 表示设置默认值，required 铜过boolean设置是否是必须要传入的参数，value 值表示接受的传入的参数类型。7、@ResponseBody作用： 该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；8、@Component相当于通用的注解，当不知道一些类归到哪个层时使用，但是不建议。9、@Repository用于注解dao层，在daoImpl类上面注解。

Spring与SpringMVC的区别1、Spring 是是一个开源框架，是为了解决企业应用程序开发，简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等，将应用逻辑的开发留给了你。Spring使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。Spring的两大核心AOP与IOC，可以单独用于任何应用，包括与Struts等MVC框架与Hibernate等ORM框架的集成，目前很多公司所谓的轻量级开发就是用 Spring + Struts(2)+Hibernate。2、Spring MVC就是一个MVC框架，Spring MVC annotation式的开发比Struts2方便，可以直接代替上面的Struts（当然Struts的做为一个非常成熟的MVC，功能上感觉还是比Spring强一点，不过Spring MVC已经足够用了）。spring mvc的执行效率比struts高，是因为struts的值栈影响效率Spring MVC类似于struts的一个MVC开框架，其实都是属于Spring ，Spring MVC需要有Spring 的架包作为支撑才能跑起来。

用maven导入的？导入的包是否有非mave仓库中的？

总商品成交笔数英文怎么说Gross Transactions Concluded on Merchandise

@Valid 只能用来验证 @RequestBody 标注的参数

mysqlspring mvc db.properties:driver=com.mysql.jdbc.Driver url=jdbc:mysql://114.215.207.30:3306busticket?useUnicode=true&characterEncoding=UTF-8username=PBDBpassword=PBDB springmvc-servlet.xml: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd ">严重: Servlet.service() for servlet [springmvc] in context with path [/Test] threw exception [Request processing failed; nested exception is org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.exceptions.PersistenceException: Error querying database. Cause: org.springframework.jdbc.CannotGetJdbcConnectionException: Could not get JDBC Connection; nested exception is org.apache.commons.dbcp.SQLNestedException: Cannot load JDBC driver class "com.mysql.jdbc.Driver "The error may exist in com/aowin/dao/CardMapper.xmlThe error may involve com.aowin.dao.CardMapper.selectThe error occurred while executing a queryCause: org.springframework.jdbc.CannotGetJdbcConnectionException: Could not get JDBC Connection; nested exception is org.apache.commons.dbcp.SQLNestedException: Cannot load JDBC driver class "com.mysql.jdbc.Driver "] with root causejava.lang.ClassNotFoundException: com.mysql.jdbc.Driver at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1714) at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1559) at org.apache.commons.dbcp.BasicDataSource.createConnectionFactory(BasicDataSource.java:1420) at org.apache.commons.dbcp.BasicDataSource.createDataSource(BasicDataSource.java:1371) at org.apache.commons.dbcp.BasicDataSource.getConnection(BasicDataSource.java:1044) at org.springframework.jdbc.datasource.DataSourceUtils.doGetConnection(DataSourceUtils.java:111) at org.springframework.jdbc.datasource.DataSourceUtils.getConnection(DataSourceUtils.java:77) at org.mybatis.spring.transaction.SpringManagedTransaction.openConnection(SpringManagedTransaction.java:80) at org.mybatis.spring.transaction.SpringManagedTransaction.getConnection(SpringManagedTransaction.java:66) at org.apache.ibatis.executor.BaseExecutor.getConnection(BaseExecutor.java:271) at org.apache.ibatis.executor.SimpleExecutor.prepareStatement(SimpleExecutor.java:69) at org.apache.ibatis.executor.SimpleExecutor.doQuery(SimpleExecutor.java:56) at org.apache.ibatis.executor.BaseExecutor.queryFromDatabase(BaseExecutor.java:259) at org.apache.ibatis.executor.BaseExecutor.query(BaseExecutor.java:132) at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:105) at org.apache.ibatis.executor.CachingExecutor.query(CachingExecutor.java:81) at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:104) at org.apache.ibatis.session.defaults.DefaultSqlSession.selectList(DefaultSqlSession.java:98) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.mybatis.spring.SqlSessionTemplate$SqlSessionInterceptor.invoke(SqlSessionTemplate.java:355) at com.sun.proxy.$Proxy14.selectList(Unknown Source) at org.mybatis.spring.SqlSessionTemplate.selectList(SqlSessionTemplate.java:195) at org.apache.ibatis.binding.MapperMethod.executeForMany(MapperMethod.java:114) at org.apache.ibatis.binding.MapperMethod.execute(MapperMethod.java:58) at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:43) at com.sun.proxy.$Proxy15.select(Unknown Source) at com.aowin.service.imp.SelectImp.select(SelectImp.java:53) at com.aowin.controller.CardController.chong(CardController.java:49) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) at java.lang.reflect.Method.invoke(Method.java:606) at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:222) at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:137) at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:110) at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:814) at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:737) at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85) at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:959) at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:893) at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:969) at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:871) at javax.servlet.http.HttpServlet.service(HttpServlet.java:647) at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:845) at javax.servlet.http.HttpServlet.service(HttpServlet.java:728) at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:305) at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:210) at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:222) at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:123) at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:472) at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:171) at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:99) at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:953) at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:118) at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:408) at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1008) at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:589) at org.apache.tomcat.util.net.AprEndpoint$SocketProcessor.run(AprEndpoint.java:1852) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615) at java.lang.Thread.run(Thread.java:745)

spring的RequestMappingHandlerAdapter中的messageConverters就能够全局格式化日期格式1. 配置spring-servlet- 引入请求映射器org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter- 加入消息转化器messageConverters- 引入Json转化器org.springframework.http.converter.json.MappingJackson2HttpMessageConverter- 实现对象转化器objectMapper- 日期转换格式定义dateFormat2. 代码<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"><property name="webBindingInitializer"><bean class="com.suixingpay.common.web.WebBindingInitializer"><property name="conversionService"><bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean"></bean></property></bean></property><property name="messageConverters"><list><bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter" /><bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"><property name="objectMapper"><bean class="com.fasterxml.jackson.databind.ObjectMapper"><property name="dateFormat"><bean class="java.text.SimpleDateFormat"><constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" /></bean></property><property name="serializationInclusion"><value type="com.fasterxml.jackson.annotation.JsonInclude.Include">NON_NULL</value></property></bean></property><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value><value>text/plain;charset=UTF-8</value><value>text/json;charset=UTF-8</value><value>application/json;charset=UTF-8</value></list></property></bean></list></property></bean>

这是格力雅居系列机组，号称飘窗下的战斗机，是格力第五代多联机，采用CAN通讯的机子，与star系列是同一代多联机。

本文先叙述，如何操作PDF模板生成PDF文件，再说明在SpringMVC中如何根据PDF模板生成PDF文件。使用PDF模板生成PDF文件需要以下几个步骤：下面按步骤说明：1. 使用Microsoft Office Word画好模板此步骤就不详述了，就是一个普通的Word文件（template.docx）。给个示例截图：2. 使用Adobe Acrobat X Pro将Word文件转换为带表单字段的PDF模板文件1) 打开Adobe Acrobat X Pro2) 选择“创建PDF表单”3) 选择源：（PDF、Word、Excel或其它文件类型），下一步4) 定位Word文件路径，下一步5) Adobe Acrobat X Pro会自动猜测表单字段位置，如图6) 一般生成的表单字段都不符合我们的要求，选中删除即可。7) 点击右键选择文本框，拖动到适当的位置，设置好域名称，字号，字体等。8) 保存模板文件。（template.pdf）3. 使用itext操作PDF模板，填充数据，生成PDF文件1) 需要jar包：itext.jar、itextAsian.jar2) 核心代码：package personal.hutao.test;import java.io.ByteArrayOutputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.OutputStream;import java.util.HashMap;import java.util.Map;import org.junit.Test;import com.lowagie.text.DocumentException;import com.lowagie.text.pdf.AcroFields;import com.lowagie.text.pdf.PdfReader;import com.lowagie.text.pdf.PdfStamper;public class TestPdf { @Test public void test() throws IOException, DocumentException { String fileName = "D:/template.pdf"; // pdf模板 PdfReader reader = new PdfReader(fileName); ByteArrayOutputStream bos = new ByteArrayOutputStream(); PdfStamper ps = new PdfStamper(reader, bos); AcroFields fields = ps.getAcroFields(); fillData(fields, data()); ps.setFormFlattening(true); ps.close(); OutputStream fos = new FileOutputStream("D:/contract.pdf"); fos.write(bos.toByteArray());} public void fillData(AcroFields fields, Map<String, String> data) throws IOException, DocumentException { for (String key : data.keySet()) { String value = data.get(key); fields.setField(key, value); } } public Map<String, String> data() { Map<String, String> data = new HashMap<String, String>(); data.put("borrower", "胡桃同学"); return data; }}3) 打开contract.pdf，如图至此，就实现了根据PDF模板生成PDF文件。SpringMVC的视图中已提供了对PDF模板文件的支持：org.springframework.web.servlet.view.document.AbstractPdfStamperView。那么只需要配置好此视图就可以了。具体分为以下步骤：1) 实现抽象类 AbstractPdfStamperViewpackage personal.hutao.view;import java.io.IOException;import java.util.Map;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.web.servlet.view.document.AbstractPdfStamperView;import com.lowagie.text.DocumentException;import com.lowagie.text.pdf.AcroFields;import com.lowagie.text.pdf.PdfStamper;public class PdfStamperView extends AbstractPdfStamperView { public static final String DATA = "data"; public static final String FILENAME = "mergePdfFileName"; @SuppressWarnings("unchecked") @Override protected void mergePdfDocument(Map<String, Object> model, PdfStamper stamper, HttpServletRequest request, HttpServletResponse response) throws Exception { response.setHeader("Content-Disposition", "attachment;filename=" + new String(model.get(FILENAME).toString().getBytes(), "ISO8859-1")); AcroFields fields = stamper.getAcroFields(); fillData(fields, (Map<String, String>) model.get(DATA)); stamper.setFormFlattening(true); } private void fillData(AcroFields fields, Map<String, String> data) throws IOException, DocumentException { for (String key : data.keySet()) { String value = data.get(key); fields.setField(key, value); } }}2) 在SpringMVC的配置文件中配置视图<!-- 按照BeanName解析视图 --><bean class="org.springframework.web.servlet.view.BeanNameViewResolver"> <property name="order" value="1" /></bean><!-- 定义Pdf模版视图 --><bean id="contract" class="personal.hutao.view.PdfStamperView"> <property name="url" value="/WEB-INF/template/template.pdf" /></bean>3) Controller中的业务逻辑处理package personal.hutao.controller;import static personal.hutao.view.PdfStamperView.DATA;import static personal.hutao.view.PdfStamperView.FILENAME;import java.util.HashMap;import java.util.Map;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;import com.coamctech.sample.commons.controller.BaseController;@RequestMapping("/contract")@Controllerpublic class TestController { @RequestMapping("/export/pdf") public String exportPersonalCreaditLoanContract(Model model) { model.addAttribute(DATA, data()); model.addAttribute(FILENAME, "XXX贷款合同"); return "contract"; } private Map<String, String> data() { Map<String, String> data = new HashMap<String, String>(); data.put("borrower", "胡桃同学"); return data; }}

1、通过注解方式，能够将jsp对应到form表单action中对应的类中2、在类中进行逻辑操作3、将处理后的结果返回到jsp

jsp:<form:form modelAttribute="address,product" action="product_save" method="post"> <fieldset> <legend>Add a product</legend> <p> <label for="address">Address:</label> <input type="text" name="city" id="city" value="rrr" tabindex="1"> </P>x <p> <label for="address.name">address.name:</label> <input type="text" name="name" id="name" value="jjjj" tabindex="2"> </p> <p> <label for="product">Product Name: </label> <input type="text" id="product.name" name="product.name" value="kkk" tabindex="3"> </p>java:@RequestMapping(value="/product_save") public String saveProduct(@ModelAttribute("product") Product product, @ModelAttribute("address") Address address,BindingResult bindingResult, Model model) {

你吧userController的 @Resourcesprivate IUserService userService;这样写试试

各位好啊，又和大家见面了，欢迎阅读本期品玩出海周报。本周，品玩挑选的最具代表性出海新闻是：消息人士称，跨境时尚零售商SHEIN正考虑重启赴美IPO计划，最早2022年上市。图注：SHEIN网站截图对此，SHEIN方面表示公司当下没有上市计划，SHEIN两年前曾计划赴美上市，但后来取消计划。有传言称，SHEIN上市受阻和国内渐趋严格的监管、美国方面的税务审查有关。根据安永的一份报告，已上市中国跨境电商企业中，有10家在A股上市，4家在中国香港上市，赴美上市的有1家。报告还称，走向资本市场的道路上，税务合规优化是中国跨境电商企业无法回避、亟待解决的问题。论及SHEIN的成功秘诀，除了柔性供应链、根据市场及时反馈的设计生产，最重要的是享受社媒流量红利。SHEIN在数年前较早通过社媒营销和红人营销来扩充其影响力，成为海外消费者口耳相传的品牌，目前该品牌已入驻TikTokShop。此外，SHEIN移动应用是2021年全球下载量第二多的购物应用，其私域流量池十分可观。在过去的一周，出海圈还有以下要闻：品牌出海方面，欧洲大卖致欧家居中止IPO，安克创新是股东；realme计划在下个月以其最高价的机型进入欧洲高端手机市场，2022年全球销量目标增加50%。游戏出海方面，42款中国手游去年海外市场收入超1亿美元，《原神》排行第一；网易在日本开设新游戏工作室NagoshiStudio，将专注于开发在全球发布的高质量游戏机游戏。东南亚市场，2021年东南亚在线食品配送GMV达155亿美元，Grab贡献一半GMV；印尼金融科技公司Ayoconnect获1500万美元融资，联合创始人曾任Lazada董事总经理。出海营销方面，OneSight公布2021第四季度出海品牌社媒影响力榜单，《原神》登顶，电商赛道竞争激烈，PatPat、Anker排名下滑。以上就是本周的出海要闻，咱们下周见。欢迎扫描下方图片二维码添加小助手，加入出海交流社群。扫描二维码，添加小助手进群致欧家居IPO中止，安克创新是股东据雷递网公众号报道，致欧家居科技股份有限公司日前上市申请被中止，安克创新持股为9.15%。致欧家居2021年上半年营收32亿，净利润为1.4亿，扣费后净利为1.26亿元。公司曾计划募资14.86亿元，其中，3.18亿元用于研发设计中心建设项目，5.17亿元用于仓储物流体系扩建项目，3.5亿元用于郑州总部运营管理中心建设项目，3亿元用于补充流动资金。realme目标欧洲高端手机市场，2022年全球销量目标增加50%品玩1月27日讯，1月26日，realme创始人兼CEO李炳忠表示，该公司将在下个月以其最高价的机型进入欧洲高端手机市场，以扩大廉价系列以外的产品线，并使其今年全球智能手机销量增加50%。李炳忠表示，realme计划于2月开始在欧洲各地销售高端GT2Pro手机，定价为700-800美元。报道称，这大约是其目前通过亚马逊销售的GT大师版349欧元建议售价的两倍，与市场领导者苹果、三星的其他高端手机价格水准比肩。根据研究公司CounterpointResearch估计，欧洲智能手机市场在2021年1-11月产生的营收为806.5亿美元，其中高端手机占555.6亿美元。网易在日本开设新游戏工作室NagoshiStudio据新浪科技报道，网易在日本开设新游戏工作室NagoshiStudio，将专注于开发在全球发布的高质量游戏机游戏。网易聘请日本游戏开发商世嘉公司的NagoshiToshihiro来运营位于日本东京的Nagoshi工作室，该工作室将专注于开发面向全球的高质量主机游戏。与竞争对手腾讯相比，网易在国际扩张方面没有那么积极。后者一直以来寻求通过收购和投资小型游戏公司实习全球化。与此同时，网易一直在建立工作室，并在其他公司持有少量股份。SensorTower：42款中国手游去年海外市场收入超1亿美元，《原神》第一品玩1月24日讯，市场研究机构SensorTower数据显示，2021年共42款中国手游在海外市场的收入超过1亿美元，在2020年的基础上进一步增加5款。出海收入TOP30手游产品在AppStore和GooglePlay的总收入达到115亿美元，较2020年92.4亿美元增长24%，是2019年的1.8倍。2021年9月，米哈游《原神》在上市1周年之际，移动端海外收入达到2.3亿美元，打破该游戏在2020年10月创下的出海手游月收入纪录。美国市场为TOP30手游贡献了36亿美元的收入，相较2020年增长53%，取代日本，成为中国手游最大的出海市场。墨腾创投：2021年东南亚在线食品配送GMV达155亿美元近日，墨腾创投发布《东南亚在线食品配送报告》，2021年，东南亚地区在线食品配送GMV为155亿美元，比2020年的最高点增长30%。平台中，Grab平台GMV为76亿美元，其次是foodpanda，GMV为34亿美元，Gojek的GMV为20亿美元。国家方面，尽管印尼、泰国和新加坡仍是东南亚最大的食品配送市场，但泰国和马来西亚的同比增长率最高。Grab等平台的成功表明即使东南亚市场竞争激烈，超级应用这一商业模式是依旧有竞争力。印尼金融科技公司Ayoconnect获1500万美元融资，TigerGlobal领投据TechInAsia报道，总部位于印尼的金融API平台Ayoconnect日前获得由TigerGlobal领投的1500万美元B轮融资，公司联合创始人JakobRost曾任Lazada董事总经理。Ayoconnect成立于2016年，汇集多个来源的金融数据，帮助其合作伙伴为用户提供更丰富的金融服务。该轮融资后，公司估值提升至8000万美元左右。2021第四季度出海品牌社媒影响力榜单：电商赛道竞争激烈OneSight日前发布2021年第四季度出海品牌社媒影响力榜单，消费电子、游戏、泛娱乐行业整体表现亮眼。榜单前5名分别为：《原神》、WeTV、《MLBB》、《PUBGMobile》、TikTok。据OneSight官方公众号，2021Q4电子商务出海品牌在海外社媒影响力排名方面呈现变化大、竞争激烈的趋势。如PatPat、Anker这样的老牌选手均有一定程度的排名下降，与此同时，如Cider、Pinkoi这样的后浪势力却持续推动电子商务这一榜单江湖的发展。

　　1.封装分页Page类　　package com.framework.common.page.impl;　　　　import java.io.Serializable;　　　　import com.framework.common.page.IPage;　　/**　　*　　*　　*　　*/　　public abstract class BasePage implements IPage, Serializable {　　　　/**　　*　　*/　　private static final long serialVersionUID = -3623448612757790359L;　　　　public static int DEFAULT_PAGE_SIZE = 20;　　private int pageSize = DEFAULT_PAGE_SIZE;　　private int currentResult;　　private int totalPage;　　private int currentPage = 1;　　private int totalCount = -1;　　　　public BasePage(int currentPage, int pageSize, int totalCount) {　　this.currentPage = currentPage;　　this.pageSize = pageSize;　　this.totalCount = totalCount;　　}　　　　public int getTotalCount() {　　return this.totalCount;　　}　　　　public void setTotalCount(int totalCount) {　　if (totalCount < 0) {　　this.totalCount = 0;　　return;　　}　　this.totalCount = totalCount;　　}　　　　public BasePage() {　　}　　　　public int getFirstResult() {　　return (this.currentPage - 1) * this.pageSize;　　}　　　　public void setPageSize(int pageSize) {　　if (pageSize < 0) {　　this.pageSize = DEFAULT_PAGE_SIZE;　　return;　　}　　this.pageSize = pageSize;　　}　　　　public int getTotalPage() {　　if (this.totalPage <= 0) {　　this.totalPage = (this.totalCount / this.pageSize);　　if ((this.totalPage == 0) || (this.totalCount % this.pageSize != 0)) {　　this.totalPage += 1;　　}　　}　　return this.totalPage;　　}　　　　public int getPageSize() {　　return this.pageSize;　　}　　　　public void setPageNo(int currentPage) {　　this.currentPage = currentPage;　　}　　　　public int getPageNo() {　　return this.currentPage;　　}　　　　public boolean isFirstPage() {　　return this.currentPage <= 1;　　}　　　　public boolean isLastPage() {　　return this.currentPage >= getTotalPage();　　}　　　　public int getNextPage() {　　if (isLastPage()) {　　return this.currentPage;　　}　　return this.currentPage + 1;　　}　　　　public int getCurrentResult() {　　this.currentResult = ((getPageNo() - 1) * getPageSize());　　if (this.currentResult < 0) {　　this.currentResult = 0;　　}　　return this.currentResult;　　}　　　　public int getPrePage() {　　if (isFirstPage()) {　　return this.currentPage;　　}　　return this.currentPage - 1;　　}　　　　　　}　　　　　　package com.framework.common.page.impl;　　　　import java.util.List;　　/**　　*　　*　　*　　*/　　public class Page extends BasePage {　　　　/**　　*　　*/　　private static final long serialVersionUID = -970177928709377315L;　　　　public static ThreadLocal<Page> threadLocal = new ThreadLocal<Page>();　　　　private List<?> data;　　　　public Page() {　　}　　　　public Page(int currentPage, int pageSize, int totalCount) {　　super(currentPage, pageSize, totalCount);　　}　　　　public Page(int currentPage, int pageSize, int totalCount, List<?> data) {　　super(currentPage, pageSize, totalCount);　　this.data = data;　　}　　　　public List<?> getData() {　　return data;　　}　　　　public void setData(List<?> data) {　　this.data = data;　　}　　　　　　}　　　　2.封装分页插件　　package com.framework.common.page.plugin;　　　　import java.sql.Connection;　　import java.sql.PreparedStatement;　　import java.sql.ResultSet;　　import java.sql.SQLException;　　import java.util.List;　　import java.util.Properties;　　　　import javax.xml.bind.PropertyException;　　　　import org.apache.commons.lang3.StringUtils;　　import org.apache.ibatis.executor.ErrorContext;　　import org.apache.ibatis.executor.ExecutorException;　　import org.apache.ibatis.executor.statement.BaseStatementHandler;　　import org.apache.ibatis.executor.statement.RoutingStatementHandler;　　import org.apache.ibatis.mapping.BoundSql;　　import org.apache.ibatis.mapping.MappedStatement;　　import org.apache.ibatis.mapping.ParameterMapping;　　import org.apache.ibatis.mapping.ParameterMode;　　import org.apache.ibatis.plugin.Interceptor;　　import org.apache.ibatis.plugin.Intercepts;　　import org.apache.ibatis.plugin.Invocation;　　import org.apache.ibatis.plugin.Plugin;　　import org.apache.ibatis.reflection.MetaObject;　　import org.apache.ibatis.reflection.property.PropertyTokenizer;　　import org.apache.ibatis.scripting.xmltags.ForEachSqlNode;　　import org.apache.ibatis.session.Configuration;　　import org.apache.ibatis.type.TypeHandler;　　import org.apache.ibatis.type.TypeHandlerRegistry;　　　　import com.framework.common.page.impl.Page;　　import com.framework.common.utils.ReflectUtil;　　/**　　*　　*　　*　　*/　　@Intercepts({ @org.apache.ibatis.plugin.Signature(type = org.apache.ibatis.executor.statement.StatementHandler.class, method = "prepare", args = { Connection.class }) })　　public class PagePlugin implements Interceptor {　　　　private String dialect = "";　　private String pageSqlId = "";　　　　@Override　　public Object intercept(Invocation invocation) throws Throwable {　　if (invocation.getTarget() instanceof RoutingStatementHandler) {　　BaseStatementHandler delegate = (BaseStatementHandler) ReflectUtil　　.getValueByFieldName(　　(RoutingStatementHandler) invocation.getTarget(),　　"delegate");　　MappedStatement mappedStatement = (MappedStatement) ReflectUtil　　.getValueByFieldName(delegate,　　"mappedStatement");　　　　Page page = Page.threadLocal.get();　　if (page == null) {　　page = new Page();　　Page.threadLocal.set(page);　　}　　　　if (mappedStatement.getId().matches(".*(" + this.pageSqlId + ")$") && page.getPageSize() > 0) {　　BoundSql boundSql = delegate.getBoundSql();　　Object parameterObject = boundSql.getParameterObject();　　　　String sql = boundSql.getSql();　　String countSqlId = mappedStatement.getId().replaceAll(pageSqlId, "Count");　　MappedStatement countMappedStatement = null;　　if (mappedStatement.getConfiguration().hasStatement(countSqlId)) {　　countMappedStatement = mappedStatement.getConfiguration().getMappedStatement(countSqlId);　　}　　String countSql = null;　　if (countMappedStatement != null) {　　countSql = countMappedStatement.getBoundSql(parameterObject).getSql();　　} else {　　countSql = "SELECT COUNT(1) FROM (" + sql + ") T_COUNT";　　}　　　　int totalCount = 0;　　PreparedStatement countStmt = null;　　ResultSet resultSet = null;　　try {　　Connection connection = (Connection) invocation.getArgs()[0];　　countStmt = connection.prepareStatement(countSql);　　BoundSql countBoundSql = new BoundSql(mappedStatement.getConfiguration(), countSql, boundSql.getParameterMappings(), parameterObject);　　　　setParameters(countStmt, mappedStatement, countBoundSql, parameterObject);　　　　resultSet = countStmt.executeQuery();　　if(resultSet.next()) {　　totalCount = resultSet.getInt(1);　　}　　} catch (Exception e) {　　throw e;　　} finally {　　try {　　if (resultSet != null) {　　resultSet.close();　　}　　} finally {　　if (countStmt != null) {　　countStmt.close();　　}　　}　　}　　　　page.setTotalCount(totalCount);　　　　ReflectUtil.setValueByFieldName(boundSql, "sql", generatePageSql(sql,page));　　}　　}　　　　return invocation.proceed();　　}　　　　　　/**　　* 对SQL参数(?)设值,参考org.apache.ibatis.executor.parameter.DefaultParameterHandler　　* @param ps　　* @param mappedStatement　　* @param boundSql　　* @param parameterObject　　* @throws SQLException　　*/　　private void setParameters(PreparedStatement ps,MappedStatement mappedStatement,BoundSql boundSql,Object parameterObject) throws SQLException {　　ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());　　List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();　　if (parameterMappings != null) {　　Configuration configuration = mappedStatement.getConfiguration();　　TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();　　MetaObject metaObject = parameterObject == null ? null: configuration.newMetaObject(parameterObject);　　for (int i = 0; i < parameterMappings.size(); i++) {　　ParameterMapping parameterMapping = parameterMappings.get(i);　　if (parameterMapping.getMode() != ParameterMode.OUT) {　　Object value;　　String propertyName = parameterMapping.getProperty();　　PropertyTokenizer prop = new PropertyTokenizer(propertyName);　　if (parameterObject == null) {　　value = null;　　} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {　　value = parameterObject;　　} else if (boundSql.hasAdditionalParameter(propertyName)) {　　value = boundSql.getAdditionalParameter(propertyName);　　} else if (propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)&& boundSql.hasAdditionalParameter(prop.getName())) {　　value = boundSql.getAdditionalParameter(prop.getName());　　if (value != null) {　　value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));　　}　　} else {　　value = metaObject == null ? null : metaObject.getValue(propertyName);　　}　　TypeHandler typeHandler = parameterMapping.getTypeHandler();　　if (typeHandler == null) {　　throw new ExecutorException("There was no TypeHandler found for parameter "+ propertyName + " of statement "+ mappedStatement.getId());　　}　　typeHandler.setParameter(ps, i + 1, value, parameterMapping.getJdbcType());　　}　　}　　}　　}　　　　/**　　* 根据数据库方言，生成特定的分页sql　　* @param sql　　* @param page　　* @return　　*/　　private String generatePageSql(String sql,Page page){　　if(page!=null && StringUtils.isNotBlank(dialect)){　　StringBuffer pageSql = new StringBuffer();　　if("mysql".equals(dialect)){　　pageSql.append(sql);　　pageSql.append(" LIMIT "+page.getCurrentResult()+","+page.getPageSize());　　}else if("oracle".equals(dialect)){　　pageSql.append("SELECT * FROM (SELECT TMP_TB.*,ROWNUM ROW_ID FROM (");　　pageSql.append(sql);　　pageSql.append(") AS TMP_TB WHERE ROWNUM <= ");　　pageSql.append(page.getCurrentResult()+page.getPageSize());　　pageSql.append(") WHERE ROW_ID > ");　　pageSql.append(page.getCurrentResult());　　}　　return pageSql.toString();　　}else{　　return sql;　　}　　}　　　　@Override　　public Object plugin(Object target) {　　return Plugin.wrap(target, this);　　}　　　　@Override　　public void setProperties(Properties properties) {　　try {　　if (StringUtils.isEmpty(this.dialect = properties　　.getProperty("dialect"))) {　　throw new PropertyException("dialect property is not found!");　　}　　if (StringUtils.isEmpty(this.pageSqlId = properties　　.getProperty("pageSqlId"))) {　　throw new PropertyException("pageSqlId property is not found!");　　}　　} catch (PropertyException e) {　　e.printStackTrace();　　}　　}　　　　}附上出处链接：http://www.jb51.net/article/71829.htm　　　　　　

是讲女主角遭遇了车祸去了天国，思念她的男友徘徊在女友发生事故的现场一直追忆着往昔。

GMV（全称Gross Merchandise Volume），即商品交易总额，是成交总额（一定时间段内）的意思。gmv=销售额+取消订单金额+拒收订单金额+退货订单金额。多用于电商行业，一般包含拍下未支付订单金额。主要是指网站的成交金额，而成交金额包括：付款金额和未付款。Gmv和成交金额的区别是Gmv包括销售额，取消订单金额，拒收订单金额以及退货订单金额，而成交金额只包括付款金额和未付款金额拓展资料1.成交金额（AMO）：表示每日已成交证券金额的数据。例如，同样1000亿的成交金额，1000点时和3000点时的成交不是一个级别的。股市的涨跌不完全取决于资金，但没有资金是万万不能的。乃至今后一个相当长的阶段，以沪市为例，成交金额的大小和行情的关系大致以1000亿为分界线，1000亿以下无行情。2.成交金额：维持在1000亿以上，可以判定是强势，上升是主基调，这也是本博一直关注此轮回调成交金额是否会萎缩到1000亿以下的原因。只要1000亿的水平保持住，行情就没完，就有戏。成交金额1500以下，行情强势但上攻有困难，有行情但难有大行情。1500－2000亿是上攻需要量，而且比较健康，持续时间长而且扎实。2000亿以上行情会走得很强，但多方消耗过大，气势磅礴却不能长久，超过2500亿绝对是杀敌一万自损三千，得不偿失，是一轮涨势终结的标志。3.换手率指标：有助于分析个股的交投情况，那么分析大盘的运行态势则可以借助于成交金额这一指标。由于小盘股换手率10%以上就达到警示水平，而大盘股则要达到20%以上，所以涉及到整个市场以换手率来计算并不具有代表性。另外，随着市场规模的扩大，板块的冷热也会出现明显的分化。这样，在判断整体市场运行格局方面，便需要借助成交金额来进行分析。

在struts2中用过filter过滤器，在springmvc中还有拦截器，它们都能过滤请求，但是到底有什么区别呢？一、定义拦截器 ：是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。过滤器：是在javaweb中，你传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉），或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符.。二、xml文件配置1.filter 该过滤器的方法是创建一个类XXXFilter实现此接口，并在该类中的doFilter方法中声明过滤规则，然后在配置文件web.xml中声明他所过滤的路径<filter> <filter-name>XXXFilter</filter-name> <filter-class> com.web.util.XXXFilter </filter-class> </filter> <filter-mapping> <filter-name>XXXFilter</filter-name> <url-pattern>*.action</url-pattern> </filter-mapping> <filter> <filter-name>XXXFilter</filter-name> <filter-class> com.web.util.XXXFilter </filter-class></filter><filter-mapping> <filter-name>XXXFilter</filter-name> <url-pattern>*.action</url-pattern></filter-mapping>2.Interceptor 它也要实现HandlerInterceptor 接口，这里只介绍方法注解配置<!-- 拦截器 --> <mvc:interceptors> <!-- 多个拦截器,顺序执行 --> <mvc:interceptor> <mvc:mapping path="/entryOrJsonController/*" /><!-- 如果不配置或/*,将拦截所有的Controller --> <bean class="com.wy.interceptor.CommonInterceptor"></bean> </mvc:interceptor> </mvc:interceptors> <!-- 拦截器 --> <mvc:interceptors> <!-- 多个拦截器,顺序执行 --> <mvc:interceptor> <mvc:mapping path="/entryOrJsonController/*" /><!-- 如果不配置或/*,将拦截所有的Controller --> <bean class="com.wy.interceptor.CommonInterceptor"></bean> </mvc:interceptor> </mvc:interceptors>三、具体区别filter Interceptor多个的执行顺序 根据filter mapping配置的先后顺序 按照配置的顺序，但是可以通过order控制顺序规范 在Servlet规范中定义的，是Servlet容器支持的 Spring容器内的，是Spring框架支持的。使用范围 只能用于Web程序中 既可以用于Web程序，也可以用于Application、Swing程序中。深度 Filter在只在Servlet前后起作用 拦截器能够深入到方法前后、异常抛出前后等四、总结 两者的本质区别：拦截器是基于java的反射机制的，而过滤器是基于函数回调。从灵活性上说拦截器功能更强大些，Filter能做的事情，他都能做，而且可以在请求前，请求后执行，比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。不过还是根据不同情况选择合适的。

Filter可认为是Servlet的一种“变种”，它主要用于对用户请求进行预处理，也可以对HttpServletResponse进行后处 理，是个典型的处理链。它与Servlet的区别在于：它不能直接向用户生成响应。完整的流程是：Filter对用户请求进行预处理，接着将请求

关于 QPS、TPS、PV、UV、GMV、IP、RPS 这些词语，看起来好像挺专业。但实际上，我认为是这是每个程序员必懂的知识点了，你可以搞不懂它们怎么计算的，但是你最少要了解它们分别代表什么意思。 2019年12月09日 - 初稿 阅读原文 - https://wsgzao.github.io/post/qps/ 扩展阅读 Queries Per Second，每秒查询数。每秒能够响应的查询次数。 QPS 是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。每秒的响应请求数，也即是最大吞吐能力。 Transactions Per Second 的缩写，每秒处理的事务数目。一个事务是指一个客户机向服务器发送请求然后服务器做出反应的过程。客户机在发送请求时开始计时，收到服务器响应后结束计时，以此来计算使用的时间和完成的事务个数，最终利用这些信息作出的评估分。 TPS 的过程包括：客户端请求服务端、服务端内部处理、服务端返回客户端。 例如，访问一个 Index 页面会请求服务器 3 次，包括一次 html，一次 css，一次 js，那么访问这一个页面就会产生一个 “T”，产生三个 “Q”。 Page View 即页面浏览量，通常是衡量一个网络新闻频道或网站甚至一条网络新闻的主要指标。户每一次对网站中的每个页面访问均被记录 1 次。用户对同一页面的多次刷新，访问量累计。 根据这个特性，刷网站的 PV 就很好刷了。 与 PV 相关的还有 RV ，即重复访问者数量 Repeat Visitors。 访问数（Unique Visitor）指独立访客访问数，统计 1 天内访问某站点的用户数 (以 cookie 为依据)，一台电脑终端为一个访客。 （Internet Protocol）独立 IP 数，是指 1 天内多少个独立的 IP 浏览了页面，即统计不同的 IP 浏览用户数量。同一 IP 不管访问了几个页面，独立 IP 数均为 1；不同的 IP 浏览页面，计数会加 1。IP 是基于用户广域网 IP 地址来区分不同的访问者的，所以，多个用户（多个局域网 IP）在同一个路由器（同一个广域网 IP）内上网，可能被记录为一个独立 IP 访问者。如果用户不断更换 IP，则有可能被多次统计。 是 Gross Merchandise Volume 的简称。只要是订单，不管消费者是否付款、卖家是否发货、是否退货，都可放进 GMV 。 代表吞吐率，即 Requests Per Second 的缩写。吞吐率是服务器并发处理能力的量化描述，单位是 reqs/s，指的是某个并发用户数下单位时间内处理的请求数。 某个并发用户数下单位时间内能处理的最大的请求数，称之为最大吞吐率。

当请求发生时， DispatcherServlet 将请求递交给 hangler mapping, 让其检测请求并提出一个

你可以把springmvc当成struts2，大概就明白了。以下内容来自网络，请认真看一遍。Spring是一个轻型容器(light-weight container)，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model)。在此基础之上，Spring提供了AOP（Aspect-Oriented Programming, 面向层面的编程）的实现，用它来提供非管理环境下申明方式的事务、安全等服务；对Bean工厂的扩展ApplicationContext更加方便我们实现J2EE的应用；DAO/ORM的实现方便我们进行数据库的开发；Web MVC和Spring Web提供了Java Web应用的框架或与其他流行的Web框架进行集成。1)开源框架2)IoC（控制反转）,将类的创建和依赖关系写在配置文件里，由配置文件注入，实现了松耦合3)AOP 将安全，事务等于程序逻辑相对独立的功能抽取出来，利用spring的配置文件将这些功能插进去，实现了按照方面编程，提高了复用性前言最近在看Spring MVC的源码,就把自己对MVC模式和对各种框架的实现的认识写出来给大家看看,算是一个总结.所以,恳请大家用怀疑的眼光来看待这篇文章,假如有认识不对的地方,麻烦指出.MVC与WEB应用MVC是什么就不用我多说了.对于现有较成熟的Model-View-Control(MVC)框架而言,其注意的主要问题无外乎下面这些:Model:模型应该包含由视图显示的数据.在J2EE Web应用中,数据通常应该由普通的javabean组成.一旦一个控制器选择了视图,模型就要包含视图相应的数据.模型本身不应该进一步的访问数据,也不应该和业务对象相联系.模型要解决的问题包括:l 封装要显示的数据l 我不认为模型要依赖于特定的框架l 不一定非得是javabeanView:视图负责显示出模型包含的信息,视图不必了解控制器或是底层业务对象的具体实现视图要解决的问题包括:l 在显示给定数据模型的情况下显示内容l 不应该包含有业务逻辑l 可能需要执行显示逻辑,比如颜色交替的显示某个数组的各行l 视图最好不处理验证的错误,数据的验证应该在由其他组件完成l 视图不应该处理参数,参数应该交由控制器集中处理Control:控制器就好像MVC里的中枢神经,它也许会需要一些助手来帮助它比如解析视图,解析参数等.控制器可以访问到业务对象或者是它的代理是很重要的,比如Struts里的Action.控制器要解决的问题包括:l 检查和抽取请求参数l 调用业务对象,传递从请求中获取的参数l 创建模型,视图讲显示对应的模型l 选择一个合适的视图发送给客户端l 控制器有时不会只有一个现有的框架现在已经有很多的MVC的框架实现.比较流行的应该就是Struts和Webwork了Struts这是最流行的web框架,几乎成为了实际上的工业标准.除了上面讨论的MVC模式应该有的优点以外.它还有如下一些缺点:l 每个Action只生成一次,然后就被缓存起来,再次请求这个Action的时候就不会生成新的对象,而是重复使用第一次生成的对象,这就意味着每个Action必须是线程安全的l 采用ActionForm封装了表单数据,但是却只能对应String类型的数据, 虽然它可以使用工具Commons Beanutils进行类型转化,但是仅仅是提供了对象级别的支持l 严重的依赖于Servlet API, 测试比较困难(不过下一版Struts里的Action.execute的方法签名讲会换成execute(ActionContext actionContext),依赖也许不会那么严重)l 框架本身的验证规则比较简单,一般都是依赖于Commons Validation进行验证l 想在Action前后做些处理很困难.有时甚至不得不自己去写专门的控制器l 由于Struts都是具体的类继承,这样很容易打破封装?l 提供各式各样的自定义的标签,但是数据绑定太原始了,这样就使页面代码依赖于Struts这个特定的框架,而它却不是规范,我觉得这是很致命的l 它太面向JSP了,尽管使用其他视图技术是有可能的,但是使用的时候却不是很方便Webwork这个框架虽然我没使用过,但是却一直在关注它的发展 Webwork的设计思想采用了比Struts更为聪明的一种方式,就技术角度上说比Struts要高出不少.它以Command模式为基础.分为Xwork和Webwork,而且框架并不依赖于Servlet API. Xwork提供了很多核心功能:拦截器（Interceptor）,运行时表单验证,类型转换,IoC容器等. WebWork建立在Xwork之上,用于处理基于HTTP的响应和请求.用Map和ActionContext封装了Session,Application等这些Servlet对象.从而解除了和Servlet API的耦合. 但是它仍然不是完美的:l 为每一个请求都创建一个Action可能有些浪费.(但是Servlet引擎也是为每个请求创建多个对象,但是也没看出来对性能有多大的影响?)l 当项目越来越大的时候,配置文件可能会很零乱.好像它不支持多个配置文件l 异常处理是Command模式里值得注意的问题:我们不知道某一特定命令可能会抛出什么特定的异常,所以execute()被迫抛出异常,而不论异常是运行时异常,还是已检查异常 Spring MVC Framework的目标上面说了一些MVC的原理,以及现在主流框架的一些问题,现在来看Spring是如何处理的. Spring MVC框架根据不同的角色定义了很多接口,但是它最大的问题也是依赖于Servlet APISpring MVC Framework有这样一些特点:l 它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是java组件.并且和Spring提供的其他基础结构紧密集成.l 不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)l 可以任意使用各种视图技术,而不仅仅局限于JSPl 支持各种请求资源的映射策略l 它应是易于扩展的我认为评价一个框架,应该有几个原则l 它应该是易于使用的,易于测试的Spring 易于使用吗?我不这么觉得,尤其是它的配置文件.在最恐怖的情况下,各种业务逻辑,基础设施也许会拥挤在一个配置文件里.而如事务处理这些基础设施应该是由容器管理而不是开发人员,就算把这些分开到几个配置文件里,逻辑上虽然清晰了,但是基础设置却还是暴露在外边Spring易于测试吗?对Spring进行单元测试很容易,测试起来很方便l 应该在多个层次上提供接口Spring提供了很多接口,而几乎每个接口都有默认的抽象实现,每个抽象实现都有一些具体实现,所以在可扩展性这点上Spring无疑是很优秀的l 框架内部和框架外部应该被区别对待框架内部可以很复杂,但是使用起来一定要简单,Spring的内部比较麻烦,但是它很好的隐藏了这种复杂性,使用起来很舒服,比如设置一个bean的属性.仅仅是setPropertyValue(String propertyName, Object value)就完成,至于怎么去设置,Spring完全隐藏了这种复杂性l 完善的文档和测试集这个就不用说了,老外的东西,都很完善 Spring Web框架基本流程知道了Spring MVC框架,现在来看看它的流程Spring MVC Framework大至流程如下:当web程序启动的时候,ContextLoaderServlet会把对应的配置文件信息读取出来,通过注射去初始化控制器DispatchServlet. 而当接受到一个HTTP请求的时候, DispatchServlet会让HandlerMapping去处理这个请求.HandlerMapping根据请求URL(不一定非要是URL,完全可以自定义,非常灵活)来选择一个Controller. 然后DispatchServlet会在调用选定的Controller的handlerRequest方法,并且在这个方法前后调用这个Controller的interceptor(假如有配置的话),然后返回一个视图和模型的集合ModelAndView.框架通过ViewResolver来解析视图并且返回一个View对象,最后调用View的render方法返回到客户端DispatcherServlet这是框架的控制器,是一个具体类,它通过运行时的上下文对象来初始化.控制器本身并不去控制流程,而只是是Controller的”控制器”,他只是把处理请求的责任委托给了对应的Controller. 控制器继承自抽象基类FrameworkServlet,它的属性webApplicationContext就代表着这个web程序上下文,而这个上下文对象默认实现就是从一个XML文件读取配置信息(当然也可以是其他文件格式). WebApplicationContext其实是beans包的东西,这个包提供了这个Spring整个框架的基础结构,以后我会分析这个包的内容.但是现在仅仅需要知道WebApplicationContext代表一个web应用的上下文对象. 现在来看看DispatchServlet是如何工作的:DispatchServlet由于继承自抽象基类FrameworkServlet,而FrameworkServlet里的doGet(),doPost()方法里有调用serviceWrapper(),跳到serviceWrapper()里去看,结果发现它有把具体实现委托给了doService(request, response); 方法.所以现在已经很清楚了, DispatchServlet真正实现功能的是doService() 这个方法. 特别的, FrameworkServlet的initFrameworkServlet()这个方法是控制器的初始化方法,用来初始化HandlerMappings之类的对象,这也是延迟到子类实现的.其实就是一个Template模式的实现.don"t call us, we will call u.总的看来,Spring就是通过这样来实现它的控制反转的:用框架来控制流程,而不是用户 跳到doService()一看究竟,就会发现真正工作的又是另一个助手函数doDispatch(request, response),没办法,继续看下去,发现这样两行代码HandlerExecutionChain mappedHandler = null; mappedHandler = getHandler(processedRequest, false);看HandlerExecutionChain源码就发现它其实就是对Controller和它的Interceptors的进行了包装; getHandler()就是从HandlerMappings(这是一个List,存放的handlerMapping对象)中取出对应的handlerMapping对象, 每个HandlerMapping对象代表一个Controller和URL的映射(其实在运行的时候是一个HandlerExecutionChain和URL的映射,而HandlerExecutionChain对象其实就是对Controller和它interceptors的一个包装器,可以把HandlerMapping看成Controller和URL的映射).而这个HandlerMapping是通过配置文件在运行时注射进来的,一般是SimpleUrlHandlerMapping这个子类 取得了HandlerMapping对象,继续向下看,发现: if (mappedHandler.getInterceptors() != null) { for (int i = 0; i < mappedHandler.getInterceptors().length; i++) { HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i]; if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) { triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null); return; } interceptorIndex = i; } }这里就是在调用Controller的拦截器,原理就是这句了: interceptor.preHandle(processedRequest, response, mappedHandler.getHandler(), mv);preHandle方法传入了mappedHandler.getHandler()这个参数来实现递归调用!而interceptor.postHandle方法如此一般.只不过这个方法是在handleRequest方法后调用 继续看下去: HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); mv = ha.handle(processedRequest, response, mappedHandler.getHandler());发现Controller的handleRequest真正的操作又被代理给了HandlerAdapter的handle方法,并且返回一个ModelAndView,我想这里增加一层的意义应该是为了解除Controller和DispatchServlet的耦合吧. 接着就很简单了,调用render()方法,在这个方法里面由ViewResoler解析出视图名,再调用视图对象的render方法把合适的视图展现给用户 到此,控制器的流程就OVER了HandlerMapping通过使用HandlerMapping,控制器可以用URL和某一个Controller进行标准的映射,而实现URL映射的具体子类的UrlHandlerMapping. Spring还允许我们自定义映射,比如通过Session,cookie或者用户状态来映射.而这一切仅仅只需要实现HandlerMapping接口而已.不过URL映射已经能满足大部分的要求ControllerController 类似Structs的Action, Controller接口只有一个方法handleRequest(),放回一个ModelAndView对象,如同设计目标所说的那样,每个Controller都是一个java组件,所以它可以在上下文环境中任意配置,组件属性都会在初始化的时候被配置.Spring自己提供了几个具体的实现.方便我们使用ViewResolverController通常返回包含视图名字而不是视图对象的ModelAndView对象.从而彻底的解除了控制器和视图之间的耦合关系,并且在这里还可以提供国际化的支持.在你的配置文件中你可以:welcomeView.class = org.springframework.web.servlet.view. InternalResourceViewwelcomeView.url=/welcome.jsp也可以welcomeView.class = org.springframework.web.servlet.view.xslt. XsltViewwelcomeView.url=/xslt/default.xslt View这也是一个java组件,它不做任何请求处理或是业务逻辑,它仅仅获取模型传递的数据,并把数据显示出来.它里面的 render方法按照如下流程工作:l 设置模型的数据到request作用域l 取得视图的URLl 转发到对应的URL总结:Spring的web框架是一个很优秀的框架,在这里只是走马观花的分析了Spring的工作流程和一些关键的类,但是并没有去深入的去探讨它背后所体现的思想,还有它的优缺点等东西.这些都等下次再说吧

从Struts2的发展过程来看，Struts2继承了Struts与WebWork的血脉，Struts2取两者之精华，形成新德框架，但是struts2还是更多的继承了struts的设计思想，并加入了WebWork的优点。在了解Struts2体系之前，让我们先看看struts2对struts做了哪些修改。Struts2与struts的不同主要体现在以下几个方面。（1） Action类1》在struts中都是使用抽象类编程而不是接口，因此他要求开发Action类继承一个抽象的基类，如DispatchAction等。2》Struts2则基于接口编程，我们的Action类可以实现一个Action接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。更加强大的是，在struts2中Action接口不是必需的，任何有execute()函数的pojo对象都可以用作struts2的Action类来使用。（2） 线程模式1》 struts的Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单列策略限制了struts Action能做的事，并且要在开发时特别小心，Action资源必须是线程安全的或同步的；2》 struts2的Action对象为每一个请求产生一个实例，因此没有线程安全问题。（3） Servlet依赖1》 struts的Action依赖于Servlet API，当一个Action被调用时，HttpServletRequest和HttpServletResponse被传递给执行方法，例如：publicActionForward execute(Actionmapping mapping,ActionForm Form,HttpServletRequestrequest,HttpServletResponse response){}2》 struts2的Action不依赖与容器，允许Action脱离容器单独被测试。如果需要，Struts2的Action任然可以访问初始的request和response。例如下面的这个类MyAction.Java，他可以通过ActionContext对象取得Session值，也可以通过ServletActionContext对象取得request对象。Publicclass MyAction{ protected Object getSession(String key){ return ActionContext.getContext().getSession(key);}protectedHttpServletRequest getRequest(){return(String)ServletActionContext.getRequest();}}（4） 可测试性1》 测试Struts Action的一个主要问题是，execute（）方法暴露了Servlet API，这使得测试要依赖于容器。虽然有第三方的软件struts TestCase能够使用模拟对象来进行测试，但显然会让我们的测试变得更加复杂。2》 Struts2 Action的类是POJO对象，因此可以直接编写测试类来测试Action类，只需要在测试类中注入属性即可。（5） 捕获输入1》 struts使用ActionForm对象捕获用户输入，所有的ActionForm必须继承一个基类ActionForm。因为其他的JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态表单可以作为创建传统ActionForm的选择，但是，开发者可能是再创建已经存在的JavaBean，仍然会导致有冗余的JavaBean；2》 struts2直接使用Action属性作为输入属性，消除对第二个输入对象的需求。输入属性可能是有自己子属性的rich对象类型。Action属性能够通过Web页面的taglibs访问。同时，struts2也支持ActionForm模式。（6） 表达式语言1》 struts整合了JSTL，这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱2》 struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言OGNL（7） 绑定值到页面1》 struts使用标准jsp机制把对象绑定到页面中来访问2》 struts2使用ValueStack（值堆栈）技术，使taglib能够访问值，而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）（8） 类型转换1》 struts的ActionForm属性通常都是String类型，并不使用 Commons-Beanutils进行类型转换。每个类提供一个转换器，对每个实例来说是不可配置的；2》 struts2使用OGNL进行OGNL进行类型转换，提供了基本和常用对象转换器。（9） 数据校验1》 struts支持在ActionForm的Validate方法中手动校验，或者通过Commons Validator来扩展校验。同一个类可以有不同的校验内容，但不能校验子对象；2》 struts2支持通过validata（）方法和XWork校验框架来进行校验，XWork校验框架使用为属性类型定义的校验和内容校验，来支持chain校验子属性。（10） Action执行的控制1》 struts支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须提供相同的生命周期；2》 struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期，堆栈能够根据需要和不同的Action一起使用

使用springMVC作为系统的整体基础架构，负责MVC的分离，在springMVC框架的模型部分，控制业务跳转，利用mybatis框架对持久层提供支持，Spring做管理，管理springMVC和mybatis。

springMVC，是spring的一个子框架，当然拥有spring的特性，如依赖注入SpringMVC 是类似于 Struts2 的一个 MVC 框架，在实际开发中，接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示，但是上手难度却比 Struts2 简单多了。而且由于 Struts2 所暴露出来的安全问题，SpringMVC 已经成为了大多数企业优先选择的框架。springMVC的DispatcherServlet继承自 FrameworkServlet继承自HttpServletBean 继承自HttpServlet（也就是你说的servelt） 本质上是一样的东西。一句话就是高级版的servlet.SSH和SSM定义SSH 通常指的是 Struts2，Spring ，Hibernate。SSM 则指的是 SpringMVC，Spring，MyBatisSSH 通常指的是 Struts2 做前端控制器，Spring 管理各层的组件，Hibernate 负责持久化层。SSM 则指的是 SpringMVC 做前端控制器，Spring 管理各层的组件，MyBatis 负责持久化层。共同之处是都使用了Spring的依赖注入DI来管理各层的组件，使用了面向切面编程AOP来实现日志管理，权限认证，事务等通用功能的切入。不同之处是 Struts2 和 SpringMVC 做前端控制器的区别，以及 Hibernate 和 MyBatis 做持久化时的区别。但是，Struts2 也可以和 MyBatis 搭配使用，SpringMVC 也可以和 Hibernate 搭配使用。本文为了简化对比，指定 Struts2 要和 Hibernate 搭配，SpringMVC 要和 MyBatis 搭配。

海尔空调KFR一35G/KTA81U1与KFR一35G/KKC81U1有什么区别亲，您好呀！很高兴为您解答！❤️❤️❤️根据查询的信息，海尔空调KFR-35G/KTA81U1和KFR-35G/KKC81U1的主要区别在于：1. 外观设计：两者外观设计稍微有些不同，KFR-35G/KTA81U1的机身略为更薄，而且把显显示屏放在茄厅了机身正面，KFR-35G/KKC81U1的显示屏位于遥控器上。2. 挂机内机的制冷咐租量：KFR-35G/KTA81U1的制冷量为1.5匹，而KFR-35G/KKC81U1的制冷量为1匹。3. 空调能效等级：两者的能效等级不同，颤简隐KFR-35G/KTA81U1的能效等级为3级，而KFR-35G/KKC81U1的能效等级为2级。4. 价格：KFR-35G/KTA81U1和KFR-35G/KKC81U1的价格也有所不同，通常KFR-35G/KTA81U1的价格略高于KFR-35G/KKC81U1。扩展资料：海尔空调是由中国海尔集团公司生产和销售的空调产品。该公司成立于1984年，总告链部位于中国青岛。海尔空调以其高品质、高性能和智能化管理而著名。其产品覆盖了墙壁式空调、中央空调、多联机和新风系统等多个领域，满足了不同用户的需求。同时，海尔空调也积极探索悄让环保技术，推出了多款节能产品，达到了国际先袜运孙进水平，受到了国内外用户的高度评价。你的意思是说KTA比KKC更胜一筹亲，综上比较，是的。有的人说KKC比KTA更胜一筹，我也不知道谁说的好亲，再分析下二者，根据自己的需求选择，没有确定说哪款好。扩展资料：海尔KFR一35G/KTA81U1和KFR一搜槐35G/KKC81U1这两款空调均为变频技术，有制冷和制热功能，而KTA81U1空调采用符合国家一级能效标准，减少能耗，KKC81U1空调采用变频智能省电技术，更加节能环保。绝纤而KTA81U1空调还拥有全新的壁挂式外形设计，而KKC81U1空调采用拉丝剔除抗菌技术，可有效抑制细菌滋生，具有更强的并漏仿抗菌性能。 如果我的回答可以帮到您(kFR一40GMVA81U1是2匹空调吗)，请及时采纳哦！

springmvc登录验证使用db校验：import java.util.ArrayList;import java.util.Collection;import java.util.List;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.security.core.GrantedAuthority;import org.springframework.security.core.authority.SimpleGrantedAuthority;import org.springframework.security.core.userdetails.User;import org.springframework.security.core.userdetails.UserDetails;import org.springframework.security.core.userdetails.UserDetailsService;import org.springframework.security.core.userdetails.UsernameNotFoundException;import org.springframework.stereotype.Repository;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import UserBean;@Repository@Service@Transactional(readOnly=true)public class SimpleUserDetailsService implements UserDetailsService {@Autowiredprivate UserDao userDAO;private UserBean domainUser; public UserDetails loadUserByUsername(String login)throws UsernameNotFoundException {domainUser = userDAO.getUser(login);boolean enabled = true;boolean disabled = false;boolean accountNonExpired = true;boolean accountExpired = false;boolean credentialsNonExpired = true;boolean credentialsExpired = false;boolean accountNonLocked = true;boolean accountLocked = false;if (null != domainUser){return new User(domainUser.getUsername(), //getLogin(),domainUser.getPassword(),enabled,accountNonExpired,credentialsNonExpired,accountNonLocked,getAuthorities(domainUser.getIduser() ) );} else {return new User("**20**","**//**",disabled,accountExpired,credentialsExpired,accountLocked,getAuthorities(-20 ) ) ;}}public Collection<? extends GrantedAuthority> getAuthorities(Integer userid) {List<GrantedAuthority> authList = getGrantedAuthorities(getRoles(userid));return authList;}public List<String> getRoles(Integer userid) {List<String> roles = new ArrayList<String>();roles = userDAO.getUserRoles(userid);return roles;}public static List<GrantedAuthority> getGrantedAuthorities(List<String> roles) {List<GrantedAuthority> authorities = new ArrayList<GrantedAuthority>();for (String role : roles) {authorities.add(new SimpleGrantedAuthority(role));}return authorities;}

ApplicationContext context=new ClassPathXmlApplicationContext("classpath*:applicationContext.xml");CustomerService customerService=(CustomerService)context.getBean("customerService");

因为这个现成不受spring容器的监管，所以无法注入bean。采用如下方法：以下是例子： ApplicationContext ctx = new AnnotationConfigApplicationContext(BulletinService.class); BulletinServicebulletinService= ctx.getBean(BulletinService.class);试试吧。

nested exception is java.lang.ClassNotFoundException: org.springframework.orm.hibernate4.LocalSessionFactoryBean这个类没有找到

第一种方法：新建Chrome快捷方式　　右击桌面上的Chrome浏览器图标，在弹出的右键菜单中选择“复制”，复制一个图标副本到桌面。右击该副本，选择“属性”，打开相应的对话框，在“目标”文本框的字符后面添加以下语句：“--user-agent="Android"”，如下图：Chrome模拟手机浏览器　　注意user前面是两个“-”，并且“chrome.exe”与“--user”之间有一个空格。确定之后，打开这个新建的Chrome快捷方式，输入3g.qq.com就可以浏览到像手机里打开一样的页面了。但是我反复测试就是失败，怎么回事？后来我发现原因了，原来要把之前打开的所有Chrome页面全部关闭后才行，换句话说，要把Chrome完全退出后再打开。第二种方法：Chrome开发者模式　　新建一个Chrome页面，然后按F12（也可以是点击菜单-工具-开发者工具），然后点击右下角的黑色锯齿小图标，如下图：Chrome模拟手机浏览器　　切换到“Overrides”标签，勾选“User Agent”和“Device metrics”，然后在“User Agent”下的下拉列表中选择不同浏览器、不同系统的选项，“Device metrics”选项会根据不同的选择显示不同的分辨率。　　注：如果没有合适的“User Agent”选项可以选择最下边的other，自定义谷歌chrome浏览器的User Agent，然后通过“Device metrics”选项自定义分辨率。第三种方法：一次性模拟iPhone和安卓手机开始–运行中输入以下命令，启动浏览器：模拟谷歌Android：chrome.exe --user-agent="Mozilla/5.0 (Linux; U; Android 2.2; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1"模拟苹果iPhone：chrome.exe --user-agent="Mozilla/5.0 (iPad; U; CPU OS 3_2_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B500 Safari/531.21.10"这种方法仅供特殊情况下使用，因为重启Chrome将不能恢复正常User-Agent，所以是一次性，推荐使用一、二两种方法。

基于安全的考虑， W3C 规范规定浏览器禁止访问不同域(origin)的资源，目前绝大部分浏览器遵循这一规范，从而衍生出了跨域资源共享 ( CORS )问题，相比于 IFRAME 或 JSONP ， CORS 更全面并且更安全， Spring Mvc 为我们提供了一套多粒度的CORS解决方案。 关于 CORS 的介绍，主要参考文章 《Cross-Origin Resource Sharing (CORS)》 CORS 的工作原理是添加新的 HTTP headers 来让服务器描述哪些源的请求可以访问该资源，对于可能对服务器造成不好影响的请求，规范规定浏览器需要先发送“预检”请求（也就是 OPTION 请求），在预检请求通过后再发送实际的请求，服务器还可以通知客户端是否应该随请求发送“凭据”（例如 Cookie 和 HTTP 身份验证），更详细的介绍可以参考上面的文章，本文主要讨论 Spring Mvc 对 CORS 的支持。 需要注意的是： 不需要发送”预检“请求 可以看见 @CrossOrigin 注解可以标注在类或者方法上，其中几个常量如 DEFAULT_ORIGINS 已经在Spring 5.0弃用，取而代之的是 CorsConfiguration#applyPermitDefaultValues 方法。 标注在类上，该类的所有方法均会生效 同时也可以类和方法结合使用 @CrossOrigin 注解比较适用于较细粒度的跨域控制，对于全局的跨域控制， Spring Mvc 提供了 Global Configuration 配置。 Spring Mvc 对于全局的 CORS 比较简单，分为两个方案 创建 WebConfig 类实现 WebMvcConfigurer 接口，通过 CorsRegistry 设置跨域信息 通过 CorsConfiguration 设置跨域信息，并将 CorsConfiguration 通过 CorsFilter 构造函数传递进去 Spring Mvc 对于 CORS 可以说是非常方便，本文主要是想让各位开发者对跨域有个整体的了解，各个参数代表的含义，而不是在所有项目中都一概而论的设置为“*”，要在自身项目的实际需求以及安全性上多做思考，防止生产事故。

Defi 收益挖矿里的一池二池没有官方定义，是圈内玩家自发归纳总结的概念。一般来说一池是指那些抵押单币 （比如抵押USDT, ETH, WBTC 这些），或者抵押成熟的大体量交易对（USDC-USDT , BTC-USDT, ETH-USDT） 获得收益的池子。这些池子不会因为项目方币种价格剧烈波动给你带来损失。（但还是会有被黑和跑路风险）二池，是指抵押项目方代币的交易对才可以获得收益。比如说我有个项目XXX，为了锁定代币流动性（减少抛售），开出几个二池， XXX-ETH, XXX-USD 让投资者把项目代币XXX锁定起来。这些矿池除了被黑和跑路的风险，还要暴露在矿币价格暴涨暴跌的风险中。矿币单独抵押的算1池2池没有定论，似乎都可以。二池的特点是表面收益率极高（有的二池收益率能到夸张的年化百分之几十万），但是隐藏在其中的是极高风险，可以让贸然冲入其中all in的韭菜倾家荡产。

可能是因为Spring框架本身提供了一些注解来进行事务管理，使得在不使用XML配置的情况下也能够方便地配置和使用事务。例如，使用 @Transactional 注解可以将一个方法标记为事务方法，从而在方法执行时自动开启事务，如果方法执行成功则提交事务，否则回滚事务。此外，Spring也提供了一些默认的事务管理器，可以通过注解进行配置和使用。因此，使用注解配置事务可以减少XML配置的复杂度，提高代码的可读性和可维护性。

首先 @Transaction 是属于 Spring部分的下面来说说使用spring中的@Transaction配置详解1、Spring默认Transactional事物管理机制如果程序抛出的是运行期例外，则数据回滚 事物处理如果是重新Exception例外，则数据不会滚。可以通过配置修改该规则@Transactional(noRollbackFor=RuntimeException.class)方法事物说明@Transactional(RollbackFor=Exception.clas)@Transactional(readyOnly=true)@Transactional(timeout=100)默认30@Transactional(isolation)数据库的隔离级别{Read Uncommited:读取未提交的数据(会出现脏读 不可重复读 幻读)Read Commited:读已提交的数据(会出现不可重复读和幻读)Repeatable Read:可重复读(会出现幻读)Serializable:串行化}脏读:一个事务读取到另外一个事务未提交的更新的数据不可重复读:在同一个事务中，多次读取同一个数据返回结果有所不同，就是后续的读取可以读到另外一个事务的已经提交的更新数据可重复读:在同一个事务多次读取数据时，能够保证所读取的数据一样，也就是后读取的不能读到另外一个事务已经提交的数据幻读: 一个事务读取到另外一个事务已经提交的更新的数据针对查询方法@Transactional(propagation=Propagation.NOT_SUPPORTED)针对某个方法不开启事务@Transactional(propagation=Propagation.REQUIRED)spring默认的事务支持Propagation参数解析1、REQUIRED:业务方法需要在一个事务中运行。如果方法运行中，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。2、NOT_SUPPORIED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。3、REQUIRES_NEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起， 新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。4、MANDATORY:该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器会抛出例外。5、SUPPORTS:这一事务属性表明，如果业务方法在某一个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。6、NEVER：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。7、NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按REQUIRED属性执行，它使用了一个单独事的事务， 这个事务拥有多个 可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只会对DataSourceTransactionManager事务管理器起效。

你好。根据你的描述：实现自定义JSP标签跟SPRING有什么关系吗。。 通过实现在JSP 的TAGSUPPORT。。等等不就可以实现自定义标签吗。

根据你的描述： 实现自定义JSP标签跟SPRING有什么关系吗。。 通过实现在JSP 的TAGSUPPORT。。等等不就可以实现自定义标签吗。

根据描述： 实现自定义JSP标签跟SPRING关系 通实现JSP TAGSUPPORT等等实现自定义标签

1. Content-Type MediaType，即是Internet Media Type，互联网媒体类型；也叫做MIME类型，在Http协议消息头中，使用Content-Type来表示具体请求中的媒体类型信息。[html] view plain copy 类型格式：type/subtype(;parameter)? type 主类型，任意的字符串，如text，如果是*号代表所有； subtype 子类型，任意的字符串，如html，如果是*号代表所有； parameter 可选，一些参数，如Accept请求头的q参数， Content-Type的 charset参数。 例如： Content-Type: text/html;charset:utf-8; 常见的媒体格式类型如下： text/html ： HTML格式 text/plain ：纯文本格式 text/xml ： XML格式 image/gif ：gif图片格式 image/jpeg ：jpg图片格式 image/png：png图片格式 以application开头的媒体格式类型： application/xhtml+xml ：XHTML格式 application/xml ： XML数据格式 application/atom+xml ：Atom XML聚合格式 application/json ： JSON数据格式 application/pdf ：pdf格式 application/msword ： Word文档格式 application/octet-stream ： 二进制流数据（如常见的文件下载） application/x-www-form-urlencoded ： <form encType=””>中默认的encType，form表单数据被编码为key/value格式发送到服务器（表单默认的提交数据的格式） 另外一种常见的媒体格式是上传文件之时使用的： multipart/form-data ： 需要在表单中进行文件上传时，就需要使用该格式 以上就是我们在日常的开发中，经常会用到的若干content-type的内容格式。2. Spring MVC中关于关于Content-Type类型信息的使用 首先我们来看看RequestMapping中的Class定义：[html] view plain copy @Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Mapping public @interface RequestMapping { String[] value() default {}; RequestMethod[] method() default {}; String[] params() default {}; String[] headers() default {}; String[] consumes() default {}; String[] produces() default {}; } value: 指定请求的实际地址， 比如 /action/info之类。method： 指定请求的method类型， GET、POST、PUT、DELETE等consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html;produces: 指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回params： 指定request中必须包含某些参数值是，才让该方法处理headers： 指定request中必须包含某些指定的header值，才能让该方法处理请求其中，consumes， produces使用content-typ信息进行过滤信息；headers中可以使用content-type进行过滤和判断。3. 使用示例 3.1 headers[html] view plain copy @RequestMapping(value = "/test", method = RequestMethod.GET, headers="Referer=http://www.ifeng.com/") public void testHeaders(@PathVariable String ownerId, @PathVariable String petId) { // implementation omitted } 这里的Headers里面可以匹配所有Header里面可以出现的信息，不局限在Referer信息。 示例2[html] view plain copy @RequestMapping(value = "/response/ContentType", headers = "Accept=application/json") public void response2(HttpServletResponse response) throws IOException { //表示响应的内容区数据的媒体类型为json格式，且编码为utf-8(客户端应该以utf-8解码) response.setContentType("application/json;charset=utf-8"); //写出响应体内容 String jsonData = "{"username":"zhang", "password":"123"}"; response.getWriter().write(jsonData); } 服务器根据请求头“Accept=application/json”生产json数据。当你有如下Accept头，将遵守如下规则进行应用：①Accept：text/html,application/xml,application/json 将按照如下顺序进行produces的匹配 ①text/html ②application/xml ③application/json②Accept：application/xml;q=0.5,application/json;q=0.9,text/html 将按照如下顺序进行produces的匹配 ①text/html ②application/json ③application/xml 参数为媒体类型的质量因子，越大则优先权越高(从0到1)③Accept：*/*,text/*,text/html 将按照如下顺序进行produces的匹配 ①text/html ②text/* ③*/*即匹配规则为：最明确的优先匹配。Requests部分Header解释示例Accept 指定客户端能够接收的内容类型 Accept: text/plain, text/html Accept-Charset 浏览器可以接受的字符编码集。 Accept-Charset: iso-8859-5 Accept-Encoding 指定浏览器可以支持的web服务器返回内容压缩编码类型。 Accept-Encoding: compress, gzip Accept-Language 浏览器可接受的语言 Accept-Language: en,zh Accept-Ranges 可以请求网页实体的一个或者多个子范围字段 Accept-Ranges: bytes Authorization HTTP授权的授权证书 Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== Cache-Control 指定请求和响应遵循的缓存机制 Cache-Control: no-cache Connection 表示是否需要持久连接。（HTTP 1.1默认进行持久连接） Connection: close Cookie HTTP请求发送时，会把保存在该请求域名下的所有cookie值一起发送给web服务器。 Cookie: $Version=1; Skin=new; Content-Length 请求的内容长度 Content-Length: 348 Content-Type 请求的与实体对应的MIME信息 Content-Type: application/x-www-form-urlencoded Date 请求发送的日期和时间 Date: Tue, 15 Nov 2010 08:12:31 GMT Expect 请求的特定的服务器行为 Expect: 100-continue From 发出请求的用户的Email From: user@email.com Host 指定请求的服务器的域名和端口号 Host: www.zcmhi.com If-Match 只有请求内容与实体相匹配才有效 If-Match: “737060cd8c284d8af7ad3082f209582d” If-Modified-Since 如果请求的部分在指定时间之后被修改则请求成功，未被修改则返回304代码 If-Modified-Since: Sat, 29 Oct 2010 19:43:31 GMT If-None-Match 如果内容未改变返回304代码，参数为服务器先前发送的Etag，与服务器回应的Etag比较判断是否改变 If-None-Match: “737060cd8c284d8af7ad3082f209582d” If-Range 如果实体未改变，服务器发送客户端丢失的部分，否则发送整个实体。参数也为Etag If-Range: “737060cd8c284d8af7ad3082f209582d” If-Unmodified-Since 只在实体在指定时间之后未被修改才请求成功 If-Unmodified-Since: Sat, 29 Oct 2010 19:43:31 GMT Max-Forwards 限制信息通过代理和网关传送的时间 Max-Forwards: 10 Pragma 用来包含实现特定的指令 Pragma: no-cache Proxy-Authorization 连接到代理的授权证书 Proxy-Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ== Range 只请求实体的一部分，指定范围 Range: bytes=500-999 Referer 先前网页的地址，当前请求网页紧随其后,即来路 Referer: http://www.zcmhi.com/archives/71.html TE 客户端愿意接受的传输编码，并通知服务器接受接受尾加头信息 TE: trailers,deflate;q=0.5 Upgrade 向服务器指定某种传输协议以便服务器进行转换（如果支持） Upgrade: HTTP/2.0, SHTTP/1.3, IRC/6.9, RTA/x11 User-Agent User-Agent的内容包含发出请求的用户信息 User-Agent: Mozilla/5.0 (Linux; X11) Via 通知中间网关或代理服务器地址，通信协议 Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1) Warning 关于消息实体的警告信息 Warn: 199 Miscellaneous warning Responses 部分 Header解释示例Accept-Ranges 表明服务器是否支持指定范围请求及哪种类型的分段请求 Accept-Ranges: bytes Age 从原始服务器到代理缓存形成的估算时间（以秒计，非负） Age: 12 Allow 对某网络资源的有效的请求行为，不允许则返回405 Allow: GET, HEAD Cache-Control 告诉所有的缓存机制是否可以缓存及哪种类型 Cache-Control: no-cache Content-Encoding web服务器支持的返回内容压缩编码类型。 Content-Encoding: gzip Content-Language 响应体的语言 Content-Language: en,zh Content-Length 响应体的长度 Content-Length: 348 Content-Location 请求资源可替代的备用的另一地址 Content-Location: /index.htm Content-MD5 返回资源的MD5校验值 Content-MD5: Q2hlY2sgSW50ZWdyaXR5IQ== Content-Range 在整个返回体中本部分的字节位置 Content-Range: bytes 21010-47021/47022 Content-Type 返回内容的MIME类型 Content-Type: text/html; charset=utf-8 Date 原始服务器消息发出的时间 Date: Tue, 15 Nov 2010 08:12:31 GMT ETag 请求变量的实体标签的当前值 ETag: “737060cd8c284d8af7ad3082f209582d” Expires 响应过期的日期和时间 Expires: Thu, 01 Dec 2010 16:00:00 GMT Last-Modified 请求资源的最后修改时间 Last-Modified: Tue, 15 Nov 2010 12:45:26 GMT Location 用来重定向接收方到非请求URL的位置来完成请求或标识新的资源 Location: http://www.zcmhi.com/archives/94.html Pragma 包括实现特定的指令，它可应用到响应链上的任何接收方 Pragma: no-cache Proxy-Authenticate 它指出认证方案和可应用到代理的该URL上的参数 Proxy-Authenticate: Basic refresh 应用于重定向或一个新的资源被创造，在5秒之后重定向（由网景提出，被大部分浏览器支持） Refresh: 5; url=http://www.zcmhi.com/archives/94.htmlRetry-After 如果实体暂时不可取，通知客户端在指定时间之后再次尝试 Retry-After: 120 Server web服务器软件名称 Server: Apache/1.3.27 (Unix) (Red-Hat/Linux) Set-Cookie 设置Http Cookie Set-Cookie: UserID=JohnDoe; Max-Age=3600; Version=1 Trailer 指出头域在分块传输编码的尾部存在 Trailer: Max-Forwards Transfer-Encoding 文件传输编码 Transfer-Encoding:chunked Vary 告诉下游代理是使用缓存响应还是从原始服务器请求 Vary: * Via 告知代理客户端响应是通过哪里发送的 Via: 1.0 fred, 1.1 nowhere.com (Apache/1.1) Warning 警告实体可能存在的问题 Warning: 199 Miscellaneous warning WWW-Authenticate 表明客户端请求实体应该使用的授权方案 WWW-Authenticate: Basic 3.2 params的示例[html] view plain copy @RequestMapping(value = "/test/{userId}", method = RequestMethod.GET, params="myParam=myValue") public void findUser(@PathVariable String userId) { // implementation omitted } 仅处理请求中包含了名为“myParam”，值为“myValue”的请求，起到了一个过滤的作用。3.3 consumes/produces[html] view plain copy @Controller @RequestMapping(value = "/users", method = RequestMethod.POST, consumes="application/json", produces="application/json") @ResponseBody public List<User> addUser(@RequestBody User userl) { // implementation omitted return List<User> users; } 方法仅处理request Content-Type为“application/json”类型的请求. produces标识==>处理request请求中Accept头中包含了"application/json"的请求，同时暗示了返回的内容类型为application/json;4. 总结 在本文中，首先介绍了Content-Type主要支持的格式内容，然后基于@RequestMapping标注的内容介绍了主要的使用方法，其中,headers, consumes,produces,都是使用Content-Type中使用的各种媒体格式内容，可以基于这个格式内容来进行访问的控制和过滤。

是 MediaType.APPLICATION_JSON_UTF8_VALUE而不是 MediaType.APPLICATION_JSON_UTF8这两个的返回值是不一样的 consumes 指定的是一个String 类型

一.导入excel （1）使用spring上传文件a.前台页面提交<form name="excelImportForm" action="${pageContext.request.contextPath}/brand/importBrandSort" method="post" onsubmit="return checkImportPath();" enctype="multipart/form-data" id="excelImportForm"> <input type="hidden" name="ids" id="ids"> <div class="modal-body"> <div class="row gap"> <label class="col-sm-7 control-label"><input class="btn btn-default" id="excel_file" type="file" name="filename" accept="xls"/></label> <div class="col-sm-3"> <input class="btn btn-primary" id="excel_button" type="submit" value="导入Excel"/> </div> </div> </div> <div class="modal-footer"> <button type="button" class="btn btn-default" data-dismiss="modal" onClick="uncheckBoxes();">取消</button> </div>b.后台spring的controller进行相关操作，这里主要讲的是使用spring上传文件，和读取文件信息。使用spring上传文件之前，需要配置bean。<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>@RequestMapping(value = "/importBrandSort", method = RequestMethod.POST) public ModelAndView importBrandSort(@RequestParam("filename") MultipartFile file,HttpServletRequest request,HttpServletResponse response) throws Exception { String temp = request.getSession().getServletContext().getRealPath(File.separator)+ "temp"; // 临时目录 File tempFile = new File(temp);if (!tempFile.exists()) { tempFile.mkdirs(); }DiskFileUpload fu = new DiskFileUpload();fu.setSizeMax(10 * 1024 * 1024); // 设置允许用户上传文件大小,单位:位 fu.setSizeThreshold(4096); // 设置最多只允许在内存中存储的数据,单位:位 fu.setRepositoryPath(temp); // 设置一旦文件大小超过getSizeThreshold()的值时数据存放在硬盘的目录 // 开始读取上传信息 //int index = 0; /* List fileItems = null;try { fileItems = fu.parseRequest(request); }catch (Exception e) {e.printStackTrace(); }Iterator iter = fileItems.iterator(); // 依次处理每个上传的文件 FileItem fileItem = null;while (iter.hasNext()) { FileItem item = (FileItem) iter.next();// 忽略其他不是文件域的所有表单信息if (!item.isFormField()) {fileItem = item; // index++; } }if (fileItem == null)return null; */ if (file == null)return null; logger.info(file.getOriginalFilename());String name = file.getOriginalFilename();// 获取上传文件名,包括路径 //name = name.substring(name.lastIndexOf("\") + 1);// 从全路径中提取文件名 long size = file.getSize(); if ((name == null || name.equals("")) && size == 0)return null; InputStream in = file.getInputStream(); List<BrandMobileInfoEntity> BrandMobileInfos = brandService .importBrandPeriodSort(in); // 改为人工刷新缓存KeyContextManager.clearPeriodCacheData(new // PeriodDimensions());// 清理所有缓存int count = BrandMobileInfos.size();String strAlertMsg ="";if(count!=0){ strAlertMsg= "成功导入" + count + "条！"; }else {strAlertMsg = "导入失败！"; }logger.info(strAlertMsg); //request.setAttribute("brandPeriodSortList", BrandMobileInfos); //request.setAttribute("strAlertMsg", strAlertMsg);request.getSession().setAttribute("msg",strAlertMsg);return get(request, response);//return null; }代码中的注释部分是如果不使用spring的方式，如何拿到提交过来的文件名（需要是要apache的一些工具包），其实使用spring的也是一样，只是已经做好了封装，方便我们写代码。 代码中的后半部分是读取完上传文文件的信息和对数据库进行更新之后，输出到前台页面的信息。上述代码中： InputStream in = file.getInputStream(); List<BrandMobileInfoEntity> BrandMobileInfos = brandService .importBrandPeriodSort(in);读取excel的信息。 （2）使用poi读取excela.更新数据库@Override public List<BrandMobileInfoEntity> importBrandPeriodSort(InputStream in) throws Exception { List<BrandMobileInfoEntity> brandMobileInfos = readBrandPeriodSorXls(in); for (BrandMobileInfoEntity brandMobileInfo : brandMobileInfos) { mapper.updateByConditions(brandMobileInfo); } return brandMobileInfos; }这部分是sevice层的代码，用于读取excel信息之后更新数据库数据，我这里是使用mybatis。定义一个类BrandMobileInfoEntity，用与保存excel表每一行的信息，而List< BrandMobileInfoEntity > 则保存了全部信息，利用这些信息对数据库进行更新。 b.读取excel信息private List<BrandMobileInfoEntity> readBrandPeriodSorXls(InputStream is) throws IOException, ParseException { HSSFWorkbook hssfWorkbook = new HSSFWorkbook(is); List<BrandMobileInfoEntity> brandMobileInfos = new ArrayList<BrandMobileInfoEntity>(); BrandMobileInfoEntity brandMobileInfo; // 循环工作表Sheet for (int numSheet = 0;numSheet < hssfWorkbook.getNumberOfSheets(); numSheet++) {HSSFSheet hssfSheet = hssfWorkbook.getSheetAt(numSheet);if (hssfSheet == null) { continue; } // 循环行Rowfor (int rowNum = 1; rowNum <= hssfSheet.getLastRowNum(); rowNum++) { brandMobileInfo = new BrandMobileInfoEntity();HSSFRow hssfRow = hssfSheet.getRow(rowNum);for (int i = 0; i < hssfRow.getLastCellNum(); i++) {HSSFCell brandIdHSSFCell = hssfRow.getCell(i); if (i == 0) {brandMobileInfo.setBrandId(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 1) { continue; } else if (i == 2) {brandMobileInfo.setMobileShowFrom(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 3) {brandMobileInfo.setMobileShowTo(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 4) {brandMobileInfo.setSellMarkValue(getCellValue(brandIdHSSFCell)); } else if (i == 5) { brandMobileInfo.setWarehouse(getCellValue(brandIdHSSFCell));} else if (i == 6) {brandMobileInfo.setSortA1(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 7) {brandMobileInfo.setSortA2(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 8) {brandMobileInfo.setSortB(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 9) { brandMobileInfo.setSortC10(Integer.parseInt(getCellValue(brandIdHSSFCell))); }else if (i == 10) {brandMobileInfo.setSortC(Integer.parseInt(getCellValue(brandIdHSSFCell))); } else if (i == 11) {brandMobileInfo.setHitA(getCellValue(brandIdHSSFCell));} else if (i == 12) {brandMobileInfo.setHitB(getCellValue(brandIdHSSFCell)); } else if (i == 13) { brandMobileInfo.setHitC(getCellValue(brandIdHSSFCell));} else if (i == 14) { brandMobileInfo.setCustomSellType(getCellValue(brandIdHSSFCell));}else if (i == 15){ continue; }else if (i == 16) { brandMobileInfo.setChannelId(Integer.parseInt(getCellValue(brandIdHSSFCell))); } } brandMobileInfos.add(brandMobileInfo);} } return brandMobileInfos; }这种代码有点搓，还没有优化，可以大概看到是怎么读取信息的。 （3）使用mybatis更新数据。

restful 是一个风格而不是一个标准，在springmvc web开发中可以说是兴起于Rails的一种优雅的URI表述方式，是资源的状态和状态转移的描述。springmvc rest 实现springmvc的resturl是通过@RequestMapping 及@PathVariable annotation提供的,通过如@RequestMapping(value="/blog/{id}",method=RequestMethod.DELETE)即可处理/blog/1 的delete请求.Java代码 @RequestMapping(value="/blog/{id}",method=RequestMethod.DELETE) public ModelAndView delete(@PathVariable Long id,HttpServletRequest request,HttpServletResponse response) { blogManager.removeById(id); return new ModelAndView(LIST_ACTION); } @RequestMapping @PathVariable如果URL中带参数，则配合使用，如Java代码 @RequestMapping(value="/blog/{blogId}/message/{msgId}",method=RequestMethod.DELETE) public ModelAndView delete(@PathVariable("blogId") Long blogId,@PathVariable("msgId") Long msgId,HttpServletRequest request,HttpServletResponse response) { } spring rest配置指南1. springmvc web.xml配置Xml代码 <!-- 该servlet为tomcat,jetty等容器提供,将静态资源映射从/改为/static/目录，如原来访问 http://localhost/foo.css ,现在http://localhost/static/foo.css --> <servlet-mapping> <servlet-name>default</servlet-name> <url-pattern>/static/*</url-pattern> </servlet-mapping> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <!-- URL重写filter,用于将访问静态资源http://localhost/foo.css 转为http://localhost/static/foo.css --> <filter> <filter-name>UrlRewriteFilter</filter-name> <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class> <init-param> <param-name>confReloadCheckInterval</param-name> <param-value>60</param-value> </init-param> <init-param> <param-name>logLevel</param-name> <param-value>DEBUG</param-value> </init-param> </filter> <filter-mapping> <filter-name>UrlRewriteFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <!-- 覆盖default servlet的/, springmvc servlet将处理原来处理静态资源的映射 --> <servlet-mapping> <servlet-name>springmvc</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> <!-- 浏览器不支持put,delete等method,由该filter将/blog?_method=delete转换为标准的http delete方法 --> <filter> <filter-name>HiddenHttpMethodFilter</filter-name> <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class> </filter> <filter-mapping> <filter-name>HiddenHttpMethodFilter</filter-name> <servlet-name>springmvc</servlet-name> </filter-mapping> 2. webapp/WEB-INF/springmvc-servlet.xml配置,使用如下两个class激活@RequestMapping annotationJava代码 <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/> 完整配置Java代码 <beans default-autowire="byName" > <!-- 自动搜索@Controller标注的类 --> <context:component-scan base-package="com.**.controller"/> <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/> <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/> <!-- Default ViewResolver --> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> <property name="prefix" value="/pages"/> <property name="suffix" value=".jsp"></property> </bean> <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource" p:basename="i18n/messages"/> <!-- Mapping exception to the handler view --> <bean id="exceptionResolver" class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"> <!-- to /commons/error.jsp --> <property name="defaultErrorView" value="/commons/error"/> <property name="exceptionMappings"> <props> </props> </property> </bean> </beans> 3. Controller编写Java代码 /** * @RequestMapping("/userinfo") 具有层次关系，方法级的将在类一级@RequestMapping之一, * 如下面示例, 访问方法级别的@RequestMapping("/new"),则URL为 /userinfo/new */ @Controller @RequestMapping("/userinfo") public class UserInfoController extends BaseSpringController{ //默认多列排序,example: username desc,createTime asc protected static final String DEFAULT_SORT_COLUMNS = null; private UserInfoManager userInfoManager; private final String LIST_ACTION = "redirect:/userinfo"; /** * 通过spring自动注入 **/ public void setUserInfoManager(UserInfoManager manager) { this.userInfoManager = manager; } /** 列表 */ @RequestMapping public ModelAndView index(HttpServletRequest request,HttpServletResponse response,UserInfo userInfo) { PageRequest<Map> pageRequest = newPageRequest(request,DEFAULT_SORT_COLUMNS); //pageRequest.getFilters(); //add custom filters Page page = this.userInfoManager.findByPageRequest(pageRequest); savePage(page,pageRequest,request); return new ModelAndView("/userinfo/list","userInfo",userInfo); } /** 进入新增 */ @RequestMapping(value="/new") public ModelAndView _new(HttpServletRequest request,HttpServletResponse response,UserInfo userInfo) throws Exception { return new ModelAndView("/userinfo/new","userInfo",userInfo); } /** 显示 */ @RequestMapping(value="/{id}") public ModelAndView show(@PathVariable Long id,HttpServletRequest request,HttpServletResponse response) throws Exception { UserInfo userInfo = (UserInfo)userInfoManager.getById(id); return new ModelAndView("/userinfo/show","userInfo",userInfo); } /** 编辑 */ @RequestMapping(value="/{id}/edit") public ModelAndView edit(@PathVariable Long id,HttpServletRequest request,HttpServletResponse response) throws Exception { UserInfo userInfo = (UserInfo)userInfoManager.getById(id); return new ModelAndView("/userinfo/edit","userInfo",userInfo); } /** 保存新增 */ @RequestMapping(method=RequestMethod.POST) public ModelAndView create(HttpServletRequest request,HttpServletResponse response,UserInfo userInfo) throws Exception { userInfoManager.save(userInfo); return new ModelAndView(LIST_ACTION); } /** 保存更新 */ @RequestMapping(value="/{id}",method=RequestMethod.PUT) public ModelAndView update(@PathVariable Long id,HttpServletRequest request,HttpServletResponse response) throws Exception { UserInfo userInfo = (UserInfo)userInfoManager.getById(id); bind(request,userInfo); userInfoManager.update(userInfo); return new ModelAndView(LIST_ACTION); } /** 删除 */ @RequestMapping(value="/{id}",method=RequestMethod.DELETE) public ModelAndView delete(@PathVariable Long id,HttpServletRequest request,HttpServletResponse response) { userInfoManager.removeById(id); return new ModelAndView(LIST_ACTION); } /** 批量删除 */ @RequestMapping(method=RequestMethod.DELETE) public ModelAndView batchDelete(@RequestParam("items") Long[] items,HttpServletRequest request,HttpServletResponse response) { for(int i = 0; i < items.length; i++) { userInfoManager.removeById(items[i]); } return new ModelAndView(LIST_ACTION); } } 上面是rapid-framework 新版本生成器生成的代码,以后也将应用此规则,rest url中增删改查等基本方法与Controller的方法映射规则Java代码 /userinfo => index() /userinfo/new => _new() /userinfo/{id} => show() /userinfo/{id}/edit => edit() /userinfo POST => create() /userinfo/{id} PUT => update() /userinfo/{id} DELETE => delete() /userinfo DELETE => batchDelete() 注(不使用 /userinfo/add => add() 方法是由于add这个方法会被maxthon浏览器当做广告链接过滤掉,因为包含ad字符)4. jsp 编写Html代码 <form:form action="${ctx}/userinfo/${userInfo.userId}" method="put"> </form:form> 生成的html内容如下, 生成一个hidden的_method=put,并于web.xml中的HiddenHttpMethodFilter配合使用，在服务端将post请求改为put请求Java代码 <form id="userInfo" action="/springmvc_rest_demo/userinfo/2" method="post"> <input type="hidden" name="_method" value="put"/> </form> 另外一种方法是你可以使用ajax发送put,delete请求.5. 静态资源的URL重写 如上我们描述，现因为将default servlet映射至/static/的子目录，现我们访问静态资源将会带一个/static/前缀. 如 /foo.gif, 现在访问该文件将是 /static/foo.gif. 那如何避免这个前缀呢，那就是应用URL rewrite,现我们使用 http://tuckey.org/urlrewrite/, 重写规则如下Xml代码 <urlrewrite> <!-- 访问jsp及jspx将不rewrite url,其它.js,.css,.gif等将重写,如 /foo.gif => /static/foo.gif --> <rule> <condition operator="notequal" next="and" type="request-uri">.*.jsp</condition> <condition operator="notequal" next="and" type="request-uri">.*.jspx</condition> <from>^(/.*..*)$</from> <to>/static$1</to> </rule> </urlrewrite> 另笔者专门写了一个 RestUrlRewriteFilter来做同样的事件，以后会随着rapid-framework一起发布. 比这个更加轻量级.并且该代码已经贡献给spring,不知会不会在下一版本发布在线DEMO地址: http://demo.rapid-framework.org.cn:8080/springmvc_rest_demo/userinfo

区别如下：gmv即Gross Merchandise Volume，主要是指网站的成交金额，而这里的成交金额包括：付款金额和未付款。revenue专指国家或企业的收入，主要指国家的税收。gmv虽然不是实际的交易数据，但同样可以作为参考依据，因为只顾客点击了购买，无论有没有实际购买，都是统计在gmv里面的。可以用gmv来研究顾客的购买意向，顾客买了之后发生退单的比率，gmv与实际成交额的比率等等。

先把checkcode相关的代码全部去掉