[转]SSM（Spring+SpringMVC+Mybatis）框架搭建详细教程【附源代码Demo】

一、新建项目

　　运行IDEA，进入初始化界面，然后我们选择新建项目（进入主界面新建项目也是一样的）

　　

　　在Maven选项卡里面找到对应的java web选项，然后我们点下一步

　　

　　这一步填入组织等信息，这里比较随意，按照自己的需求进行填写，然后下一步

　　

　　这里我早已配置好本地Maven仓库，因此直接默认即可。如果没进行配置本地默认仓库的话，请网上查找对应的资料进行配置

　　

　　输入Project name，和需要保存的路径，然后finish

　　

　　去泡一杯咖啡吧，这里需要一小段时间哦~

　　稍等片刻，idea已经为我们自动建好了一切。到这里，我们的第一步，新建项目阶段已经完成，欢庆一下，进入下一个阶段。

 　　

　　新建好项目后，我们首先打开SSM_Demo，修改一下JDK版本。

　　

　　

　　在settings里面对项目版本进行修改：

　　

　　原来是1_5，现在改为1_8，可能会存在spring等框架版本和jdk版本不兼容问题，因此，提前升级了版本。

二、目录结构调整

首先我们配置Maven的项目结构，选择Project Structure

　　

　　选择Modules标签页，然后新建并标识对应的项目结构

　　最终的文件结构如下所示：

　　

　　

 

　　- Java为主Java代码文件夹

　　　　- Controllers 控制器文件文件夹

　　　　- Dao （数据访问）层文件夹

　　　　- Service（业务逻辑）层文件夹

　　　　- Entity（实体）层文件夹

　　- resources资源文件夹

　　　　- mapper mybatis sql文件夹

　　- webapp web页面文件夹

　　- Test 测试文件夹

三、Maven包的初始化

Maven是采用配置文件的方式进行jar包的自动导入，因此，我们需要进行对配置文件的修改来进行jar包的导入。

　　打开pom.xml文件

　　

 　　添加我们将会用到的一系列jar包配置（这里将我的配置直接复制过来，作为参考）

  1 
  3   4.0.0
  4   QX_JFrame
  5   Demo
  6   war
  7   1.0-SNAPSHOT
  8   Demo Maven Webapp
  9   http://maven.apache.org
 10   
 11     
 12     
 13       junit
 14       junit
 15       4.12
 17     
 18     
 19     
 20       org.springframework
 21       spring-core
 22       4.3.5.RELEASE
 23     
 24     
 25       org.springframework
 26       spring-aop
 27       4.3.5.RELEASE
 28     
 29     
 30       org.springframework
 31       spring-orm
 32       4.3.5.RELEASE
 33     
 34     
 35     
 36       org.springframework
 37       spring-tx
 38       4.3.5.RELEASE
 39     
 40     
 41       org.springframework
 42       spring-test
 43       4.3.5.RELEASE
 44     
 45     
 46       org.springframework
 47       spring-mock
 48       2.0.8
 49     
 50     
 51       org.springframework
 52       spring-jdbc
 53       4.3.5.RELEASE
 54     
 55     
 56       org.springframework
 57       spring-context
 58       4.3.5.RELEASE
 59     
 60     
 61       org.springframework
 62       spring-context-support
 63       4.3.5.RELEASE
 64     
 65     
 66       org.springframework
 67       spring-expression
 68       4.3.5.RELEASE
 69     
 70     
 71     
 72       org.springframework
 73       spring-web
 74       4.3.1.RELEASE
 75     
 76     
 77       org.springframework
 78       spring-webmvc
 79       4.3.1.RELEASE
 80     
 81 
 82     
 83       com.github.pagehelper
 84       pagehelper
 85       3.7.3
 86     
 87     
 88       com.github.jsqlparser
 89       jsqlparser
 90       0.9.1
 91     
 92     
 93     
 94       mysql
 95       mysql-connector-java
 96       5.1.38
 97     
 98     
 99     
