欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

Spring MVC 4.1.3 + MyBatis零基础搭建Web开发框架(注解模式)

程序员文章站 2024-03-05 11:54:18
首先感谢一下润和软件，指引我走上了spring mvc web开发的道路。 下面进入正题 搭建开发环境： netbeans8.0.2 + mysql5.6...

首先感谢一下润和软件，指引我走上了spring mvc web开发的道路。

下面进入正题

搭建开发环境：

netbeans8.0.2 + mysql5.6 + jdk1.7 + tomcat8.0.15

  1. 本次采用的spring mvc jar包如下：
  2. spring-aop-4.1.3.release.jar
  3. spring-beans-4.1.3.release.jar
  4. spring-context-4.1.3.release.jar
  5. spring-context-support-4.1.3.release.jar
  6. spring-core-4.1.3.release.jar
  7. spring-expression-4.1.3.release.jar
  8. spring-jdbc-4.1.3.release.jar
  9. spring-oxm-4.1.3.release.jar
  10. spring-tx-4.1.3.release.jar
  11. spring-web-4.1.3.release.jar
  12. spring-webmvc-4.1.3.release.jar

1.首先创建web项目

web.mvc

2.引入所有的jar文件

3.配置web.xml

做web开发的都知道,web.xml是项目的入口，我们既然使用spring那么当然要添加spring的支持啦！

spring默认加载的是applicationcontext.xml，由于我们需要集成mybatis

所以我把spring的配置文件强制指定名称，并与mybatis一起配置，减少配置文件数量

先指定spring配置文件名名称与路径

<!-- spring 上下文参数 加载spring配置文件 --> 
 <context-param> 
  <param-name>contextconfiglocation</param-name> 
  <param-value>classpath*:xmlconfig/springmvc-mybatis.xml</param-value> 
 </context-param>

再执行spring上下文监听配置

<listener> 
 <listener-class>org.springframework.web.context.contextloaderlistener</listener-class> 
</listener>

添加支持spring mvc 的配置

说明：添加支持目前有3种方式。

