Web项目框架搭建【二】——Spring+Spring MVC+MyBatis 整合

Spring + Spring MVC + MyBatis 整合

此次整合我分两个配置文件：

　　1）分别是spring-mybatis.xml，包含spring和mybatis的配置文件，

　　2）还有个是spring-mvc的配置文件，

　　3）此外有2个资源文件：jdbc.propertis和log4j.properties

以下是框架版本及来源：

　　Spring 4.0.2 RELEASE（PS：无需手动下载，Maven会自动下）

　　Spring MVC 4.0.2 RELEASE（PS：无需手动下载，Maven会自动下）

　　MyBatis 3.2.6（下载：https://github.com/mybatis/mybatis-3/releases?after=mybatis-3.2.7）

*设置 xml 文件的代码提示功能 

打 开 Eclipse 依次选择 Window > Preferences > Xml > Xml Files > Editor > Content Assist > Auto activation > Prompt when these characters are inserted，设置框中默认是 <=: ，改成<=:qwertyuioplkjhgfdsazxcvbnm就ok了。

下面是项目完整结构，先有个印象：

4.1 Maven引入需要的jar包

为了方便后面说的时候不需要引入JAR包，这里直接给出所有需要的JAR包，这都是基本的JAR包，每个包的是干什么的都有注释

pom.xml

  1 
  2       
  3       4.0.2.RELEASE
  4       
  5     3.2.6
  6     
  7     1.7.7
  8     1.2.17
  9   
 10   
 11     
 12       junit
 13       junit
 14       3.8.1
 15       test
 16     
 17     
 18     
 19         javax
 20         javaee-api
 21         7.0
 22     
 23     
 24         junit
 25         junit
 26         4.11
 27         
 28         test
 29     
 30     
 31     
 32         org.springframework
 33         spring-core
 34         ${spring.version}
 35     
 36     
 37         org.springframework
 38         spring-web
 39         ${spring.version}
 40     
 41     
 42         org.springframework
 43         spring-oxm
 44         ${spring.version}
 45     
 46     
 47         org.springframework
 48         spring-tx
 49         ${spring.version}
 50     
 51     
 52         org.springframework
 53         spring-jdbc
 54         ${spring.version}
 55     
 56     
 57         org.springframework
 58         spring-webmvc
 59         ${spring.version}
 60     
 61     
 62         org.springframework
 63         spring-aop
 64         ${spring.version}
 65     
 66     
 67         org.springframework
 68         spring-context-support
 69         ${spring.version}
 70     
 71     
 72         org.springframework
 73         spring-test
 74         ${spring.version}
 75     
 76     
 77     
 78         org.mybatis
 79         mybatis
 80         ${mybatis.version}
 81     
 82     
 83     
 84         org.mybatis
 85         mybatis-spring
 86         1.2.2
 87     
 88     
 89     
 90         mysql
 91         mysql-connector-java
 92         5.1.30
 93     
 94     
 95     
 96         commons-dbcp
 97         commons-dbcp
 98         1.2.2
 99     
100     
101     
102         jstl
103         jstl
104         1.2
105     
106     
107     
108     
109         log4j
110         log4j
111         ${log4j.version}
112     
113     
114     
115         com.alibaba
116         fastjson
117         1.1.41
118     
119     
120         org.slf4j
121         slf4j-api
122         ${slf4j.version}
123     
124     
125         org.slf4j
126         slf4j-log4j12
127         ${slf4j.version}
128     
129     
130     
131     
132         org.codehaus.jackson
133         jackson-mapper-asl
134         1.9.13
135     
136     
137     
138         commons-fileupload
139         commons-fileupload
140         1.3.1
141     
142     
143         commons-io
144         commons-io
145         2.4
146     
147     
148         commons-codec
149         commons-codec
150         1.9
151     
152   
153   
154     hongceshi
155     
156      
157         org.apache.maven.plugins
158         maven-compiler-plugin
159         3.5.1
160         
161             1.8
162             1.8
163             UTF-8
164         
165      
166   
167   

4.2 Spring与MyBatis的整合