100       c3p0
101       c3p0
102       0.9.1.2
103     
104     
105     
106     
107       jstl
108       jstl
109       1.2
110     
111     
112     
113     
114       commons-fileupload
115       commons-fileupload
116       1.3.1
117     
118     
119     
120       commons-io
121       commons-io
122       2.4
123     
124     
125     
126     
127       org.json
128       json
129       20160212
130     
131     
132     
133       net.sf.json-lib
134       json-lib
135       2.4
136     
137     
138     
139       commons-lang
140       commons-lang
141       2.6
142     
143     
144     
145       commons-beanutils
146       commons-beanutils
147       1.8.3
148     
149     
150     
151       commons-collections
152       commons-collections
153       3.2.1
154     
155     
156     
157       commons-logging
158       commons-logging
159       1.2
160     
161     
162     
163       net.sf.ezmorph
164       ezmorph
165       1.0.6
166     
167     
168     
169     
170       com.alibaba
171       fastjson
172       1.2.12
173     
174     
175     
176       com.google.code.gson
177       gson
178       2.6.2
179     
180     
181     
182     
183       net.iharder
184       base64
185       2.3.8
186     
187     
188     
189       commons-codec
190       commons-codec
191       1.10
192     
193     
194     
195     
196       org.apache.logging.log4j
197       log4j-core
198       2.6.2
199     
200     
201       org.jetbrains
202       annotations-java5
203       RELEASE
204     
205     
206     
207       org.mybatis
208       mybatis
209       3.3.0
210     
211     
212       org.mybatis
213       mybatis-spring
214       1.2.3
215     
216   
217   
218     Demo
219   
220 

　　待配置好的jar包都自动下载并导入后，我们maven包的导入阶段就完成了，下面我们开始整合各个组件。

四、Spring MVC的配置

 　　在resources资源文件夹下新建spring-servlet.xml文件，并在配置文件中声明spring mvc框架对控制器、页面、资源的访问

　　

　　在其中添加下面配置标签信息：

 1 
 2 
12 
13     
14     
15 
16     
17 
18     
19     
20     
21     
22         
23             
24             
25     
26     
27     
28     
29     
30     
31 

　　

　　这里的Controllers对应的是我们之前新建好的Controllers包文件夹。

　　对web.xml进行配置，将我们刚才添加的spring-servlet.xml配置进去

　　

　　

　　这里的classpath为resources资源目录

　　这一步配置的web.xml内容如下：

 1 
 4 
 8   Archetype Created Web Application
 9   
10     /index.jsp
11   
12   
13   
14     spring
15     org.springframework.web.servlet.DispatcherServlet
16     
17     
18       contextConfigLocation
19       classpath:spring-servlet.xml
20     
21     
22     1
23   
24   
25     spring
26     /
27   
28 

　　我们新建一个控制器测试一下（在Controllers包新建java类，RequestTestController）：

　　

　　接下来在RequestTestController里面写一个rest api接口：

　　

　　接口代码如下：

 1 package Controllers;
 2 
 3 import org.springframework.web.bind.annotation.GetMapping;
 4 import org.springframework.web.bind.annotation.RequestMapping;
 5 import org.springframework.web.bind.annotation.RestController;
 6 
 7 @RestController
 8 @RequestMapping("/api/RequestTest")
 9 public class RequestTestController {
10 
11     @GetMapping()
12     public String TestString(){
13         return "this is a test string. Time:2017-10-29 20:42:00";
14     }
15 }

　　这样，我们便可以通过url地址来进行访问我们的接口数据

　　

　　在右上角的运行服务器配置按钮，打开服务器配置项

 　　

　　这里如果左侧列表是空的话，我们就需要点击加号进行服务器的添加，选择Tomcat Server下的Local。然后点击刚刚添加的标签，在右侧输入Server Name，下面会自动提示设置编译方式，选一个编译方式，然后点击OK即可（这一步的前提是装好了Tomcat服务器，如果没有安装，则需要先安装Tomcat服务器）。