第一种：拦截 /*.do

<!-- spring mvc 拦截器配置 --> 
<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*:/xmlconfig/springmvc-servlet.xml</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup> 
 </servlet> 
 <servlet-mapping> 
 <servlet-name>springmvc</servlet-name> 
 <url-pattern>/*.do</url-pattern> 
</servlet-mapping>

优势：拦截明确，不会和其他的拦截冲突

缺点：url不美观

第二种：拦截 /*

<!-- spring mvc 拦截器配置 --> 
<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*:/xmlconfig/springmvc-servlet.xml</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup> 
 </servlet> 
 <servlet-mapping> 
 <servlet-name>springmvc</servlet-name> 
 <url-pattern>/*</url-pattern> 
</servlet-mapping>

优点：支持rest风格，url美观

缺点：会拦截静态资源

第三种，也是我推荐的一种：拦截 /

<!-- spring mvc 拦截器配置 --> 
<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*:/xmlconfig/springmvc-servlet.xml</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup> 
 </servlet> 
 <servlet-mapping> 
 <servlet-name>springmvc</servlet-name> 
 <url-pattern>/</url-pattern> 
</servlet-mapping>

优点：支持rest风格，url美观，不拦截静态资源

我们采用第三种做为我们的拦截方案，将配置添加到web.xml中。

大家都知道，web项目最怕的就是乱码，而spring为我们提供了字符编码的过滤器，我们也给配置到web.xml中

<!-- 字符编码配置 --> 
<filter> 
 <filter-name>characterencodingfilter</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>characterencodingfilter</filter-name> 
 <url-pattern>/*</url-pattern> 
</filter-mapping>

我们采用的是tomcat服务器，为了让静态的资源直接交给tomcat处理，所以我们在web.xml中配置了以下配置

<!-- 激活tomcat的defaultservlet来处理静态文件 --> 
<servlet-mapping> 
 <servlet-name>default</servlet-name> 
 <url-pattern>*.jpg</url-pattern> 
</servlet-mapping> 
<servlet-mapping> 
 <servlet-name>default</servlet-name> 
 <url-pattern>*.gif</url-pattern> 
</servlet-mapping> 
<servlet-mapping> 
 <servlet-name>default</servlet-name> 
 <url-pattern>*.png</url-pattern> 
</servlet-mapping> 
<servlet-mapping> 
 <servlet-name>default</servlet-name> 
 <url-pattern>*.js</url-pattern> 
</servlet-mapping> 
<servlet-mapping> 
 <servlet-name>default</servlet-name> 
 <url-pattern>*.css</url-pattern> 
</servlet-mapping>

4.配置springmvc-mybatis.xml和springmvc-servlet.xml

相信很多人都在这里卡主了，因为配置实在是太多了，各种方式都有

为了不妨碍大家，我决定直接将完整的配置直接贴出来

springmvc-mybatis.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:p="http://www.springframework.org/schema/p"  
  xmlns:mvc="http://www.springframework.org/schema/mvc"  
  xmlns:context="http://www.springframework.org/schema/context"  
  xmlns:util="http://www.springframework.org/schema/util"  
  xsi:schemalocation="http://www.springframework.org/schema/beans 
   http://www.springframework.org/schema/beans/spring-beans-4.1.xsd  
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-4.1.xsd  
   http://www.springframework.org/schema/mvc 
   http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd  
   http://www.springframework.org/schema/util 
   http://www.springframework.org/schema/util/spring-util-4.1.xsd"> 
 
 <!-- 数据源定义--> 
 <bean id="datasource" class="com.jolbox.bonecp.bonecpdatasource"> 
  <property name="driverclass" value="jdbc:mysql://127.0.0.1:3306/web" /> 
  <property name="jdbcurl" value="root" /> 
  <property name="username" value="123456" /> 
  <property name="password" value="com.mysql.jdbc.driver" /> 
 </bean> 
  
 <bean id="sqlsessionfactory" class="org.mybatis.spring.sqlsessionfactorybean"> 
  <property name="datasource" ref="datasource" /> 
  <property name="mapperlocations" value="classpath*:dbmap/*mapper.xml" /> 
 </bean> 
  
 <!-- 配置事务管理器 --> 
 <bean id="transactionmanager" 
   class="org.springframework.jdbc.datasource.datasourcetransactionmanager"> 
  <property name="datasource" ref="datasource" /> 
 </bean> 
  
 <bean id="jdbctemplate" class="org.springframework.jdbc.core.jdbctemplate"> 
  <property name="datasource"> 
   <ref bean="datasource" /> 
  </property> 
 </bean> 
 <bean id="defaultlobhandler" 
   class="org.springframework.jdbc.support.lob.defaultlobhandler" 
   lazy-init="true"/> 
 <!-- 查 找 类 路 径 下 的 映 射 器 并 自 动 将 它 们 创 建 成 mapperfactorybean--> 
 <bean class="org.mybatis.spring.mapper.mapperscannerconfigurer"> 
  <property name="basepackage" value="com.ansitech.web.orm.mapper" /> 
 </bean> 
</beans>

spring-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" 
  xsi:schemalocation="http://www.springframework.org/schema/mvc 
  http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd 
  http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
  http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.1.xsd"> 
  
 <description>spring mvc configuration</description> 
  
 <!-- 对静态资源文件的访问，交给default servlet handler处理 --> 
 <mvc:default-servlet-handler/> 
  
 <!-- 启用spring mvc 注解 --> 
 <context:annotation-config /> 
  
 <!-- 默认的注解映射的支持 --> 
 <mvc:annotation-driven /> 
  
 <!-- 设置使用注解的类所在的jar包 --> 
 <context:component-scan base-package="com.ansitech.web"></context:component-scan> 
  
 <!-- 完成请求和注解pojo的映射 --> 
<bean class= 
  "org.springframework.web.servlet.mvc.annotation.annotationmethodhandleradapter"/> 
  
 <!-- jsp视图文件解析配置 --> 
<bean class="org.springframework.web.servlet.view.internalresourceviewresolver"> 
 <property name="viewclass" value="org.springframework.web.servlet.view.jstlview"/> 
 <property name="prefix" value="/web-inf/view/"/> 
 <property name="suffix" value=".jsp"/> 
 <property name="viewnames" value="jsp/*"/> 
 <property name="order" value="1"/> 
</bean> 
  
<bean class="org.springframework.web.servlet.view.urlbasedviewresolver"> 
 <property name="viewclass" value="org.springframework.web.servlet.view.jstlview"/> 
 <property name="prefix" value="/web-inf/view/"/> 
 <property name="suffix" value=".jsp"/> 
 <property name="order" value="2"/> 
</bean> 
 
 <!-- 上传文件拦截，设置最大上传文件大小 10m=10*1024*1024(b)=10485760 bytes --> 
 <bean id="multipartresolver" 
   class="org.springframework.web.multipart.commons.commonsmultipartresolver"> 
  <!-- one of the properties available; the maximum file size in bytes --> 
  <property name="maxuploadsize"> 
   <value>5242880</value> 
  </property> 
 </bean> 
</beans>

web.xml

<?xml version="1.0" encoding="utf-8"?> 
 
<web-app 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" 
   version="3.0"> 
 <!-- 程序session配置 --> 
 <session-config> 
  <!-- session过期时间(单位：分) --> 
  <session-timeout>30</session-timeout> 
 </session-config> 
  
 <!-- 激活tomcat的defaultservlet来处理静态文件 --> 
 <servlet-mapping> 
  <servlet-name>default</servlet-name> 
  <url-pattern>*.jpg</url-pattern> 
 </servlet-mapping> 
 <servlet-mapping> 
  <servlet-name>default</servlet-name> 
  <url-pattern>*.gif</url-pattern> 
 </servlet-mapping> 
 <servlet-mapping> 
  <servlet-name>default</servlet-name> 
  <url-pattern>*.png</url-pattern> 
 </servlet-mapping> 
 <servlet-mapping> 
  <servlet-name>default</servlet-name> 
  <url-pattern>*.js</url-pattern> 
 </servlet-mapping> 
 <servlet-mapping> 
  <servlet-name>default</servlet-name> 
  <url-pattern>*.css</url-pattern> 
 </servlet-mapping> 
 
 <!-- spring 上下文参数 加载spring配置文件 --> 
 <context-param> 
  <param-name>contextconfiglocation</param-name> 
  <param-value>classpath*:xmlconfig/springmvc-mybatis.xml</param-value> 
 </context-param> 
 
 <listener> 
  <listener-class>org.springframework.web.context.contextloaderlistener</listener-class> 
 </listener> 
  
 <!-- spring mvc 拦截器配置 --> 
 <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*:/xmlconfig/springmvc-servlet.xml</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup> 
 </servlet> 
 <servlet-mapping> 
  <servlet-name>springmvc</servlet-name> 
  <url-pattern>/</url-pattern> 
 </servlet-mapping> 
  
 <!-- 字符编码配置 --> 
 <filter> 
  <filter-name>characterencodingfilter</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>characterencodingfilter</filter-name> 
  <url-pattern>/*</url-pattern> 
 </filter-mapping> 
 
 <!-- 欢迎页 --> 
 <welcome-file-list> 
  <welcome-file>/index.html</welcome-file> 
 </welcome-file-list> 
</web-app>

接下来就是包的结构了

前缀大家可以自己定义自己喜欢的，但是后边的结构，是整个框架的核心，所以请大家按照我的格式去建

前缀com.ansitech

com.ansitech.orm

com.ansitech.orm.base

com.ansitech.orm.mapper

com.ansitech.service

com.ansitech.service.po

com.ansitech.service.impl

com.ansitech.web

com.ansitech.web.controller

大家可能不理解，为什么要这么建呢？

那么我们来以用户管理模块来解释，用户对象为user

那么我们需要建立基础对象：

com.ansitech.orm.base.user.java

package com.ansitech.orm.base; 
 
/** 
 * 用户对象 
 * 
 * @author qsyang 
 */ 
