SSM框架模板（低配，或者说过程详情）

SSM(Spring、SpringMVC、MyBatis)

首先对Spring框架和mybatis框架进行整合：（需要进行测试，是否获取到数据库的内容，才能进行下一步对Springmvc框架的整合。如果熟悉的话，可以尝试使用log4j日志测试。这个方法更好一些，详情见博客：）(36条消息) SSM框架模板（高配：一次性配完所有需要的配置文件）_one day321的博客-CSDN博客

目录结构：

pom.xml文件的模板：

最开始需要做的是导入依赖包，在pom.xml文件：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>SSM_2</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>


  <dependencies>
<!--    单元测试包-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

<!--    最常用的包，这个包包括core,beans,-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.18</version>
    </dependency>
<!--Spring-beans包，bean标签-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.3.18</version>
    </dependency>
<!--jdbc包，进行数据库操作的包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.18</version>
    </dependency>
<!--事务管理包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.3.18</version>
    </dependency>
<!--数据库源的包-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.28</version>
    </dependency>
<!--进行mybatis操作的包-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>

<!--    mybatis-spring的包，进行整合的包-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.6</version>
    </dependency>

  </dependencies>

<!--  这个是IDEA必须存在的，指在用途是告诉IDEA，Mapper.xml文件的位置，因为一般默认情况下IDEA是不会去Java目录的，尽管你添加Java路径都没用-->
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.xml</include>
        </includes>
      </resource>
    </resources>
  </build>

</project>

applicationContext.xml文件模板：

导入依赖包pom.xml文件之后，配置applicationContext.xml文件，进行连接数据库、事件管理，以及配置Mapper文件和mybatis的映射。（三步，最后一步映射需要在创建mybatis核心配置文件和Mapper文件之后再去配置。）

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

    <!--由spring管理    配置数据源数据库连接(从jdbc属性文件中读取参数) -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="jdbc:mysql://localhost:3307/student?serverTimezone=Asia/Shanghai"/>
        <property name="username" value="root"/>
        <property name="password" value="dada"/>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

    <!-- 整合 mybatis -->
    <bean id="sqlSessionFactory"
          class="org.mybatis.spring.SqlSessionFactoryBean"
          p:dataSource-ref="dataSource"
          p:configLocation="classpath:mybatis-config.xml"/>

    <!--  mybatis自动扫描 将Mapper接口生成代理注入到Spring -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
          p:sqlSessionFactoryBeanName="sqlSessionFactory"
          p:basePackage="dao" />


    <!-- 配置事务管理器 完成手动事务管理  由spring管理事务-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--
        支持注解驱动的事务管理，指定事务管理器。
        配置事务 提供回滚，发生异常数据回滚  需要在类/方法上写注解 @Transactional -->
    <tx:annotation-driven transaction-manager="txManager"/>

<!--    需要注意，这一句不能遗漏，因为我是在Controller类编写的Test测试，用的注解方法，需要用这个扫描注释注解-->
    <context:component-scan base-package="controller"/>
</beans>

在配置applicationContext.xml文件之后，先按照这个文件的第三步配置映射，需要配置mybatis-config.xml文件（告诉映射Mapper.xml文件的位置。注意这个的配置，还需要前面在pom.xml配置bulid标签）和Mapper.xml文件（主要文件，用来存放SQL映射信息）。

mybatis-config.xml文件：

<?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>
    <mappers>
         <mapper resource="mybatis/UserMapper.xml"/>
    </mappers>
</configuration>  

Mapper.xml文件：（放在Java目录下的mybatis包里面）

<?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="dao.UserDao">

    <select id="queryAll" resultType="po.User" parameterType="po.User">
        select *from register
    </select>
</mapper>

这个映射文件，是我进行测试用的，它的作用是查询数据库的所有信息。

测试文件：

UserTestController.java:  （Controller层）

package controller;

import dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import po.User;

import java.util.List;

@Controller("userTestImpl")
public class UserTestImpl {

    @Autowired
    private UserDao userDao;
    public void test(){
        User user = new User();
        List<User> userList = userDao.queryAll(user);
        for (int i = 0; i <userList.size() ; i++) {
            System.out.println(userList.get(i));
        }

    }
}

进行测试TestUser类：

package controller;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
    
    public static void main(String args[]){
        ApplicationContext appcon = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserTestImpl ut= (UserTestImpl) appcon.getBean("userTestImpl");
        ut.test();
    }
}

需要补充一点，进行测试类之前，还需要编写POJO类和dao层的接口。（这个简单，就不介绍了。）

最后得到一个测试结果：说明连接数据库是成功的。那么就可以尝试将SpringMVC的框架编写进去。

添加Springmvc框架：

添加SpringMVC框架之后的目录结构：

 

pom.xml文件需要添加的依赖包：

首先，第一步：仍然是导入pom.xml的依赖包，（有关SpringMVC的依赖包，只需要添加spring-webmvc就可以。jstl这个依赖包，是为了在JSP的show页面，使用jstl标签的方法）

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.18</version>
    </dependency>
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>jstl</artifactId>
          <version>1.2</version>
      </dependency>

web.xml文件：（新增配置文件）

第二步：配置web.xml文件。