　　然后我们点击右上角的运行，如果没有什么问题的话，我们的控制台界面会提示服务启动成功！（我这样下来是不会出问题的）

　　

　　等浏览器打开以后，我们输入我们配置的api地址：http://localhost:8080/api/RequestTest

　　

　　这样，spring mvc已经成功整合到了项目里面！

五、Spring和Mybatis的配置

　　稍歇片刻后，我们继续进行Mybatis和Spring组件的整合...

　　先添加jdbc.properties（JDBC连接配置文件，当然这个文件里面的内容直接写到mybatis配置文件里面也是可以的）

　　

　　内容如下：

  jdbc.properties

　　继续在resources文件夹里面添加mybatis配置文件 spring-mybatis.xml

　　内容如下：

  spring-mybatis.xml

　　添加spring支持（applicationContext.xml），并在spring支持里面将mybatis配置文件进行引入

　　内容如下:

 1 
 2 
 7 
 8     
 9     
10     
11     
12 

　　applicationContext.xml配置文件是对spring的配置，我们配置spring组件的扫描包围Service和Dao层目录，然后将spring-mybatis.xml配置文件导入.

　　完成这三个后的文件目录是这样子的：

　　

　　target文件夹是刚才编译运行时候自动产生的，不要惊慌~~~

　　完成这几步后，我们还需要将spring的配置加载到已有的框架中去，打开web.xml文件，进行添加spring配置

　　在刚才的web-app标签内继续添加spring支持：

　　

　　此刻完整的web.xml文件内容如下：

  web.xml

　　到此刻，我们的spring、mybatis已经整合完毕，接下来稍歇片刻，我们进行demo的完成。

六、demo的构建

 　　打开数据库，我们新建一个数据库，并设计两张测试表，student和studentclass

　　

　　student表的设计如下：

　　

