Maven快速创建SpringMVC web工程详解(2)

一、前言

　　在上一篇文章中，讲解了如何用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 配置文件方式。

时间： 2024-10-26 18:58:48

Maven快速创建SpringMVC web工程详解(2)的相关文章

转:Eclipse中创建Maven版的Web工程(详解)

一.搭建步骤 ?首先创建一个Maven的Project,如下图: ?点击Next,勾选 Create a simple project ?点击Next,注意Packing要选择war,因为我们创建的是一个Web工程 ?由于packing是war包,那么下面也就多出了webapp的目录 ?由上图可知,这其实是一个Maven的目录结构,对于Maven来说这是一个Web工程,但对于Eclipse来说这是一个Java工程.Web工程目录至少得有一个WebContent以及WebContent下有web.

使用 maven 创建 java web 工程

本文主要讲述使用 maven 命令行的形式来创建  java web 工程 开发环境 jdk 1.7 maven 3.5.0 spring 3.2 tomcat 7 eclipse Mars Release (4.5.0) 1.  maven 来构建 java web 骨架 mvn archetype:generate -DgroupId=com.reycg -DartifactId=MVC-HelloWorld -DarchetypeArtifactId=maven-archetype-web

Web.xml详解(转)

这篇文章主要是综合网上关于web.xml的一些介绍,希望对大家有所帮助,也欢迎大家一起讨论. ---题记 一.            Web.xml详解: (一)  web.xml加载过程(步骤) 首先简单说一下,web.xml的加载过程. 当我们去启动一个WEB项目时,容器包括(JBoss.Tomcat等)首先会读取项目web.xml配置文件里的配置,当这一步骤没有出错并且完成之后,项目才能正常地被启动起来. l  启动WEB项目的时候,容器首先会去它的配置文件web.xml读取两个节点: 

SpringMVC视图机制详解[附带源码分析]

目录 前言 重要接口和类介绍 源码分析 编码自定义的ViewResolver 总结 参考资料 前言 SpringMVC是目前主流的Web MVC框架之一. 如果有同学对它不熟悉,那么请参考它的入门blog:http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html 本文将分析SpringMVC的视图这部分内容,让读者了解SpringMVC视图的设计原理. 重要接口和类介绍 1. View接口 视图基础接口,它的各种实现类是无

Eclipse 下用Maven构建ssh框架web工程

之前的项目中用到了maven,而且是web项目(但不是标准的ssh架构),趁着假期,重用南哥的pom文件,自己也试试用maven构建web项目,搭建完整的ssh开发框架. 工具准备:jdk,eclipse,maven Eclipse 插件:Hibernate Tools (以上工具软件请请自行Google下载安装) 当然,构建过程需要畅通的网络,以确保maven能顺利下载依赖包. 第一步,在eclipse新建Maven项目, New->Maven Project: 两个next之后选择maven

SpringMVC拦截器详解[附带源码分析]

目录 前言 重要接口及类介绍 源码分析 拦截器的配置 编写自定义的拦截器 总结 前言 SpringMVC是目前主流的Web MVC框架之一. 如果有同学对它不熟悉,那么请参考它的入门blog:http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html 拦截器是每个Web框架必备的功能,也是个老生常谈的主题了. 本文将分析SpringMVC的拦截器功能是如何设计的,让读者了解该功能设计的原理. 重要接口及类介绍 1. Hand

web.config详解

在开发中经常会遇到这样的情况,在部署程序时为了保密起见并不将源代码随项目一同发布,而我们开发时的环境与部署环境可能不一致(比如数据库不一样),如 果在代码中保存这些配置这些信息部署时需要到用户那里更改代码再重新编译,这种部署方式非常麻烦.在.net中提供了一种便捷的保存项目配置信息的办法, 那就是利用配置文件,配置文件的文件后缀一般是.config,在asp.net中配置文件名一般默认是web.config.每个web.config 文件都是基于XML的文本文件,并且可以保存到Web应用程序中的

Eclipse中创建标准web工程以及标准目录结构说明

最近公司有个Web项目,项目结构如下: 虽然运行没有错,但是实在是别扭,标准的web应用一般不采用这种结构: 因此总结一下:     1.如何在Eclipse中创建一个标准的Web应用.     2.标准Web应用推荐的目录结构.   第一:如何在Eclipse中创建一个标准的web应用:(假设项目名称为:myweb) 1) PS:projectname一般全小写字母,最好不要出现数字和大写字母. 2) PS:default output flolder要根据project_name修改. 3)

IntelliJ IDEA14 和 Maven 系列：使用IntelliJ IDEA 14和Maven 7 创建java web项目（一）

Intellij IDEA作为最好的Java IDE,创建Maven项目还是比较简单的,但是创建一个Maven Web项目还是要修改一些配置的,下面进行总结整理. 1前言 在创建项目中,IDEA提供了很多项目模板,比如Spring MVC模板,可以直接创建一个基于Maven的Spring MVC的demo,各种配置都已经设定好了,直接编译部署就可以使用. 最开始自己创建maven web项目时,要么创建一个springmvc项目进行修改,要么创建了一个maven项目(不是web项目),自己添加w