Java SSM框架的配置方法、MVC结构的分析、响应的流程

今天头一次配置成功一个SSM框架，兴奋之余，还应该从使用的角度，将整个ssm配置的方法，配置的原因，认真的分析一下。在结束了对SSM框架简单的分析之后，就要开始回归基础，全面的认真复习。所以这个文档，要尽量的完整，目标就是，这个文档是是对SSM框架的学习，也是一个将来复习的资料。

1 RESOURCES 配置文件

1.1 配置文件简介

这个部分用来解读在resources文件夹下的配置信息。这一部分是整个ssm框架中，最难的一部分，也是最复杂的一部分。在配置这个部分的时候，尽管是不停的肤质粘贴，偶尔改一改路径。但是这样的一个 过程要比写业务逻辑代码麻烦的多。

1.1.1 jdbc.properties

这个文件是用来保存和数据库连击的相关的信息，比如JDBC驱动器、数据库户名、数据库密码等等，和数据库相关的静态信息，都会以KV的形式，保存在这个文件中。这样在需要对数据库的信息进行改变时，只需要打开这个文件，就可以对数据库的配置进行改变。与之前传统数据库连接方式相比，在修改时，不用改变多处的信息。

1.1.2 spring-mvc.xml

和名字显示的显示的一样，这是一个对MVC配置的一个文件。简单来讲有下面的几点功能：

1 设定用来存放controller的包的位置。

2 以文件前缀、后缀的方式，设定存放JSP文件的路径。

我对这个文件的理解为，从controller获取执行哪一个文件的信息，在将这个信息，通过前缀和后缀的包装，传递给下一级。

1.1.3 spring-mybatis.xml

这个配置也常常叫做：applicationContext.xml，但是其实是一个东西，都是用来配置mybatis。

1 将标注Spring注解的类自动转化成Bean，并且完成Bean的注入。

2 配置数据库相关的资源。

3 配置数据库的sessionFactory

4 配置需要被扫描的用来存放DAO接口的接口包。

5 配置事务管理器。

1.1.4 UserDAO.xml

mapper.xml稍微好理解一些。就是使用DAO接口的全限定地址，和DAO中的操作数据库的sql方法，封装起来，那么调用DAO接口的某个方法的时候，就可以使用mapper.xml中封装的sql语句操作数据库。

通常在这个文件也叫做mapper.xml文件.

1.1.5 web.xml

 

<?xmlversion="1.0" encoding="UTF-8"?>
<web-appxmlns="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"
version="3.1">
​
<display-name>SSM</display-name>
<description>SSM_test</description>
​
<!-- 编码过滤器 -->
<filter>
<filter-name>encodingFilter</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>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
​
<!-- 配置前端控制器Spring MVC DispatcherServlet -->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置两个文件 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</init-param>
​
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
​
​
<!--将所有的请求使用上面配置的 DispatcherServlet 分发器分发-->
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<!-- 匹配所有请求，此处也可以配置成 *.do 形式 -->
<url-pattern>/</url-pattern>
</servlet-mapping>
​
​
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
​
</web-app>
​

 

1.1.6 其他

Logback是一个关于log日志的配置文件，并没有使用sql文件夹。还有就是pom.xml文件,看起来很多，其实也就是添加了几个依赖罢了。

　　pom.xml

<?xmlversion="1.0" encoding="UTF-8"?>
​
<projectxmlns="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>com.xzj</groupId>
<artifactId>ssmSecondTry</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
​
<name>ssmSecondTry Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
​
<properties>
<!-- 设置项目编码编码 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<!-- spring版本号 -->
<spring.version>4.3.5.RELEASE</spring.version>
<!-- mybatis版本号 -->
<mybatis.version>3.4.1</mybatis.version>
</properties>
​
<dependencies>
​
<!-- java ee -->
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
</dependency>
​
<!-- 单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
​
<!-- 实现slf4j接口并整合 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.2</version>
</dependency>
​
<!-- JSON -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.8.7</version>
</dependency>
​
​
<!-- 数据库 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
<scope>runtime</scope>
</dependency>
​
<!-- 数据库连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
​
<!-- MyBatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
​
<!-- mybatis/spring整合包 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
​
<!-- Spring -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
​
</dependencies>
<build>
<finalName>ssmSecondTry</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<!-- 设置JDK版本 -->
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
​

 　　logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="debug">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

