关于后端:SSM系列教材-一-SpringSping-MVC-Mybatis-三大框架整合详细步骤

71次阅读

共计 11940 个字符，预计需要花费 30 分钟才能阅读完成。

本例演示从 0 开始逐个整合 SSM 的步骤，要学习本常识，须要具备 Spring, SpringMVC, Mybatis 的根底，如果没有这些根底，请把根底把握之后再学习，不要跳跃学习，欲速则不达。

必读： 基于框架的程序要胜利运行，对于 JAR 包的版本，配置文件的正确性有着刻薄的要求，任何一个中央出错了，都会导致框架程序运行失败。如果你是第一次学习本框架，务必严格依照教程的领导，齐全模拟操作 ，直到胜利看到运行成果。第一次胜利之后，信念，思路都会有较好的铺垫，而后再依据本人的纳闷，在“胜利”的代码上做本来想做的改变和调整，这样能够大大节约学习的工夫，提高效率， 切勿一来就擅自改变，给本人的学习制作阻碍

步骤 1:IDEA
步骤 2: 数据库
步骤 3: 创立表
步骤 4: 筹备数据
步骤 5:JDK 版本
步骤 6: 先运行，再学习
步骤 7: 新建我的项目
步骤 8: 导入 jar 包
步骤 9:pojo
步骤 10:CategoryMapper
步骤 11:Category.xml
步骤 12:CategoryService
步骤 13:CategoryServiceImpl
步骤 14:CategoryController
步骤 15:web.xml
步骤 16:applicationContext.xml
步骤 17:springMVC.xml
步骤 18:listCategory.jsp
步骤 19: 部署在 tomcat 中，重启测试
步骤 20: 思路图
步骤 21: 删掉，从头开始，这次全副本人做

步骤 1 : IDEA

本教程是应用 Eclipse 制作的，如果是用 IDEA，请跳转到 IDEA 如何创立 SSM 我的项目。然而跳转过来后的教程，没有以后对每个类，配置文件，JSP 的解说有那么具体，所以最好应用 Eclipse 把以后的教程撸一遍，了解之后，再应用 IDEA 教程

步骤 2 : 数据库

首先筹备数据库 how2java
如果没有装置数据库，请参考 装置 mysql-server

注： 新装置的数据库账号密码是 root:admin, 后续的配置里，也是用的这个账号密码。如果明码不是这个，本知识点下载区 (点击进入) 的可运行我的项目跑不起来，所以尽量批改明码为 admin, 批改明码方法：批改 root 明码

create database how2java;

步骤 3 : 创立表

接着筹备表 Category 只有 2 个字段 id 和 name

use how2java;

CREATE TABLE category_ (id int(11) NOT NULL AUTO_INCREMENT,
        name varchar(30) ,
        PRIMARY KEY (id)
) DEFAULT CHARSET=UTF8;

步骤 4 : 筹备数据

use how2java;

insert into category_ values(null,"category1");
insert into category_ values(null,"category2");
insert into category_ values(null,"category3");
insert into category_ values(null,"category4");
insert into category_ values(null,"category5");

select * from category_

步骤 5 : JDK 版本

本教程是通过 JDK8 编译的，如果您机器上运行环境是低版本 JDK，将无奈辨认其中的类，否则会呈现如图所示的谬误。
请应用 JDK8，请参考 检测 JDK 版本，以及下载与配置

请勿应用 JDK9 或者更高版本，有兼容性危险

步骤 6 : 先运行，再学习

SSM 整合须要做不少步骤，任何一步部做漏了，做错了，都有可能失败，这样会影响学习的信念，并且误以为本教程是走不通的。

所以先下载下载区 (点击进入) 的可运行我的项目 ssm.rar，解压后导入到 eclipse 中，启动 Tomcat，察看是否失常运行。确定能够运行，确定教程是能够跑得起来的，再学习上面的内容。

导入到 Eclipse 中并运行的方法请参考：导入动静 Web 我的项目到 Eclipse 中

部署胜利之后，测试地址

http:`//127.0.0.1:8080/ssm/listCategory`

步骤 7 : 新建我的项目

