13.SSM框架集~Spring + SpringMVC + Mybatis 整合案例

13.SSM框架集~Spring + SpringMVC + Mybatis 整合案例

本文是上一篇文章的后续,详情点击该链接

SpringMVC的响应

        我们可以使用SpringMVC搭建一个项目，在单元方法中使用SpringMVC提供的方式来获取请求信息，然后根据功能需求，声明请求处理的逻辑代码，进行请求的处理。当请求处理完成后，我们需要将此次请求的处理结果响应给浏览器，以前我们是自己在Servlet中使用response对象来完成响应的

使用ServletAPI方式

@Controller
    @RequestMapping("/UserController")
    public void UserController(HttpServletRequest request, HttpServletResponse response) throws IOException {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //转发,跳转回去
        response.sendRedirect(request.getContextPath() + "/main.jsp");
    }

        单元方法的返回值类型设置void。因为使用response对象在单元方法中直接对此次请求进行了响应，不再通过DispatcherServlet了，既然已经响应了，就不需要再给DispatcherServlet返回值了。在单元方法上声明HttpServletResponse形参，来接收此次请求的response对象。

使用forward关键字完成响应

   @RequestMapping("/forWardJsp")
    public String ForWardJsp(String name,Integer age){
        //处理请求
        System.out.println(name + " " + age);
        //响应结果
        return "forward:/main.jsp";
    }

        使用通过单元方法的返回值来告诉DispatcherServlet请求转发指定的资源,如果是请求转发，forward关键字可以省略不写的。

使用redirect关键字完成响应

    @RequestMapping("/redirectJsp")
    public String redirectJsp(String name,Integer age){
        //处理请求
        System.out.println(name + " " + age);
        //响应结果
        return "redirect:/main.jsp";
    }

        使用通过单元方法的返回值来告诉DispatcherServlet重定向指定的资源，注意这个redirect关键字不可以省去。

使用View视图转发和重定向

@RequestMapping("/Demo")
    public View Demo(HttpServletRequest request){
        //转发
        //View   v=new InternalResourceView("/main.jsp");
        //重定向
        View  v =new RedirectView(request.getContextPath()+"/main.jsp");
        return  v;
    }

        RedirectView中所做的操作，最终的实现是在renderMergedOutputModel中完成实现的，简单来说RedirectView实现了链接的重定向，并且将数据保存到FlashMap中，这样在跳转后的链接中可以获取一些数据.

使用ModelAndView 转发重定向

    @RequestMapping("/DemoS")
    public ModelAndView DemoS(HttpServletRequest request){
        ModelAndView view = new ModelAndView();
        //转发一
        //view.setViewName("forward:/main.jsp");
        //重定向一
        //view.setViewName("redirect:/main.jsp");
        //转发二
        //view.setView(new InternalResourceView("/main.jsp"));
        //重定向二
        view.setView(new RedirectView(request.getContextPath() + "/main.jsp"));
        return view;
    }

       ModelAndView中的Model代表模型，View代表视图，这个名字就很好地解释了该类的作用。业务处理器调用模型层处理完用户请求后，把结果数据存储在该类的model属性中，把要返回的视图信息存储在该类的view属性中，然后让该ModelAndView返回该Spring MVC框架。

ResponseBody 响应 json 数据

关于ajax可以点击这篇文章

       当浏览器发起一个ajax请求给服务器，服务器调用对应的单元方法处理ajax请求。 而ajax的请求在被处理完成后，其处理结果需要直接响应。而目前我们在单元方 法中响应ajax请求，使用的是response对象，需要我们自己将要响应的数据转换 为json字符串响应，比较麻烦，而我们一直希望在单元方法中无论是否是ajax请求，都使用return语句来完成资源的响应,既然我们希望使用单元方法的返回值来响应ajax请求的处理结果，而目前DispatcherServlet的底层会将单元方法的返回值按照请求转发或者重定向来处理，所以就需要我们告诉DispatcherServlet，单元方法的返回值不要按照请求转发或者重定向处理，而是按照直接响应处理，将单元方法的返回值直接响应给浏览器。

导入jackson的jar

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.9.9</version>
</dependency>

	
	//需要加上@ResponseBody,响应的结果直接是json对象,在前台页面无需转换
    @RequestMapping("/AjaxTest")
    @ResponseBody
    public User AjaxTest(HttpServletResponse response) throws IOException {
        User user = new User(1,"alvin","man");
        return user;
    }

        <!--   导入jQuery    -->
        <script type="text/javascript" src="js/jquery-1.9.1.js"></script>

        <script type="text/javascript">
            $(function () {
                $.post("AjaxTest",function (result) {
                    console.log(result)
                });
            },"json")
        </script>

