spring在web.xml中的配置

spring配置文件各个属性详解

spring配置文件各个属性详解分类：spring 2012-08-09 11:25 9316人阅读评论(2) 收藏举报springaophibernateattributesxhtmlwebsphere目录(?)[+]一、引用外部属性文件<bean id="propertyConfigurer"class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><list><value>classpath:mail.properties</value><value>classpath:jdbc.properties</value></list></property></bean>我们定义了一个PropertyPlaceholderConfigurer类的实例，并将其位置属性设置为我们的属性文件。

该类被实现为Bean工厂的后处理器，并将使用定义在文件中的属性来代替所有的占位符（${...}value）。

注意：而在spring2.5的版本中提供了一种更简便的方式，如：1.<context:property-placeholderlocation="classpath:config/jdbc.properties"/>这样以后要使用属性文件中的资源时，可以使用${属性名}来获得。

二、常用数据源的配置第一种是：DBCP数据源，（需要加入2个jar文件，在spring中的lib下jakarta-commons/commons-dbcp.jar和commons-pools.jar）主要配置如下：<bean id="dataSource"class="mons.dbcp.BasicDataSource"><property name="driverClassName"value="com.mysql.jdbc.Driver"></property><property name="url"value="${jdbc.url}"></property><property name="username" value="${ername}"></property><property name="password" value="${jdbc.password}"></property></bean>第二种是：c3p0数据源，跟第一种一个类型，需加入c3p0.jar包。

基于spring-mvc.xml和application-context.xml的配置与深入理解

基于spring-mvc.xml和application-context.xml的配置与深⼊理解⽬录前沿1、application-context.xml是全局的2、spring-mvc.xml 是spring mvc的配置（1）application-context.xml配置1、⾸先介绍⼀下启动⼀个项⽬的整体流程：2、现在开始正式讲解applicationContext.xml中的配置内容⾸先准备db.properties 配置⽂件SqlSessionTemplate介绍：applicationContext.xml配置：Spring和Mybatis整合有两种⽅式事务管理的两种⽅式：（2）sping-mvc.xml的配置1.⾃动扫描2.注解驱动3.静态资源处理4.避免IE执⾏AJAX时，返回JSON出现下载⽂件5.启动SpringMVC的注解功能，完成请求和注解POJO的映射6.配置⽂件上传7.配置viewResolver视图解析8.定义跳转的⽂件的前后缀，视图模式配置前沿1、application-context.xml是全局的应⽤于多个serverlet，配合listener⼀起使⽤，web.xml中配置如下：<listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param>2、spring-mvc.xml 是spring mvc的配置web.xml中配置如下：<servlet><servlet-name>springMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:config/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup><async-supported>true</async-supported></servlet>application-context.xml这个⼀般是采⽤⾮spring mvc架构，⽤来加载Application Context。

Spring配置定时器（注解+xml）方式—整理

Spring配置定时器（注解+xml）⽅式—整理⼀、注解⽅式1. 在Spring的配置⽂件ApplicationContext.xml，⾸先添加命名空间1 xmlns:task="/schema/task"2 /schema/task3 /schema /task/springtask3.1.xsd42. 最后是我们的task任务扫描注解1<task:annotation-driven/>3. spring扫描位置1<context:annotation-config/>2<context:component-scan base-package="com.test"/>4.写⾃⼰的定时任务1 @Component //import ponent;2public class MyTestServiceImpl implements IMyTestService {3 @Scheduled(cron="0/5 * * * * ? ") //每5秒执⾏⼀次4public void myTest(){5 System.out.println("进⼊测试");6 }7 }♦注意：定时器的任务⽅法不能有返回值（如果有返回值，spring初始化的时候会告诉你有个错误、需要设定⼀个proxytargetclass的某个值为true）⼆、XML⽅式1.在spring配置⽂件中创建bean，创建schedule1<bean id="schedule"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">3<property name="triggers">4<list>5<ref bean="testTrigger"/>6</list>7</property>8</bean>2. 在spring配置⽂件中创建bean，创建你的triggers1<bean id="testTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">3<property name="jobDetail" ref="testJobDetail"/>4<property name="cronExpression" value="0 1/5 * * * ?"/>5</bean>3. 在spring配置⽂件中创建bean，指定定时器作⽤在那个类那个⽅法上⾯1<bean id="testJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">3<property name="targetObject" ref="targetTestService"/>4<property name="targetMethod" value="timerTest"/>5</bean>♦注明：把定时器作⽤在targetTestService对象中的timerTest⽅法上⾯4. 当然还得把你作⽤的对象交Spring来管理，所以在spring配置⽂件中创建作⽤类的 bean1<bean id="targetTestService" class=".service.TargetTestService" scope="prototype"></bean>♦这是时间的设置规则org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运⾏时间，只需要设置其cronExpression属性。

