Maven快速创建SpringMVC web工程详解

Posted 2020-08-04 老农小江

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Maven快速创建SpringMVC web工程详解相关的知识，希望对你有一定的参考价值。

一、前言

　　在上一篇文章中，讲解了如何用maven创建web工程，并简单搭建基于Spring框架的MVC工程，但是配置较为简单，很多配置尚未涉及；本文对 Spring MVC工程的更多详细配置、使用，进行进一步的讲解，搭建一个完整、可用的Spring web工程框架。

二、配置文件目录放置修改

　　根据maven工程提倡的标准目录结构，我们将/WEB-INF/目录下的Spring配置文件移到 /src/main/resources/ 目录下；而因为Spring默认加载的配置文件目录为/WEB-INF/下，所以我们修改 web.xml 文件中Spring的默认加载目录，修改后的 web.xml 文件内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="3.0"
    xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">   

    <!-- 初始化Ioc容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener> 
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </context-param>  
    <!--  
        Spring MVC的核心就是DispatcherServlet，使用springMVC的第一步就是将下面的servlet放入web.xml ，
        servlet-name属性非常重要，默认情况下，DispatchServlet会加载这个名字-servlet.xml的文件，
        如下，就会加载 springmvc-servlet.xml，也是在WEN-INF目录下。
        而这里配置成加载classpath目录下文件，即src/main/resources目录下配置文件。
    -->
    <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:springmvc-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- 
        设置dispatchservlet的匹配模式，通过把dispatchservlet映射到/，这种配置就是REST风格；
        其带来rest风格优势的同时，也意味着默认servlet会处理所有的请求，包括静态资源（即静态资源会被拦截，
        若需要配置静态资源不被拦截，请查看下方“五、配置不拦截静态资源”）；
        而如果不想拦截所有资源的话，可配置成映射到 “*.do” 的方式，这样DispatcherServlet就只会拦截带 “*.do” 后缀的URL,
        从而不会访问不到静态资源。
     -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

删除 applicationContext.xml 配置文件。
（注：web容器初始化时，容器对于web.xml的加载过程是“context-param >> listener >> fileter >> servlet”）

三、配置字符过滤器

　　为了处理中文乱码问题，有必要配置一个全局的字符过滤器，在 web.xml 文件中，添加以下配置内容：

<!-- 字符集过滤器 -->
<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>
<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

　　这里配置全局字符编码为UTF-8，配置成功后，中文传输将不会再乱码。

四、配置404错误页

　　一个完整的web工程配置404等错误页是有必要的；在前端webapp目录下，添加error目录并新建404.html文件，然后在 web.xml 文件中，添加以下配置内容：（500错误等错误页面也可照此配置，再添加一个<error-page>标签即可）

<!-- 404错误页 -->
<error-page>
    <error-code>404</error-code>
    <location>/error/404.html</location>
</error-page>

　　配置后，启动系统，会发现无法跳转到404页面，这是因为，前面配置 Spring 的时候，将前端静态资源拦截了，所以需要配置不拦截静态资源。

五、配置不拦截静态资源

　　配置不拦截静态资源主要有２种方式，一是在 web.xml 文件中直接配置servlet，二是在 Spring 的配置文件中通过 <mvc:resources> 标签配置，两者之间选其一即可。（其实还有一种方式是编写自定义拦截器代码，但实现相对较为麻烦，不推荐，在此就不再详述）
　　方式一、web.xml文件中添加配置：（老的servlet版本可能不支持 <url-pattern> 标签连续写在一起，笔者用的servlet是3.0版本）

<!-- 不拦截静态资源 ,文件名后缀方式-->
<servlet-mapping> 
    <servlet-name>default</servlet-name> 
    <url-pattern>*.css</url-pattern> 
    <url-pattern>*.gif</url-pattern> 
    <url-pattern>*.jpg</url-pattern> 
    <url-pattern>*.js</url-pattern> 
    <url-pattern>*.html</url-pattern>
</servlet-mapping>

或