public class user { 
 
 private int id; 
 private string loginname; 
 private string loginpwd; 
 /** 
  * 用户类型 1 管理员 2 普通用户 
  */ 
 private int typeid; 
 
 public int getid() { 
  return id; 
 } 
 
 public void setid(int id) { 
  this.id = id; 
 } 
 
 public string getloginname() { 
  return loginname; 
 } 
 
 public void setloginname(string loginname) { 
  this.loginname = loginname; 
 } 
 
 public string getloginpwd() { 
  return loginpwd; 
 } 
 
 public void setloginpwd(string loginpwd) { 
  this.loginpwd = loginpwd; 
 } 
 
 public int gettypeid() { 
  return typeid; 
 } 
 
 public void settypeid(int typeid) { 
  this.typeid = typeid; 
 } 
}

基础对象建好了，我们需要做一个mapper来实现用户对象的增删改查

com.ansitech.orm.mapper.usermapper.java

package com.ansitech.orm.mapper; 
 
import com.ansitech.orm.base.user; 
import org.apache.ibatis.annotations.param; 
 
/** 
 * 用户数据接口 
 * 
 * @author qsyang 
 */ 
public interface usermapper { 
 
 void add(user user); 
 
 user get(@param("id") int id); 
 
 void update(user user); 
 