1.2 JDBC.PROPERTIES

1.2.1 代码

driver =com.mysql.jdbc.Driver
url =jdbc:mysql://localhost:3306/mySSM
username =root
password =admin97
​
​
maxPoolSize =30
minPoolSize =10
autoCommitOnClose =false
checkoutTimeout =10000
acquireRetryAttempts =2

1.2.2 代码解析

前面四行是我们在操作JDBC的时候，常常操作的四项，分别是：驱动器、地址、用户名、密码。

第7行设定最大连接数为30。最大连接数是连接池能申请的最大连接数。如果数据连接请求超过此数，后面的数据连接请求将被加入到等待队列中，这会影响之后的数据库操作。

第8行设定最小连接数为10。最小连接数是连接池一直保持的数据连接。如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费掉。

第9行设定在关闭之后，不会自动执行commit。如果设置为true，那么在数据库的连接状态关闭的时候，会将没有commit的数据库操作，执行commit。

第10行设定连接超时时间。

第11行设定失败后尝试的次数。

这一个文件的设置十分明确。并且在它被读取的时候，也是以键值对的形式被读取的。

1.2 SPRING-MVC.XML

1.2.1 代码

<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="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.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">
​
<!-- 扫描web相关的bean -->
<context:component-scanbase-package="com.xzj.controller"/>
​
<!-- 开启SpringMVC注解模式 -->
<mvc:annotation-driven/>
​
<!-- 静态资源默认servlet配置 -->
<mvc:default-servlet-handler/>
​
<!-- 配置jsp 显示ViewResolver -->
<beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
<propertyname="viewClass"value="org.springframework.web.servlet.view.JstlView"/>
<propertyname="prefix"value="/WEB-INF/views/"/>
<propertyname="suffix"value=".jsp"/>
</bean>
</beans>

1.2.2 代码解析

在这样的一个文件中，第1～11行都是环境。

第14行设置存放controller的目录，在这个目录下的类都会被扫描。

第17行将设定模式为注解模式，解析base-package目录下面带有@Controller注解的类。

第23～27行设定这个解析的前缀和后缀，前缀设定这个文件的目录，后缀设定这个文件的拓展名。

1.2.3 功能简析

SpringMVC是View层的一部分，来自于页面的信息由SpringMVC控制的Controller将请求发送到Model层中的Service中，然后再Model中处理业务逻辑。从Model返回的model，添加上前缀和后缀，传递到View层中。

所以，具体的细分的话，这是一个介于页面和Model层之间的模块：

1 将来自页面的请求，传递到合适的controller。

2 将从controller返回的一个jsp文件名的字符串，在这里包装之后，的到下一个jsp文件的全限定路径，然后显示出来。当然并不是所有的controller都有返回值，如果没有，那就是在当前的页面修改。

 

1.3 SPRING-MYBATIS.XML

1.3.1 代码

<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
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">
​
<!-- 设定扫描路径 -->
<context:component-scanbase-package="com.xzj.service"/>
​
<!-- 导入数据库配置文件 -->
<context:property-placeholderlocation="classpath:jdbc.properties"/>
​
<!-- 数据库连接池 -->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="${driver}"/>
<propertyname="jdbcUrl"value="${url}"/>
<propertyname="user"value="${username}"/>
<propertyname="password"value="${password}"/>
<propertyname="maxPoolSize"value="${maxPoolSize}"/>
<propertyname="minPoolSize"value="${minPoolSize}"/>
<propertyname="autoCommitOnClose"value="${autoCommitOnClose}"/>
<propertyname="checkoutTimeout"value="${checkoutTimeout}"/>
<propertyname="acquireRetryAttempts"value="${acquireRetryAttempts}"/>
</bean>
​
<!-- 配置SqlSessionFactory -->
<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- 注入数据库连接池 -->
<propertyname="dataSource"ref="dataSource"/>
​
<!-- 扫描model包 使用别名 -->
<propertyname="typeAliasesPackage"value="com.xzj.model"/>
​
<!-- 扫描sql配置文件:mapper需要的xml文件 -->
<propertyname="mapperLocations"value="classpath:mapper/*.xml"/>
</bean>
​
<!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
<beanclass="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!-- 注入sqlSessionFactory -->
<propertyname="sqlSessionFactoryBeanName"value="sqlSessionFactory"/>
​
<!-- 给出需要扫描Dao接口包 -->
<propertyname="basePackage"value="com.xzj.DAO"/>
</bean>
​
<!-- 配置事务管理器 -->
<beanid="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据库连接池 -->
<propertyname="dataSource"ref="dataSource"/>
</bean>
​
<!-- 配置基于注解的声明式事务 -->
<tx:annotation-driventransaction-manager="transactionManager"/>
</beans>

