关闭

手把手教你整合最优雅SSM框架:SpringMVC + Spring + MyBatis

346人阅读 评论(0) 收藏 举报
分类:

我们看招聘信息的时候,经常会看到这一点,需要具备SSH框架的技能;而且在大部分教学课堂中,也会把SSH作为最核心的教学内容。
但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配合注解的方式,编程非常快捷,而且通过restful风格定义url,让地址看起来非常优雅。
另外,MyBatis也可以替换Hibernate,正因为MyBatis的半自动特点,我们程序猿可以完全掌控SQL,这会让有数据库经验的程序猿能开发出高效率的SQL语句,而且XML配置管理起来也非常方便。
好了,如果你也认同我的看法,那么下面我们一起来做整合吧!

在写代码之前我们先了解一下这三个框架分别是干什么的?
相信大以前也看过不少这些概念,我这就用大白话来讲,如果之前有了解过可以跳过这一大段,直接看代码!

SpringMVC:它用于web层,相当于controller(等价于传统的servlet和struts的action),用来处理用户请求。举个例子,用户在地址栏输入http://网站域名/login,那么springmvc就会拦截到这个请求,并且调用controller层中相应的方法,(中间可能包含验证用户名和密码的业务逻辑,以及查询数据库操作,但这些都不是springmvc的职责),最终把结果返回给用户,并且返回相应的页面(当然也可以只反馈josn/xml等格式数据)。springmvc就是做前面和后面过程的活,与用户打交道!!

Spring:太强大了,以至于我无法用一个词或一句话来概括它。但与我们平时开发接触最多的估计就是IOC容器,它可以装载bean(也就是我们java中的类,当然也包括service dao里面的),有了这个机制,我们就不用在每次使用这个类的时候为它初始化,很少看到关键字new。另外spring的aop,事务管理等等都是我们经常用到的。

MyBatis:如果你问我它跟鼎鼎大名的Hibernate有什么区别?我只想说,他更符合我的需求。第一,它能自由控制sql,这会让有数据库经验的人(当然不是说我啦~捂脸~)编写的代码能搞提升数据库访问的效率。第二,它可以使用xml的方式来组织管理我们的sql,因为一般程序出错很多情况下是sql出错,别人接手代码后能快速找到出错地方,甚至可以优化原来写的sql。


SSM框架整合配置

好了,前面bb那么多,下面我们真正开始敲代码了~

首先我们打开IED,我这里用的是eclipse(你们应该也是用的这个,对吗?),创建一个动态web项目,建立好相应的目录结构(重点!)

项目结构图

(打了马赛克是因为这里还用不到,你们不要那么污好不好?)

我说一下每个目录都有什么用吧(第一次画表格,我发现markdown的表格语法很不友好呀~)
这个目录结构同时也遵循maven的目录规范~

文件名 作用
src 根目录,没什么好说的,下面有main和test。
main 主要目录,可以放java代码和一些资源文件。
java 存放我们的java代码,这个文件夹要使用Build Path -> Use as Source Folder,这样看包结构会方便很多,新建的包就相当于在这里新建文件夹咯。
resources 存放资源文件,譬如各种的spring,mybatis,log配置文件。
mapper 存放dao中每个方法对应的sql,在这里配置,无需写daoImpl。
spring 这里当然是存放spring相关的配置文件,有dao service web三层。
sql 其实这个可以没有,但是为了项目完整性还是加上吧。
webapp 这个貌似是最熟悉的目录了,用来存放我们前端的静态资源,如jsp js css。
resources 这里的资源是指项目的静态资源,如js css images等。
WEB-INF 很重要的一个目录,外部浏览器无法访问,只有羡慕内部才能访问,可以把jsp放在这里,另外就是web.xml了。你可能有疑问了,为什么上面java中的resources里面的配置文件不妨在这里,那么是不是会被外部窃取到?你想太多了,部署时候基本上只有webapp里的会直接输出到根目录,其他都会放入WEB-INF里面,项目内部依然可以使用classpath:XXX来访问,好像IDE里可以设置部署输出目录,这里扯远了~
test 这里是测试分支。
java 测试java代码,应遵循包名相同的原则,这个文件夹同样要使用Build Path -> Use as Source Folder,这样看包结构会方便很多。
resources 没什么好说的,好像也很少用到,但这个是maven的规范。

我先新建好几个必要的,并为大家讲解一下每个包的作用,顺便理清一下后台的思路~

包结构图