<!-- 不拦截静态资源 ,目录方式-->
<servlet-mapping> 
    <servlet-name>default</servlet-name> 
    <url-pattern>/images/*</url-pattern> 
    <url-pattern>/js/*</url-pattern> 
    <url-pattern>/css/*</url-pattern> 
    <url-pattern>/error/*</url-pattern>  
</servlet-mapping>

　　方式二、springmvc-servlet.xml文件中添加配置：

<!-- 
设置不过滤内容，比如:css,jquery,img 等资源文件 ；
通过mvc:resources设置静态资源，这样servlet就会处理这些静态资源，而不通过控制器
-->  
<!-- 文件名后缀方式 -->
<mvc:resources location="/" mapping="/**/*.html"/>
<mvc:resources location="/" mapping="/**/*.js"/>
<mvc:resources location="/" mapping="/**/*.css"/>
<mvc:resources location="/" mapping="/**/*.png"/>
<mvc:resources location="/" mapping="/**/*.gif"/>

或

<!-- 目录方式 -->
<mvc:resources location="/error/" mapping="/error/**"/> 
<mvc:resources location="/images/" mapping="/images/**"/>  
<mvc:resources location="/js/" mapping="/js/**"/>  
<mvc:resources location="/css/" mapping="/css/**"/>  
<mvc:resources location="/" mapping="/*.ico"/>

（注意：这种方式需在 springmvc-servlet.xml 配置文件中另外再添加以下配置，否则，前端请求正常的业务URL，浏览器会抛“NetworkError: 405 Method Not Allowed”异常）

 <!-- 添加注解驱动 -->  
 <mvc:annotation-driven />

　　在以上两种配置方式中，都有按目录配置过滤、按文件名后缀配置过滤两种方式，其中，按文件后缀配置的方式优点是比较通用，不用为每个子目录配置一个，而按目录配置的方式优点是更加灵活、精确。若配置在web.xml 中，会激活 Tomcat 的 defaultServlet 先拦截，这样就不会进入Spring了；若配置在 springmvc-servlet.xml 中，则是由 Spring 本身去处理静态资源的访问。

六、配置SLF4J

　　程序员都知道，在任何一个工程中，日志是必不可少的组成部分，灵活地运用日志，可以有效地帮助程序员记录、分析、定位并解决问题；有很多日志库可供我们选择，如Log4J、Logback、SLF4J 等，也可直接使用 java.util 包下的Logger类，笔者这里配置的是SLF4J 。（说明：slf4j只是接口，log4j才是具体实现，所以此处maven引用的是 slf4j-log4j12 包，maven会自动将其关联的包全部添加进来）
　　1、引用依赖包，在 pom.xml 文件中引用SLF4J，添加以下代码：

<!-- slf4j -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.21</version>
</dependency>

（注：若需指定版本的 jar ,可到 http://mvnrepository.com/ 查找）
　　2、添加 log4j 配置文件：
　　在 src/main/resources 目录下添加 log4j.xml 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/xml/doc-files/log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <!-- 输出方式 Appenders -->
    <appender name="console" class="org.apache.log4j.ConsoleAppender">
        <param name="Target" value="System.out" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[%d{yyyy-MM-dd HH:mm:ss\} %-5p] [%t] (%c:%L) - %m%n" />
        </layout>
    </appender>

    <!-- 输出到日志文件  -->
    <appender name="filelog_appender" class="org.apache.log4j.RollingFileAppender">
        <!-- 设置File参数：日志输出文件名 -->
        <param name="File" value="${catalina.base}/logs/SpringMVCDemo.log" /> 
        <!-- 设置是否在重新启动服务时，在原有日志的基础添加新日志 -->
        <param name="Append" value="true" />
        <!-- 设置文件大小 -->
        <param name="MaxFileSize" value="20MB" />
        <!-- 设置文件备份 -->
        <param name="MaxBackupIndex" value="10000" />
        <!-- 设置输出文件项目和格式 -->
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="[%d{yyyy-MM-dd HH:mm:ss\} %-5p] [%t] (%c:%L) - %m%n" />
        </layout>
    </appender>

    <!-- 输出到日志文件 每天一个日志 -->
    <appender name="filelog_daily" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="File" value="${catalina.base}/logs/SpringMVCDemo_daily.log" /> 
        <param name="DatePattern" value="‘daily.‘yyyy-MM-dd‘.log‘" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern"
                value="[%d{yyyy-MM-dd HH:mm:ss\} %-5p] [%t] (%c:%L) - %m%n" />
        </layout>
    </appender>

    <!-- 设置 应用 SpringMVCDemo的日志级别 -->
    <logger name="com.cndmss">
        <level value="info" />
    </logger>

    <!-- 设置spring 各个包 日志级别 -->
    <logger name="org.springframework.core">
        <level value="info" />
    </logger>
    <logger name="org.springframework.beans">
        <level value="info" />
    </logger>
    <logger name="org.springframework.context">
        <level value="info" />
    </logger>
    <logger name="org.springframework.web">
        <level value="info" />
    </logger>

    <!-- Root Logger -->
    <root>
        <priority value="info" />
        <appender-ref ref="console" />
        <appender-ref ref="filelog_appender" />
        <appender-ref ref="filelog_daily" />
    </root>