1.3.2 代码解析

第14行：加上这一行以后，将自动扫描路径下面的包，如果一个类带了@Service注解，将自动注册到Spring容器，不需要在spring-mybatis.xml文件定义bean了。类似的注解还有Component、Repository、Controller。

例如：有下面一个类位于com.xzj.service或其子目录中：

@Service("xxx")
@Scope("yyy")
publicclasstestextendsAimplementsB{
······
}

那么就相当于在spring-mybatis.xml添加了一段这样的<bean>。

<beanid="xxx"class="com.xzj.service.test"scope="yyy">
...... 
</bean>

简而言之，这是一个将带有注解的类添加到Spring容器的语句。

第20～30行，创建数据库连接池，读取jdbc.properties文件中的有关于数据库的设置，按照这样的设置，设定数据库连接池的属性。

1.3.3 功能简析

纵观整个项目，就是这一块是最复杂的，在上面的代码中：

第50行和第38行的bean将DAO接口和mapper连接起来。这样的配置，使得在使用DAO接口的时候，直接调用接口方法，就可以直接调用DAO.xml中的sql语句。

另外的一点就是注册了service的目录，将service的内容注册到了Spring的容器中。也就是说，这个这个文件配置了两个方面的内容：一个是以service代表的业务逻辑，一个是以DAO及其映射mapper代表的数据访问，这两者共同组成了Model层。

1.4 WEB.XML

1.4.1 web.xml的代码

<?xmlversion="1.0" encoding="UTF-8"?>
<web-appxmlns="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"
version="3.1">
​
<display-name>SSM</display-name>
<description>SSM_test</description>
​
​
<!-- 编码过滤器 -->
<filter>
<filter-name>encodingFilter</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>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
​
​
<!-- 配置前端控制器Spring MVC DispatcherServlet -->
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!-- 配置两个文件 -->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</init-param>
​
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<!-- 匹配所有请求，此处也可以配置成 *.do 形式 -->
<url-pattern>/</url-pattern>
</servlet-mapping>
​
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
​
</web-app>
​

1.4.2 代码解析

配置编码过滤器。

配置分发器，并且这里的分发器中，注入了两个xml文件。

配置welcome页面。

 

 

2 MVC三层结构的简析

2.1 MVC的构成

 

2.1.1 M层

M层表示Model层，模型层。用来实现业务逻辑、对数据进行访问。

这一层大概分为三个部分，Model、Service、DAO这样的三块，以我创建的这个工程来讲三个部分分别是：

1 User类，这个类中有三个属性，分别有他们的get、set方法。

2 Service接口及其实现类。在spring-mybatis.xml中配置，从而被扫描。

3 UserDAO接口，在spring-mybatis.xml中配置，与UserDAO.xml配对，被动态实现。

即:这层的三个模块都是在spring-mybatis.xml中被配置的。

2.1.2 V层

V层表示View层，显示层。是用来和用户交互的可视化界面，如html和jsp文件在浏览器中的显示。同样，在这些显示页面中，可以设定不同的请求，根据不同的前端动作，提交给分发器。那么这样的到的响应也不同。

2.1.3 C层

C层表示Controller控制器。C层大致上有两种功能：

1 根据不同的请求，调用M层中不同业务逻辑处理。

2 得到了来自M层处理结果的返回，给予V层的显示结果也不相同。

这一块是在spring-mvc.xml配置的。

2.2 M层的具体构成

2.2.1 简述

M层是Model层，负责业务逻辑和数据访问。以这个项目为例子，除了controller 以外的Java类和接口都是属于Model层的的，除此之外还有UserDAO.xml也是属于Model层的。

2.2.2 User类

User的代码如下：