springmvc框架搭建之xml配置说明(spring4+hibernate4)

SpringMVC框架搭建说明Spring4.1.4 + hibernate4.3.81、web.xml配置程序运行时从web.xml开始，加载顺序为：context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet如下为web.xml的配置说明<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><!—-显示项目名称--><display-name>bmymis2</display-name> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!—-字符编码过滤器,解决中文乱码问题--><filter><filter-name>encodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>UTF-8</param-value></init-param><init-param><param-name>forceEncoding</param-name><param-value>true</param-value></init-param></filter><!—- springmvc配置--><servlet><servlet-name>springServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup> //容器启动时首先初始化该servlet </servlet><servlet-mapping><servlet-name>springServlet</servlet-name><url-pattern>/</url-pattern> //表示所有页面都由springmvc处理</servlet-mapping><!—-浏览器输入到项目名，默认打开如下配置页面--><welcome-file-list><welcome-file>/web/login.jsp</welcome-file></welcome-file-list><!—-错误跳转页面--><error-page><error-code>404</error-code><location>/404.html</location></error-page></web-app>2、applicationContext-common.xml配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><context:property-placeholder location="classpath:application.properties"/><!—-扫描包路径选项，使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入，有了该配置,那么<context:annotation-config/>这个配置就可以省略（以下配置包含了<context:annotation-config/>配置）--><context:component-scan base-package="xxx.xxx.xxx"/><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><!—Hibernate的注解配置 --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><prop key="hibernate.dialect">${hibernate.dialect}</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop></props></property><property name="packagesToScan" value="xxx.xxx.xxx.model" /></bean><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><bean id="persistenceExceptionTranslationPostProcessor"class="org.springframework.dao.annotation.PersistenceExceptionTranslationPost Processor"/> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="add*" propagation="REQUIRED"/><tx:method name="get*" propagation="REQUIRED"/><tx:method name="*" read-only="true"/></tx:attributes></tx:advice><aop:config expose-proxy="true"><aop:pointcut id="txPointcut"expression="execution(*xxx.xxx.xxx.service..*.*(..))"/><aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/> </aop:config></beans>3、application.properties配置jdbc.driverClassName=org.postgresql.Driverjdbc.url=jdbc:postgresql://ip:5432/数据库名ername=postgresjdbc.password=123hibernate.dialect=org.hibernate.dialect.PostgreSQLDialecthibernate.show_sql=truehibernate.format_sql=false4、spring-mvc.xml配置<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><mvc:annotation-driven><context:component-scan base-package="xxx.xxx.xxx "use-default-filters="false"></context:component-scan><beanclass="org.springframework.web.servlet.view.InternalResourceView Resolver"><property name="prefix"value="/jsp/"/><property name="suffix"value=".jsp"/></bean> <mvc:default-servlet-handler/><mvc:view-controller path="/"view-name="login"/></beans>。

Spring中注解配置与xml配置分析

虽然 2.0 版本发布以来，Spring 陆续提供了十多个注解，但是提供的这些注解只是为了在某些情况下简化 XML 的配置，并非要取代 XML 配置方式。这一点可以从 Spring IoC 容器的初始化类可以看出：ApplicationContext 接口的最常用的实现类是 ClassPathXmlApplicationContext 和 FileSystemXmlApplicationContext，以及面向 Portlet 的 XmlPortletApplicationContext 和面向 web 的 XmlWebApplicationContext，它们都是面向 XML 的。Spring 3.0 新增了另外两个实现类：AnnotationConfigApplicationContext 和 AnnotationConfigWebApplicationContext。从名字便可以看出，它们是为注解而生，直接依赖于注解作为容器配置信息来源的 IoC 容器初始化类。由于 AnnotationConfigWebApplicationContext 是 AnnotationConfigApplicationContext 的 web 版本，其用法与后者相比几乎没有什么差别
也可以单独显式地来启用某个注解处理器，而且可以给处理器添加拦截器：
<be.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean class="monAnnotationBeanPostProcessor"/>
<mvc:annotation-driven />
当然了也可以使用如下的方式显式地加载：