<?xml version="1.0" encoding="UTF-8"?>
<web-app
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
		http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        id="WebApp_ID" version="4.0">

    <!-- 引入Spring 的配置-->
    <!-- ContextLoaderListener 需要 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- Bootstraps the root web application context before servlet initialization -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 引入SpringMVC 的配置-->
    <!-- 这个Spring Web应用程序的前端控制器(DispatcherServlet)，负责
        处理所有应用程序请求  -->
    <servlet>
        <servlet-name>springDispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!-- 将所有请求映射到 DispatcherServlet 进行处理 -->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
    <!-- 针对 前端与控制器 数据传递时 的字符过滤器(避免中文乱码) -->
    <filter>
        <filter-name>encoder</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoder</filter-name>
        <servlet-name>springDispatcherServlet</servlet-name>
    </filter-mapping>
    
</web-app>

配置这个文件的时候，我犯了一点错误：因为我是在网上寻找的模板，然后就是在这一句：

<!-- 将所有请求映射到 DispatcherServlet 进行处理 -->
    <servlet-mapping>
        <servlet-name>springDispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>        //就是这个地方，我找到的模板上用的是*.do   //导致最后我在浏览器输入index，出现404.应该修改为/    。这样就不会出现问题。
    </servlet-mapping>

添加springmvc.xml文件模板配置：

这个文件，用来映射Controller层和 JSP之间的数据交互。return "login"   

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

    
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--扫包-->
    <context:component-scan base-package="controller"/>

</beans>

UserController：（控制层和JSP层的代码交互）

第三步：着手创建运行代码。

首先将业务逻辑从Controller分离出来，用一个service层表示。（这里我仍然用查询所有数据的内容为测试）

所以，service层的写法，其实和dao层的方法是一样的。比较简单就略过了。

主要是contoller层，创建了一个UserController。它主要和JSP进行交互。

package controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import po.User;
import service.UserService;

import java.util.List;

@Controller
public class UserController {

    @Autowired
    private UserService userService;
    @RequestMapping("/queryAll")
    public String queryAll(User user, Model model){
        List<User> list= userService.queryAll(user);
        model.addAttribute("userList",list);
        return "show";
    }
    
//    这个是为了方便输入index就显示下面那个index.jsp的页面。
    @RequestMapping("/index")
    public String index(Model model){
        model.addAttribute("user",new User());
        return "index";
    }

}

JSP层的代码：

index.jsp：

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form:form modelAttribute="user" method="post" action="${pageContext.request.contextPath}/queryAll">
    <input type="submit" value="查看所有信息">
</form:form>
</body>
</html>

show.jsp：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<table>
    <tr>
        <th>账号</th>
        <th>密码</th>
        <th>性别</th>
        <th>姓名</th>
    </tr>

    <c:forEach items="${userList}" var="user">
        <tr>
            <th>${user.account}</th>
            <th>${user.password}</th>
            <th>${user.sex}</th>
            <th>${user.name}</th>
        </tr>
    </c:forEach>
</table>
</body>
</html>

这里犯了一个很常见的错误：

 <c:forEach items="${userList}" var="user">

在这一行，我写成了userList，没有使用EL表达式${}的正确格式。导致的问题就是使用user.account。它是不会有提示的。

点拔：

${userList}   像这种EL表达式，它对应的是Controller层 model.addribute("userList",Object )。

那么怎么确定，它获取的是我们需要的EL表示式。主要看返回的是那个页面。

最后测试结果：

一个完整的SSM框架的模板，就完成了。

后续，需要添加其它的功能，那么需要改变的地方，从两部分改变。

一部分：添加功能的SQL映射 （Mapper.xml和mybatis-config.xml）

另一部分：添加Controller和Jsp 对应的映射。

（像pom.xml、application、springmvc、web.xml 这些配置文件只需要配置一次就够了）

首先从mybatis框架改变Mapper.xml的映射文件，改变mybatis-config.xml的指定。最好再测试一下是否获取到了数据。

再从SpringMVC框架 添加UserController类和对应的JSP类。（这两个的数据要相互交映，这一点需要注意。）

UserController类：

@RequestMapping("/index")  指定浏览器的输入页面。

model.addAttribute("user",new User());

return "index";   将model.addribute的数据返回给index.jsp页面。

JSP类（index.jsp、show.jsp）：

<form:form modelAttribute="user"   对应index.jsp的model返回的数据

action="${pageContext.request.contextPath}/queryAll">  对应queryALL的contoller的@RequestMapping("/queryAll")方法。

<c:forEach items="${userList}" var="user">  同理，对应queryAll的方法里面的model数据userList

最后，通过练习，发现，其实除了Controll层，可以返回与JSP数据进行交互，也可以在service层进行和JSP数据交互。因为Service层负责业务逻辑。所以，如果是 从JSP获取的数据，那么首先是提交给Controller层，然后Controller层提交给Service层进行数据交互。

小结：（一定需要注意一下不同）

像前面的例子，查询所有用户信息，它是从数据库内部获取所有信息。所以是从dao层获取数据然后交给Service，再交给Controller层。最后交给JSP层显示。

这种，Controller提供数据给JSP层，是通过model.addribute的方式，提供数据给JSP。

但是，如果是 登录或者按需查询这样的表单信息，它是从JSP获取数据交给Controller，然后Controller交给数据给Service进行查询，最后Service层返回结果给JSP层显示。（常见的是这种用法。通过登录验证去练习）

这种，JSP提供数据给Controller层，它是通过 form:action="${pagecontext/request/contextPath}/某个Controller的@RequestMapping的名称。"这种方式提供数据到了controller层。

像这种方式，Controller层不需要model.addribute()的方式返回数据。即这种由JSP提供的数据，不需要进行数据绑定。直接返回给service层，service层才提供数据到JSP层。