SSM框架原理及使用方法

阅读量：4096 次

发布时间：2019-05-25

本文共 26163 字，大约阅读时间需要 87 分钟。

作用：

SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层

使用spring MVC负责请求的转发和视图管理

spring实现业务对象管理，mybatis作为数据对象的持久化引擎

原理：

SpringMVC：

1.客户端发送请求到DispacherServlet（分发器）

2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller

3.Controller调用业务逻辑处理后，返回ModelAndView

4.DispacherSerclet查询视图解析器，找到ModelAndView指定的视图

5.视图负责将结果显示到客户端

Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们中的类，当然也包括service dao里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字new。另外spring的aop，事务管理等等都是我们经常用到的。

Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。mybatis的操作都是围绕一个sqlSessionFactory实例展开的。mybatis通过配置文件关联到各实体类的Mapper文件，Mapper文件中配置了每个类对数据库所需进行的sql语句映射。在每次与数据库交互时，通过sqlSessionFactory拿到一个sqlSession，再执行sql命令。

使用方法：

要完成一个功能：

先写实体类entity，定义对象的属性，（可以参照数据库中表的字段来设置，数据库的设计应该在所有编码开始之前）。

写Mapper.xml（Mybatis），其中定义你的功能，对应要对数据库进行的那些操作，比如 insert、selectAll、selectByKey、delete、update等。

写Mapper.java，将Mapper.xml中的操作按照id映射成Java函数。

写Service.java，为控制层提供服务，接受控制层的参数，完成相应的功能，并返回给控制层。

写Controller.java，连接页面请求和服务层，获取页面请求的参数，通过自动装配，映射不同的URL到相应的处理函数，并获取参数，对参数进行处理，之后传给服务层。

写JSP页面调用，请求哪些参数，需要获取什么数据。

DataBase ===> Entity ===> Mapper.xml ===> Mapper. ===> Service.java ===> Controller.java ===> Jsp.

====================================================================================================================================

Spring MVC 拥有控制器，作用跟Struts类似，接收外部请求，解析参数传给服务层

Spring 容器属于协调上下文，管理对象间的依赖，提供事务机制

mybatis 属于orm持久层框架，将业务实体与数据表联合起来

Spring MVC 控制层，想当与 Struts的作用

Spring 控制反转和依赖注入创建对象交由容器管理，达到了解耦的作用

mybatis 主要用来操作数据库（数据库的增删改查）

IOC:控制反转，是一种降低对象之间耦合关系的设计思想，面试的时候最好能说出来个例子，加深理解。例子：租房子，以前租房子需要一个房子一个房子找，费时费力，然后现在加入一个房屋中介，把你需要的房型告诉中介，就可以直接选到需要的房子，中介就相当于spring容器。

AOP:面向切面编程，是面向对象开发的一种补充，它允许开发人员在不改变原来模型的基础上动态的修改模型以满足新的需求，如：动态的增加日志、安全或异常处理、事务管理、权限检查等。AOP使业务逻辑各部分间的耦合度降低，提高程序可重用性，提高开发效率。

1. IOC（Inverse of Control）：控制反转，也可以称为依赖倒置。

所谓依赖，从程序的角度看，就是比如A要调用B的方法，那么A就依赖于B，反正A要用到B，则A依赖于B。所谓倒置，你必须理解如果不倒置，会怎么着，因为A必须要有B，才可以调用B，如果不倒置，意思就是A主动获取B的实例：B b = new B()，这就是最简单的获取B实例的方法（当然还有各种设计模式可以帮助你去获得B的实例，比如工厂、Locator等等），然后你就可以调用b对象了。所以，不倒置，意味着A要主动获取B，才能使用B；到了这里，就应该明白了倒置的意思了。倒置就是A要调用B的话，A并不需要主动获取B，而是由其它人自动将B送上门来。

形象的举例就是：

通常情况下，假如你有一天在家里口渴了，要喝水，那么你可以到你小区的小卖部去，告诉他们，你需要一瓶水，然后小卖部给你一瓶水！这本来没有太大问题，关键是如果小卖部很远，那么你必须知道：从你家如何到小卖部；小卖部里是否有你需要的水；你还要考虑是否开着车去；等等等等，也许有太多的问题要考虑了。也就是说，为了一瓶水，你还可能需要依赖于车等等这些交通工具或别的工具，问题是不是变得复杂了？那么如何解决这个问题呢？