Spring中加载xml配置文件的几种方式

项目中一个需求就是所有的功能都是插件的形式装入系统，这就需要利用Spring去动态加载某一位置下的配置文件，就总结了下Spring中加载xml配置文件的方式, xml是最常见的spring 应用系统配置源。

Spring中的几种容器都支持使用xml装配bean，包括：XmlBeanFactory,ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,XmlWebApplicationContext,.....一: XmlBeanFactory 引用资源1.Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");二: ClassPathXmlApplicationContext 编译路径使用ClassPathXmlApplicationContext对象获取，必须把applicationContext.xml放置到类的加载路径中，也就是Src下面1.ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:appcontext.xml");// src目录下的2.ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao)context.getBean("userDao");3.ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-oracle.xml","applicationContext.xml"});UserDao userDao = (UserDao)context.getBean("userDao");// src/conf 目录下的4.ApplicationContext factory=new ClassPathXmlApplicationContext("conf/appcontext.xml");5.ApplicationContext factory=new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml");三: FileSystemXmlApplicationContext用文件系统的路径必须把applicationContext.xml放置到工程目录下面，也就是项目路径的下面1.ApplicationContext factory=newFileSystemXmlApplicationContext("src/appcontext.xml");//使用了classpath: 前缀,作为标志, 这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径没有classpath的话就是从当前的工作目录2.ApplicationContext factory=newFileSystemXmlApplicationContext("classpath:appcontext.xml");3.ApplicationContext factory=newFileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");4.ApplicationContext factory=newFileSystemXmlApplicationContext("G:/Test/src/appcontext.xml");四: XmlWebApplicationContext是专为Web工程定制的。

Spring的xml文件详解

Spring的xml⽂件详解spring的xml配置⽂件头：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd">........</beans>⼀直在复制黏贴，但是不知道作⽤是什么，不理解的话常出错。

xmlns和命名空间⾸先，介绍⼀下xmlns的作⽤，如下所⽰，⼀个 xml ⽂档中如果包含如下两种定义不同，但是名称相同的元素， xml 解析器是⽆法解析的，因为它不能确定当你调⽤document.getElementsByTagName("book") 时应该返回哪个元素。

<table><tr><td>Apples</td><td>Bananas</td></tr></table><table><name>African Coffee Table</name><width>80</width><length>120</length></table>这时候可以通过在名称增加前缀解决这个问题<h:table> <h:tr><h:td>Apples</h:td><h:td>Bananas</h:td></h:tr></h:table><f:table> <f:name>African Coffee Table</f:name><f:width>80</f:width><f:length>120</f:length></f:table>由此，引⼊⼀个概念命名空间，通过增加前缀表⽰不同的那是不同命名空间下的table，从⽽解决了⽭盾，但是不同的⼈都有⾃⼰创建的不同的命名空间来描述同样的东西，不利于xml⽂件信息的解析，⽐如说，同样都是⽔果，可以从颜⾊和⾹味不同⾓度来定义成如下两种形式：<perfume:fruit><name>....</name><perfume>.....</perfume></perfume:fruit><color:fruit><name>....</name><color>....</color></color:fruit>为此，w3c(万维⽹联盟)对于⼀些类型，定义了对应的命名空间和这些类型的标准，xml解释器碰到这些类型的时候就会通过这些标准去解析这类型的标签，为了确保命名空间的唯⼀，所以不同的命名空间的通常使⽤URL作为被识别的id，如下例⼦:xmlns:xsi="/2001/XMLSchema-instance"这句话的作⽤是当前引⼊了⼀个叫做xsi的命名空间，xsi可以在接下来要使⽤该命名空间时所使⽤的，如下:<xsi:schemaLocation="...... ......">⽽这个很长的字符串，则是xsi这个名称空间被xml解释器内部所识别的时候所真正使⽤的id，但也本⾝只是被当做⼀个字符串名字去处理，xml解释器根据这个id去获取它对应的标准，从⽽知道这个命名空间定义有什么样的标签(xml解释器⾃带有⼀些通⽤的命名空间的标准)，这个字符串虽然看起来是URL，但是和对应的⽹页上的信息没有关系，只是⽤来提供命名空间唯⼀性的作⽤，⽹址有时可以被打开，上⾯会有关于该命名空间的信息。

