中软国际暑期实习day03(2020.08.12)-整合SSM项目

今天在前一天的基础上，学习了Spring和SpringMVC以及Mybatis之间的整合。

在此之前，我们得先明白这三者的功能及关系。

• Spring是一个框架族，在SSM项目中负责管理SpringMVC和Mybatis，是整个项目的框架。

• SpringMVC是Spring的一种，是MVC设计模式在Spring中的实现。
  MVC的全名是Model View Controller，是模型(Model)-视图(view)-控制器(controller)的缩写，是一种设计模式。它是用一种业务逻辑、数据与界面显示分离的方法来组织代码，将众多的业务逻辑聚集到一个部件里面，在需要改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑，达到减少编码的时间，提高代码复用性。

• Mybatis是用于处理数据库的框架。

下面在具体的项目里面进行SSM项目整合。

0.事先建立好相应的数据库及表

t_user表（数据库名为whut02）

/*
 Navicat Premium Data Transfer

 Source Server         : localhost_3306
 Source Server Type    : MySQL
 Source Server Version : 50728
 Source Host           : localhost:3306
 Source Schema         : whut02

 Target Server Type    : MySQL
 Target Server Version : 50728
 File Encoding         : 65001

 Date: 11/08/2020 20:37:23
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `password` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `age` int(11) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES (1, 'zhangsan', '123456', 20);
INSERT INTO `t_user` VALUES (2, 'lisi', '123456', 20);

SET FOREIGN_KEY_CHECKS = 1;

1.新建maven项目

• 新建maven项目

• 设置maven

建立成功后，项目目录如下所示：

其中web.xml是该项目的入口，也是该项目配置文件；index.jsp是该项目的主页。

2.导入相应的依赖

<!-- 依赖 -->
  <dependencies>
    <!-- SpringMVC -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.7.RELEASE</version>
    </dependency>

    <!-- SpringJDBC -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.7.RELEASE</version>
    </dependency>

    <!-- SpringAOP -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.7.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.7.RELEASE</version>
    </dependency>

    <!-- Mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.5</version>
    </dependency>

    <!-- Mybatis整合Spring -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.5</version>
    </dependency>

    <!-- mysql驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.20</version>
    </dependency>

    <!-- c3p0 连接池技术  -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.4</version>
    </dependency>

    <!-- JSTL jsp standard Tag library -->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- Servlet API-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>

3.在main目录下新建java目录（源代码目录）和resources（资源目录）

4.根据所要处理的数据库表创建相应的实体类

User.java

package com.example.bean;

/**
 * @className: User
 * @description:
 * @author:
 * @date: 12/08/2020 15:58
 */
public class User {
    private int id;
    private String username;
    private String password;
    private int age;

    public User() {
    }

    public User(int id, String username, String password, int age) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

5.建立相应实体类的数据访问对象（data access object，dao）接口

IUserDao.java

package com.example.dao;

import com.example.bean.User;

import java.util.List;

public interface IUserDao {
    /**
     * 获取所有用户
     * @return
     */
    List<User> findAll();
}

6.建立相应实体类的数据库映射文件（.xml文件）

UserDao.xml

<?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.example.dao.IUserDao">
    <select id="findAll" resultType="com.example.bean.User">
        select *
        from t_user
    </select>
</mapper>

7.创建相应实体类的业务层接口及其实现类

• IUserService.java

package com.example.service;

import com.example.bean.User;

import java.util.List;

/**
 * 用户业务层接口
 */
public interface IUserService {
    /**
     * 查询所有用户
     * @return
     */
    List<User> findAll();
}

• UserServiceImpl.java

package com.example.service.impl;

import com.example.bean.User;
import com.example.dao.IUserDao;
import com.example.service.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @className: UserServiceImpl
 * @description:
 * @author:
 * @date: 12/08/2020 16:19
 */
@Service
public class UserServiceImpl implements IUserService {

    // 从IOC中取出mybatis 实现好的实现类
    // Autowired 自动注入  将类从IOC容器中取出
    @Autowired
    IUserDao userDao;

    /**
     * 查询所有用户
     *
     * @return
     */
    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }
}

8.创建相应的控制器类

Handler.java

package com.example.controller;

import com.example.service.IUserService;
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;

/**
 * @className: Handler
 * @description: 控制器类
 * @author:
 * @date: 12/08/2020 16:23
 */
@Controller
@RequestMapping("/users")
public class Handler {
    @Autowired
    IUserService userService;

    // 表示  当访问到 /users/findAll 就映射到 findAll方法上
    @RequestMapping("/findAll")
    public ModelAndView findAll() {
        // ModelAndView  数据视图
        ModelAndView mv = new ModelAndView();
        // 指定视图
        mv.setViewName("index");
        mv.addObject("list", userService.findAll());
        return mv;
    }
}