解决这个问题的方法很简单：小卖部提供送货上门服务，凡是小卖部的会员，你只要告知小卖部你需要什么，小卖部将主动把货物给你送上门来！这样一来，你只需要做两件事情，你就可以活得更加轻松自在：

第一：向小卖部注册为会员。

第二：告诉小卖部你需要什么。

这和Spring的做法很类似！Spring就是小卖部，你就是A对象，水就是B对象

第一：在Spring中声明一个类：A

第二：告诉Spring，A需要B

假设A是UserAction类，而B是UserService类

[html]
<bean id="userService" class="org.leadfar.service.UserService"/>  
<bean id="documentService" class="org.leadfar.service.DocumentService"/>  
<bean id="orgService" class="org.leadfar.service.OrgService"/>  
  
<bean id="userAction" class="org.leadfar.web.UserAction">  
     <property name="userService" ref="userService"/>  
</bean>  

在Spring这个商店（工厂）中，有很多对象/服务：userService,documentService,orgService，也有很多会员：userAction等等，声明userAction需要userService即可，Spring将通过你给它提供的通道主动把userService送上门来，因此UserAction的代码示例类似如下所示：

[java]
package org.leadfar.web;  
public class UserAction{  
     private UserService userService;  
     public String login(){  
          userService.valifyUser(xxx);  
     }  
     public void setUserService(UserService userService){  
          this.userService = userService;  
     }  
}  

在这段代码里面，你无需自己创建UserService对象（Spring作为背后无形的手，把UserService对象通过你定义的setUserService()方法把它主动送给了你，这就叫依赖注入！），当然咯，我们也可以使用注解来注入。Spring依赖注入的实现技术是：动态代理

2. AOP：即面向切面编程

面向切面编程的目标就是分离关注点。什么是关注点呢？就是你要做的事，就是关注点。假如你是个公子哥，没啥人生目标，天天就是衣来伸手，饭来张口，整天只知道玩一件事！那么，每天你一睁眼，就光想着吃完饭就去玩（你必须要做的事），但是在玩之前，你还需要穿衣服、穿鞋子、叠好被子、做饭等等等等事情，这些事情就是你的关注点，但是你只想吃饭然后玩，那么怎么办呢？这些事情通通交给别人去干。在你走到饭桌之前，有一个专门的仆人A帮你穿衣服，仆人B帮你穿鞋子，仆人C帮你叠好被子，仆人C帮你做饭，然后你就开始吃饭、去玩（这就是你一天的正事），你干完你的正事之后，回来，然后一系列仆人又开始帮你干这个干那个，然后一天就结束了！

AOP的好处就是你只需要干你的正事，其它事情别人帮你干。也许有一天，你想裸奔，不想穿衣服，那么你把仆人A解雇就是了！也许有一天，出门之前你还想带点钱，那么你再雇一个仆人D专门帮你干取钱的活！这就是AOP。每个人各司其职，灵活组合，达到一种可配置的、可插拔的程序结构。

从Spring的角度看，AOP最大的用途就在于提供了事务管理的能力。事务管理就是一个关注点，你的正事就是去访问数据库，而你不想管事务（太烦），所以，Spring在你访问数据库之前，自动帮你开启事务，当你访问数据库结束之后，自动帮你提交/回滚事务！

AOP 其实是一个“横切”技术。它可以在剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块。

持久层：DAO层（mapper）

DAO层：DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，
- DAO层的设计首先是设计DAO的接口，
- 然后在Spring的配置文件中定义此接口的实现类，
- 然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，
- DAO层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置。

业务层：Service层

Service层：Service层主要负责业务模块的逻辑应用设计。
- 首先设计接口，再设计其实现的类
- 接着再在Spring的配置文件中配置其实现的关联。这样我们就可以在应用中调用Service接口来进行业务处理。
- Service层的业务实现，具体要调用到已定义的DAO层的接口，
- 封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性，程序显得非常简洁。

表现层：Controller层（Handler层）

Controller层:Controller层负责具体的业务模块流程的控制，
- 在此层里面要调用Service层的接口来控制业务流程，
- 控制的配置也同样是在Spring的配置文件里面进行，针对具体的业务流程，会有不同的控制器，我们具体的设计过程中可以将流程进行抽象归纳，设计出可以重复利用的子单元流程模块，这样不仅使程序结构变得清晰，也大大减少了代码量。