包名 名称 作用
dao 数据访问层(接口) 与数据打交道,可以是数据库操作,也可以是文件读写操作,甚至是redis缓存操作,总之与数据操作有关的都放在这里,也有人叫做dal或者数据持久层都差不多意思。为什么没有daoImpl,因为我们用的是mybatis,所以可以直接在配置文件中实现接口的每个方法。
entity 实体类 一般与数据库的表相对应,封装dao层取出来的数据为一个对象,也就是我们常说的pojo,一般只在dao层与service层之间传输。
dto 数据传输层 刚学框架的人可能不明白这个有什么用,其实就是用于service层与web层之间传输,为什么不直接用entity(pojo)?其实在实际开发中发现,很多时间一个entity并不能满足我们的业务需求,可能呈现给用户的信息十分之多,这时候就有了dto,也相当于vo,记住一定不要把这个混杂在entity里面,答应我好吗?
service 业务逻辑(接口) 写我们的业务逻辑,也有人叫bll,在设计业务接口时候应该站在“使用者”的角度。额,不要问我为什么这里没显示!IDE调皮我也拿它没办法~
serviceImpl 业务逻辑(实现) 实现我们业务接口,一般事务控制是写在这里,没什么好说的。
web 控制器 springmvc就是在这里发挥作用的,一般人叫做controller控制器,相当于struts中的action。

还有最后一步基础工作,导入我们相应的jar包,我使用的是maven来管理我们的jar,所以只需要在poom.xml中加入相应的依赖就好了,如果不使用maven的可以自己去官网下载相应的jar,放到项目WEB-INF/lib目录下。关于maven的学习大家可以看慕课网的视频教程,这里就不展开了。我把项目用到的jar都写在下面,版本都不是最新的,大家有经验的话可以自己调整版本号。另外,所有jar都会与项目一起打包放到我的github上,喜欢的给个star吧~

poom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
    <modelversion>4.0.0</modelversion>
    <groupid>com.soecode.ssm</groupid>
    ssm</artifactid>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>ssm Maven Webapp</name>
    <url>http://github.com/liyifeng1994/ssm</url>
    <dependencies>
        <!-- 单元测试 -->
        <dependency>
            <groupid>junit</groupid>
            junit</artifactid>
            <version>4.11</version>
        </dependency>
 
        <!-- 1.日志 -->
        <!-- 实现slf4j接口并整合 -->
        <dependency>
            <groupid>ch.qos.logback</groupid>
            logback-classic</artifactid>
            <version>1.1.1</version>
        </dependency>
 
        <!-- 2.数据库 -->
        <dependency>
            <groupid>mysql</groupid>
            mysql-connector-java</artifactid>
            <version>5.1.37</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupid>c3p0</groupid>
            c3p0</artifactid>
            <version>0.9.1.2</version>
        </dependency>
 
        <!-- DAO: MyBatis -->
        <dependency>
            <groupid>org.mybatis</groupid>
            mybatis</artifactid>
            <version>3.3.0</version>
        </dependency>
        <dependency>
            <groupid>org.mybatis</groupid>
            mybatis-spring</artifactid>
            <version>1.2.3</version>
        </dependency>
 
        <!-- 3.Servlet web -->
        <dependency>
            <groupid>taglibs</groupid>
            standard</artifactid>
            <version>1.1.2</version>
        </dependency>
        <dependency>
            <groupid>jstl</groupid>
            jstl</artifactid>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupid>com.fasterxml.jackson.core</groupid>
            jackson-databind</artifactid>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupid>javax.servlet</groupid>
            javax.servlet-api</artifactid>
            <version>3.1.0</version>
        </dependency>
 
        <!-- 4.Spring -->
        <!-- 1)Spring核心 -->
        <dependency>
            <groupid>org.springframework</groupid>
            spring-core</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            spring-beans</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            spring-context</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <!-- 2)Spring DAO层 -->
        <dependency>
            <groupid>org.springframework</groupid>
            spring-jdbc</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            spring-tx</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <!-- 3)Spring web -->
        <dependency>
            <groupid>org.springframework</groupid>
            spring-web</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            spring-webmvc</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
        <!-- 4)Spring test -->
        <dependency>
            <groupid>org.springframework</groupid>
            spring-test</artifactid>
            <version>4.1.7.RELEASE</version>
        </dependency>
 
        <!-- redis客户端:Jedis -->
        <dependency>
            <groupid>redis.clients</groupid>
            jedis</artifactid>
            <version>2.7.3</version>
        </dependency>
        <dependency>
            <groupid>com.dyuproject.protostuff</groupid>
            <artifactid>protostuff-core</artifactid>
            <version>1.0.8</version>
        </dependency>
        <dependency>
            <groupid>com.dyuproject.protostuff</groupid>
            <artifactid>protostuff-runtime</artifactid>
            <version>1.0.8</version>
        </dependency>
 
        <!-- Map工具类 -->
        <dependency>
            <groupid>commons-collections</groupid>
            <artifactid>commons-collections</artifactid>
            <version>3.2</version>
        </dependency>
    </dependencies>
    <build>
        <finalname>ssm</finalname>
    </build>
</project>
</code>

下面真的要开始进行编码工作了,坚持到这里辛苦大家了~

第一步:我们先在spring文件夹里新建spring-dao.xml文件,因为spring的配置太多,我们这里分三层,分别是dao service web。

读入数据库连接相关参数(可选) 配置数据连接池
配置连接属性,可以不读配置项文件直接在这里写死 配置c3p0,只配了几个常用的 配置SqlSessionFactory对象(mybatis) 扫描dao层接口,动态实现dao接口,也就是说不需要daoImpl,sql和参数都写在xml文件上