-- ----------------------------
-- Table structure for `student`
-- ----------------------------
DROP TABLE IF EXISTS `student`;
CREATE TABLE `student` (
  `Uid` binary(36) NOT NULL COMMENT 'Uid',
  `Name` varchar(20) NOT NULL,
  `Age` int(3) NOT NULL,
  `ClassId` int(3) NOT NULL,
  PRIMARY KEY (`Uid`),
  KEY `StudentClass` (`ClassId`),
  CONSTRAINT `StudentClass` FOREIGN KEY (`ClassId`) REFERENCES `studentclass` (`ClassId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

　　studentclass表的设计如下：

　　

-- ----------------------------
-- Table structure for `studentclass`
-- ----------------------------
DROP TABLE IF EXISTS `studentclass`;
CREATE TABLE `studentclass` (
  `ClassId` int(3) NOT NULL AUTO_INCREMENT,
  `ClassName` varchar(10) DEFAULT NULL,
  PRIMARY KEY (`ClassId`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

　　将数据库建好后，我们进行Entity，Dao，Service层以及mapper文件的的编写。

　　首先在mapper文件夹新建一个mapper文件：StudentMapper.xml

  1 
  2 
  3 
  4     
  5         
  6         
  7         
  8         
  9     
 10     
 11         Uid, Name, Age, ClassId
 12     
 13     
 14         select
 15         
 16         from student
 17         where Uid = #{uid,jdbcType=BINARY}
 18     
 19     
 20         SELECT
 21         
 22         from student
 23         
 24             1=1
 25             
 26                 and Uid=#{uid,jdbcType=BINARY}
 27             
 28             
 29                 and Name=#{name,jdbcType=VARCHAR}
 30             
 31             
 32                 and Age=#{age,jdbcType=INTEGER}
 33             
 34             
 35                 and ClassId=#{classid,jdbcType=INTEGER}
 36             
 37         
 38     
 39     
 40         delete from student
 41         where Uid = #{uid,jdbcType=BINARY}
 42     
 43     
 44         insert into student (Uid, Name, Age,
 45         ClassId)
 46         values (#{uid,jdbcType=BINARY}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER},
 47         #{classid,jdbcType=INTEGER})
 48     
 49     
 50         insert into student
 51         
 52             
 53                 Uid,
 54             
 55             
 56                 Name,
 57             
 58             
 59                 Age,
 60             
 61             
 62                 ClassId,
 63             
 64         
 65         
 66             
 67                 #{uid,jdbcType=BINARY},
 68             
 69             
 70                 #{name,jdbcType=VARCHAR},
 71             
 72             
 73                 #{age,jdbcType=INTEGER},
 74             
 75             
 76                 #{classid,jdbcType=INTEGER},
 77             
 78         
 79     
 80     
 81         update student
 82         
 83             
 84                 Name = #{name,jdbcType=VARCHAR},
 85             
 86             
 87                 Age = #{age,jdbcType=INTEGER},
 88             
 89             
 90                 ClassId = #{classid,jdbcType=INTEGER},
 91             
 92         
 93         where Uid = #{uid,jdbcType=BINARY}
 94     
 95     
 96         update student
 97         set Name = #{name,jdbcType=VARCHAR},
 98         Age = #{age,jdbcType=INTEGER},
 99         ClassId = #{classid,jdbcType=INTEGER}
100         where Uid = #{uid,jdbcType=BINARY}
101     
102 

　　以上这段代码是直接使用mybatis generator直接进行生成的，如果不想手写的话（手写容易出错），可以直接使用该工具进行生成，该工具的下载以及使用参见本人博客地址：http://www.cnblogs.com/qixiaoyizhan/p/7597315.html

　　添加Entity实体

　　

 1 package Entity;
 2 
 3 public class Student {
 4     private byte[] uid;
 5 
 6     private String name;
 7 
 8     private Integer age;
 9 
10     private Integer classid;
11 
12     public byte[] getUid() {
13         return uid;
14     }
15 
16     public void setUid(byte[] uid) {
17         this.uid = uid;
18     }
19 
20     public String getName() {
21         return name;
22     }
23 
24     public void setName(String name) {
25         this.name = name == null ? null : name.trim();
26     }
27 
28     public Integer getAge() {
29         return age;
30     }
31 
32     public void setAge(Integer age) {
33         this.age = age;
34     }
35 
36     public Integer getClassid() {
37         return classid;
38     }
39 
40     public void setClassid(Integer classid) {
41         this.classid = classid;
42     }
43 }

　　在Dao层写Mybatis接口（不需要写实现类，mybatis不需要），新建StudentMapper

　　

 1 package Dao;
 2 
 3 import Entity.Student;
 4 import org.springframework.stereotype.Repository;
 5 
 6 import java.util.List;
 7 
 8 @Repository
 9 public interface StudentMapper {
10     int deleteByPrimaryKey(byte[] uid);
11 
12     int insert(Student record);
13 
14     int insertSelective(Student record);
15 
16     Student selectByPrimaryKey(byte[] uid);
17 
18     List selectByCondition(Student record);
19 
20     int updateByPrimaryKeySelective(Student record);
21 
22     int updateByPrimaryKey(Student record);
23 }

　　在Service层写对Dao层的访问逻辑，当然Demo没有什么业务处理逻辑，仅作为Demo

　　

　　IStudentService 接口：

 1 package Service;
 2 
 3 import Entity.Student;
 4 
 5 import java.util.List;
 6 
 7 public interface IStudentService {
 8     int deleteByPrimaryKey(byte[] uid);
 9 
10     int insert(Student record);
11 
12     int insertSelective(Student record);
13 
14     Student selectByPrimaryKey(byte[] uid);
15 
16     List selectByCondition(Student record);
17 
18     int updateByPrimaryKeySelective(Student record);
19 
20     int updateByPrimaryKey(Student record);
21 }

　　StudentService 实现了 IStudentService 接口：

 1 package Service;
 2 
 3 import Dao.StudentMapper;
 4 import Entity.Student;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Service;
 7 
 8 import java.util.List;
 9 
10 @Service
11 public class StudentService implements IStudentService {
12     @Autowired
13     private StudentMapper studentMapper;
14 
15     @Override
16     public int deleteByPrimaryKey(byte[] uid) {
17         return studentMapper.deleteByPrimaryKey(uid);
18     }
19 
20     @Override
21     public int insert(Student record) {
22         return studentMapper.insert(record);
23     }
24 
25     @Override
26     public int insertSelective(Student record) {
27         return studentMapper.insertSelective(record);
28     }
29 
30     @Override
31     public Student selectByPrimaryKey(byte[] uid) {
32         return studentMapper.selectByPrimaryKey(uid);
33     }
34 
35     @Override
36     public List selectByCondition(Student record) {
37         return studentMapper.selectByCondition(record);
38     }
39 
40     @Override
41     public int updateByPrimaryKeySelective(Student record) {
42         return studentMapper.updateByPrimaryKeySelective(record);
43     }
44 
45     @Override
46     public int updateByPrimaryKey(Student record) {
47         return studentMapper.updateByPrimaryKey(record);
48     }
49 }

　　然后我们写一个StudentController用于调用Service

 　　

 1 package Controllers;
 2 
 3 import Entity.Student;
 4 import Service.IStudentService;
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.web.bind.annotation.GetMapping;
 7 import org.springframework.web.bind.annotation.RequestMapping;
 8 import org.springframework.web.bind.annotation.RestController;
 9 
10 import java.util.List;
11 
12 @RestController
13 @RequestMapping("/api/Student")
14 public class StudentController {
15     @Autowired
16     private IStudentService service;
17 
18     @GetMapping()
19     public String Get() {
20         List students = service.selectByCondition(new Student());
21         String jsonResult = com.alibaba.fastjson.JSON.toJSONString(students);
22         return jsonResult;
23     }
24 }

　　走到这一步的代码目录结构是这样子的：

　　

　　如果进行顺利的话，我们运行我们的Tomacat服务器，并调用我们的新接口：http://localhost:8080/api/Student

　　运行时候，别忘记了修改jdbc.properties文件里的连接url以及用户名密码！！！

　　

　　

　　哇，数据成功显示！（别把这个数据当成你会真的显示出来的一样，这是我数据库原有的数据，哈哈哈）

　　

　　还不快去添加几条数据调用一下试试嘛~

七、结尾

　　至此，我们的SSM框架已经基本搭建完毕，我们已经用我们搭建的Demo从真实的数据库中获取到了数据，并转成了Json格式，在浏览器中用Rest api接口的形式获取到了。

　　该项目源代码可以在Github上找到，如果需要的可以直接去下载->

　　https://github.com/dong666/SSM-Demo (不赶紧访问点个Star嘛？

本文为七小站主原创作品，转载请注明出处： http://www.cnblogs.com/qixiaoyizhan/ 且在文章页面明显位置给出原文链接，否则保留追究法律责任的权利。 

 

===================以上为转载信息===========================

===================以下为个人实践后备注信息===========================

 

pom.xml中引入的依赖包过多，搭建一个最简单的项目需要的最基本的依赖包如下（只列出包的artifactId）：

spring-webmvc

jstl

mysql-connector-java

mybatis

mybatis-spring

spring-jdbc

c3p0

 

另外我项目中使用的数据库连接字符串是 

 jdbc.url=jdbc:mysql://10.0.1.176:3306/db_test?characterEncoding=utf8      （IP:端口/数据库名）

 

转载于:https://www.cnblogs.com/luohengstudy/p/7911149.html