Spring中xml的配置

Spring中xml的配置（摘抄）出自：1、value元素<value/>元素通过字符串来指定属性或构造器参数的值。

<bean id="myDataSource" detroy-method="close"class="mons.dbcp.BasicDataSource"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></proerpty><property name="url"><value>jdbc:mysql://localhost:3306/mydb</value></property><property name="username"><vlaue>root</value></property></bean>2、idref元素idref元素用来将容器内其它bean的id传给<constructor-arg/>或<property/>元素，同时提供错误难功能。

<bean id="theTargetBean" class="..."/><bean id="theClientBean" class="..."><property name="targetName"><idref bean="theTargetBean" /></property></bean>等同于:<bean id="theTargetBean" class="..." /><bean id="theClientBean" class="..."><property name="targetName"><value>theTargetBean</value></bean>使用idref标记允许容器在部署时验证所被引用的bean是否存在。

springboot解析xml_SpringBoot使用及原理浅尝

springboot解析xml_SpringBoot使用及原理浅尝Spring Boot 是一个用于构建Spring 应用程序的框架，它简化了Spring 应用程序的开发过程并提供了一种快速开发的方式。

Spring Boot可以使用XML配置，下面将介绍Spring Boot使用XML配置的方法及原理。

一、Spring Boot使用XML配置的方法1.添加依赖要使用Spring Boot的XML配置，首先需要在项目的pom.xml文件中添加相应的依赖。

Spring Boot提供了spring-boot-starter-parent这个父级依赖，可以继承这个依赖来快速配置相关的依赖版本。

同时，还需要添加spring-boot-starter-web依赖用于构建Web应用程序。

2.创建XML配置文件在src/main/resources目录下创建一个application.xml文件。

在这个文件中，可以配置Spring Boot需要的相关信息，比如数据源、事务管理器、登录验证等。

3. 创建Java配置类4.运行应用程序二、Spring Boot使用XML配置原理Spring Boot使用XML配置的原理其实和普通的Spring应用程序是相似的，只不过Spring Boot提供了更简便的配置方式。

主要原理如下：1.自动配置Spring Boot通过自动配置的方式简化了配置过程。

通过Spring Boot的自动配置机制，可以根据classpath中的jar包、类名、注解等信息，来推断应用程序的配置，并自动加载所需的配置。

2.配置加载3. Bean装载4.自动装配总结Spring Boot提供了使用XML配置的功能，可以通过添加依赖、创建XML配置文件和Java配置类来实现。

Spring Boot的配置原理主要包括自动配置、配置加载、Bean装载和自动装配。

Spring Boot的自动配置功能简化了配置过程，使开发者可以更快地搭建应用程序。

spring接口通过配置支持返回多种格式（xml,json,html,excel）

spring接⼝通过配置⽀持返回多种格式（xml,json,html,excel）1. 简介本⽂主要给⼤家介绍使⽤SpringMVC的后端服务如何通过配置来⽀持多种返回值类型（xml,json,html,excel）2. 基础概念2.1 HttpHeader中Content-Type和Accept设置的区别Accept:接⼝要返回给客户端的数据格式curl --header 'Accept:application/json' http://localhost:8080/todoContent-Type:客户端发送给服务器端的数据格式curl -X PUT --header 'Content-Type:application/json' -d '{"title":"周末⽇程","content":"睡觉"}' http://localhost:8080/todo2.2 SpringMVC⽣成输出的两种⽅式1）当服务端使⽤Restful的⽅式，只为客户端的ajax或其他服务端请求提供数据时，通常会使⽤@ResponseBody来标识你的返回，这时候Spring使⽤HttpMessageConverter来把返回的对象格式化成所需的格式。