</log4j:configuration>

　　3、修改 web.xml 配置，在 web.xml 文件中添加以下配置代码：　

<!-- Log4j监听配置 -->
<context-param>
    <param-name>log4jConfigLocation</param-name>
    <param-value>classpath:log4j.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

　　4、使用
　　通过 LoggerFactory 类获取 Logger 对象，然后调用相应日志级别方法。（注意： import 包时需引用 slf4j 的包）
　　例：

package com.cndmss.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
@RequestMapping(value = "/user")
public class UserinfoController {
    private Logger logger = LoggerFactory.getLogger(UserinfoController.class);
    /**
     * 输出slf4j日志测试
     * @param request
     * @param response
     */
    @RequestMapping(value = "/logtest")
    public void logtest(HttpServletRequest request,HttpServletResponse response){
        logger.debug("输出debug信息");
        logger.info("输出info信息");
        logger.warn("输出warn信息");
        logger.error("输出error信息");
    }
}

七、配置Junit进行单元测试

　　在开发者的日常工作中，单元测试的重要性不言而喻，这里集成 Junit 单元测试框架。
　　1、引用依赖包，在 pom.xml 文件中引用 Junit 所需的包，添加以下代码：

<!-- junit 所需jar -->
<!-- junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<!-- spring test -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>3.2.17.RELEASE</version>
</dependency>

　　2、使用
　　引入 Junit 所需的 jar 包后，就可以直接使用了，下面是demo代码：
　　IUserInfoService.java

package com.cndmss.service;
/**
 * @desc 用户信息Service接口
 * @author xiaojiang
 * @date 2016年8月24日 下午4:36:57
 */
public interface IUserinfoService {
    /**
     * 根据用户ID获取用户信息
     * @param id 用户ID
     * @return String
     */
    public String getUserinfoById(long id);
}

　　UserinfoServiceImpl.java

package com.cndmss.impl.service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import com.cndmss.service.IUserinfoService;
/**
 * @desc 用户信息Service接口实现类
 * @author xiaojiang
 * @date 2016年8月24日 下午4:39:16
 */
@Service
public class UserinfoServiceImpl implements IUserinfoService{
    private Logger logger = LoggerFactory.getLogger(UserinfoServiceImpl.class);
    /**
     * 根据用户ID获取用户信息
     * @param id 用户ID
     * @return String
     */
    @Override
    public String getUserinfoById(long id) {
        logger.info("待查询的用户ID->" + id);
        return "用户信息";
    }

}

　　JunitTest.java

package com.cndmss.test.junit;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.cndmss.service.IUserinfoService;
/**
 * @desc junit测试
 * @author xiaojiang
 * @date 2016年8月24日 下午4:32:57
 */
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration({"classpath*:/*-servlet.xml"})  
public class JunitTest {
    private static Logger logger = LoggerFactory.getLogger(JunitTest.class);
    @Resource
    IUserinfoService userinfoService;
    /**
     * Spring 整合 Junit 做单元测试 demo
     * 
     */
    @Test
    public void junitDemo(){
        long id = 1001L;
        String result = userinfoService.getUserinfoById(id);
        logger.info("result->" + result);
    }
}

　　由demo代码可知，junit的使用较为简单。但是demo是针对 service 层进行单元测试，如果说我们需要对 controller 层进行单元测试，我们只需另外再写一个 http 工具类，发起 http 请求即可。事实上，大多数时候，我们都是对 service 做单元测试，而 controller 层进行单元测试较少，所以此处不再贴代码了，需要的请下载本文末尾源码。

