springMvc3.0.5搭建全程 （转）

用了大半年的Spring MVC3.0，用着感觉不错。简单写一个搭建Spring MVC3.0的流程(以Spring3.0.5为列)，数据库交互使用spring JDBC Template，附件有项目（没有jar包）。整个项目架构如下图所示：


1、去官网下载3.0.5所有jar包，所需jar包，见附件图片，每个jar包得用处如下：

org.springframework.aop- 3.0.0.RELEASE--------------------spring的面向切面编程,提供AOP(面向切面编程)实现

org.springframework.asm- 3.0.0.RELEASE--------------------Spring独立的asm程序,相遇Spring2.5.6的时候需要asmJar 包.3.0开始提供他自己独立的asmJar

org.springframework.aspects- 3.0.0.RELEASE----------------Spring提供对AspectJ框架的整合\

org.springframework.beans- 3.0.0.RELEASE------------------SpringIoC(依赖注入)的基础实现

org.springframework.context.support- 3.0.0.RELEASE--------Spring-context的扩展支持,用于MVC方面

org.springframework.context- 3.0.0.RELEASE----------------Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各种视图层框架的封装等

org.springframework.core- 3.0.0.RELEASE-------------------Spring3.0的核心工具包

org.springframework.expression- 3.0.0.RELEASE-------------Spring表达式语言

org.springframework.instrument.tomcat- 3.0.0.RELEASE------Spring3.0对Tomcat的连接池的集成

org.springframework.instrument- 3.0.0.RELEASE-------------Spring3.0对服务器的代理接口

org.springframework.jdbc- 3.0.0.RELEASE-------------------对JDBC的简单封装

org.springframework.jms- 3.0.0.RELEASE--------------------为简化JMS API的使用而作的简单封装

org.springframework.orm- 3.0.0.RELEASE--------------------整合第三方的ORM框架，如hibernate,ibatis,jdo，以及spring的JPA实现

org.springframework.oxm-3.0.0.RELEASE--------------------Spring 对Object/XMl的映射支持,可以让Java与XML之间来回切换

org.springframework.test- 3.0.0.RELEASE--------------------对Junit等测试框架的简单封装

org.springframework.transaction- 3.0.0.RELEASE-------------为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理

org.springframework.web.portlet- 3.0.0.RELEASE-------------SpringMVC的增强

org.springframework.web.servlet- 3.0.0.RELEASE-------------对JEE6.0 Servlet3.0的支持

org.springframework.web.struts- 3.0.0.RELEASE--------------整合Struts的时候的支持

org.springframework.web- 3.0.0.RELEASE--------------------SpringWeb下的工具包



 

2、借鉴spring官网写法，建立一个src-resources Source Folder，再新建目录META-INF,存放springmvc-servlet.xml和jdbc-context.xml文件(事务和数据库连接池的管理)；以及database.properties和log4j.properties。


JDBC-context.xml文件：

 