spring-dao.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置整合mybatis过程 -->
    <!-- 1.配置数据库相关参数properties的属性:${url} -->
    <context:property-placeholder location="classpath:jdbc.properties">
 
    <!-- 2.数据库连接池 -->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!-- 配置连接池属性 -->
        <property name="driverClass" value="${jdbc.driver}">
        <property name="jdbcUrl" value="${jdbc.url}">
        <property name="user" value="${jdbc.username}">
        <property name="password" value="${jdbc.password}">
 
        <!-- c3p0连接池的私有属性 -->
        <property name="maxPoolSize" value="30">
        <property name="minPoolSize" value="10">
        <!-- 关闭连接后不自动commit -->
        <property name="autoCommitOnClose" value="false">
        <!-- 获取连接超时时间 -->
        <property name="checkoutTimeout" value="10000">
        <!-- 当获取连接失败重试次数 -->
        <property name="acquireRetryAttempts" value="2">
    </property></property></property></property></property></property></property></property></property></bean>
 
    <!-- 3.配置SqlSessionFactory对象 -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean" id="sqlSessionFactory">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource">
        <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
        <property name="configLocation" value="classpath:mybatis-config.xml">
        <!-- 扫描entity包 使用别名 -->
        <property name="typeAliasesPackage" value="com.soecode.lyf.entity">
        <!-- 扫描sql配置文件:mapper需要的xml文件 -->
        <property name="mapperLocations" value="classpath:mapper/*.xml">
    </property></property></property></property></bean>
 
    <!-- 4.配置扫描Dao接口包,动态实现Dao接口,注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
        <!-- 给出需要扫描Dao接口包 -->
        <property name="basePackage" value="com.soecode.lyf.dao">
    </property></property></bean>
</context:property-placeholder></beans></code>

因为数据库配置相关参数是读取配置文件,所以在resources文件夹里新建一个jdbc.properties文件,存放我们4个最常见的数据库连接属性,这是我本地的,大家记得修改呀~还有喜欢传到github上“大头虾们”记得删掉密码,不然别人就很容易得到你服务器的数据库配置信息,然后干一些羞羞的事情,你懂的!!

jdbc.properties

1
2
3
4
<code class="language-properties hljs avrasm">jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3307/ssm?useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=</code>

友情提示:配置文件中的jdbc.username,如果写成username,可能会与系统环境中的username变量冲突,所以到时候真正连接数据库的时候,用户名就被替换成系统中的用户名(有得可能是administrator),那肯定是连接不成功的,这里有个小坑,我被坑了一晚上!!

因为这里用到了mybatis,所以需要配置mybatis核心文件,在recources文件夹里新建mybatis-config.xml文件。

使用自增主键 使用列别名 开启驼峰命名转换 create_time -> createTime

mybatis-config.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8" ?-->
 
<configuration>
    <!-- 配置全局属性 -->
    <settings>
        <!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
        <setting name="useGeneratedKeys" value="true">
 
        <!-- 使用列别名替换列名 默认:true -->
        <setting name="useColumnLabel" value="true">
 
        <!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
        <setting name="mapUnderscoreToCamelCase" value="true">
    </setting></setting></setting></settings>
</configuration></code>

第二步:刚弄好dao层,接下来到service层了。在spring文件夹里新建spring-service.xml文件。

扫描service包所有注解 @Service 配置事务管理器,把事务管理交由spring来完成 配置基于注解的声明式事务,可以直接在方法上@Transaction

spring-service.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 扫描service包下所有使用注解的类型 -->
    <context:component-scan base-package="com.soecode.lyf.service">
 
    <!-- 配置事务管理器 -->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <!-- 注入数据库连接池 -->
        <property name="dataSource" ref="dataSource">
    </property></bean>
 
    <!-- 配置基于注解的声明式事务 -->
    <tx:annotation-driven transaction-manager="transactionManager">
</tx:annotation-driven></context:component-scan></beans></code>

第三步:配置web层,在spring文件夹里新建spring-web.xml文件。

开启SpringMVC注解模式,可以使用@RequestMapping,@PathVariable,@ResponseBody等 对静态资源处理,如js,css,jpg等 配置jsp 显示ViewResolver,例如在controller中某个方法返回一个string类型的”login”,实际上会返回”/WEB-INF/login.jsp” 扫描web层 @Controller

spring-web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
    <!-- 配置SpringMVC -->
    <!-- 1.开启SpringMVC注解模式 -->
    <!-- 简化配置:
        (1)自动注册DefaultAnootationHandlerMapping,AnotationMethodHandlerAdapter
        (2)提供一些列:数据绑定,数字和日期的format @NumberFormat, @DateTimeFormat, xml,json默认读写支持
    -->
    <mvc:annotation-driven>
 
    <!-- 2.静态资源默认servlet配置
        (1)加入对静态资源的处理:js,gif,png
        (2)允许使用"/"做整体映射
     -->
     <mvc:default-servlet-handler>
 
     <!-- 3.配置jsp 显示ViewResolver -->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView">
        <property name="prefix" value="/WEB-INF/jsp/">
        <property name="suffix" value=".jsp">
     </property></property></property></bean>
 
     <!-- 4.扫描web相关的bean -->
     <context:component-scan base-package="com.soecode.lyf.web">