八、配置Spring JDBC

　　1、引用依赖包，在 pom.xml 文件中引用 Spring JDBC所需的包，添加以下代码：

<!-- spring jdbc 所需 jar-->
<!-- spring jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>3.2.17.RELEASE</version>
</dependency>
<!-- mysql连接驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.39</version>
</dependency>

　　2、添加 dao-servlet.xml 配置文件
　　我们可将配置内容直接加在 springmvc-servlet.xml 文件中，但是这样一个配置文件的内容会越来越多，会使配置文件显得杂乱，所以，将 JDBC 的配置再另外单独新建一个文件，这样有利于整个工程的 Spring 配置文件的管理，文件结构清晰。（请准备好 Mysql 数据源，并建好库、表）
dao-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:mvc="http://www.springframework.org/schema/mvc"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
    <!-- 配置数据源信息 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/spring_demo" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <!-- 配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property>
    </bean>
</beans>

　　3、将数据源信息配置在 properties 文件中。（不需要请略过，但笔者后面讲解是依赖这种方式）
　　通常情况下，我们会将数据源信息配置在 properties 文件中，以便统一管理（尤其是多数据源的情况下），配置后，当工程启动时，就会去 properties 文件中加载数据源信息，步骤如下：
　　a、在 src/main/resources/properties 目录下创建 jdbc.properties 文件，并添加数据源信息。
　　jdbc.properties

#-----mysql数据源-----
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://127.0.0.1:3306/spring_demo
jdbc.username=root
jdbc.password=root

　　b、修改 dao-servlet.xml 配置文件，修改后部分代码如下：

<!-- 加载所有本地properties配置信息 -->
<context:property-placeholder location="classpath:properties/*.properties" />
<!-- 配置数据源信息 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName" value="${jdbc.driverClass}" />
    <property name="url" value="${jdbc.jdbcUrl}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
</bean>

　　4、修改 web.xml 配置
　　因为添加了 dao-servlet.xml 配置文件，而前文的 web.xml 配置并没有加载所有的 Spring 配置文件，当 Spring 启动时，会抛注入异常，所以，需修改 web.xml 文件中的配置，当工程启动时就会加载所有的 Spring 配置文件，修改内容如下：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc-servlet.xml</param-value>
</context-param>

修改为：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:*-servlet.xml</param-value>
</context-param>

　　5、使用（更多详细代码，请下载本文末尾源码）　
　　UserinfoDaoImpl.java

package com.cndmss.impl.dao;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import com.cndmss.dao.IUserinfoDao;
import com.cndmss.entity.Userinfo;
import com.cndmss.entity.UserinfoMapper;
/**
 * @desc 用户信息Dao接口实现类
 * @author xiaojiang
 * @date 2016年8月24日 下午4:38:46
 */
@Repository
public class UserinfoDaoImpl implements IUserinfoDao{
    @Resource
    private JdbcTemplate jdbcTemplate;
    @Resource
    private UserinfoMapper userInfoMapper;
    /**
     * 查询用户列表
     * @return
     * @throws Exception
     */
    public List<Userinfo> queryUserInfoList() throws Exception {
        final String SQL = "SELECT a.* FROM userinfo a";
        return jdbcTemplate.query(SQL, userInfoMapper);
    }
}

　　UserinfoTest.java

package com.cndmss.test.user;
import java.util.List;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.cndmss.dao.IUserinfoDao;
import com.cndmss.entity.Userinfo;
/**
 * @desc 用户信息测试
 * @author xiaojiang
 * @date 2016年8月25日 上午11:27:04
 */
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration({"classpath*:/*-servlet.xml"})  
public class UserinfoTest {
    private static Logger logger = LoggerFactory.getLogger(UserinfoTest.class);
    @Resource
    IUserinfoDao userinfoDao;
    /**
     * Spring jdbc用户查询测试 
     */
    @Test
    public void queryUserInfoTest(){
        try {
            List<Userinfo> list = userinfoDao.queryUserInfoList();
            if((null != list) && (0 < list.size())){
                for(Userinfo u:list){
                    logger.info("用户ID->" + u.getId());
                    logger.info("用户姓名->" + u.getName());
                    logger.info("用户年龄->" + u.getAge()); 
                }
            }else{
                logger.warn("没有查到用户数据");
            }
        } catch (Exception e) {
            logger.error("用户查询异常",e);
        }
    }
}

