SSM（SPRING+SPRINGMVC+MYBATIS）框架搭建详细教程【附源代码DEMO】

最新推荐文章于 2024-09-23 16:07:08 发布

m0_38072563

最新推荐文章于 2024-09-23 16:07:08 发布

阅读量553

点赞数

http://www.cnblogs.com/qixiaoyizhan/p/7751732.html

【前言】

　　应某网络友人邀约，需要一个SSM框架的Demo作为基础学习资料，于是乎，就有了本文。一个从零开始的SSM框架Demo对一个新手来说，是非常重要的，可大大减少在学习过程中遇到的各种各样的坑，说到最后，也算是助人为乐吧！下面我们从零开始进行SSM框架的搭建，在介绍最后，我会把项目部署在GitHub以便需要Demo的亲朋好友们进行下载~~~

　　https://github.com/dong666/SSM-Demo　（访问记得Star哦~）

　　本Demo是在IDEA下搭建的Maven项目，在进行下面阅读前先了解这一点！

【开发环境】

　　1.操作系统：Windows7 ×64 Sp1

　　2.Java-Version：1.8.0_101

　　3.IDE:IntelliJ IDEA 2017.2.2 x64

一、新建项目

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

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

四、Spring MVC的配置

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

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

 1 <?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: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-3.1.xsd
 8 http://www.springframework.org/schema/context
 9 http://www.springframework.org/schema/context/spring-context-3.1.xsd
10 http://www.springframework.org/schema/mvc
11 http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
12 
13     <!-- 启动注解驱动的Spring MVC功能，注册请求url和注解POJO类方法的映射-->
14     <mvc:annotation-driven >
15 
16     </mvc:annotation-driven>
17 
18     <!-- 启动包扫描功能，以便注册带有@Controllers、@service、@repository、@Component等注解的类成为spring的bean -->
19     <context:component-scan base-package="Controllers" />
20     <!-- 对模型视图名称的解析，在请求时模型视图名称添加前后缀 -->
21     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
22         <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
23         <property name="prefix" value="/"/>    <!-- 前缀 -->
24         <property name="suffix" value=".jsp"/>    <!-- 后缀 -->
25     </bean>
26     <!-- 访问静态文件（jpg,js,css）的方法 -->
27     <!--<mvc:resources location="/files/" mapping="/files/**" />-->
28     <!--<mvc:resources location="/scripts/" mapping="/scripts/**" />-->
29     <!--<mvc:resources location="/styles/" mapping="/styles/**" />-->
30     <!--<mvc:resources location="/Views/" mapping="/Views/**" />-->
31 </beans>

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

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

　　这里的classpath为resources资源目录

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

 1 <!DOCTYPE web-app PUBLIC
 2         "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 3         "http://java.sun.com/dtd/web-app_2_3.dtd" >
 4 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5          xmlns="http://java.sun.com/xml/ns/javaee"
 6          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 7          version="3.0">
 8   <display-name>Archetype Created Web Application</display-name>
 9   <welcome-file-list>
10     <welcome-file>/index.jsp</welcome-file>
11   </welcome-file-list>
12   <!-- Spring MVC配置 -->
13   <servlet>
14     <servlet-name>spring</servlet-name>
15     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
16     <!--Spring-servlet.xml config-->
17     <init-param>
18       <param-name>contextConfigLocation</param-name>
19       <param-value>classpath:spring-servlet.xml</param-value>
20     </init-param>
21     <!-- load-on-startup元素标记容器是否在启动的时候就加载这个servlet(实例化并调用其init()方法) -->
22     <load-on-startup>1</load-on-startup>
23   </servlet>
24   <servlet-mapping>
25     <servlet-name>spring</servlet-name>
26     <url-pattern>/</url-pattern>
27   </servlet-mapping>
28 </web-app>

　　我们新建一个控制器测试一下（在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配置文件里面也是可以的）

　　内容如下：

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

　　内容如下：

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

　　内容如下:

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans
 3         xmlns="http://www.springframework.org/schema/beans"
 4         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5         xmlns:context="http://www.springframework.org/schema/context"
 6         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 7 
 8     <context:annotation-config />
 9     <!-- 配置component所在的包，自动加载需要管理的Bean -->
