源码下载：http://download.csdn.NET/detail/u010469432/6786687
https://blog.csdn.net/u010469432/article/details/17587699
先说一下Spring3 MVC的优点：
spring MVC 属于轻量级框架
1、Spring3 MVC的学习难度小于Struts2，Struts2用不上的多余功能太多。呵呵，当然这不是决定因素。
2、Spring3 MVC很容易就可以写出性能优秀的程序，Struts2要处处小心才可以写出性能优秀的程序（指MVC部分）
3、Spring3 MVC的灵活是你无法想像的，Spring的扩展性有口皆碑，Spring3 MVC当然也不会落后，不会因使用了MVC框架而感到有任何的限制。
对于SpringMVC的一些文档型理论知识我不再多加赘述，今天主要是一步一步的开始搭建框架，当然这是我工作中的成果。
不多说，上代码：
1.创建Web project,我使用的是myeclipse。起名为Springmvc(名字自定)
2.引用SpringMVC 需要的核心jar包：
3.配置web.xml文件
[html] view plain copy
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<!-- 配置监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 在项目启动时，加载Src/config下的所有以 spring- 开头的.xml 配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:config/spring-*.xml</param-value>
</context-param>
<!--项目启动后默认打开的页面 -->
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
<!--这里的配置是关键，servlet-name -->
<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/springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 配置servlet映射
在访问URL时路径要写为： /service/+ Controller 层@RequestMapping("/admin") 中的admin /+方法上的@RequestMapping(value = "/login")中的 login
例如 登陆表单 提交的action就是 /service/admin/login -->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/service/*</url-pattern>
</servlet-mapping>
</web-app> 4.配置Spring.xml文件，此文件的名称必须与web.xml中的servlet-name名称一致。
[html] view plain copy
<?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:cache="http://www.springframework.org/schema/cache" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.1.xsd
http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd"
default-autowire="byName">
<!-- 自动搜索@Controller标注的类 -->
<context:component-scan base-package="com.yfapp.platform" />
<context:annotation-config />
<bean
class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
<!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 -->
<bean
class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
<property name = "messageConverters">
<list>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/plain;charset=UTF-8</value>
</list>
</property>
</bean>
</list>
</property>
</bean>
<!-- 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="" />
<property name="suffix" value=".jsp"></property>
</bean>
<!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 -->
<cache:annotation-driven cache-manager="cacheManager"/>
<bean id="cacheManager" class="org.springframework.cache.concurrent.ConcurrentMapCacheManager" />
</beans> 5.配置数据库读取文件jdbc.properties放在类文件夹src下我这里加载的是SqlServer数据库
[html] view plain copy
driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver //连接的数据库
url=jdbc:sqlserver://127.0.0.1:1433; DatabaseName=renji
username=sa
password=admin
6.配置数据库相关的文件
spring-application.xml(文件名称可以自定义，但是需要在web.xml文件中加载这里即对应web.xml中的<!--在你项目启动时加载spring- 开头的.xml文件-->)
[html] view plain copy
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<!-- 读取资源文件 步骤5 的文件 -->
<bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties" />
</bean>
<!-- 这个是Spring的注入技术 给org.apache.commons.dbcp.BasicDataSource 类的属性注入对应的值 ,读取数据库配置信息-->
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${driverClassName}"></property>
<property name="password" value="${password}"></property>
<property name="username" value="${username}"></property>
<property name="url" value="${url}"></property>
</bean>
<!-- 这个是向第7步中的 DbUtilsTemplate.java 类的dataSource变量注入值 -->
<bean id="dbUtilsTemplate" class="com.yfapp.platform.dao.template.DbUtilsTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
</beans> 7.数据库操作类：DbUtilsTemplate.Java这是我封装好的工具类直接使用就可以了。
[html] view plain copy
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class DbUtilsTemplate {
private DataSource dataSource;
private QueryRunner queryRunner;
private static final Log LOG = LogFactory.getLog(DbUtilsTemplate.class);
public void setDataSource(BasicDataSource dataSource) {
this.dataSource = dataSource;
}
/**
* 执行sql语句
* @param sql sql语句
* @return 受影响的行数
*/
public int update(String sql) {
return update(sql, null);
}
/**
* 执行sql语句
* <code>
* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");
* </code>
* @param sql sql语句
* @param param 参数
* @return 受影响的行数
*/
public int update(String sql, Object param) {
return update(sql, new Object[] { param });
}
/**
* 执行sql语句
* @param sql sql语句
* @param params 参数数组
* @return 受影响的行数
*/
public int update(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
int affectedRows = 0;
try {
if (params == null) {
affectedRows = queryRunner.update(sql);
} else {
affectedRows = queryRunner.update(sql, params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to update data", e);
}
return affectedRows;
}
/**
* 执行批量sql语句
* @param sql sql语句
* @param params 二维参数数组
* @return 受影响的行数的数组
*/
public int[] batchUpdate(String sql, Object[][] params) {
queryRunner = new QueryRunner(dataSource,true);
int[] affectedRows = new int[0];
try {
affectedRows = queryRunner.batch(sql, params);
} catch (SQLException e) {
LOG.error("Error occured while attempting to batch update data", e);
}
return affectedRows;
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @return 查询结果
*/
public List<Map<String, Object>> queryForList(String sql) {
return queryForList(sql, null);
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public List<Map<String, Object>> queryForList(String sql, Object param) {
return queryForList(sql, new Object[] {param});
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param params 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public List<Map<String, Object>> queryForList(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
try {
if (params == null) {
list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler());
} else {
list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @return 查询结果
*/
public <T> List<T> queryForList(Class<T> entityClass, String sql) {
return queryForList(entityClass, sql, null);
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public <T> List<T> queryForList(Class<T> entityClass, String sql, Object param) {
return queryForList(entityClass, sql, new Object[] { param });
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @param params 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public <T> List<T> queryForList(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
List<T> list = new ArrayList<T>();
try {
if (params == null) {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass));
} else {
list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return list;
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @return 对象
*/
public <T> T query(Class<T> entityClass, String sql) {
return queryFirst(entityClass, sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 对象
*/
public <T> T queryFirst(Class<T> entityClass, String sql, Object param) {
return queryFirst(entityClass, sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param params 参数数组
* @return 对象
*/
@SuppressWarnings("unchecked")
public <T> T queryFirst(Class<T> entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new BeanHandler(entityClass));
} else {
object = queryRunner.query(sql, new BeanHandler(entityClass), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return (T) object;
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @return 封装为Map的对象
*/
public Map<String, Object> queryFirst(String sql) {
return queryFirst(sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param param 参数
* @return 封装为Map的对象
*/
public Map<String, Object> queryFirst(String sql, Object param) {
return queryFirst(sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param params 参数数组
* @return 封装为Map的对象
*/
@SuppressWarnings("unchecked")
public Map<String, Object> queryFirst(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
Map<String, Object> map = null;
try {
if (params == null) {
map = (Map<String, Object>) queryRunner.query(sql, new MapHandler());
} else {
map = (Map<String, Object>) queryRunner.query(sql, new MapHandler(), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return map;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @return 结果对象
*/
public Object queryForObject(String sql, String columnName) {
return queryForOjbect(sql, columnName, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @param param 参数
* @return 结果对象
*/
public Object queryForObject(String sql, String columnName, Object param) {
return queryForOjbect(sql, columnName, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnName 列名
* @param params 参数数组
* @return 结果对象
*/
public Object queryForOjbect(String sql, String columnName, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnName));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnName), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @return 结果对象
*/
public Object queryForObject(String sql, int columnIndex) {
return queryForObject(sql, columnIndex, null);
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @param param 参数
* @return 结果对象
*/
public Object queryForObject(String sql, int columnIndex, Object param) {
return queryForObject(sql, columnIndex, new Object[] { param });
}
/**
* 查询某一条记录，并将指定列的数据转换为Object
* @param sql sql语句
* @param columnIndex 列索引
* @param params 参数数组
* @return 结果对象
*/
public Object queryForObject(String sql, int columnIndex, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
Object object = null;
try {
if (params == null) {
object = queryRunner.query(sql, new ScalarHandler(columnIndex));
} else {
object = queryRunner.query(sql, new ScalarHandler(columnIndex), params);
}
} catch (SQLException e) {
LOG.error("Error occured while attempting to query data", e);
}
return object;
}
/**
* 获取记录数
* @param sql
* @param entityClass
* @return 结果对象
*/
public Object getCount(String sql,Class entityClass){
queryRunner = new QueryRunner(dataSource,true);
Object i=null;
try {
List list = (List) queryRunner.query(sql, new BeanListHandler(entityClass));
if(list.size()>0){
i=list.get(0);
}
} catch (SQLException e) {
e.printStackTrace();
}
return i;
}
/**
* 获取记录数
* @param sql
* @param entityClass
* @param param
* @return 结果对象
*/
public Object getCount(String sql,Class entityClass,Object param ){
return getCount(sql,entityClass,new Object[] { param });
}
/**
* 获取记录数
* @param sql
* @param entityClass
* @param Object[] params
* @return 结果对象
*/
public Object getCount(String sql,Class entityClass,Object[] params ){
queryRunner = new QueryRunner(dataSource,true);
Object i=null;
try{
if (params == null) {
i= getCount(sql,entityClass);
}else{
List list = (List) queryRunner.query(sql, new BeanListHandler(entityClass),params);
if(list.size()>0){
i=list.get(0);
}
}
}catch (Exception e) {
}
return i;
}
} 8。到此为止，框架已经搭建成功了，可以启动一下项目，
启动成功！
下面我写个测试例子大家看一下：
我的项目是写成了三层分开的架构，控制层(Controller)，服务层接口(Service)，服务层实现类(ServiceImpl)，数据库操作接口(Dao)，数据库操作实现类(DaoImpl).
1.login页面：
[html] view plain copy
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://"
+ request.getServerName() + ":" + request.getServerPort()
+ path + "/";
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<form action="service/admin/login" method="post">
<div class="user clr">
<span class="fl">管 理 员 ：</span><input name="adminCode" type="text"
class="fl " />
</div>
<div class="user clr">
<span class="fl">密 码 ：</span><input
name="adminPwd" type="password" class="fl" />
</div>
<div class="user clr">
<input name="" type="reset" value="重 置" class="cancel_btn fr" /><input
name="" type="submit" class="login_btn fr" value="登 录" />
</div>
</form>
</body>
</html>
2.Controller（控制）层的代码：AdminController.java
[html] view plain copy
package com.yfapp.platform.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.yfapp.platform.entity.Admin;
import com.yfapp.platform.service.AdminService;
@Controller
@RequestMapping("/admin")
public class AdminController {
@Autowired
private AdminService adminService;
/**
* 管理员登陆
* @param admin 登陆传入的用户对象
* @return String 要跳转到的页面
*/
@RequestMapping(value = "/login")
public String login(HttpServletRequest request, HttpServletResponse response, Admin admin) throws Throwable {
Admin ad =new Admin();
if(null!=admin.getAdminPwd()||null!=admin.getAdminCode()){
ad = adminService.login(admin);
}else{
ad=null;
}
if (null != ad) {
request.getSession().setAttribute("admin", ad);
return "/indexhome";
} else {
request.setAttribute("imgs", "请重新登录！");
return "/login";
}
}
}
3.服务层接口:AdminService.java 以及 服务层实现类AdminServiceImpl.java
[html] view plain copy
package com.yfapp.platform.service;
import com.yfapp.platform.entity.Admin;
public interface AdminService{
//登陆
Admin login(Admin admin);
}
[html] view plain copy
package com.yfapp.platform.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.yfapp.platform.dao.AdminDao;
import com.yfapp.platform.entity.Admin;
import com.yfapp.platform.service.AdminService;
@Service("adminService")
public class AdminServiceImpl implements AdminService{
@Autowired
private AdminDao adminDao;
/**
* 登陆
*/
public Admin login(Admin admin){
return adminDao.login(admin);
}
} 4.数据库操作接口类 BaseDao.java 和 AdminDao.java
BaseDao.java是基础的操作类，这里面可以将写一些基本的数据库操作方法比如增删改查，我这里就不写了，写这个主要是映射数据库连接，创建连接池。
AdminDao.java是功能模块的接口类，如果你要写别的模块的时候只需要想AdminDao一样继承BaseDao就行，当然如果不需要BaseDao 也可以不写BaseDao，这样写只是应用了java的思想。使用了泛型。
[html] view plain copy
package com.yfapp.platform.dao;
import java.io.Serializable;
public interface BaseDao<PO,ID extends Serializable> {
} [html] view plain copy
package com.yfapp.platform.dao;
import com.yfapp.platform.entity.Admin;
public interface AdminDao extends BaseDao<Admin, Integer>{
// 登陆
Admin login(Admin admin);
} 5.数据库操作接口实现类 BaseDaoImpl.java 和 AdminDaoImpl.java
[html] view plain copy
package com.yfapp.platform.dao.impl;
import java.io.Serializable;
import org.springframework.beans.factory.annotation.Autowired;
import com.yfapp.platform.dao.BaseDao;
import com.yfapp.platform.dao.template.DbUtilsTemplate;
public class BaseDaoImpl<PO,ID extends Serializable> implements BaseDao<PO,ID>
{ //这个是之前说的数据库操作帮助类，使用注解的方式，此变量在spring-application.xml中注入值。
@Autowired
protected DbUtilsTemplate dbUtilsTemplate;
} [html] view plain copy
package com.yfapp.platform.dao.impl;
import org.springframework.stereotype.Repository;
import com.yfapp.platform.dao.AdminDao;
import com.yfapp.platform.entity.Admin;
@Repository
public class AdminDaoImpl extends BaseDaoImpl<Admin, Integer> implements AdminDao {
/**
* 管理员登陆
*/
public Admin login(Admin admin) {
String sql="select adminCode,adminPwd,loginTime from yf_admin where adminCode=? and adminPwd=?";
Object[] params = { admin.getAdminCode(),admin.getAdminPwd() };
Admin ad = dbUtilsTemplate.queryFirst(Admin.class, sql, params);
return ad;
}
}
6。我的测试数据库表结构，使用的是SqlServer：
7.登陆成功要跳转的页面：indexhome.jsp
[html] view plain copy
<%@page import="com.yfapp.platform.entity.Admin"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme() + "://"
+ request.getServerName() + ":" + request.getServerPort()
+ path + "/";
Admin admin = (Admin) request.getSession().getAttribute("admin");
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
欢迎您：<%=admin.getAdminCode()%>|上次登录时间：<%=admin.getLoginTime()%>
|今天是：
<span id="webjx"><script>
setInterval(
"webjx.innerHTML=new Date().toLocaleString()+' 星期'+'日一二三四五六'.charAt(new Date().getDay());",
1000);
</script> </span>
</body>
</html>
8.重新运行项目：
测试结果：
在浏览器中访问 http://localhost:8080/Springmvc/
点击登陆：
完了！
源码下载：http://download.csdn.net/detail/u010469432/6786687
xml配置文件中配置如下：
<spring:bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<spring:property name="locations">
<spring:list>
<spring:value>classpath:conf/jdbc.properties</spring:value>
</spring:list>
</spring:property>
</spring:bean>
<spring:bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<spring:property name="driverClassName"
value="${jdbc.driverClassName}" />
<spring:property name="url"
value="${jdbc.url}" />
<spring:property name="username" value="${jdbc.username}" />
<spring:property name="password" value="${jdbc.password}" />
<spring:property name="maxActive" value="30" />
<spring:property name="maxIdle" value="10" />
<spring:property name="maxWait" value="1000" />
<spring:property name="defaultAutoCommit" value="true" />
</spring:bean>jdbc.properties配置文件中连接数据库配置：
#sqlserver数据源配置
jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.url=jdbc:sqlserver://192.168.1.60:1408;DatabaseName=test
jdbc.username=sa
jdbc.password=1
#mysql数据源配置
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.1.60:3306/test
jdbc.username=root
jdbc.password=root
#Oracle数据源配置
jdbc.driverClassName=oracle.jdbc.driver.OracleDriver
jdbc.url=jdbc:oracle:thin:@10.60.17.9:1521:orcl
jdbc.username=admin
jdbc.password=admin