2）当你需要提供表现层(⽐如：HTML)，这时候SpringMVC使⽤ViewResolver来将处理你的返回。

有时候你的应⽤程序这两者都要提供2.3 SpringMVC输出格式判定很多时候为了⽀持多个系统或多个终端，你需要让相同的数据已不同的表现形式输出。

SpringMVC使⽤ContentNegotationStrategy来判定⽤户请求希望得到什么格式的数据。

ContentNegotationStrategy通过三种⽅式来识别⽤户想要返回什么样的数据通过请求URL后缀：http://myserver/myapp/accounts/list.html 返回html格式通过请求的参数：http://myserver/myapp/accounts/list?format=xls 该设置默认不开启，默认key是format。

springMVC配置（XML配置详解）

springMVC配置（XML配置详解）原⽂出⾃：web.xml配置：servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样，所有的.htm的请求，都会被DispatcherServlet处理；初始化 DispatcherServlet 时，该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件，并在那⾥定义相关的Beans，重写在全局中定义的任何Beans，像上⾯的web.xml中的代码，对应的是dispatcher-servlet.xml；当然也可以使⽤<init-param>元素，⼿动指定配置⽂件的路径；dispatcher-servlet.xml 配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller：package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器，@RequestMapping注解标记⼀个访问的路径（/index.htm），return "index"标记返回视图（index.jsp）；注：如果@RequestMapping注解在类级别上，则表⽰⼀相对路径，在⽅法级别上，则标记访问的路径；从@RequestMapping注解标记的访问路径中获取参数：Spring MVC ⽀持RESTful风格的URL参数，如：@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版，使⽤{}传⼊页⾯参数，使⽤@PathVariable 获取传⼊参数，即可通过地址：http://localhost:8080/crm/index/tanqimin.htm 访问；根据不同的Web请求⽅法，映射到不同的处理⽅法：使⽤登陆页⾯作⽰例，定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。

spring mvc框架 web.xml配置文件 Could not open ServletContext resource

搭建Spring 的mvc框架的时候报出来这个错误，上面的代码是在web.xml中配置的，加载的就是*-servlet.xml文件，当前默认加载的是springMVC-servlet.xml如果不给项目指定加载文件，默认加载的就是<servlet-name>名字</servlet-name>，名字-servlet.xml文件。

如果写成需要说明的是配置了servlet,在WEB-INF目录下应该有个[servlet-name]-servlet.xml文件,用于配置controller之前一直出现找不到/WEB-INF/spring-servlet.xml错误,是因为把它和applicationContext.xml放到了一起,编译过后出现在了WEB-INF/classes文件夹下面。

最后再说一下我们遇到问题盲目搜索往往不能迅速得到有效的解决方案，所以我们先从官方去寻找线索，看一看spring的官方文档，在The Web的章节中可以发现这样一段话：简单翻译一下上图标记的小段落：如果不特意指定参数名为contextConfigLoction的<context-parameter>元素，那么spring的ContextLoderListener监听器就会在/WEB-INF/下去寻找并加载该目录下的名为applicationContext.xml这个文件。

So，我们应该在web.xml中添加<context-param>标签并再次指定spring核心文件的位置：这样就OK了，注意这段配置尽量写在靠前的位置，因为在tomcat启动后web项目会先初始化上下文，我们这段配置正是指定了上下文配置的文件位置，在上下文初始化完成之后才应当继续加载其余各种配置，而我们的springMVC的servlet仅仅是springMVC 框架的相关配置，就好比struts2的配置一样，项目整体还是由spring去管理的。

Spring考试

• 1.(单选题)下列关于Spring配置文件的说法不正确的是o A.Spring默认是读取/WEB-INF/applicationContext.xml配置文件o B.Spring的配置文件可以配置在类路径下，并可以重命名，但是需要在web.xml 文件中指定o C.把applicationContext.xml文件放到src目录下，Spring也可以读到o D.可以通过在web.xml中的<context-param><param-name>和<param-value>进行指定Spring配置文件Dlgtq。

正确答案：C把applicationContext.xml文件放到src目录下，需要在web。

xml里设置<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext.xml</param-value>0jpk 7。