</context:component-scan></mvc:default-servlet-handler></mvc:annotation-driven></beans></code>

第四步:最后就是修改web.xml文件了,它在webappWEB-INF下。

web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<code class="language-xml hljs "><web-app metadata-complete="true" version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee
                      http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
    <!-- 如果是用mvn命令生成的xml,需要修改servlet版本为3.1 -->
    <!-- 配置DispatcherServlet -->
    <servlet>
        <servlet-name>seckill-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 配置springMVC需要加载的配置文件
            spring-dao.xml,spring-service.xml,spring-web.xml
            Mybatis - > spring -> springmvc
         -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/spring-*.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>seckill-dispatcher</servlet-name>
        <!-- 默认匹配所有的请求 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>
</code>

我们在项目中经常会使用到日志,所以这里还有配置日志xml,在resources文件夹里新建logback.xml文件,所给出的日志输出格式也是最基本的控制台s呼出,大家有兴趣查看logback官方文档

logback.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
<configuration debug="true">
     
        <!-- encoders are by default assigned the type ch.qos.logback.classic.encoder.PatternLayoutEncoder -->
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <root level="debug">
         
    </appender-ref></root>
</configuration></code>

到目前为止,我们一共写了7个配置文件,我们一起来看下最终的配置文件结构图

配置文件结构图


一开始想就这样结束教程,但是发现其实很多人都还不会把这个SSM框架用起来,特别是mybatis部分。那我现在就以最常见的“图书管理系统”中【查询图书】和【预约图书】业务来做一个demo吧!

首先新建数据库名为ssm,再创建两张表:图书表book和预约图书表appointment,并且为book表初始化一些数据,sql如下。