 int delete(@param("id") int id); 
 
}

使用orm模式，我们需要创建一个抽象的用户对象来解决额外属性查询的问题

com.ansitech.orm.abstractuser.java

package com.ansitech.orm; 
 
import com.ansitech.orm.base.user; 
 
/** 
 * 抽象用户对象 
 * 
 * 提供其他属性获取 
 * 
 * @author qsyang 
 */ 
public abstract class abstractuser extends user{ 
 
 //获取当前用户所属分类名称 
 public abstract string findtypename(); 
}

有了数据接口了，我们需要对外提供服务

com.ansitech.service.iuserservice.java

package com.ansitech.service; 
 
import com.ansitech.orm.abstractuser; 
import com.ansitech.orm.base.user; 
 
/** 
 * 用户服务接口 
 * 
 * @author qsyang 
 */ 
public interface iuserservice { 
 
 //添加系统管理员 
 void addsystemuser(string loginname, string loginpwd); 
 
 //添加普通用户 
 void addnormaluser(string loginname, string loginpwd); 
  
 //根据用户id查询抽象用户 
 abstractuser getabstractuserbyid(int userid); 
 
 //根据用户id查询用户 
 user getuserbyid(int userid); 
 
 //修改用户信息 
 void updateuser(int userid, string loginname, string loginpwd); 
 
 //根据用户id删除用户 
 int deleteuser(int userid); 
}

有了服务接口，就要有实现接口

com.ansitech.service.impl.userservice.java

package com.ansitech.service.impl; 
 
import com.ansitech.orm.abstractuser; 
import com.ansitech.orm.base.user; 
import com.ansitech.orm.mapper.usermapper; 
import com.ansitech.service.iuserservice; 
import org.springframework.beans.factory.annotation.autowired; 
import org.springframework.stereotype.service; 
 
/** 
 * 用户接口实现类 
 * 
 * @author qsyang 
 */ 
@service 
public class userservice implements iuserservice { 
 
 @autowired 
 private usermapper usermapper; 
 