</context-param>可以让spring读到• 2.(单选题)下列关于Spring特性中IoC描述错误的是o A.IoC就是指程序之间的关系由程序代码直接操控o B.所谓“控制反转”是指控制权由应用代码转到外部容器，即控制权的转移o C.IoC将控制创建的职责搬进了框架中，从应用代码脱离开来o D.使用Spring的IoC容器时只需指出组件需要的对象，在运行时Spring的IoC 容器会根据XML配置数据提供给它7Jtg8。

正确答案：AIOC是来完成相互依赖的对象的创建、协调工作。

• 3.(单选题)下列关于Spring的装配模式（default-autowire）描述不正确的是o A.Spring中，至少有两种装配模式，按“类型”和“名字”o B.Spring中默认是按名字进行装配的o C.可以用default-autowire=”byType”配置按类型装配o D.一旦在一个Spring配置文件中配置了default-autowire=”byType”，其它的配置文件也是按此种装配方式进行装配ADtbu。

如何使用多个Spring的xml配置文件

如何使用多个Spring的xml配置文件(多模块配置)在用Struts Spring Hibernate进行项目团队开发的时候，我们每个开发人员可能都会用到spring的配置文件，如果我们每个开放人员都用同一个的话，这样会给项目开发带来一定的影响，不过大家不用急，Spring为我们提供了很好的方法，我们可以写多个xml文件，然后将每个文件引入进来就行了，话不多说了，马上开始！！方法一、在web.xml中定义 contextConfigLocation参数.spring会使用这个参数加载.所有”逗号”分割的xml.如果没有这个参数,spring默认加载WEB-INF/applicationContext.xml文件(我们现在将Spring配置文件都放在WEB-INF下面)<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:conf/spring/applicationContext_core*.xml,classpath*:conf/spring/applicationContext_dict*.xml,classpath*:conf/spring/applicationContext_hibernate.xml,classpath*:conf/spring/applicationContext_staff*.xml,classpath*:conf/spring/applicationContext_security.xmlclasspath*:conf/spring/applicationContext_modules*.xmlclasspath*:conf/spring/applicationContext_cti*.xmlclasspath*:conf/spring/applicationContext_apm*.xml</param-value></context-param>contextConfigLocation 参数定义了要装入的 Spring 配置文件。

web.xml配置文件超详细说明！！！

web.xml配置⽂件超详细说明！！！⼀、web.xml是什么？⾸先 web.xml 是java web 项⽬的⼀个重要的配置⽂件，但是web.xml⽂件并不是Java web⼯程必须的。

web.xml⽂件是⽤来配置：欢迎页、servlet、filter等的。

当你的web⼯程没⽤到这些时，你可以不⽤web.xml⽂件来配置你的web⼯程。

所在位置项⽬名/web/WEB-INFO/web.xml，如下图所⽰web.xml能做的事情：其实，web.xml的模式(Schema)⽂件中定义了多少种标签元素，web.xml中就可以出现它的模式⽂件所定义的标签元素，它就能拥有定义出来的那些功能。

web.xml的模式⽂件是由Sun公司定义的，每个web.xml⽂件的根元素<web-app>中，都必须标明这个web.xml使⽤的是哪个模式⽂件。

如：web.xml 配置⽂件具体的内容⼆、Web.xml详解：1.web.xml加载过程（步骤）⾸先简单讲⼀下，web.xml的加载过程。

当启动⼀个WEB项⽬时，容器包括（JBoss、Tomcat等）⾸先会读取项⽬web.xml配置⽂件⾥的配置，当这⼀步骤没有出错并且完成之后，项⽬才能正常地被启动起来。

1. 启动WEB项⽬的时候，容器⾸先会去它的配置⽂件web.xml读取两个节点: <listener></listener>和<context-param></context-param>。

2. 紧接着，容器创建⼀个ServletContext（application），这个WEB项⽬所有部分都将共享这个上下⽂。

3. 容器以<context-param></context-param>的name作为键，value作为值，将其转化为键值对，存⼊ServletContext。

4. 容器创建<listener></listener>中的类实例，根据配置的class类路径<listener-class>来创建监听，在监听中会有contextInitialized(ServletContextEvent args)初始化⽅法，启动Web应⽤时，系统调⽤Listener的该⽅法，在这个⽅法中获得：[html]1. <span style="font-family:Times New Roman;">ServletContextapplication=ServletContextEvent.getServletContext();</span>context-param的值就是application.getInitParameter("context-param的键");得到这个context-param的值之后，你就可以做⼀些操作了。