schema.sql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<code class="language-sql hljs ">-- 创建图书表
CREATE TABLE `book` (
  `book_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '图书ID',
  `name` varchar(100) NOT NULL COMMENT '图书名称',
  `number` int(11) NOT NULL COMMENT '馆藏数量',
  PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 COMMENT='图书表'
 
-- 初始化图书数据
INSERT INTO `book` (`book_id`, `name`, `number`)
VALUES
    (1000, 'Java程序设计', 10),
    (1001, '数据结构', 10),
    (1002, '设计模式', 10),
    (1003, '编译原理', 10)
 
-- 创建预约图书表
CREATE TABLE `appointment` (
  `book_id` bigint(20) NOT NULL COMMENT '图书ID',
  `student_id` bigint(20) NOT NULL COMMENT '学号',
  `appoint_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '预约时间' ,
  PRIMARY KEY (`book_id`, `student_id`),
  INDEX `idx_appoint_time` (`appoint_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='预约图书表'</code>

entity包中添加两个对应的实体,图书实体Book.java和预约图书实体Appointment.java

Book.java

1
2
3
4
5
6
7
8
9
10
11
12
13
<code class="language-java hljs ">package com.soecode.lyf.entity;
 
public class Book {
 
    private long bookId;// 图书ID
 
    private String name;// 图书名称
 
    private int number;// 馆藏数量
 
    // 省略构造方法,getter和setter方法,toString方法
 
}</code>

Appointment.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<code class="language-java hljs ">package com.soecode.lyf.entity;
 
import java.util.Date;
 
/**
 * 预约图书实体
 */
public class Appointment {
 
    private long bookId;// 图书ID
 
    private long studentId;// 学号
 
    private Date appointTime;// 预约时间
 
    // 多对一的复合属性
    private Book book;// 图书实体
 
    // 省略构造方法,getter和setter方法,toString方法
 
}</code>

dao包新建接口BookDao.javaAppointment.java

BookDao.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<code class="language-java hljs ">package com.soecode.lyf.dao;
 
import java.util.List;
 
import com.soecode.lyf.entity.Book;
 
public interface BookDao {
 
    /**
     * 通过ID查询单本图书
     *
     * @param id
     * @return
     */
    Book queryById(long id);
 
    /**
     * 查询所有图书
     *
     * @param offset 查询起始位置
     * @param limit 查询条数
     * @return
     */
    List<book> queryAll(@Param("offset") int offset, @Param("limit") int limit);
 
    /**
     * 减少馆藏数量
     *
     * @param bookId
     * @return 如果影响行数等于>1,表示更新的记录行数
     */
    int reduceNumber(long bookId);
}
</book></code>

AppointmentDao.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<code class="language-java hljs ">package com.soecode.lyf.dao;
 
import org.apache.ibatis.annotations.Param;
 
import com.soecode.lyf.entity.Appointment;
 
public interface AppointmentDao {
 
    /**
     * 插入预约图书记录
     *
     * @param bookId
     * @param studentId
     * @return 插入的行数
     */
    int insertAppointment(@Param("bookId") long bookId, @Param("studentId") long studentId);
 
    /**
     * 通过主键查询预约图书记录,并且携带图书实体
     *
     * @param bookId
     * @param studentId
     * @return
     */
    Appointment queryByKeyWithBook(@Param("bookId") long bookId, @Param("studentId") long studentId);
 
}</code>

提示:这里为什么要给方法的参数添加@Param注解呢?是因为该方法有两个或以上的参数,一定要加,不然mybatis识别不了。上面的BookDao接口的queryById方法和reduceNumber方法只有一个参数book_id,所以可以不用加 @Param注解,当然加了也无所谓~


注意,这里不需要实现dao接口不用编写daoImpl, mybatis会给我们动态实现,但是我们需要编写相应的mapper。
mapper目录里新建两个文件BookDao.xmlAppointmentDao.xml,分别对应上面两个dao接口,代码如下。

BookDao.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
 
<mapper namespace="com.soecode.lyf.dao.BookDao">
    <!-- 目的:为dao接口方法提供sql语句配置 -->
    <select id="queryById" parametertype="long" resulttype="Book">
        <!-- 具体的sql -->
        SELECT
            book_id,
            name,
            number
        FROM
            book
        WHERE
            book_id = #{bookId}
    </select>
 
    <select id="queryAll" resulttype="Book">
        SELECT
            book_id,
            name,
            number
        FROM
            book
        ORDER BY
            book_id
        LIMIT #{offset}, #{limit}
    </select>
 
    <update id="reduceNumber">
        UPDATE book
        SET number = number - 1
        WHERE
            book_id = #{bookId}
        AND number > 0
    </update>
</mapper></code>

AppointmentDao.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<code class="language-xml hljs "><!--?xml version="1.0" encoding="UTF-8"?-->
 
<mapper namespace="com.soecode.lyf.dao.AppointmentDao">
    <insert id="insertAppointment">
        <!-- ignore 主键冲突,报错 -->
        INSERT ignore INTO appointment (book_id, student_id)
        VALUES (#{bookId}, #{studentId})
    </insert>
 
    <select id="queryByKeyWithBook" resulttype="Appointment">
        <!-- 如何告诉MyBatis把结果映射到Appointment同时映射book属性 -->
        <!-- 可以自由控制SQL -->
        SELECT
            a.book_id,
            a.student_id,
            a.appoint_time,
            b.book_id "book.book_id",
            b.`name` "book.name",
            b.number "book.number"
        FROM
            appointment a
        INNER JOIN book b ON a.book_id = b.book_id
        WHERE
            a.book_id = #{bookId}
        AND a.student_id = #{studentId}
    </select>
</mapper></code>

mapper总结namespace是该xml对应的接口全名,selectupdate中的id对应方法名,resultType是返回值类型,parameterType是参数类型(这个其实可选),最后#{...}中填写的是方法的参数,看懂了是不是很简单!!我也这么觉得~ 还有一个小技巧要交给大家,就是在返回Appointment对象包含了一个属性名为book的Book对象,那么可以使用"book.属性名"的方式来取值,看上面queryByKeyWithBook方法的sql。


dao层写完了,接下来test对应的package写我们测试方法吧。
因为我们之后会写很多测试方法,在测试前需要让程序读入spring-dao和mybatis等配置文件,所以我这里就抽离出来一个BaseTest类,只要是测试方法就继承它,这样那些繁琐的重复的代码就不用写那么多了~

BaseTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<code class="language-java hljs ">package com.soecode.lyf;
 
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
/**
 * 配置spring和junit整合,junit启动时加载springIOC容器 spring-test,junit
 */
@RunWith(SpringJUnit4ClassRunner.class)
// 告诉junit spring配置文件
@ContextConfiguration({ "classpath:spring/spring-dao.xml", "classpath:spring/spring-service.xml" })
public class BaseTest {
 
}
</code>

因为spring-serviceservice层的测试中会时候到,这里也一起引入算了!

新建BookDaoTest.javaAppointmentDaoTest.java两个dao测试文件。

BookDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<code class="language-java hljs ">package com.soecode.lyf.dao;
 
import java.util.List;
 
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
 
import com.soecode.lyf.BaseTest;
import com.soecode.lyf.entity.Book;
 
public class BookDaoTest extends BaseTest {
 
    @Autowired
    private BookDao bookDao;
 
    @Test
    public void testQueryById() throws Exception {
        long bookId = 1000;
        Book book = bookDao.queryById(bookId);
        System.out.println(book);
    }
 
    @Test
    public void testQueryAll() throws Exception {
        List<book> books = bookDao.queryAll(0, 4);
        for (Book book : books) {
            System.out.println(book);
        }
    }
 
    @Test
    public void testReduceNumber() throws Exception {
        long bookId = 1000;
        int update = bookDao.reduceNumber(bookId);
        System.out.println("update=" + update);
    }
 
}</book></code>

BookDaoTest测试结果

testQueryById
testQueryById

testQueryAll
testQueryAll

testReduceNumber
testReduceNumber

AppointmentDaoTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<code class="language-java hljs ">package com.soecode.lyf.dao;
 
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
 
import com.soecode.lyf.BaseTest;
import com.soecode.lyf.entity.Appointment;
 
public class AppointmentDaoTest extends BaseTest {
 
    @Autowired
    private AppointmentDao appointmentDao;
 
    @Test
    public void testInsertAppointment() throws Exception {
        long bookId = 1000;
        long studentId = 12345678910L;
        int insert = appointmentDao.insertAppointment(bookId, studentId);
        System.out.println("insert=" + insert);
    }
 
    @Test
    public void testQueryByKeyWithBook() throws Exception {
        long bookId = 1000;
        long studentId = 12345678910L;
        Appointment appointment = appointmentDao.queryByKeyWithBook(bookId, studentId);
        System.out.println(appointment);
        System.out.println(appointment.getBook());
    }
 
}</code>

AppointmentDaoTest测试结果

testInsertAppointment
testInsertAppointment

testQueryByKeyWithBook
testQueryByKeyWithBook


嗯,到这里一切到很顺利~那么我们继续service层的编码吧~可能下面开始信息里比较大,大家要做好心理准备~

首先,在写我们的业务之前,我们先定义几个预约图书操作返回码的数据字典,我们这类使用枚举类,没听过的小伙伴要好好恶补一下了(我也是最近才学到的= =)

预约业务操作返回码说明

返回码 说明
1 预约成功
0 库存不足
-1 重复预约
-2 系统异常

新建一个包叫enums,在里面新建一个枚举类AppointStateEnum.java,用来定义预约业务的数据字典,没听懂没关系,我们直接看代码吧~是不是感觉有模有样了!

AppointStateEnum.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<code class="language-java hljs ">package com.soecode.lyf.enums;
 
/**
 * 使用枚举表述常量数据字典
 */
public enum AppointStateEnum {
 
    SUCCESS(1, "预约成功"), NO_NUMBER(0, "库存不足"), REPEAT_APPOINT(-1, "重复预约"), INNER_ERROR(-2, "系统异常");
 
    private int state;
 
    private String stateInfo;
 
    private AppointStateEnum(int state, String stateInfo) {
        this.state = state;
        this.stateInfo = stateInfo;
    }
 
    public int getState() {
        return state;
    }
 
    public String getStateInfo() {
        return stateInfo;
    }
 
    public static AppointStateEnum stateOf(int index) {
        for (AppointStateEnum state : values()) {
            if (state.getState() == index) {
                return state;
            }
        }
        return null;
    }
 
}</code>

接下来,在dto包下新建AppointExecution.java用来存储我们执行预约操作的返回结果。

AppointExecution.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<code class="language-java hljs ">package com.soecode.lyf.dto;
 
import com.soecode.lyf.entity.Appointment;
import com.soecode.lyf.enums.AppointStateEnum;
 
/**
 * 封装预约执行后结果
 */
public class AppointExecution {
 
    // 图书ID
    private long bookId;
 
    // 秒杀预约结果状态
    private int state;
 
    // 状态标识
    private String stateInfo;
 
    // 预约成功对象
    private Appointment appointment;
 
    public AppointExecution() {
    }
 
    // 预约失败的构造器
    public AppointExecution(long bookId, AppointStateEnum stateEnum) {
        this.bookId = bookId;
        this.state = stateEnum.getState();
        this.stateInfo = stateEnum.getStateInfo();
    }
 
    // 预约成功的构造器
    public AppointExecution(long bookId, AppointStateEnum stateEnum, Appointment appointment) {
        this.bookId = bookId;
        this.state = stateEnum.getState();
        this.stateInfo = stateEnum.getStateInfo();
        this.appointment = appointment;
    }
 
    // 省略getter和setter方法,toString方法
 
}
</code>

咱们终于可以编写业务代码了,在service包下新建BookService.java图书业务接口。

BookService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<code class="language-java hljs ">package com.soecode.lyf.service;
 
import java.util.List;
 
import com.soecode.lyf.dto.AppointExecution;
import com.soecode.lyf.entity.Book;
 
/**
 * 业务接口:站在"使用者"角度设计接口 三个方面:方法定义粒度,参数,返回类型(return 类型/异常)
 */
public interface BookService {
 
    /**
     * 查询一本图书
     *
     * @param bookId
     * @return
     */
    Book getById(long bookId);
 
    /**
     * 查询所有图书
     *
     * @return
     */
    List<book> getList();
 
    /**
     * 预约图书
     *
     * @param bookId
     * @param studentId
     * @return
     */
    AppointExecution appoint(long bookId, long studentId);
 
}</book></code>

service.impl包下新建BookServiceImpl.java使用BookService接口,并实现里面的方法。

BookServiceImpl

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
<code class="language-java hljs ">package com.soecode.lyf.service.impl;
 
import java.util.List;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import com.soecode.lyf.dao.AppointmentDao;
import com.soecode.lyf.dao.BookDao;
import com.soecode.lyf.dto.AppointExecution;
import com.soecode.lyf.entity.Appointment;
import com.soecode.lyf.entity.Book;
import com.soecode.lyf.enums.AppointStateEnum;
import com.soecode.lyf.service.BookService;
 
@Service
public class BookServiceImpl implements BookService {
 
    private Logger logger = LoggerFactory.getLogger(this.getClass());
 
    // 注入Service依赖
    @Autowired
    private BookDao bookDao;
 
    @Autowired
    private AppointmentDao appointmentDao;
 
 
    @Override
    public Book getById(long bookId) {
        return bookDao.queryById(bookId);
    }
 
    @Override
    public List<book> getList() {
        return bookDao.queryAll(0, 1000);
    }
 
    @Override
    @Transactional
    /**
     * 使用注解控制事务方法的优点: 1.开发团队达成一致约定,明确标注事务方法的编程风格
     * 2.保证事务方法的执行时间尽可能短,不要穿插其他网络操作,RPC/HTTP请求或者剥离到事务方法外部
     * 3.不是所有的方法都需要事务,如只有一条修改操作,只读操作不需要事务控制
     */
    public AppointExecution appoint(long bookId, long studentId) {
        try {
            // 减库存
            int update = bookDao.reduceNumber(bookId);
            if (update <= 0) {// 库存不足
                return new AppointExecution(bookId, AppointStateEnum.NO_NUMBER);
            } else {
                // 执行预约操作
                int insert = appointmentDao.insertAppointment(bookId, studentId);
                if (insert <= 0) {// 重复预约
                    return new AppointExecution(bookId, AppointStateEnum.REPEAT_APPOINT);
                } else {// 预约成功
                    Appointment appointment = appointmentDao.queryByKeyWithBook(bookId, studentId);
                    return new AppointExecution(bookId, AppointStateEnum.SUCCESS, appointment);
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            // 所有编译期异常转换为运行期异常
            return new AppointExecution(bookId, AppointStateEnum.INNER_ERROR);
        }
    }
 
}
</book></code>

下面我们来测试一下我们的业务代码吧~因为查询图书的业务不复杂,所以这里只演示我们最重要的预约图书业务!!

BookServiceImplTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<code class="language-java hljs ">package com.soecode.lyf.service.impl;
 
import static org.junit.Assert.fail;
 
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
 
import com.soecode.lyf.BaseTest;
import com.soecode.lyf.dto.AppointExecution;
import com.soecode.lyf.service.BookService;
 
public class BookServiceImplTest extends BaseTest {
 
    @Autowired
    private BookService bookService;
 
    @Test
    public void testAppoint() throws Exception {
        long bookId = 1001;
        long studentId = 12345678910L;
        AppointExecution execution = bookService.appoint(bookId, studentId);
        System.out.println(execution);
    }
 
}
</code>

BookServiceImplTest测试结果

testAppoint
testAppoint

首次执行是“预约成功”,如果再次执行的话,应该会出现“重复预约”,哈哈,我们所有的后台代码都通过单元测试啦~~是不是很开心~


咱们还需要在dto包里新建一个封装json返回结果的类Result.java,设计成泛型。

Result.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<code class="language-java hljs ">package com.soecode.lyf.dto;
 
/**
 * 封装json对象,所有返回结果都使用它
 */
public class Result<t> {
 
    private boolean success;// 是否成功标志
 
    private T data;// 成功时返回的数据
 
    private String error;// 错误信息
 
    public Result() {
    }
 
    // 成功时的构造器
    public Result(boolean success, T data) {
        this.success = success;
        this.data = data;
    }
 
    // 错误时的构造器
    public Result(boolean success, String error) {
        this.success = success;
        this.error = error;
    }
 
    // 省略getter和setter方法
}
</t></code>

最后,我们写web层,也就是controller,我们在web包下新建BookController.java文件。

BookController.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
<code class="language-java hljs ">package com.soecode.lyf.web;
 
import java.util.List;
 
import org.apache.ibatis.annotations.Param;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
 
import com.soecode.lyf.dto.AppointExecution;
import com.soecode.lyf.dto.Result;
import com.soecode.lyf.entity.Book;
import com.soecode.lyf.service.BookService;
 
@Controller
@RequestMapping("/book") // url:/模块/资源/{id}/细分 /seckill/list
public class BookController {
 
    private Logger logger = LoggerFactory.getLogger(this.getClass());
 
    @Autowired
    private BookService bookService;
 
    @RequestMapping(value = "/list", method = RequestMethod.GET)
    private String list(Model model) {
        List<book> list = bookService.getList();
        model.addAttribute("list", list);
        // list.jsp + model = ModelAndView
        return "list";// WEB-INF/jsp/"list".jsp
    }
 
    // ajax json
    @RequestMapping(value = "/{bookId}/detail", method = RequestMethod.GET)
    @ResponseBody
    private String detail(@PathVariable("bookId") Long bookId, Model model) {
        if (bookId == null) {
            return "redirect:/book/list";
        }
        Book book = bookService.getById(bookId);
        if (book == null) {
            return "forward:/book/list";
        }
        model.addAttribute("book", book);
        return "detail";
    }
 
    @RequestMapping(value = "/{bookId}/appoint", method = RequestMethod.POST, produces = {
            "application/json; charset=utf-8" })
    private Result appoint(@PathVariable("bookId") Long bookId, @Param("studentId") Long studentId) {
        if (studentId == null || studentId.equals("")) {
            return new Result<>(false, "学号不能为空");
        }
        AppointExecution execution = bookService.appoint(bookId, studentId);
        return new Result(true, execution);
    }
 
}
</appointexecution></appointexecution></book></code>

因为我比较懒,所以我们就不测试controller了,好讨厌写前端,呜呜呜~

到此,我们的SSM框架整合配置,与应用实例部分已经结束了,我把所有源码和jar包一起打包放在了我的GitHub上,需要的可以去下载,喜欢就给个star吧,这篇东西写了两个晚上也不容易啊。

源码下载:http://github.com/liyifeng1994/ssm

0
0
查看评论
发表评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场

spring 基础配置

1、mybatis层   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"   "http://mybatis.org/dtd/mybatis-3-config.dtd"> ...
  • JasmineZm1
  • JasmineZm1
  • 2017-12-29 08:00
  • 10

SSM+Maven 稳定整合(dao层无实现类)

JDBC.properties File Content: driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306 username=root password=root #\u5B9A\u...
  • cyjdapao
  • cyjdapao
  • 2018-01-08 12:51
  • 84

Shiro学习笔记(三)---Spring+SpringMVC示例程序

通过前面的笔记,我们知道了一些基础知识,这里自己动手写一个SS(Spring+SpringMVC)集成Shiro框架,因为本示例还没有涉及到持久化操作,所以Mybatis或者Hibernate没有集成,在后面的项目实战中会给出示例。 1.创建一个maven工程,填写pom文件,我的pom文件如下:...
  • xiaoxsen
  • xiaoxsen
  • 2018-01-08 23:15
  • 52

springboot+mybatis 搭建环境

Springboot  +  mybatis 环境搭建 springBoot 就是讲一些基础的框架集合起来,提供默认的配置,减少人为的配置。不用 springBoot 而用 spring 也是可以将项目搭建起来的。   开发环境: IDEA(推荐) ...
  • nimoyaoww
  • nimoyaoww
  • 2018-01-07 15:33
  • 54

SpringMVC 使用@ResponseBody返回json 中文乱码

方法一,使用(produces = "application/json; charset=utf-8"): @RequestMapping(value="/getUsersByPage",produces = "application/...
  • m0_37499059
  • m0_37499059
  • 2017-12-14 01:32
  • 18

手把手教你整合最优雅SSM框架:SpringMVC + Spring + MyBatis

原文链接 我们看招聘信息的时候,经常会看到这一点,需要具备SSH框架的技能;而且在大部分教学课堂中,也会把SSH作为最核心的教学内容。  但是,我们在实际应用中发现,SpringMVC可以完全替代Struts,配合注解的方式,编程非常快捷,而且通过restful风格定义ur...
  • a214919447
  • a214919447
  • 2017-03-06 16:36
  • 1582

SSM框架——详细整合教程(Spring+SpringMVC+MyBatis)

使用SSM(Spring、SpringMVC和Mybatis)已经有三个多月了,项目在技术上已经没有什么难点了,基于现有的技术就可以实现想要的功能,当然肯定有很多可以改进的地方。之前没有记录SSM整合的过程,这次刚刚好基于自己的一个小项目重新搭建了一次,而且比项目搭建的要更好一些。以前解决问题的过程...
  • gebitan505
  • gebitan505
  • 2015-03-19 11:44
  • 1220795

使用maven,实现ssm(spring+springmvc+mybatis)三大框架的整合DEMO

刚进一家新公司,要求使用ssm三大框架,而且这个组合是现在的主流,所以在整合的同时将步骤一步一步记录下来,方便以后的再次使用。 1.首先是建立一个Maven-project,具体操作请参考我的另一篇文章 点击这里  2. 然后导入maven依赖,这里将我的依赖列出如下 [...
  • white_ice
  • white_ice
  • 2017-03-10 14:14
  • 5945

手把手教你整合最优雅SSM框架:SpringMVC + Spring + MyBatis

小疯手把手带你整合SpringMVC+Spring+MyBatis三大框架,俗称SSM,用它完全代替传统的SSH框架,把它们最优雅的一面发挥出来。整合配置结束后,会有一个应用实例“图书管理系统”带给大家,希望能快速上手这个框架!
  • qq598535550
  • qq598535550
  • 2016-06-19 01:57
  • 76504

SpringMVC整合Mybatis的对象别名设置方式

1.在mybatis_config.xml中Mybatis别名设置<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//myba...
  • xinghuo0007
  • xinghuo0007
  • 2016-12-12 12:13
  • 1244
    个人资料
    • 访问:315129次
    • 积分:5017
    • 等级:
    • 排名:第6550名
    • 原创:61篇
    • 转载:750篇
    • 译文:0篇
    • 评论:20条
    最新评论