实战 ：Spring MVC + 注解 +SqlServer 框架搭建及详解
源码下载：http://download.csdn.net/detail/u010469432/6786687
先说一下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文件
org.springframework.web.context.ContextLoaderListener
contextConfigLocation
classpath:config/spring-*.xml
login.jsp
springmvc
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath*:config/springmvc.xml
1
springmvc
/service/*
4.配置Spring.xml文件，此文件的名称必须与web.xml中的servlet-name名称一致。
text/plain;charset=UTF-8
5.配置数据库读取文件jdbc.properties放在类文件夹src下我这里加载的是SqlServer数据库
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中的)
7.数据库操作类：DbUtilsTemplate.java这是我封装好的工具类直接使用就可以了。
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语句
*
* executeUpdate("update user set username = 'kitty' where username = ?", "hello kitty");
*
* @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> queryForList(String sql) {
return queryForList(sql, null);
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public List> queryForList(String sql, Object param) {
return queryForList(sql, new Object[] {param});
}
/**
* 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
* @param sql sql语句
* @param params 参数数组
* @return 查询结果
*/
@SuppressWarnings("unchecked")
public List> queryForList(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
List> list = new ArrayList>();
try {
if (params == null) {
list = (List>) queryRunner.query(sql, new MapListHandler());
} else {
list = (List>) 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 List queryForList(Class entityClass, String sql) {
return queryForList(entityClass, sql, null);
}
/**
* 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 查询结果
*/
public List queryForList(Class 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 List queryForList(Class entityClass, String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
List list = new ArrayList();
try {
if (params == null) {
list = (List) queryRunner.query(sql, new BeanListHandler(entityClass));
} else {
list = (List) 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 query(Class entityClass, String sql) {
return queryFirst(entityClass, sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param param 参数
* @return 对象
*/
public T queryFirst(Class entityClass, String sql, Object param) {
return queryFirst(entityClass, sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成对象
* @param entityClass 类名
* @param sql sql语句
* @param params 参数数组
* @return 对象
*/
@SuppressWarnings("unchecked")
public T queryFirst(Class 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 queryFirst(String sql) {
return queryFirst(sql, null);
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param param 参数
* @return 封装为Map的对象
*/
public Map queryFirst(String sql, Object param) {
return queryFirst(sql, new Object[] { param });
}
/**
* 查询出结果集中的第一条记录，并封装成Map对象
* @param sql sql语句
* @param params 参数数组
* @return 封装为Map的对象
*/
@SuppressWarnings("unchecked")
public Map queryFirst(String sql, Object[] params) {
queryRunner = new QueryRunner(dataSource,true);
Map map = null;
try {
if (params == null) {
map = (Map) queryRunner.query(sql, new MapHandler());
} else {
map = (Map) 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;
}
}
启动成功！
下面我写个测试例子大家看一下：
我的项目是写成了三层分开的架构，控制层(Controller)，服务层接口(Service)，服务层实现类(ServiceImpl)，数据库操作接口(Dao)，数据库操作实现类(DaoImpl).
1.login页面：
<%@ 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 + "/";
%>
2.Controller（控制）层的代码：AdminController.java
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";
}
}
}
package com.yfapp.platform.service;
import com.yfapp.platform.entity.Admin;
public interface AdminService{
//登陆
Admin login(Admin admin);
}
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);
}
}
BaseDao.java是基础的操作类，这里面可以将写一些基本的数据库操作方法比如增删改查，我这里就不写了，写这个主要是映射数据库连接，创建连接池。
AdminDao.java是功能模块的接口类，如果你要写别的模块的时候只需要想AdminDao一样继承BaseDao就行，当然如果不需要BaseDao 也可以不写BaseDao，这样写只是应用了java的思想。使用了泛型。
package com.yfapp.platform.dao;
import java.io.Serializable;
public interface BaseDao {
}
package com.yfapp.platform.dao;
import com.yfapp.platform.entity.Admin;
public interface AdminDao extends BaseDao{
// 登陆
Admin login(Admin admin);
}
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 implements BaseDao
{ //这个是之前说的数据库操作帮助类，使用注解的方式，此变量在spring-application.xml中注入值。
@Autowired
protected DbUtilsTemplate dbUtilsTemplate;
}
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 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
<%@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");
%>
8.重新运行项目：
测试结果：
在浏览器中访问 http://localhost:8080/Springmvc/
点击登陆：
完了！
源码下载：http://download.csdn.net/detail/u010469432/6786687