spring中读取xml配置文件、获取bean

读取xml文件/*** 利用XmlBeanFactory(Resource resource)* 这里Resource必须是xml格式* Resource包括：AbstractResource, ClassPathResource, FileSystemResource, * InputStreamResource, ServletContextResource, UrlResource*//** 利用InputStreamResource(InputStream inputStream)* 要将applicationContext.xml放在项目根目录下*/InputStream is = null;try {is = new FileInputStream("applicationContext.xml");} catch (FileNotFoundException e) {e.printStackTrace();}Resource resource = new InputStreamResource(is);BeanFactory factory = new XmlBeanFactory(resource);UserDao userDao = (UserDao)factory.getBean("userDao");/** 利用Properties* 要将bean.properties放在类路径－－源文件夹（src）目录下*/具体见1.利用ClassPathXmlApplicationContext可以从classpath中读取XML文件(1) ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao)context.getBean("userDao");(2) ClassPathXmlApplicationContext resource = new ClassPathXmlApplicationContext(new String[]{"applicationContext-ibatis-oracle.xml","applicationC ontext.xml","applicationContext-data-oracle.xml"});BeanFactory factory = resource;UserDao userDao = (UserDao) factory.getBean("userDao");2. 利用ClassPathResource可以从classpath中读取XML文件Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");加载一个xml文件org.spring framewonfig.PropertyPlaceholderConfigurer不起作用3．利用XmlWebApplicationContext读取从Web应用程序的文件架构中，指定相对位置来读取定义文件。

如何通过properties文件配置web.xml中的参数

如何通过properties⽂件配置web.xml中的参数⽬录前⾔实现思路web.xml中需要修改的部分filter.properties⽂件PropUtils⼯具类查看web.xml参数启动服务器进⾏测试web.xml前⾔因为公司项⽬需要，⽬前有本地环境、测试环境、开发环境。

每次在将项⽬打包成war包的时候，都需要修改多处的配置，⽽使⽤maven的profile打包项⽬的时候，可以根据执⾏打包命令时所带的参数来进⾏⾃动修改。

但是这种⽅式只对properties⽂件⽣效，即可以⾃动修改properties中的参数，但是公司的项⽬有⼀个web.xml中的配置参数也需要修改，这时候就要考虑如何通过properties⽂件动态修改web.xml中的参数了。

实现思路web.xml中需要修改的部分<web-app xmlns="/xml/ns/javaee" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_3_0.xsd"version="3.0" metadata-complete="true"><welcome-file-list><welcome-file>/index.jsp</welcome-file></welcome-file-list><servlet><servlet-name>mypage-dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:spring/spring-*.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>mypage-dispatcher</servlet-name><url-pattern>/</url-pattern></servlet-mapping><servlet-mapping><servlet-name>default</servlet-name><url-pattern>*.html</url-pattern></servlet-mapping><filter><filter-name>testFilter</filter-name><filter-class>com.solr.filter.StringFilter</filter-class><init-param><param-name>jersey.config.server.provider.packages</param-name><param-value>mon.action;</param-value></init-param></filter><filter-mapping><filter-name>testFilter</filter-name><url-pattern>*.*</url-pattern></filter-mapping></web-app>这⾥需要改动的是45⾏，这是过滤器的初始化参数。

springMVC配置文件详解

web.xml的配置web.xml应该是整个项目最重要的配置文件了，不过servlet3.0中已经支持注解配置方式了。

在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。

但是在spring框架中就不用了，因为Spring中是依赖注入（Dependency Injection）的也叫控制反转（Inversion of Control）。

但是也要配置一个重要的servlet，就是前端控制器（DispatcherServlet）。

配置方式与普通的servlet基本相似。

配置内容如下：<servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><url-pattern>/</url-pattern></servlet-mapping>这里需要注意，springmvc.xml是spring配置文件，将在后面讨论。

web.xml配置详解

web.xml配置详解引⽂：对于⼀个J2EE领域的程序员⽽⾔，基本上每天都会和web应⽤打交道。