10     <context:component-scan base-package="Service,Dao" />
11     <import resource="spring-mybatis.xml" />
12 </beans>

　　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 <?xml version="1.0" encoding="UTF-8"?>
  2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3 <mapper namespace="Dao.StudentMapper">
  4     <resultMap id="BaseResultMap" type="Entity.Student">
  5         <id column="Uid" jdbcType="BINARY" property="uid" />
  6         <result column="Name" jdbcType="VARCHAR" property="name" />
  7         <result column="Age" jdbcType="INTEGER" property="age" />
  8         <result column="ClassId" jdbcType="INTEGER" property="classid" />
  9     </resultMap>
 10     <sql id="Base_Column_List">
 11         Uid, Name, Age, ClassId
 12     </sql>
 13     <select id="selectByPrimaryKey" parameterType="byte[]" resultMap="BaseResultMap">
 14         select
 15         <include refid="Base_Column_List" />
 16         from student
 17         where Uid = #{uid,jdbcType=BINARY}
 18     </select>
 19     <select id="selectByCondition" parameterType="Entity.Student" resultMap="BaseResultMap">
 20         SELECT
 21         <include refid="Base_Column_List"/>
 22         from student
 23         <where>
 24             1=1
 25             <if test="uid != null">
 26                 and Uid=#{uid,jdbcType=BINARY}
 27             </if>
 28             <if test="name != null">
 29                 and Name=#{name,jdbcType=VARCHAR}
 30             </if>
 31             <if test="age != null">
 32                 and Age=#{age,jdbcType=INTEGER}
 33             </if>
 34             <if test="classid != null">
 35                 and ClassId=#{classid,jdbcType=INTEGER}
 36             </if>
 37         </where>
 38     </select>
 39     <delete id="deleteByPrimaryKey" parameterType="byte[]">
 40         delete from student
 41         where Uid = #{uid,jdbcType=BINARY}
 42     </delete>
 43     <insert id="insert" parameterType="Entity.Student">
 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     </insert>
 49     <insert id="insertSelective" parameterType="Entity.Student">
 50         insert into student
 51         <trim prefix="(" suffix=")" suffixOverrides=",">
 52             <if test="uid != null">
 53                 Uid,
 54             </if>
 55             <if test="name != null">
 56                 Name,
 57             </if>
 58             <if test="age != null">
 59                 Age,
 60             </if>
 61             <if test="classid != null">
 62                 ClassId,
 63             </if>
 64         </trim>
 65         <trim prefix="values (" suffix=")" suffixOverrides=",">
 66             <if test="uid != null">
 67                 #{uid,jdbcType=BINARY},
 68             </if>
 69             <if test="name != null">
 70                 #{name,jdbcType=VARCHAR},
 71             </if>
 72             <if test="age != null">
 73                 #{age,jdbcType=INTEGER},
 74             </if>
 75             <if test="classid != null">
 76                 #{classid,jdbcType=INTEGER},
 77             </if>
 78         </trim>
 79     </insert>
 80     <update id="updateByPrimaryKeySelective" parameterType="Entity.Student">
 81         update student
 82         <set>
 83             <if test="name != null">
 84                 Name = #{name,jdbcType=VARCHAR},
 85             </if>
 86             <if test="age != null">
 87                 Age = #{age,jdbcType=INTEGER},
 88             </if>
 89             <if test="classid != null">
 90                 ClassId = #{classid,jdbcType=INTEGER},
 91             </if>
 92         </set>
 93         where Uid = #{uid,jdbcType=BINARY}
 94     </update>
 95     <update id="updateByPrimaryKey" parameterType="Entity.Student">
 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     </update>
102 </mapper>

　　以上这段代码是直接使用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<Student> 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<Student> 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<Student> 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<Student> students = service.selectByCondition(new Student());
21         String jsonResult = com.alibaba.fastjson.JSON.toJSONString(students);
22         return jsonResult;
23     }
24 }

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