9.在resources目录下新建mybatis、spring和springmvc等配置文件

• config.xml（mybatis配置文件）

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

<configuration>


</configuration>

• spring.xml（spring配置文件）

<?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:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
">
    <!-- 配置Mybatis和Spring的整合   实质就是将mybatis的核心类  sqlSession交给Spring来管理  -->
    <!--
        Spring 两大核心机制
            IOC Inversion of Control  控制反转  将对象的创建反转到Spring上    IOC理解做容器  里面存放Spring创建的对象  在程序需要的时候分发出来
            AOP

     -->

    <!-- 1. 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!-- 1.1 指定数据库连接相关属性 -->
        <property name="jdbcUrl" value="jdbc:mysql:///whut02?serverTimezone=Asia/Shanghai"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
        <!-- 1.2 指定连接池的相关属性 -->
        <!-- 连接池的初始化数量 -->
        <property name="initialPoolSize" value="5"/>
        <!-- 连接池的最大数量-->
        <property name="maxPoolSize" value="10"/>
    </bean>

    <!-- 2.配置sqlSession -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 2.1 引入数据源 -->
        <!-- 注意 如果值是基本数据类型(int,byte,short,long,double,float,char,boolean) + String 就用value  如果引用数据类型  用ref -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 2.2 加载映射文件 -->
        <property name="mapperLocations" value="classpath:com/example/dao/*.xml"/>
        <!-- 2.3 加载mybatis的配置文件 -->
        <property name="configLocation" value="classpath:config.xml"/>
    </bean>

    <!-- 3. 将mybatis产生的代理 交给Spring管理    ==== 将接口的实现类 放到IOC容器中  -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.dao"/>
    </bean>

</beans>

• springmvc.xml（springmvc配置文件）

<?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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="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/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">

    <!-- 1. 启动注解驱动 -->
    <mvc:annotation-driven/>

    <!-- 2. 扫描业务代码 -->
    <context:component-scan base-package="com.example"/>

    <!-- 3. 配置视图解析器   将逻辑视图转换成物理视图  "index"  ==>  /index.jsp -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 指定前缀 和 后缀 -->
        <property name="prefix" value="/"/>
        <property name="suffix" value=".jsp"/>
    </bean>


</beans>

10.重新编写配置文件（web.xml）

web.xml

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <!-- web-app 标签爆红可以忽略 -->
    <display-name>Archetype Created Web Application</display-name>

    <!-- 1. 启动Spring -->
    <!-- 1.1 加载全局参数 -->
    <context-param>
        <!-- 1.1.1 加载Spring的配置文件 -->
        <!-- 表示 Spring配置文件的路径 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>
    <!-- 1.2 加载监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 2. 启动SpringMVC 其实就是配置DispatcherServlet  这个servlet可以拦截所有的请求 -->
    <servlet>
        <!-- 2.1 引入dispatcherServlet-->
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 2.2 加载SpringMVC的配置文件 -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>

    <!-- 2.3 配置servlet的映射 -->
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!-- 拦截所有的请求 -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 3. 字符编码过滤器 -->
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <!-- GB2312 ==> GBK 国标扩展码  ==> UTF-8 -->
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <!-- 配置过滤器的映射 -->
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


    <!-- 4. 配置静态资源 -->
    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.js</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.css</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>*.jpg</url-pattern>
    </servlet-mapping>

</web-app>

11.重写主页文件（index.jsp）

index.jsp

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html; charset=UTF-8" isELIgnored="false" %>
<!doctype html >
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
<c:forEach items="${list}" var="user">
    <%--  ${}  EL表达式 使用时需声明 --%>
    ${user}
</c:forEach>
</body>
</html>

12.在pom.xml文件中的build下添加代码

<resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
      </resource>
</resources>

13.配置tomcat

• 配置tomcat

• 将项目部署到tomcat上

14.启动项目

打开浏览器输入http://localhost:8090/ssm_demo01_war/users/findAll（注意我的端口号设置的是8090），将会出现以下页面（返回所有用户信息）

总结

• 在SSM项目中，spring管理整个项目，springmvc实现MVC设计模式，mybatis处理数据库。

• 三层架构

  • 持久层（采用DAO模式，对应数据库操作），借助mybatis完成。在这里对应的就是相应的实体类的数据库映射。
  • 业务层（采用事务脚本模式，将一个业务中所有的操作封装成一个方法），用到@Service注解。在这里对应相应实体类的业务层类，将数据库操作封装成一个方法。
  • 表现层（采用MVC模式）。这里对应的就是相应的控制器类。

• spring核心

  • IOC Inversion of Control 控制反转 将对象的创建反转到Spring上;IOC理解做容器 ，里面存放Spring创建的对象，在程序需要的时候分发出来
  • AOP

• spring和mybatis整合实质就是将mybatis的核心类 SqlSession交给Spring（ioc）来管理