九、配置数据库连接池

　　在实际应用中，我们通常不会直接使用 Spring 自带的数据源直接连接数据库，因为数据库直接连接的使用效率低下，所以通常会配置数据库连接池以提高数据库的使用效率，常见的数据库连接池有c3p0、dbcp、proxool、淘宝druid等，笔者这里不讨论孰优孰劣，只以配置 c3p0 作为数据库连接池配置示例。
　　１、引用依赖包，在 pom.xml 文件中引用 c3p0，添加以下代码：

<!-- c3p0 -->
<dependency>
   <groupId>com.mchange</groupId>
   <artifactId>c3p0</artifactId>
   <version>0.9.5.2</version>
</dependency>

　　２、在 jdbc.properties 文件中，添加数据库连接池所需配置参数，添加后配置文件内容如下：

#-----mysql数据源-----
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://127.0.0.1:3306/spring_demo
jdbc.username=root
jdbc.password=root
#-----c3p0连接池-----
#初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间
jdbc.c3p0.initialPoolSize=20
#连接池中保留的最小连接数
jdbc.c3p0.minPoolSize=10
#连接池中保留的最大连接数
jdbc.c3p0.maxPoolSize=30
#JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量
jdbc.c3p0.maxStatements=100
#最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃
jdbc.c3p0.maxIdleTime=60

　　３、在 dao-servlet.xml 配置文件中修改数据源连接配置，修改后配置文件部分内容如下：

<!-- 配置数据源信息 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driverClass}" />
    <property name="jdbcUrl" value="${jdbc.jdbcUrl}" />
    <property name="user" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <property name="initialPoolSize" value="${jdbc.c3p0.initialPoolSize}" />
    <property name="minPoolSize" value="${jdbc.c3p0.minPoolSize}" />
    <property name="maxPoolSize" value="${jdbc.c3p0.maxPoolSize}" />
    <property name="maxStatements" value="${jdbc.c3p0.maxStatements}" />
    <property name="maxIdleTime" value="${jdbc.c3p0.maxIdleTime}" />
</bean>

　　需要说明的是，这里的 c3p0 只配置了部分参数，c3p0 本身还有一些其它的参数可以配置，且这些配置参数一般都有默认值，感兴趣的朋友可以去了解下，这里不再详述。

十、总结

　　以上配置，基本上已包含了一个简单 Spring MVC 工程所需的大多数配置，通过这些配置，已经可以满足大多数的使用场景了。当然，更多相对复杂些的应用场景，这些配置还是有些不足的，如互联网应用经常用到的缓存、数据源切换等，限于篇幅，下一篇文章再讲。

十一、源码

下载链接: https://pan.baidu.com/s/1qYq1F44 密码: 4qrn

延伸阅读：

1、web.xml里面context-param和init-param区别？
　　application范围内的参数，存放在servletcontext中;servlet范围内的参数，只能在servlet的init()方法中取得。
2、IE浏览器页面自定义404页面显示不了？
　　IE内核的浏览器自定义的404页面文件大小需大于512字节，否则，会被IE认为自定义的404页面不够权威，从而使用其自带的404页面代替。
3、log4j.xml 与 log4j.properties 配置文件的区别？
　　其实这两者之间并没有太大区别，大多数情况下，既可用 log4j.xml 配置文件，也可用 log4j.properties 配置文件，log4j.properties 优点是配置简单，但是不支持复杂过滤器filter；log4j.xml 虽然配置文件看起来复杂些，但支持复杂过滤器和 Log4j 的新特性，且通过 log4j 源码中的 LogManager 类可知：若用户没有设置 log4j.configuration 属性，log4j默认会优先查找log4j.xml，然后查找log4j.properties，建议使用 log4j.xml 配置文件方式。

以上是关于Maven快速创建SpringMVC web工程详解的主要内容，如果未能解决你的问题，请参考以下文章

Java之SpringMVC（5分钟搭建Web工程）

Spring全家桶--SpringMVC

eclipse 创建maven 项目动态web工程完整示例