在 eclipse 中新建我的项目 ssm，应用 dynamic web project 的形式。不相熟这种形式的同学，请参考 应用 Dynamic Web Project 的形式开发 J2EE 利用

步骤 8 : 导入 jar 包

下载下载区 (点击进入) 的 lib.rar, 解压后复制到 e:/project/ssm/WebContent/WEB-INF/lib 目录下

步骤 9 : pojo

package com.how2java.pojo;

public class Category {
    private int id;
    private String name;
    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    @Override
    public String toString() {return "Category [id=" + id + ", name=" + name + "]";
    }

}

步骤 10 : CategoryMapper

package com.how2java.mapper;

import java.util.List;
import com.how2java.pojo.Category;

public interface CategoryMapper {public int add(Category category);
    public void delete(int id);
    public Category get(int id);
    public int update(Category category);
    public List<Category> list();
    public int count();}

步骤 11 : Category.xml

Category.xml 须要和 CategoryMapper 放在同一个包上面，并且 namespace 必须写 CategoryMapper 的残缺类名

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.how2java.mapper.CategoryMapper">
    <insert id="add" parameterType="Category" >
            insert into category_ (name) values (#{name})   
        </insert>
    <delete id="delete" parameterType="Category" >
            delete from category_ where id= #{id}  
        </delete>
    <select id="get" parameterType="_int" resultType="Category">
            select * from   category_  where id= #{id}   
        </select>
    <update id="update" parameterType="Category" >
            update category_ set name=#{name} where id=#{id}   
        </update>
    <select id="list" resultType="Category">
            select * from   category_     
        </select>
</mapper>

步骤 12 : CategoryService

package com.how2java.service;

import java.util.List;
import com.how2java.pojo.Category;

public interface CategoryService {List<Category> list();

}

步骤 13 : CategoryServiceImpl

CategoryServiceImpl 被注解 @Service 标示为一个 Service
并且拆卸了 categoryMapper

package com.how2java.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.how2java.mapper.CategoryMapper;
import com.how2java.pojo.Category;
import com.how2java.service.CategoryService;

@Service
public class CategoryServiceImpl  implements CategoryService{
    @Autowired
    CategoryMapper categoryMapper;
    public List<Category> list(){return categoryMapper.list();
    }

}

步骤 14 : CategoryController

CategoryController 被 @Controller 标示为了控制器
主动拆卸了 categoryService
通过 @RequestMapping 映射拜访门路 /listCategory 门路到办法 listCategory()。
在 listCategory()办法中，通过 categoryService 获取后，而后寄存在 ”cs” 这个 key 上。

package com.how2java.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.how2java.pojo.Category;
import com.how2java.service.CategoryService;
// 通知 spring mvc 这是一个控制器类
@Controller
@RequestMapping("")
public class CategoryController {
    @Autowired
    CategoryService categoryService;
    @RequestMapping("listCategory")
    public ModelAndView listCategory(){ModelAndView mav = new ModelAndView();
        List<Category> cs= categoryService.list();
        // 放入转发参数
        mav.addObject("cs", cs);
        // 放入 jsp 门路
        mav.setViewName("listCategory");
        return mav;
    }

}

步骤 15 : web.xml

在 WEB-INF 目录下新减少 web.xml，这个 web.xml 有两个作用：
1. 通过 ContextLoaderListener 在 web app 启动的时候，获取 contextConfigLocation 配置文件的文件名 applicationContext.xml，并进行 Spring 相干初始化工作

2. 有任何拜访，都被 DispatcherServlet 所拦挡，这就是 Spring MVC 那套工作机制了。

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:web="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
    <!-- spring 的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- spring mvc 外围：散发 servlet -->
    <servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- spring mvc 的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>mvc-dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

步骤 16 : applicationContext.xml

在 src 目录下新建 applicationContext.xml 文件，这是 Spring 的配置文件，其作用
1. 通过注解，将 Service 的生命周期纳入 Spring 的治理

<context:annotation-config />
        <context:component-scan base-package="com.how2java.service" />

2. 配置数据源

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

3. 扫描寄存 SQL 语句的 Category.xml

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">

4. 扫描 Mapper，并将其生命周期纳入 Spring 的治理

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           xsi:schemaLocation="
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
     http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <context:annotation-config />
        <context:component-scan base-package="com.how2java.service" />
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName">
                <value>com.mysql.jdbc.Driver</value>
            </property>
            <property name="url">
                <value>jdbc:mysql://localhost:3306/how2java?characterEncoding=UTF-8</value>
            </property>
            <property name="username">
                <value>root</value>
            </property>
            <property name="password">
                <value>admin</value>
            </property>
        </bean>
        <bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="typeAliasesPackage" value="com.how2java.pojo" />
            <property name="dataSource" ref="dataSource"/>
            <property name="mapperLocations" value="classpath:com/how2java/mapper/*.xml"/>
        </bean>
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.how2java.mapper"/>
        </bean>

    </beans>

步骤 17 : springMVC.xml

在 src 目录下新建 springMVC.xml

1. 扫描 Controller, 并将其生命周期纳入 Spring 治理

<context:annotation-config/>
<context:component-scan base-package="com.how2java.controller">
<context:include-filter type="annotation"
                        expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

2. 注解驱动，以使得拜访门路与办法的匹配能够通过注解配置

<mvc:annotation-driven />

3. 动态页面，如 html,css,js,images 能够拜访

<mvc:default-servlet-handler />

4. 视图定位到 /WEB/INF/jsp 这个目录下

<bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="viewClass"
              value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
</bean>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
    <context:annotation-config/>
    <context:component-scan base-package="com.how2java.controller">
        <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
    <mvc:annotation-driven />
    <mvc:default-servlet-handler />
    <!-- 视图定位 -->
    <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" />
    </bean>
</beans>

步骤 18 : listCategory.jsp

在 WEB-INF 下创立 jsp 目录，并创立文件 listCategory.jsp。
在这个 jsp 文件中，通过 forEach 标签，遍历 CategoryController 传递过去的汇合数据。

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

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

<table align='center' border='1' cellspacing='0'>
<tr>
    <td>id</td>
    <td>name</td>
</tr>
<c:forEach items="${cs}" var="c" varStatus="st">
    <tr>
        <td>${c.id}</td>
        <td>${c.name}</td>

    </tr>
</c:forEach>
</table>

步骤 19 : 部署在 tomcat 中，重启测试

部署在 Tomcat 中，重启 tomcat，而后拜访地址，察看成果

http://127.0.0.1:8080/ssm/listCategory

部署方法请参考 通过 Eclipse 启动 Tomcat-Run On Server

步骤 20 : 思路图

1. 首先浏览器上拜访门路 /listCategory
2. tomcat 依据 web.xml 上的配置信息，拦挡到了 /listCategory，并将其交由 DispatcherServlet 解决。
3. DispatcherServlet 依据 springMVC 的配置，将这次申请交由 CategoryController 类进行解决，所以须要进行这个类的实例化
4. 在实例化 CategoryController 的时候，注入 CategoryServiceImpl。(主动拆卸实现了 CategoryService 接口的的实例，只有 CategoryServiceImpl 实现了 CategoryService 接口，所以就会注入 CategoryServiceImpl)
5. 在实例化 CategoryServiceImpl 的时候，又注入 CategoryMapper
6. 依据 ApplicationContext.xml 中的配置信息，将 CategoryMapper 和 Category.xml 关联起来了。
7. 这样拿到了实例化好了的 CategoryController, 并调用 list 办法
8. 在 list 办法中，拜访 CategoryService, 并获取数据，并把数据放在 ”cs” 上，接着服务端跳转到 listCategory.jsp 去
9. 最初在 listCategory.jsp 中显示数据

步骤 21 : 删掉，从头开始，这次全副本人做

如果是应用的下载区 (点击进入) 下载的运行我的项目执行的，那么这个时候，就该把这个我的项目删掉，而后从头到尾本人做一遍，把这个常识变成本人的货色。

更多内容，点击理解：https://how2j.cn/k/ssm/ssm-tutorial/1137.html

正文完
后端
发表至： 后端
2020-08-23
 0
关于后端:一文搞懂蓝绿部署和金丝雀发布
关于后端:Kafka基础入门
关于后端:Docker学习路线1介绍
关于后端:面向大规模商业系统的数据库设计和实践