 @override 
 public void addsystemuser(string loginname, string loginpwd) { 
  user user = new user(); 
  user.setloginname(loginname); 
  user.setloginpwd(loginpwd); 
  //用户类型 1 管理员 2 普通用户 
  user.settypeid(1); 
  usermapper.add(null); 
 } 
 
 @override 
 public void addnormaluser(string loginname, string loginpwd) { 
  user user = new user(); 
  user.setloginname(loginname); 
  user.setloginpwd(loginpwd); 
  //用户类型 1 管理员 2 普通用户 
  user.settypeid(2); 
  usermapper.add(null); 
 } 
 
 @override 
 public abstractuser getabstractuserbyid(int userid) { 
  throw new unsupportedoperationexception("not supported yet."); 
 } 
 
 @override 
 public user getuserbyid(int userid) { 
  return usermapper.get(userid); 
 } 
 
 @override 
 public void updateuser(int userid, string loginname, string loginpwd) { 
  //先根据用户id查询用户对象 
  user user = usermapper.get(userid); 
  if (user != null) { 
   user.setloginname(loginname); 
   user.setloginpwd(loginpwd); 
   //修改用户 
   usermapper.update(user); 
  } 
 } 
 
 @override 
 public int deleteuser(int userid) { 
  return usermapper.delete(userid); 
 } 
 
}

细心的便宜，可能已经看到了，getabstractuserbyid()这个方法我们还没有实现

因为abstractuser还有具体的实现类，所以我们来新建实现类

package com.ansitech.service.po; 
 
import com.ansitech.orm.abstractuser; 
import com.ansitech.orm.base.user; 
import com.ansitech.service.impl.userservice; 
 
/** 
 * 用户数据操作对象 
 * 
 * @author qsyang 
 */ 
public class userpo extends abstractuser { 
 
 private final userservice userservice; 
 
 public userpo(userservice userservice) { 
  this.userservice = userservice; 
 } 
 
 public userpo copyfrom(user obj) { 
  this.setid(obj.getid()); 
  this.setloginname(obj.getloginname()); 
  this.setloginpwd(obj.getloginpwd()); 
  this.settypeid(obj.gettypeid()); 
  return this; 
 } 
 
 @override 
 public string findtypename() { 
  return userservice.findtypename(this.gettypeid()); 
 } 
 
}

对象已经创建好了，这个时候我们可以修改下service实现类的方法了，并且我们增加了一个方法

增加这个方法，只是因为我们有可能需要继续调用其他的mapper去查询。

修改的实现方法

@override 
public abstractuser getabstractuserbyid(int userid) { 
 user user = usermapper.get(userid); 
 if (user != null) { 
  userpo po = new userpo(this); 
  po.copyfrom(user); 
  return po; 
 } 
 return null; 
}

新增的方法：

public string findtypename(int typeid) { 
 if (typeid == 1) { 
  return "系统管理员"; 
 } else { 
  return "普通用户"; 
 } 
}

只有一来，service架构和orm架构就已经完成了，下面只需要建立控制器就可以了

package com.ansitech.web.controller.user; 
 
import com.ansitech.orm.base.user; 
import com.ansitech.service.impl.userservice; 
import org.springframework.beans.factory.annotation.autowired; 
import org.springframework.stereotype.controller; 
import org.springframework.web.bind.annotation.requestmapping; 
 
/** 
 * 用户控制器 
 * 
 * @author qsyang 
 */ 
@controller 
public class usercontroller { 
 
 @autowired 
 private userservice userservice; 
 
 @requestmapping("/user/user-index") 
 public string index() { 
  user user = userservice.getuserbyid(1); 
  if (user != null) { 
   system.out.println("user name = " + user.getloginname()); 
  } 
  return "jsp/user/index"; 
 } 
}

大家到现在有没有理解这个架构呢？

Spring MVC 4.1.3 + MyBatis零基础搭建Web开发框架(注解模式)

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

上一篇： 批量账号的login测试功能实现

下一篇： springboot整合mybatis中的问题及出现的一些问题小结

推荐阅读