Xml代码  收藏代码
  1. <span style="font-size: x-small;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"    
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
  4.     xmlns:aop="http://www.springframework.org/schema/aop"    
  5.     xmlns:tx="http://www.springframework.org/schema/tx"    
  6.     xmlns:context="http://www.springframework.org/schema/context"    
  7.     xsi:schemaLocation="     
  8.           http://www.springframework.org/schema/beans     
  9.           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     
  10.           http://www.springframework.org/schema/tx     
  11.           http://www.springframework.org/schema/tx/spring-tx-3.0.xsd    
  12.           http://www.springframework.org/schema/context     
  13.           http://www.springframework.org/schema/context/spring-context-3.0.xsd     
  14.           http://www.springframework.org/schema/aop     
  15.           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd" default-autowire="byName">  
  16.   
  17.      <context:property-placeholder location="classpath:database.properties"/>  
  18.        
  19.      <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
  20.         <property name="driverClass" value="${mysql.driverclass}"></property>  
  21.         <property name="jdbcUrl" value="${mysql.jdbcurl}"></property>  
  22.         <property name="user" value="${mysql.user}"></property>  
  23.         <property name="password" value="${mysql.password}"></property>  
  24.         <property name="acquireIncrement" value="5"></property>  <!-- 当连接池中的连接用完时，C3P0一次性创建新连接的数目2 -->  
  25.         <property name="initialPoolSize" value="10"></property>  <!-- 初始化时创建的连接数，必须在minPoolSize和maxPoolSize之间 -->  
  26.         <property name="minPoolSize" value="5"></property>  
  27.         <property name="maxPoolSize" value="20"></property>  
  28.         <!-- 最大空闲时间，超过空闲时间的连接将被丢弃  
  29.         [需要注意：mysql默认的连接时长为8小时(28800）【可在my.ini中添加 wait_timeout=30(单位秒)设置连接超时】,这里设置c3p0的超时必须<28800]   
  30.         -->  
  31.         <property name="maxIdleTime" value="300"></property>    
  32.         <property name="idleConnectionTestPeriod" value="60"></property> <!-- 每60秒检查连接池中的空闲连接 -->  
  33.         <property name="maxStatements" value="20"></property>  <!-- jdbc的标准参数  用以控制数据源内加载的PreparedStatement数量，但由于预缓存的Statement属 于单个Connection而不是整个连接 -->  
  34.      </bean>  
  35.        
  36.      <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  37.         <property name="dataSource" ref="dataSource"></property>  
  38.      </bean>  
  39.        
  40.      <!-- 声明式事务管理 -->  
  41.      <aop:config>  
  42.         <aop:advisor pointcut="execution(* com.aokunsang.service.impl.*ServiceImpl.*(..))" advice-ref="myAdvice"/>  
  43.      </aop:config>  
  44.      <tx:advice id="myAdvice" transaction-manager="txManager">  
  45.         <tx:attributes>  
  46.             <tx:method name="add*" propagation="REQUIRED"/>  
  47.             <tx:method name="update*" propagation="REQUIRED"/>  
  48.             <tx:method name="*" read-only="true" rollback-for="com.aokunsang.util.DaoException"/>  
  49.         </tx:attributes>  
  50.      </tx:advice>  
  51.        
  52.      <!-- 自动扫描组件，需要把controller去掉，否则影响事务管理 -->  
  53.      <context:component-scan base-package="com.aokunsang">  
  54.         <context:exclude-filter type="regex" expression="com.aokunsang.web.*"/>  
  55.      </context:component-scan>  
  56.        
  57. </beans></span>  

 springmvc-servlet.xml文件：

 

Xml代码  收藏代码
  1. <span style="font-size: x-small;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"    
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"    
  4.     xmlns:context="http://www.springframework.org/schema/context"    
  5.     xmlns:mvc="http://www.springframework.org/schema/mvc"    
  6.     xsi:schemaLocation="     
  7.            http://www.springframework.org/schema/beans     
  8.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd     
  9.            http://www.springframework.org/schema/context     
  10.            http://www.springframework.org/schema/context/spring-context-3.0.xsd    
  11.            http://www.springframework.org/schema/mvc     
  12.            http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">  
  13.       
  14.     <!-- 启动扫描所有的controller -->  
  15.     <context:component-scan base-package="com.aokunsang.web"/>  
  16.       
  17.     <!--  主要作用于@Controller，激活该模式  
  18.           
  19.         下面是一种简写形式，完全可以手动配置替代这种简写形式；  
  20.          它会自动注册DefaultAnnotationHandlerMapping与AnnotationMethodHandlerAdapter 两个bean,  
  21.            是spring MVC为@Controllers分发请求所必须的  
  22.      -->  
  23.     <mvc:annotation-driven/>  
  24.       
  25.     <!-- 这里拦截器还有一种配置方法【针对路径进行配置】 推荐使用这个，方便直观-->  
  26.     <mvc:interceptors>  
  27.         <mvc:interceptor>  
  28.             <mvc:mapping path="/user/MyHome"/>  
  29.             <mvc:mapping path="/usermanager/*"/>  
  30.             <bean  class="com.aokunsang.web.interceptor.MyInterceptor"></bean>  
  31.         </mvc:interceptor>  
  32.     </mvc:interceptors>  
  33.       
  34.      <!-- 全局配置   
  35.     <mvc:interceptors>  
  36.         <bean class="com.aokunsang.web.interceptor.MyInterceptor"></bean>  
  37.     </mvc:interceptors>  
  38.     -->  
  39.     <!-- 配置js，css等静态文件直接映射到对应的文件夹，不被DispatcherServlet处理 -->  
  40.     <mvc:resources location="/WEB-INF/resources/**" mapping="/resources"/>  
  41.       
  42.     <!-- jsp页面解析器，当Controller返回XXX字符串时，先通过拦截器，然后该类就会在/WEB-INF/views/目录下，查找XXX.jsp文件-->  
  43.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">  
  44.         <property name="prefix" value="/WEB-INF/views/"></property>  
  45.         <property name="suffix" value=".jsp"></property>  
  46.     </bean>  
  47.       
  48. </beans></span>  

 3、修改web.xml文件如下：

 

Xml代码  收藏代码
  1. <span style="font-size: x-small;"><context-param>  
  2.     <param-name>contextConfigLocation</param-name>  
  3.     <param-value>classpath:/META-INF/jdbc-context.xml</param-value>  
  4.   </context-param>    
  5.     
  6.   <listener>  
  7.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  8.   </listener>  
  9.   
  10.   <servlet>  
  11.     <servlet-name>spring-mvc</servlet-name>  
  12.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  13.     <init-param>  
  14.         <param-name>contextConfigLocation</param-name>  
  15.         <param-value>classpath:/META-INF/springmvc-servlet.xml</param-value>  
  16.     </init-param>  
  17.     <load-on-startup>1</load-on-startup>  
  18.   </servlet>  
  19.     
  20.   <servlet-mapping>  
  21.     <servlet-name>spring-mvc</servlet-name>  
  22.     <url-pattern>/</url-pattern>  
  23.   </servlet-mapping>  
  24.     
  25.   <filter>  
  26.     <filter-name>encodingFilter</filter-name>  
  27.     <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
  28.   </filter>  
  29.     
  30.   <filter-mapping>  
  31.     <filter-name>encodingFilter</filter-name>  
  32.     <url-pattern>/*</url-pattern>  
  33.   </filter-mapping></span>  

 4、从springmvc-servlet.xml中可以知道，我把jsp页面放在WEB-INF/views目录中，静态文件(图片，js，css等)放在Resources目录中，便于管理。

 

5、以上配置文件基本完成，下面开始代码编写：

首先说几个常用的注解：

 

Java代码  收藏代码
  1. <span style="font-size: x-small;">@Autowired  自动注入[根据类型注入]<span style="font-size: 12px; white-space: normal;"><code style="font-size: small !important;">@Autowired</code> 可以对成员变量、方法以及构造函数进行注释，而 <code style="font-size: small !important;">@Qualifier</code> 的标注对象是成员变量、方法入参、构造函数入参。</span>  
  2. @Resource   自动注入[根据名称注入],可写参数name=""  
  3. @Controller 表示控制器  
  4. @Service    表示业务处理层[一般在serviceImpl]  
  5. @Repository 表示持久层[一般在daoImpl]  
  6. @Component  当你的类不清楚是哪一层的时候使用该注解  
  7. @ResponseBody  异步返回数据类型为json  
  8. @RequestMapping  路径，请求类型等设置  
  9. @InitBinder   数据绑定</span>  

 注解的详细介绍：http://blog.csdn.net/zhongxiucheng/article/details/6662300 

 也可以参考：https://www.ibm.com/developerworks/cn/java/j-lo-spring25-ioc/

 

<a>首先写一个BaseController，可做一些数据绑定之类的全局操作(如：把日期字符串转换为Date日期)。

 

Java代码  收藏代码
  1. @Controller  
  2. public class BaseController {  
  3.   
  4.     @InitBinder  
  5.     protected void ininBinder(WebDataBinder binder){  
  6.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
  7.         binder.registerCustomEditor(Date.class, new CustomDateEditor(sdf,true));  
  8.     }  
  9. }  

 

<b>然后写一个拦截器，拦截器有两种实现方式，1、继承HandlerInterceptorAdapter类，2、实现HandlerInterceptor接口。

 

Java代码  收藏代码
  1. /** 
  2.  * 自定义拦截器 
  3.  * @author tushen 
  4.  * @date Nov 5, 2011 
  5.  */  
  6. public class MyInterceptor extends HandlerInterceptorAdapter {  
  7.   
  8.     /** 
  9.      * 最后执行，可用于释放资源 
  10.      */  
  11.     @Override  
  12.     public void afterCompletion(HttpServletRequest request,  
  13.             HttpServletResponse response, Object handler, Exception ex)  
  14.             throws Exception {  
  15.         // TODO Auto-generated method stub  
  16.         super.afterCompletion(request, response, handler, ex);  
  17.     }  
  18.   
  19.     /** 
  20.      * 显示视图前执行 
  21.      */  
  22.     @Override  
  23.     public void postHandle(HttpServletRequest request,  
  24.             HttpServletResponse response, Object handler,  
  25.             ModelAndView modelAndView) throws Exception {  
  26.           
  27.         System.out.println(request.getContentType()+"-----"+request.getCharacterEncoding()+"------"+request.getContextPath());  
  28.         System.out.println("MyInterceptor.postHandle()---viewName:"+modelAndView.getViewName());  
  29.         super.postHandle(request, response, handler, modelAndView);  
  30.     }  
  31.   
  32.     /** 
  33.      * Controller之前执行 
  34.      */  
  35.     @Override  
  36.     public boolean preHandle(HttpServletRequest request,  
  37.             HttpServletResponse response, Object handler) throws Exception {  
  38.           
  39.         String url = request.getRequestURI();  
  40.           
  41.         System.out.println("MyInterceptor.preHandle()"+url);  
  42.           
  43.         return super.preHandle(request, response, handler);  
  44.     }  
  45. }  

 

<c>在Util包中DBUtil.java中实现Spring JDBC Template的封装，操作数据库；写一个DaoException继承spring的运行时异常类NestedRuntimeException，在数据库操作异常时抛出该异常，在controller层进行处理。

<d>写一个抽象的BaseDao接口和BaseDaoImpl实现类，让所有模块共享使用（详见附件）。

 

Java代码  收藏代码
  1. /** 
  2.  *  
  3.  */  
  4. package com.aokunsang.dao;  
  5.   
  6. import java.io.Serializable;  
  7. import java.util.List;  
  8. import java.util.Map;  
  9.   
  10. /** 
  11.  * @author tushen 
  12.  * @date Nov 5, 2011 
  13.  */  
  14. public interface BaseDao {  
  15.   
  16.     /** 
  17.      * 保存或者更新实体 
  18.      * @param sql 
  19.      * @param entry 
  20.      */  
  21.     <T extends Serializable> void saveOrUpdateObject(String sql,T entry);  
  22.       
  23.     /** 
  24.      * 查询实体列表 
  25.      * @param sql 
  26.      * @param className 
  27.      * @param obj 
  28.      * @return 
  29.      */  
  30.     <T extends Serializable> List<T> getObjList(String sql,Class<T> className,Object[] objs);  
  31.       
  32.     /** 
  33.      * 查询实体 
  34.      * @param <T> 
  35.      * @param sql 
  36.      * @param objs 
  37.      * @return 
  38.      */  
  39.     <T extends Serializable> T getObject(String sql,Class<T> clazz,Object[] objs);  
  40.       
  41.     /** 
  42.      * 查询一个Map集合 
  43.      * @param sql 
  44.      * @param objs 
  45.      * @return 
  46.      */  
  47.     Map<String,?> find(String sql,Object[] objs);  
  48.       
  49.     /** 
  50.      * 批量操作 
  51.      * @param sql 
  52.      * @param objLs 
  53.      */  
  54.     void batchOperate(String sql,List<?> objLs);  
  55.       
  56.     /** 
  57.      * 判断实体是否存在 
  58.      * @param sql 
  59.      * @param obj 
  60.      * @return 
  61.      */  
  62.     int isExist(String sql,Object[] obj);  
  63.       
  64.     /** 
  65.      * 编辑操作 
  66.      * @param sql 
  67.      * @param obj 
  68.      * @return 
  69.      */  
  70.     int editObject(String sql,Object[] obj);  
  71. }  

 

 

6、一切就绪，启动tomcat，访问http://localhost:8080/springmvc，看是否访问到了WEB-INF中的index.jsp页面。

7、然后根据Controller中的路径配置，依次访问WEB-INF/views中的页面。

 

另外：再附上一张他人画得springMVC3.0的流程图，我感觉画得还是挺好的，收藏了。


posted @ 2016-10-13 14:37  丿魔方  阅读(978)  评论(0)  编辑  收藏  举报