View层

View层此层与控制层结合比较紧密，需要二者结合起来协同工发。View层主要负责前台jsp页面的表示.

各层联系

DAO层，Service层这两个层次都可以单独开发，互相的耦合度很低，完全可以独立进行，这样的一种模式在开发大项目的过程中尤其有优势

Controller，View层因为耦合度比较高，因而要结合在一起开发，但是也可以看作一个整体独立于前两个层进行开发。这样，在层与层之前我们只需要知道接口的定义，调用接口即可完成所需要的逻辑单元应用，一切显得非常清晰简单。

Service逻辑层设计
- Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层之下的，因而Service层应该既调用DAO层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。

====================================================================================================================================

最近在学习Spring+SpringMVC+MyBatis的整合。以下是参考网上的资料自己实践操作的详细步骤。

1、基本概念

1.1、Spring

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

1.2、SpringMVC

Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring MVC 分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让它们更容易进行定制。

1.3、MyBatis

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。MyBatis是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

2、开发环境搭建以及创建Maven Web项目

参看之前的博文：http://www.cnblogs.com/zyw-205520/p/4767633.html

3、SSM整合

下面主要介绍三大框架的整合，至于环境的搭建以及项目的创建，参看上面的博文。这次整合我分了2个配置文件，分别是spring-mybatis.xml，包含spring和mybatis的配置文件，还有个是spring-mvc的配置文件，此外有2个资源文件：jdbc.propertis和log4j.properties。完整目录结构如下（最后附上源码下载地址）：

使用框架的版本：

Spring 4.0.2 RELEASE

Spring MVC 4.0.2 RELEASE

MyBatis 3.2.6

3.1、Maven引入需要的JAR包

在pom.xml中引入jar包


        
     
      4.0.0
         
     
      com.javen.maven01
         
     
      maven01
         
     
      war
         
     
      0.0.1-SNAPSHOT
         
     
      maven01 Maven Webapp
         
     
      http://maven.apache.org
             
               
                
      
       4.0.2.RELEASE
                
                
      
       3.2.6
                
                
      
       1.7.7
                
      
       1.2.17
            
              
             
                  
       
        junit
                   
       
        junit
                   
       
        3.8.1
                    
                     
       
        test
               
              
                       
                
                    
       
        org.springframework
                     
       
        spring-core
                     
       
        ${spring.version}
                 
                  
                    
       
        org.springframework
                     
       
        spring-web
                     
       
        ${spring.version}
                 
                
                    
       
        org.springframework
                     
       
        spring-oxm
                     
       
        ${spring.version}
                 
                
                    
       
        org.springframework
                     
       
        spring-tx
                     
       
        ${spring.version}
                 
                  
                    
       
        org.springframework
                     
       
        spring-jdbc
                     
       
        ${spring.version}
                 
                  
                    
       
        org.springframework
                     
       
        spring-webmvc
                     
       
        ${spring.version}
                 
                
                    
       
        org.springframework
                     
       
        spring-aop
                     
       
        ${spring.version}
                 
                  
                    
       
        org.springframework
                     
       
        spring-context-support
                     
       
        ${spring.version}
                 
                  
                    
       
        org.springframework
                     
       
        spring-test
                     
       
        ${spring.version}
                 
                
                
                    
       
        org.mybatis
                     
       
        mybatis
                     
       
        ${mybatis.version}
                 
                 
                
                    
       
        org.mybatis
                     
       
        mybatis-spring
                     
       
        1.2.2
                 
                         
                
                    
       
        javax
                     
       
        javaee-api
                     
       
        7.0
                 
                         
                
                    
       
        mysql
                     
       
        mysql-connector-java
                     
       
        5.1.36
                 
                
                
                    
       
        commons-dbcp
                     
       
        commons-dbcp
                     
       
        1.2.2
                 
                        
                
                    
       
        jstl
                     
       
        jstl
                     
       
        1.2
                 
                
                
                
                    
       
        log4j
                     
       
        log4j
                     
       
        ${log4j.version}
                 
                                    
                
                    
       
        com.alibaba
                     
       
        fastjson
                     
       
        1.1.41
                 
                    
                    
       
        org.slf4j
                     
       
        slf4j-api
                     
       
        ${slf4j.version}
                 
                  
                    
       
        org.slf4j
                     
       
        slf4j-log4j12
                     
       
        ${slf4j.version}
                 
                
                
                
                    
       
        org.codehaus.jackson
                     
       
        jackson-mapper-asl
                     
       
        1.9.13
                 
                
                
                    
       
        commons-fileupload
                     
       
        commons-fileupload
                     
       
        1.3.1
                 
                
                    
       
        commons-io
                     
       
        commons-io
                     
       
        2.4
                 
                
                    
       
        commons-codec
                     
       
        commons-codec
                     
       
        1.9
                 
            
             
             
      
       maven01
              
                  
                       
        
         org.eclipse.jetty
                        
        
         jetty-maven-plugin
                        
        
         9.2.8.v20150217
                        
                            
          
          
           80
           
                             
         
          shutdown
                             
         
          9966