什么是web应⽤？最简单的web应⽤什么样？给你⼀个web应⽤你该从何⼊⼿？1、什么是web应⽤？web应⽤是⼀种可以通过Web访问的应⽤程序。

在J2EE领域下，web应⽤就是遵守基于JAVA技术的⼀系列标准的应⽤程序。

2、最简单的web应⽤什么样？2个⽂件夹、1个xml⽂件就能成为⼀个web应⽤第⼀个⽂件夹：应⽤名，如test第⼆个⽂件夹：在test⽂件夹中创建名为WEB-INF的⽂件夹XML⽂件：在WEB-INF⽂件夹下创建web.xml⽂件，⽂件内容只需<web-app></web-app>3、给你⼀个web应⽤你该从何⼊⼿？这属于仁者见仁智者见智的问题，我通常看⼀个web应⽤是从web.xml⼊⼿的正⽂：1、web.xml学名叫部署描述符⽂件，是在Servlet规范中定义的，是web应⽤的配置⽂件。

2、部署描述符⽂件就像所有XML⽂件⼀样，必须以⼀个XML头开始。

这个头声明可以使⽤的XML版本并给出⽂件的字符编码。

DOCYTPE声明必须⽴即出现在此头之后。

这个声明告诉服务器适⽤的servlet规范的版本（如2.2或2.3）并指定管理此⽂件其余部分内容的语法的DTD(Document Type Definition，⽂档类型定义)。

所有部署描述符⽂件的顶层（根）元素为web-app。

请注意，XML元素不像HTML，他们是⼤⼩写敏感的。

因此，web-App和WEB-APP都是不合法的，web-app必须⽤⼩写。

web.xml样例：[html]<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "/dtd/web-app_2_3.dtd"><web-app></web-app>3、web.xml中XML 元素不仅是⼤⼩写敏感的，⽽且它们还对出现在其他元素中的次序敏感。

spring-mvc为什么要在web.xml中配置load-on-startup

spring-mvc为什么要在web.xml中配置load-on-startup默认情况下，servlet对象会在第一次请求servlet时被创建，创建完之后会调用其init方法。

加入无参数构造方法（我们继承的HttpServlet肯定只能是无参构建函数）或者init方法执行的业务逻辑比较多，那么在用户第一次访问servlet时的等待时间会变长（你也可以在服务启动之后自己访问一次那些需要处理耗时的servlet就没事了）。

servlet在tomcat服务器中是单实例的，一个servlet只会被创建一次，且init由于是在servlet创建完成时被调用的，所以init方法也只会被执行一次。

destroy方法在tomcat服务停止或者web应用重新加载时被调用。

spring-mvc的DispatcherServlet在初始化方法中需要扫描bean初始化web应用程序上下文（初始化spring容器）。

根据继承关系，查找ApplicationContext的初始化流程。

org.springframework.web.servlet.HttpServletBean的initServletBean方法--->org.springframework.web.servlet.FrameworkServlet的initServletBean方法{try {this.webApplicationContext = this.initWebApplicationContext();} catch (RuntimeException | ServletException var5) {throw var5;}}--->initWebApplicationContext方法protected WebApplicationContext initWebApplicationContext() {WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext()); WebApplicationContext wac = null;if (this.webApplicationContext != null) {wac = this.webApplicationContext;if (wac instanceof ConfigurableWebApplicationContext) {ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;if (!cwac.isActive()) {if (cwac.getParent() == null) {cwac.setParent(rootContext);}this.configureAndRefreshWebApplicationContext(cwac);}}}if (wac == null) {wac = this.findWebApplicationContext();}if (wac == null) {wac = this.createWebApplicationContext(rootContext);}if (!this.refreshEventReceived) {//走refresh流程this.onRefresh(wac);}if (this.publishContext) {//FrameworkServlet.class.getName() + '.CONTEXT.'+this.getServletName();String attrName = this.getServletContextAttributeName();//将WebApplicationContext注入到ServletContext的属性中，以便下次从ServletContext中获取到this.getServletContext().setAttribute(attrName, wac);}return wac;}DispatcherServlet是FrameworkServlet的子类，所以DispatcherServlet具体的初始化WebApplicationContext流程是在其父类的init方法中完成的。