4.1的jar包引入之后，首先进行Spring和MyBatis整合，然后再进行JUnit测试，先看一个项目结构图：

4.2.1 建立JDBC属性文件（有背景颜色部分需根据自己信息修改）

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/projectmanagement?useUnicode=true&characterEncoding=UTF-8
username=root
password=root
#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000

4.2.2 Log4j的配置（跳过此步也没影响）

为了方便调试，一般都会使用日志来输出信息，Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
Log4j的配置很简单，而且也是通用的，下面给出一个基本的配置，换到其他项目中也无需做多大的调整，如果想做调整或者想了解Log4j的各种配置，可以参考：Log4j配置详解 

log4j.properties

 1 #定义LOG输出级别
 2 log4j.rootLogger=INFO,Console,File
 3 #定义日志输出目的地为控制台
 4 log4j.appender.Console=org.apache.log4j.ConsoleAppender
 5 log4j.appender.Console.Target=System.out
 6 #可以灵活地指定日志输出格式，下面一行是指定具体的格式
 7 log4j.appender.Console.layout = org.apache.log4j.PatternLayout
 8 log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n
 9 
10 #文件大小到达指定尺寸的时候产生一个新的文件
11 log4j.appender.File = org.apache.log4j.RollingFileAppender
12 #指定输出目录
13 log4j.appender.File.File = logs/springmvcMybist/ssm.log
14 #定义文件最大大小
15 log4j.appender.File.MaxFileSize = 10MB
16 #输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
17 log4j.appender.File.Threshold = ALL
18 log4j.appender.File.layout = org.apache.log4j.PatternLayout
19 log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

4.2.3、建立spring-mybatis.xml配置文件

这个文件就是用来完成spring和mybatis的整合的。这里面也没多少行配置，主要的就是自动扫描，自动注入，配置数据库

spring-mybatis.xml

 1 "1.0" encoding="UTF-8"?>
 2 "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="http://www.springframework.org/schema/beans  
 7                         http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
 8                         http://www.springframework.org/schema/context  
 9                         http://www.springframework.org/schema/context/spring-context-4.0.xsd  
10                         http://www.springframework.org/schema/mvc  
11                         http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
12     
13     base-package="com.tim" />
14 
15     
16     "propertyConfigurer"
17         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
18         "location" value="classpath:jdbc.properties" />
19     
20 
21     "dataSource" class="org.apache.commons.dbcp.BasicDataSource"
22         destroy-method="close">
23         "driverClassName" value="${driver}" />
24         "url" value="${url}" />
25         "username" value="${username}" />
26         "password" value="${password}" />
27         
28         "initialSize" value="${initialSize}">
29         
30         "maxActive" value="${maxActive}">
31         
32         "maxIdle" value="${maxIdle}">
33         
34         "minIdle" value="${minIdle}">
35         
36         "maxWait" value="${maxWait}">
37     
38 
39     
40     "sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
41         "dataSource" ref="dataSource" />
42         
43         "mapperLocations" value="classpath:com/tim/dao/*.xml">
44     
45 
46     
47     class="org.mybatis.spring.mapper.MapperScannerConfigurer">
48         "basePackage" value="com.tim.dao" />
49         "sqlSessionFactoryBeanName" value="sqlSessionFactory">
50     
51 
52     
53     "transactionManager"
54         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
55         "dataSource" ref="dataSource" />
56     
57 

4.2.4、JUnit测试

经过以上步骤（log4j不配也没影响），我们已经完成了Spring和mybatis的整合，这样我们就可以编写一段测试代码来试试是否成功了。

4.2.4.1 创建测试用表

既然我们需要测试，那么我们就需要在数据库中建立一个测试表，这个表建的很简单，SQL语句为：

Mysql新建数据库，执行下面语句

CREATE TABLE IF NOT EXISTS `projectinfo` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `projectName` varchar(100) NOT NULL,
  `projectManager` varchar(100) NOT NULL,
  `createTime` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `updateTime` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

INSERT INTO `projectinfo` (`projectName`, `projectManager`) VALUES （'CME', 'Tim',);