3.2、整合SpringMVC

3.2.1、配置spring-mvc.xml

配置里面的注释也很详细，主要是自动扫描控制器，视图模式，注解的启动这三个。


      
          
           
           
         
         
         
             
           
               
                    
                         
        
         text/html;charset=UTF-8

3.2.2、配置web.xml文件

配置的spring-mvc的Servlet就是为了完成SpringMVC+MAVEN的整合。

web.xml


      
          
     
      Archetype Created Web Application
           
          
         
           
               
      
       encodingFilter
                
      
       org.springframework.web.filter.CharacterEncodingFilter
                
      
       true
                
                    
       
        encoding
                     
       
        UTF-8
                 
            
           
               
      
       encodingFilter
                
      
       /*
            
           
          
         
           
            
           
               
      
       SpringMVC
                
      
       org.springframework.web.servlet.DispatcherServlet
                
                    
       
        contextConfigLocation
                     
       
        classpath:spring-mvc.xml
                 
                
      
       1
                
      
       true
            
           
               
      
       SpringMVC
                
                
      
       /
            
           
               
      
       /index.jsp

3.2.3、Log4j的配置

为了方便调试，一般都会使用日志来输出信息，Log4j是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件，甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。

Log4j的配置很简单，而且也是通用的，下面给出一个基本的配置，换到其他项目中也无需做多大的调整，如果想做调整或者想了解Log4j的各种配置，参看我转载的一篇博文，很详细：

下面给出配置文件目录：

log4j.properties

log4j.rootLogger=INFO,Console,File  #定义日志输出目的地为控制台  log4j.appender.Console=org.apache.log4j.ConsoleAppender  log4j.appender.Console.Target=System.out  #可以灵活地指定日志输出格式，下面一行是指定具体的格式  log4j.appender.Console.layout = org.apache.log4j.PatternLayout  log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n    #文件大小到达指定尺寸的时候产生一个新的文件  log4j.appender.File = org.apache.log4j.RollingFileAppender  #指定输出目录  log4j.appender.File.File = logs/ssm.log  #定义文件最大大小  log4j.appender.File.MaxFileSize = 10MB  # 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志  log4j.appender.File.Threshold = ALL  log4j.appender.File.layout = org.apache.log4j.PatternLayout  log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n

3.2.4、使用Jetty测试

package com.javen.model;public class User {    private Integer id;    private String userName;    private String password;    private Integer age;    public Integer getId() {        return id;    }    public void setId(Integer id) {        this.id = id;    }    public String getUserName() {        return userName;    }    public void setUserName(String userName) {        this.userName = userName == null ? null : userName.trim();    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password == null ? null : password.trim();    }    public Integer getAge() {        return age;    }    public void setAge(Integer age) {        this.age = age;    }    @Override    public String toString() {        return "User [id=" + id + ", userName=" + userName + ", password="                + password + ", age=" + age + "]";    }        }

package com.javen.controller;import javax.servlet.http.HttpServletRequest;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.stereotype.Controller;  import org.springframework.ui.Model;  import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.bind.annotation.RequestMethod;import com.javen.model.User;    @Controller  @RequestMapping("/user")  // /user/**public class UserController {      private static Logger log=LoggerFactory.getLogger(UserController.class);              // /user/test?id=1    @RequestMapping(value="/test",method=RequestMethod.GET)      public String test(HttpServletRequest request,Model model){          int userId = Integer.parseInt(request.getParameter("id"));          System.out.println("userId:"+userId);        User user=null;        if (userId==1) {             user = new User();               user.setAge(11);             user.setId(1);             user.setPassword("123");             user.setUserName("javen");        }               log.debug(user.toString());        model.addAttribute("user", user);          return "index";      }  }

在浏览器中输入：http://localhost/user/test?id=1

到此 SpringMVC+Maven 整合完毕

3.3 Spring与MyBatis的整合

取消3.2.2 web.xml中注释的代码

3.3.1、建立JDBC属性文件

jdbc.properties（文件编码修改为utf-8）

driver=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost:3306/mavenusername=rootpassword=root#定义初始连接数  initialSize=0  #定义最大连接数  maxActive=20  #定义最大空闲  maxIdle=20  #定义最小空闲  minIdle=1  #定义最长等待时间  maxWait=60000

此时的目录结构为

3.3.2、建立spring-mybatis.xml配置文件

这个文件就是用来完成spring和mybatis的整合的。这里面也没多少行配置，主要的就是自动扫描，自动注入，配置数据库。注释也很详细，大家看看就明白了。

spring-mybatis.xml

3.4、JUnit测试

经过以上步骤，我们已经完成了Spring和mybatis的整合，这样我们就可以编写一段测试代码来试试是否成功了。

3.4.1、创建测试用表

既然我们需要测试，那么我们就需要建立在数据库中建立一个测试表，这个表建的很简单，SQL语句为：

-- ------------------------------ Table structure for `user_t`-- ----------------------------DROP TABLE IF EXISTS `user_t`;CREATE TABLE `user_t` (  `id` int(11) NOT NULL AUTO_INCREMENT,  `user_name` varchar(40) NOT NULL,  `password` varchar(255) NOT NULL,  `age` int(4) NOT NULL,  PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;-- ------------------------------ Records of user_t-- ----------------------------INSERT INTO `user_t` VALUES ('1', '测试', '345', '24');INSERT INTO `user_t` VALUES ('2', 'javen', '123', '10');

3.4.2、利用MyBatis Generator自动创建代码

参考博文：

这个可根据表自动创建实体类、MyBatis映射文件以及DAO接口，当然，我习惯将生成的接口名改为IUserDao，而不是直接用它生成的UserMapper。如果不想麻烦就可以不改。完成后将文件复制到工程中。如图：

3.4.3、建立Service接口和实现类

下面给出具体的内容：

IUserService.jave

package com.javen.service;  import com.javen.model.User;    public interface IUserService {      public User getUserById(int userId);  }

UserServiceImpl.java

package com.javen.service.impl;import javax.annotation.Resource;  import org.springframework.stereotype.Service;  import com.javen.dao.IUserDao;import com.javen.model.User;import com.javen.service.IUserService;    @Service("userService")  public class UserServiceImpl implements IUserService {      @Resource      private IUserDao userDao;          public User getUserById(int userId) {          // TODO Auto-generated method stub          return this.userDao.selectByPrimaryKey(userId);      }    }

3.4.4、建立测试类

测试类在src/test/java中建立，下面测试类中注释掉的部分是不使用Spring时，一般情况下的一种测试方法；如果使用了Spring那么就可以使用注解的方式来引入配置文件和类，然后再将service接口对象注入，就可以进行测试了。

如果测试成功，表示Spring和Mybatis已经整合成功了。输出信息使用的是Log4j打印到控制台。

package com.javen.testmybatis;import javax.annotation.Resource;  import org.apache.log4j.Logger;  import org.junit.Test;import org.junit.runner.RunWith;import org.springframework.test.context.ContextConfiguration;  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  import com.alibaba.fastjson.JSON;  import com.javen.model.User;import com.javen.service.IUserService;  @RunWith(SpringJUnit4ClassRunner.class)     //表示继承了SpringJUnit4ClassRunner类  @ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})    public class TestMyBatis {      private static Logger logger = Logger.getLogger(TestMyBatis.class);  //  private ApplicationContext ac = null;      @Resource      private IUserService userService = null;    //  @Before  //  public void before() {  //      ac = new ClassPathXmlApplicationContext("applicationContext.xml");  //      userService = (IUserService) ac.getBean("userService");  //  }        @Test      public void test1() {          User user = userService.getUserById(1);          // System.out.println(user.getUserName());          // logger.info("值："+user.getUserName());          logger.info(JSON.toJSONString(user));      }  }

测试结果

3.4.5、建立UserController类

UserController.java 控制器

package com.javen.controller;import java.io.File;import java.io.IOException;import java.util.Map;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import org.apache.commons.io.FileUtils;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.http.HttpStatus;import org.springframework.http.ResponseEntity;import org.springframework.stereotype.Controller;  import org.springframework.ui.Model;  import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;  import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.ResponseBody;import org.springframework.web.multipart.MultipartFile;import com.javen.model.User;import com.javen.service.IUserService;    @Controller  @RequestMapping("/user")  // /user/**public class UserController {      private static Logger log=LoggerFactory.getLogger(UserController.class);     @Resource       private IUserService userService;             // /user/test?id=1    @RequestMapping(value="/test",method=RequestMethod.GET)      public String test(HttpServletRequest request,Model model){          int userId = Integer.parseInt(request.getParameter("id"));          System.out.println("userId:"+userId);        User user=null;        if (userId==1) {             user = new User();               user.setAge(11);             user.setId(1);             user.setPassword("123");             user.setUserName("javen");        }               log.debug(user.toString());        model.addAttribute("user", user);          return "index";      }              // /user/showUser?id=1    @RequestMapping(value="/showUser",method=RequestMethod.GET)      public String toIndex(HttpServletRequest request,Model model){          int userId = Integer.parseInt(request.getParameter("id"));          System.out.println("userId:"+userId);        User user = this.userService.getUserById(userId);          log.debug(user.toString());        model.addAttribute("user", user);          return "showUser";      }       // /user/showUser2?id=1    @RequestMapping(value="/showUser2",method=RequestMethod.GET)      public String toIndex2(@RequestParam("id") String id,Model model){          int userId = Integer.parseInt(id);          System.out.println("userId:"+userId);        User user = this.userService.getUserById(userId);          log.debug(user.toString());        model.addAttribute("user", user);          return "showUser";      }              // /user/showUser3/{id}    @RequestMapping(value="/showUser3/{id}",method=RequestMethod.GET)      public String toIndex3(@PathVariable("id")String id,Map
    
      model){          int userId = Integer.parseInt(id);          System.out.println("userId:"+userId);        User user = this.userService.getUserById(userId);          log.debug(user.toString());        model.put("user", user);          return "showUser";      }       // /user/{id}    @RequestMapping(value="/{id}",method=RequestMethod.GET)      public @ResponseBody User getUserInJson(@PathVariable String id,Map
     
       model){          int userId = Integer.parseInt(id);          System.out.println("userId:"+userId);        User user = this.userService.getUserById(userId);          log.info(user.toString());        return user;      }          // /user/{id}    @RequestMapping(value="/jsontype/{id}",method=RequestMethod.GET)      public ResponseEntity
      
         getUserInJson2(@PathVariable String id,Map
       
         model){          int userId = Integer.parseInt(id);          System.out.println("userId:"+userId);        User user = this.userService.getUserById(userId);          log.info(user.toString());        return new ResponseEntity
        
         (user,HttpStatus.OK);      }         //文件上传、    @RequestMapping(value="/upload")    public String showUploadPage(){        return "user_admin/file";    }        @RequestMapping(value="/doUpload",method=RequestMethod.POST)    public String doUploadFile(@RequestParam("file")MultipartFile file) throws IOException{        if (!file.isEmpty()) {            log.info("Process file:{}",file.getOriginalFilename());        }        FileUtils.copyInputStreamToFile(file.getInputStream(), new File("E:\\",System.currentTimeMillis()+file.getOriginalFilename()));        return "succes";    }}

3.4.6、新建jsp页面

file.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"    pageEncoding="utf-8"%>
    Insert title here    上传文件

index.jsp

Hello World!

showUser.jsp

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>              测试                  ${user.userName}

至此，完成Spring+SpingMVC+mybatis这三大框架整合完成。

3.4.7、部署项目

输入地址：http://localhost/user/jsontype/2

项目下载地址：

参考博客：http://blog.csdn.net/gebitan505/article/details/44455235

你可能感兴趣的文章

Java虚拟机工具之堆栈跟踪工具jstack定位死循环

查看>>

第N个偶斐波那契数

查看>>

Intellj Idea 16添加Maven新建模块

Spring动态代理用JDK还是用CGLIB？

查看>>

负载均衡常用算法

查看>>

分布式服务器中的Session（会话）管理

Different Ways to Add Parentheses

查看>>

Spring中Bean的作用域（Scope）

查看>>

Redis持久化方法

查看>>