packagecom.xzj.model;
​
// @ author :zjxu time:2018/12/31
publicclassUser{
privateintuserID;
privateStringuserName;
privateStringuserPassword;
privateStringcomments;
​
publicintgetUserID() {
returnuserID;
}
​
publicStringgetUserName() {
returnuserName;
}
​
publicStringgetUserPassword() {
returnuserPassword;
}
​
publicStringgetComments() {
returncomments;
}
​
​
publicvoidsetUserID(intuserID) {
this.userID=userID;
}
​
publicvoidsetUserName(StringuserName) {
this.userName=userName;
}
​
publicvoidsetUserPassword(StringuserPassword) {
this.userPassword=userPassword;
}
​
publicvoidsetComments(Stringcomments) {
this.comments=comments;
}
​
@Override
publicStringtoString() {
return"User{"+
"userID="+userID+
", userName='"+userName+'\''+
", userPassword='"+userPassword+'\''+
", comments='"+comments+'\''+
'}';
}
}
​

 

言简意赅，这一段代码就是定义一个User类，并且定义了几个域。id、name、password、comments。设定了它们的getter和setter。

2.2.3 UserService接口

packagecom.xzj.service;
importcom.xzj.model.User;
​
// @ author :zjxu time:2018/12/31
​
publicinterfaceUserService{
publicUserselectUser(longuserID);
}

申明一个接口，这个接口是Model层中的service的接口。它的实现类，必须实现在这个类中定义的方法。其实这个接口并不是必须的，在spring-mybatis.xml中，配置的com.xzj.service目录中直接写UserServiceImple类，即可将这个类配置进spring中。但是有这个过接口可以将Model层中的service服务的结构更加清晰。所以在这个工程中，就使用了UserService接口。

 

2.2.4 UserServiceImple 类

packagecom.xzj.service.imple;
​
// @ author :zjxu time:2018/12/31
​
importcom.xzj.DAO.UserDAO;
importcom.xzj.model.User;
importcom.xzj.service.UserService;
importorg.springframework.stereotype.Service;
importjavax.annotation.Resource;
​
@Service("userService")
publicclassUserServiceImpleimplementsUserService{
​
@Resource
privateUserDAOuserDAO;

publicUserselectUser(longUserID) {
returnthis.userDAO.selectUser(UserID);
}
}
​