4.2.4.2、创建Bean, Dao, Services类

bean: ProjectInfoBean

package com.tim.bean;

public class ProjectInfoBean {
	int id;
	String projectName;
	String projectManager;

	public int getId() {

		return id;

	}
	public void setId(int id) {
		this.id = id;
	}
	
	public String getProjectName() {
		return projectName;
	}
	public void setProjectName(String projectName) {
		this.projectName = projectName;
	}
	
	public String getProjectManager() {
		return projectManager;
	}
	
	public void setProjectManager(String projectManager) {
		this.projectManager = projectManager;
	}
}

dao: ProjectInfoDAO

package com.tim.dao;

import com.tim.bean.ProjectInfoBean;

public interface ProjectInfoDAO {
	int deleteProjectInfoById(int id);
	int insertProjectInfo(ProjectInfoBean projectInfoBean);
	ProjectInfoBean selectProjectInfoById(int id);
	int updateProjectInfo(ProjectInfoBean projectInfoBean);
}

dao: ProjectInfoDAO.xml

com.tim.dao.ProjectInfoDAO" >   
  com.tim.bean.ProjectInfoBean" />
  selectProjectInfoById" resultMap="BaseResultMap" parameterType="java.lang.Integer" >
    select * from projectinfo where id = #{id}
  
  deleteProjectInfoById" parameterType="java.lang.Integer" >
    delete from projectinfo where id = #{id}
  
  insertProjectInfo" parameterType="com.tim.bean.ProjectInfoBean" >
    insert into projectinfo (projectName, projectManager) values (#{projectName}, #{projectManager})
  
  updateProjectInfo" parameterType="com.tim.bean.ProjectInfoBean" >
    update projectinfo set projectName = #{projectName}, projectManager = #{projectManager} where id = #{id}
  

service: IProjectInfoService.java

package com.tim.service; import com.tim.bean.ProjectInfoBean; public interface IProjectInfoService { public ProjectInfoBean getProjectInfoById (int id); }

service.impl: ProjectInfoService.java

package com.tim.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.tim.bean.ProjectInfoBean;
import com.tim.dao.ProjectInfoDAO;
import com.tim.service.IProjectInfoService;

@Service("projectInfoService")
public class ProjectInfoService implements IProjectInfoService {
    @Resource
    private ProjectInfoDAO ProjectInfoDAO;

    public ProjectInfoBean getProjectInfoById(int id) {
        return this.ProjectInfoDAO.selectProjectInfoById(id);
    }
}

4.2.4.4、建立测试类

测试类在src/test/java中建立，下面测试类中注释掉的部分是不使用Spring时，一般情况下的一种测试方法；如果使用了Spring那么就可以使用注解的方式来引入配置文件和类，然后再将service接口对象注入，就可以进行测试了。如果测试成功，表示Spring和Mybatis已经整合成功了。输出信息使用的是Log4j打印到控制台

TestMyBatis.java

package com.tim.test;

import org.apache.log4j.Logger;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.alibaba.fastjson.JSON;
import com.tim.bean.ProjectInfoBean;
import com.tim.service.IProjectInfoService;

@RunWith(SpringJUnit4ClassRunner.class)			//  表示继承了这个类
@ContextConfiguration(locations = { "classpath:spring-mybatis.xml" })
public class TestMyBatis {
	private static Logger logger = Logger.getLogger(TestMyBatis.class);
	
	@Resource
	private IProjectInfoService projectInfoService = null;
	
	@Test
	public void test() {
		ProjectInfoBean projectInfoBean = projectInfoService.getProjectInfoById(1);
		logger.info(projectInfoBean);
		logger.info("projectInfo 转化为 json");
		logger.info(JSON.toJSONString(projectInfoBean));
	}
}

开始测试：

项目右键Maven->Update Project...（重点），等更新完，右击项目->Run As->JUnit Test

4.3、整合SpringMVC

上面已经完成了2大框架的整合，SpringMVC的配置文件单独放，然后在web.xml中配置整合

4.3.1、配置spring-mvc.xml

主要是自动扫描控制器，视图模式，注解的启动这三个

spring-mvc.xml

    
    
        
            
                text/html;charset=UTF-8
            
        
    

    
    
        
            
                
                    
            
        
    

    
    

    
    com.tim.controller" />

    
    
    

    

    
    
        
        
        
    

    
    
        
        
        
        
        
        
    

4.3.2、配置web.xml文件

这里面对spring-mybatis.xml的引入以及配置的spring-mvc的Servlet就是为了完成SSM整合，之前2框架整合不需要在此处进行任何配置。配置一样有详细注释，不多解释了。

web.xml

 1 
 2  3     xmlns="http://java.sun.com/xml/ns/javaee"
 4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 5     version="3.0">
 6     Archetype Created Web Application
 7     
 8     
 9     
10         contextConfigLocation
11         classpath:spring-mybatis.xml
12     
13     
14     
15     
16         encodingFilter
17         class>org.springframework.web.filter.CharacterEncodingFilterclass>
18         true
19         
20             encoding
21             UTF-8
22         
23     
24     
25         encodingFilter
26         /*
27     
28     
29     
30     
31         org.springframework.web.context.ContextLoaderListener
32     
33     
34     
35     
36         org.springframework.web.util.IntrospectorCleanupListener
37     
38     
39     
40     
41         SpringMVC
42         org.springframework.web.servlet.DispatcherServlet
43         
44             contextConfigLocation
45             classpath:spring-mvc.xml
46         
47         1
48         true
49     
50     
51         SpringMVC
52         
53         /
54     
55     
56     
57         /index.html
58         /index.jsp
59     
60 

4.3.3、测试

至此已经完成了SSM三大框架的整合了，接下来测试一下，如果成功了，那么恭喜你，如果失败了，继续调试吧，作为程序员就是不停的与BUG做斗争！

4.3.3.1、新建jsp页面

projectInfo.jsp   此页面仅输出一下项目名称，完成一个完整的简单流程

projectInfo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>


	
		
		
	
	${projectInfoBean.projectName}

4.3.3.2、建立ProjectInfoController类

ProjectInfoController.java

package com.tim.controller;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import com.tim.bean.ProjectInfoBean;
import com.tim.service.IProjectInfoService;

@Controller
@RequestMapping("/projectInfo")
public class ProjectInfoController {
	@Resource
	private IProjectInfoService projectInfoService;
	
	@RequestMapping("/showProjectById")
	public String toIndex(HttpServletRequest request, Model model) {
		int projectInfoId = Integer.parseInt(request.getParameter("projectInfoId"));        // 页面参数名为projectInfoId
		ProjectInfoBean projectInfoBean = this.projectInfoService.getProjectInfoById(projectInfoId);
		model.addAttribute("projectInfoBean", projectInfoBean);        // 对应projectInfo.jsp页面中的${projectInfoBean.projectName}

		return "projectInfo";    // 返回的string值为projectInfo.jsp的文件名，表示返回结果映射到projectInfo.jsp文件上
	}
}

启动项目，浏览器输入http://localhost:8080/project/projectInfo/showProjectById?projectInfoId=1

其中project对应为项目名称；

projectInfo对应为ProjectInfoController.java类的RequestMapping("projectInfo")；

showProjectById对应为ProjectInfoController.java类中toIndex方法的RequestMapping("showProjectById");

projectInfoId对应为ProjectInfoController.java类中toIndex方法中的request.getParameter("projectInfoId")

至此SSM框架整合成功。

 

但是，可能会遇到一个问题：

启动Tomcat时出现如下报错：

解决方法：

1. 右键项目->Properties；

2. 选择Deployment Assembly，在右边点击Add按钮，在弹出的窗口中选择Java Build Path Entries

3. 点击Next，选择Maven Dependencies，点击Finish，然后可以看到已经把Maven Dependencies添加到Web应用结构中了

4. Clean Project，重新部署项目，问题解决。

5. 如果问题还是存在，可以尝试修改Server的Server Locations为Use Tomcat installation