SSM整合案例

需求:将数据库表的所有信息发送到网页

在数据库中创建用户信息表

搭建SSM开发环境

先导包

<?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>MailSending</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>MailSending Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <mysql-version>8.0.11</mysql-version>
    <mybatis-version>3.5.2</mybatis-version>
    <spring-version>5.2.2.RELEASE</spring-version>
    <mybatis-spring-version>2.0.4</mybatis-spring-version>
    <slf4j-version>1.7.25</slf4j-version>
    <jstl-version>1.2</jstl-version>
    <servlet-api-version>3.1.0</servlet-api-version>
    <jsp-version>2.2</jsp-version>
    <junit-version>4.12</junit-version>
    <jackson-version>2.9.9</jackson-version>
  </properties>

  <dependencies>
    <!--mysql的驱动依赖-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql-version}</version>
    </dependency>
    <!--mybatis的核心依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis-version}</version>
    </dependency>
    <!--springIOC的核心依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring-version}</version>
    </dependency>

    <!--spring-jdbc连依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring-version}</version>
    </dependency>

    <!--spring-test依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring-version}</version>
    </dependency>
    <!--spring-webmvc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring-version}</version>
    </dependency>

    <!--mybatis连接spring的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>${mybatis-spring-version}</version>
    </dependency>

    <!--日志依赖-->
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j-version}</version>
    </dependency>

    <!--jstl依赖-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>${jstl-version}</version>
    </dependency>

    <!--jackson依赖-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson-version}</version>
    </dependency>

    <!--jsp-servlet-api-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>${servlet-api-version}</version>
      <scope>provided</scope>
    </dependency>

    <!--jsp-api-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>${jsp-version}</version>
      <scope>provided</scope>
    </dependency>

    <!--单元测试的依赖-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit-version}</version>
      <scope>test</scope>
    </dependency>

    <!--AOP的命名空间依赖-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>

  </dependencies>

  <build>
    <plugins>
      <!--引入tomcat服务器插件-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <!--指定tomcat的端口号-->
          <port>8888</port>
          <!--指定访问的上下文路径-->
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

web.xml SpringMVC配置

  <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:springmvc.xml</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--除jsp以外的所有的请求都会进servlet-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

Mybatis配置

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

        <!--把jdbc.properties文件引入-->
        <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

       <!--[A]连接数据库 获得数据源-->
       <bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
           <property name="driverClassName" value="${m_driver}"></property>
           <property name="url" value="${m_url}"></property>
           <property name="username" value="${m_uname}"></property>
           <property name="password" value="${m_pwd}"></property>
       </bean>

       <!--[B]获得sqlsession工厂-->
       <bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean" >
           <property name="dataSource" ref="ds"></property>
           <property name="typeAliasesPackage" value="com.alvin.pojo"></property>
       </bean>

      <!--[C]扫描mapper文件-->
      <bean id="mapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          <property name="sqlSessionFactoryBeanName" value="factory"></property>
          <property name="basePackage" value="com.alvin.mapper"></property>
      </bean>
    
</beans>

Service配置

  <!--包的扫描-->
      <context:component-scan base-package="com.alvin.service.impl"></context:component-scan>

声明式事务

      <!--声明式事务的配置-->
      <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="ds"></property>
      </bean>

     <tx:annotation-driven></tx:annotation-driven>

配置SpringMVC

      <!--@Controller-->
     <context:component-scan base-package="com.alvin.controller"></context:component-scan>

      <!--@RequestMapping-->
     <mvc:annotation-driven></mvc:annotation-driven>

    <!--静态资源放行标签-->
    <!--mapping：代表的是网络中访问的路径  location:代表本地放行的文件位置-->
    <mvc:resources mapping="/img/**" location="/img/"></mvc:resources>

    <mvc:resources mapping="/css/**" location="/css/"></mvc:resources>

    <mvc:resources mapping="/js/**" location="/js/"></mvc:resources>

Controller

@Controller
public class UserController {

    @Autowired
    private UserService  userService;
    @RequestMapping("/findAllUser")
    @ResponseBody
    public List<User>   findAllUser(){
        return  userService.FindAll();
    }

}

Mapper

public interface UserMapper {
    //查询所有用户
    @Select("select * from t_user")
    List<User> FindAll();
}

User

public class User implements Serializable {
    private Integer uid;
    private String uname;
    private String pwd;
}

Service

import java.util.List;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> FindAll() {
        return userMapper.FindAll();
    }
}

前台

    <script type="text/javascript">
       
          $(function () {
              $.post("findAllUser",function (result) {
                  console.log(result);
              })
          })
    </script>