UserService的实现类，其中两个很重要的是两个注解11和14行的两个注解。 ​ 第11行的注解@Service("userService”)，表示是为userService服务的，这个userService是controller的userService类。

2.2.5 UserDAO 接口

packagecom.xzj.DAO;
​
// @ author :zjxu time:2018/12/31
​
importcom.xzj.model.User;
​
publicinterfaceUserDAO{
UserselectUser(longid);
}

 

 

2.2.5 UserDAO.xml

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
​
<!-- 设置为UserDao接口方法提供sql语句配置 -->
<mappernamespace="com.xzj.DAO.UserDAO">
​
<selectid="selectUser"resultType="User"parameterType="long">
SELECT * FROM userList WHERE userID = #{id}
</select>
​
</mapper>

2.3 C层的具体构成

2.3.1 简述

C层就是 controller，位于Model层和View层之间的一层。

2.3.2 Controller 类

packagecom.xzj.controller;
​
// @ author :zjxu time:2018/12/31
​
importcom.fasterxml.jackson.databind.ObjectMapper;
importcom.xzj.model.User;
importcom.xzj.service.UserService;
importorg.springframework.stereotype.Controller;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.servlet.ModelAndView;
​
importjavax.annotation.Resource;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importjava.io.IOException;
​
@Controller
publicclassUserController{
​
@Resource
privateUserServiceuserService;
​
@RequestMapping("/showUser.do")
publicvoidselectUser(HttpServletRequestrequest,HttpServletResponseresponse,ModelAndViewmav) throwsIOException{

request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("UTF-8");
​
longuserId=Long.parseLong(request.getParameter("id"));
Useruser=this.userService.selectUser(userId);
System.out.println("\n\n\n\n\n\n\n\n\n\n\n\n"+userId+"\n\n\n\n\n\n\n\n\n\n\n\n");
​
ObjectMappermapper=newObjectMapper();
response.getWriter().write(mapper.writeValueAsString(user));
response.getWriter().close();
}
​
@RequestMapping("/test")
publicModelAndViewtest(HttpServletRequestrequest,HttpServletResponseresponse)throwsIOException{
​
ModelAndViewmav=newModelAndView();
mav.addObject("name", "SpringMVC");
mav.setViewName("test");
returnmav;
​
}
​
}
​
​

 

2.3.3 Controller层注解的详细分析

在controller中，重要的地方在于这几个注解。controller、Resource、RequestMapping这单个注解。

1 注解@Controller。

表明这是一个Controller类，spring-mvc.xml文件设定的扫描目录下被扫描。

2 注解@Resource。

这个注解放在UserService的申明的前一行。它声明一个名为userService的对象，并且这个对象的类型为UserService接口的实现类。

通过@Resource注解，可以在service目录下UserServiceImple类中找到带有一个@Service("userService”)的注解，找到的注解中的变量名和这个注解下一行声明的对象的变量名是一致的。

在service目录下找到的那个类前面的注解表明在controller中的申明的对象的具体类型的UserServiceImple，它实现了UserService这个接口。

也就是说，@Service(“userService”)注解的类，为@Resource下一行的名为userService的对象服务。而它们一个位于service目录下，一个位于controller目录下。这两个目录都被添加到了spring-*.xml中。这样的对应关系，是属于两个层的

3 注解@RequestMapping

参数类型为一个字符串。这个参数的意义是从controller来的除了项目以外的三级及以下的URL地址。比如：

http://localhost:8080/ssm/test

这样的一个地址，经过分发器，来到了controller，controller会根据除了localhost/ssm/之外的地址，调用不同的方法。在controller这端，就会将后面的这段url地址通过注解，标记在方法上，或者是类上面。以这个url来看，它就会调用UserController.test(request,response)方法。

注解的位置的区别在于：

<1> 类的上方没有注解的时候，这个类的下面所有的方法的注解都需要添加参数。当然，也不是所有的方法都需要有注解。

但是只要是存在的注解都需要有参数。否则这样写的controller方法，作出的效果将会是“localhost:8080/ssm”的结果，这样welcome页面将会失效。

<2> 类的上方存在注解，那么这个注解会成为这个一个上级字符串加在类中的方法上的字符串上。就如同java的package的目录一样。com.xzj.test这样子，只不过在这里是用’/’来连接。

 

2.4 V层的具体构成

V层是直接面对用户的页面。所以在V层中，写的代码都是面向用户的操作的，尽管有一部分和请求相关，但是绝大部分还是于页面的展示相关的。

2.4.1 index.html文件

<!DOCTYPE html>
<html>
<head>
<metacharset="UTF-8">
<title>test</title>
</head>
<script>
functionselectUser() {
varxmlhttp=newXMLHttpRequest();
xmlhttp.onreadystatechange=function() {
if(xmlhttp.readyState==4&&xmlhttp.status==200) {
document.getElementById("test").innerHTML=xmlhttp.responseText;
}
}
xmlhttp.open("POST", "showUser.do", true);
xmlhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xmlhttp.send("id=100");
}
</script>
<body>
<pid="test">Hello World!</p>
<buttontype="button"onclick="selectUser()">onclick test</button>
<br/>
<ahref="test">ThisIsALinkForTest</a>
<br/>
</body>
</html>

这段html代码，其中的重点在于javascript代码中的Ajax掌握。

这段短短的javascript，发起请求，获得响应，设定显示，完成这三个工作。

按钮-响应，这一块非常基础的前端应用，主要的问题来自于响应方法中的Http请求。关于javascript的代码逻辑，虽然一眼就能明了，但是，还是要仔细研究一下ajax如何在html文件中，更加精巧的应用。

对于这个连接，就是在点击之后，会跳转到显示/WEB-INF/views/test.jsp相当于一个请求controller，并通过controller的到一个“test”的字符串，将其包装成为了一个完整的路径，在View层显示。

 

2.4.2 jsp目录及其下的test.jsp文件

<%--
CreatedbyIntelliJIDEA.
User: thisxzj
Date: 2019/1/1
Time: 23:45
TochangethistemplateuseFile|Settings|FileTemplates.
--%>
<%@pagecontentType="text/html;charset=UTF-8"language="java"%>
<html>
<head>
<title>xxx</title>
</head>
<body>
<h>test</h>
<p>我新建的项目是${name}</p>
</body>
</html>

这个jsp的路径是/WEB-INF/views/test.jsp，在从controller中返回一个字符串，比如一个“test”串，或者是modelAndView.setViewName("test”),并将其返回。

就会通过spring-mvc.xml中的下两行，将其包装成/WEB-INF/views/test.jsp。并将其显示到页面中。

<propertyname="prefix"value="/WEB-INF/views/"/>
<propertyname="suffix"value=".jsp"/>

在这样一个jsp页面中，${name}这个变量，是通过controller类中以返回modealAndView的方式，在modelAndView对象：

modelAndView.addObject("name", "SpringMVC");

那么在jsp页面中，将会读取这个KV，将name显示为成“SpringMVC”。这样就完成了一个从后台向前台的传输的过程。

 

响应过程

1 用户在浏览器窗口输入一个URL地址，以localhost:8080/ssm/为例子，由于这个URL是直接localhost/ssm/后面并没有接更多的信息，就会直接显示在web.xml中设定的welcome页面index.html。​ 这个过程发生在View层。

2 于是在浏览器页面上就会显示index.html的内容。用户按下显示onclick test的按钮，通过javascript的ajax发送一个包含一个字符串“showUser.do”和一个KV对“id = 1”的一个请求到controller，controller再根据请求中的“showUser.do”调用对应的controller方法。​ 这个过程从View层到Controller层。

3 请求来到Cotroller，通过扫描在Spring-MVC.xml中配置的目录下的所有的Java类。找到这个目录下所有带有@Controller的类。在这些类中寻找“showUser.do”对应的方法。在Controller类的第24行找到了一个selectUser方法。那么就会执行这个方法，对来自View层的请求进行响应。这个过程发生在Controller层。

4 找到这个方法了，开始执行。这个方法的核心在于，使用了userService这个对象以及它的的方法。关于如何使用的，在2.3.3中有详细的解释。在在这个类中，使用这个对象以及它的seclectUser方法，就是工作从Controller层到Model层的转移。

5 来到Model层，映入眼帘的就是Service接口的实现类ServiceImple。我们不关注Service接口，经过我的测试，去掉这个接口对程序的运行也没有影响。但是这个接口的存在，可以使Service方法更加规范化。在大型工程中，有一个这样的接口可以更加规范。在这个ServiceImple类中，申明了一个UserDAO的对象，这个对象并没有实体。通过注解，将UserDAO.xml作为这个接口的实体，使用定义在UserDAO.xml中的sql语句操作数据库。

sql语句和UserDAO的对应，通过在spring-mybatis.xml中，将mapper的目录和DAO接口的目录配置进去。这样在mapper的xml中，声明是对哪一个DAO接口的实现，并且在每一个sql方法的标签内，设置id为对应的DAO接口中的方法名，就可以视作将DAO的方法在mapper的xml中实现了。

通过目录、接口名、方法名的一系列配置，在调用UserDAO接口的方法的时候，就可以直接使用对应的sql语句。以：

Useruser=this.userService.selectUser(userId);

然后在UserServiceImple中，调用UserDAO的方法：

this.userDAO.selectUser(UserID);

在通过DAO的配置，使用UserDAO.xml中的sql语句操作数据库。

这个部分的操作都是在Model层。但是将Model层分为两个模块：service和DAO的话，那么这个部分是在Model层中是从service到DAO的转移。

6 我们忽略mapper的xml文件中具体执行了什么。只考虑对数据库操作之后有没有数据的返回。

如果没有，那么一个从前到后的SSM请求到响应就已经结束了。

大多数时候是有返回的。通过mapper的xml文件中的result设定的返回值类型，将从数据库中获取的数值，包装成一个返回类型，返回给UserServiceImple的对象。

在这个例子中是从数据库中获取指定id处的，一个User对象的所有信息，将其包装成一个User对象，返回给UserServiceImple。

这个部分的操作都是在Model层，细分的话那么这个部分是在Model层中是从DAO到service的转移。

7 UserServiceImple对象将从DAO获得了一个User对象的返回值，返回给Controller层。

这一个操作是从Model层返回到Controller层。

8 这样的一个User对象从DAO、Service传递了Controller层中由“showUser.do”对应的那个方法中继续着下一步的操作。

通过下面两行语句，将获取的User对象转换成一个字符串，然后传送到javascript代码中请求所对应的响应码responseText中。

ObjectMappermapper=newObjectMapper();
response.getWriter().write(mapper.writeValueAsString(user);

然后通过DOM操作，将html中的某个字段修改成User对象的字符串形式。完成了获取内容在页面上的显示。这一步是从Controller层到View层的传递。