软件开发中的MVC设计模式

　　软件开发的目标是减小耦合,让模块之前关系清晰.

　　MVC模式在软件开发中经常和ORM模式一起应用,主要作用是将(数据抽象,数据实体传输和前台数据展示)分层,这样前台,后台,数据库三层分离,减小耦合.

　　

　　1)Model　　:　　负责抽象并存储数据库数据

　　2)Controller :　　负责数据的转化和传输

　　3)View　　  :　　负责展示数据

　　注意　框架的应用使软件开发变得更有章可循,更规范化,软件开发的每个职责都落到了具体的模块中去

　　　　　　ORM框架　:　将数据库数据封装存储至Model类中

　　　　　　MVC框架　:　前台数据与实体数据的互为转化

　　　　　　开发者　　 :　配置框架,编写业务代码,前台数据展示页面

SpringMVC工作流

　　SpringMVC是建立在Spring framework之上的一个MVC框架,主要的组件有前端控制器、处理器映射器、处理器适配器、视图解析器.

　　　

　　1.SpringMVC的原理就如上图所展示的,客户端发来HTTP请求,

　　2.前端控制器作为一个顶层执行者获取请求,

　　3.返回一个执行链HandlerExecutionChain{HandlerInterceptor1,HandlerInterceptor2,Handler},

　　4.前端控制器请求映射器查询对应的处理器适配器,

　　5.处理器适配器代理执行处理器,

　　6.处理器响应处理,返回一个ModelAndView,

　　7.适配器返回一个ModelAndView至前端控制器

　　8.前端控制器请求视图解析器执行解析,

　　9.解析器返回一个未经渲染的视图

　　10.前端控制器渲染视图,将模型数据存于request域

　　11.视图发至浏览器进行渲染呈现

　　注意,上图分为Model,View,Controller等模块,其中Model里面可封装许多逻辑,这一部分未在步骤上进行说明.

对比Struts2

　　1.SpringMVC的前端入口是一个名为DispatchServlet的servlet,Struts2是一个Filter过滤器;

　　2.SpringMVC基于方法进行开发(一个url对应一个方法),请求参数传递到方法的形参,可以设计为单例或者多例模式,Struts2是基于类开发,传递的参数通过类的属性进行传递;

　　3.Struts2采用值栈存储请求和响应,通过OGNL存取数据,SpringMVC通过参数解析器将request内容进行解析,并给方法形参赋值,将数据和视图封装成一个ModelAndView对象,最后将ModelAndView的数据传入request中以及视图渲染,JSP使用JSTL来进行取值操作;

组件职责描述

1.前端控制器DispatcherServlet（无需开发者开发）

作用 : 接收请求，响应结果，相当于转发器，中央处理器.

　　有了DispatcherServlet减少了其它组件之间的耦合度.

类位置　　org.springframework.web.servlet.DispatcherServlet.class

配置文件  /org/springframework/web/servlet/DispatcherServlet.properties

  1. <servlet>
  2. <servlet-name>springmvc</servlet-name>
  3. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  4. <init-param>
  5. <param-name>contextConfigLocation</param-name>
  6. <param-value>classpath:springmvc.xml</param-value>
  7. </init-param>
  8. <load-on-startup>1</load-on-startup>
  9. </servlet>
  10. <servlet-mapping>
  11. <servlet-name>springmvc</servlet-name>
  12. <url-pattern>*.action</url-pattern>
  13. </servlet-mapping>

配置方式

2.处理器映射器HandlerMapping(无需开发者开发)

　　　　作用：根据请求的url查找Handler和Interceptor拦截器,

　　　　　　将它们封装在HandlerExecutionChain 对象中给前端控制器返回.

类位置　　org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping.class

  1. <!—beanName Url映射器 -->
  2. <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

配置方式

　　　　    org.springframework.web.servlet.handler.SimpleUrlHandlerMapping.class

  1. <!—
  2.  
  3. 简单url映射
  4. simpleUrlHandlerMapping是BeanNameUrlHandlerMapping的增强版本，它可以将url和处理器bean的id进行统一映射配置
  5.  -->
  6.     <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
  7.         <property name="mappings">
  8.             <props>
  9.                 <prop key="/items1.action">controller的bean id</prop>
  10.                 <prop key="/items2.action">controller的bean id</prop>
  11.             </props>
  12.         </property>
  13.     </bean>

配置方式

　　　　　org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.class

  1. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

配置方式

3.处理器适配器HandlerAdapter(无需开发者开发)

作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler

　　　　类位置　　org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter.class

  1. <!--
  2. 所有实现了org.springframework.web.servlet.mvc.Controller 接口的Bean通过此适配器进行适配、执行.
  3.  -->
  4.  
  5. <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

配置方式

　　　　　　　　　org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter.class

  1. <!--
  2. 所有实现了org.springframework.web.HttpRequestHandler 接口的Bean通过此适配器进行适配、执行.
  3. -->
  4.  
  5. <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"/>

配置方式

　　　　　　　　　org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.class

  1. <!--
  2.     注解时使用的Adapter,配合注解映射器一起使用
  3.  -->
  4.  
  5. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

配置方式

4.处理器Handler(需开发者开发)

注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler

　　　　非注解方式

  1. package com.harry.controller;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8.  
  9. import org.springframework.web.servlet.ModelAndView;
  10. import org.springframework.web.servlet.mvc.Controller;
  11.  
  12. import com.harry.entity.Items;
  13.  
  14. /***
  15.  * @author harry
  16.  *    用于处理页面请求,
  17.  *    数据来源是通过数据库ORM映射至实体类来获取,
  18.  *    这里使用静态获取数据进行简单演示.
  19.  */
  20. public class ItemList_1 implements Controller {
  21.  
  22.     @Override
  23.     public ModelAndView handleRequest(HttpServletRequest request,
  24.             HttpServletResponse response) throws Exception {
  25.  
  26.         //调用service查找 数据库，查询商品列表，这里使用静态数据模拟
  27.         List<Items> itemsList = new ArrayList<Items>();
  28.         //向list中填充静态数据
  29.  
  30.         Items items_1 = new Items();
  31.         items_1.setName("联想笔记本");
  32.         items_1.setPrice(6000f);
  33.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
  34.  
  35.         Items items_2 = new Items();
  36.         items_2.setName("苹果手机");
  37.         items_2.setPrice(5000f);
  38.         items_2.setDetail("iphone6苹果手机！");
  39.  
  40.         itemsList.add(items_1);
  41.         itemsList.add(items_2);
  42.  
  43.         //返回ModelAndView
  44.         ModelAndView modelAndView =  new ModelAndView();
  45.         //相当 于request的setAttribut，在jsp页面中通过itemsList取数据
  46.         modelAndView.addObject("itemsList", itemsList);
  47.  
  48.         //指定视图
  49.         modelAndView.setViewName("Items/itemList");
  50.  
  51.         return modelAndView;
  52.     }
  53.  
  54. }

ItemList_1.java

　　　　注解方式

  1. @Controller
  2. public class ItemList_2 {
  3. /*
  4.     RequestMappingHandlerMapping将对类中标记@ResquestMapping的方法进行映射，根据ResquestMapping定义的url匹配ResquestMapping标记的方法，匹配成功返回HandlerMethod对象给前端控制器，HandlerMethod对象中封装url对应的方法Method
  5. */
  6.     @RequestMapping("/queryItem.action")
  7.     public ModelAndView queryItem() {
  8.         // 商品列表
  9.         List<Items> itemsList = new ArrayList<Items>();
  10.  
  11.         Items items_1 = new Items();
  12.         items_1.setName("联想笔记本");
  13.         items_1.setPrice(6000f);
  14.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
  15.  
  16.         Items items_2 = new Items();
  17.         items_2.setName("苹果手机");
  18.         items_2.setPrice(5000f);
  19.         items_2.setDetail("iphone6苹果手机！");
  20.  
  21.         itemsList.add(items_1);
  22.         itemsList.add(items_2);
  23.  
  24.         // 创建modelAndView准备填充数据、设置视图
  25.         ModelAndView modelAndView = new ModelAndView();
  26.  
  27.         // 填充数据
  28.         modelAndView.addObject("itemsList", itemsList);
  29.         // 视图
  30.         modelAndView.setViewName("order/itemsList");
  31.  
  32.         return modelAndView;
  33.     }
  34.  
  35. }

ItemList_2.java

注意,注解方式应使用注解包扫描<context:component-scan base-package="com.harry.controller"/>,

包扫描可以扫描到@Bean,@Controller,@Service,@Repository等注解类.

RequestMappingHandlerMapping,HttpRequestHandlerAdapter(<mvc:annotation-driven>可自动加载这两个类)

5.视图解析器View resolver(无需开发者开发)

作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）

类位置　　org.springframework.web.servlet.view.InternalResourceViewResolver.class

  1. <!-- ViewResolver配置 -->
  2. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  3.     <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
  4.     <property name="prefix" value="/WEB-INF/jsp/"/>
  5.     <property name="suffix" value=".jsp"/>
  6. </bean>

配置方式

6.视图View(需开发者开发)

View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf...）　

案例驱动开发

　　springmvc的开发,需要配置上述工作流中的组件,入门程序紧接着框架应用：Mybatis - 开发详述的案例进行开发,

　　1.备份数据库,实体类

  1. -- MySQL dump 10.13  Distrib 5.7.18, for Linux (x86_64)
  2. --
  3. -- Host: localhost    Database: mybatis
  4. -- ------------------------------------------------------
  5. -- Server version    5.7.18-0ubuntu0.16.04.1
  6.  
  7. /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
  8. /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
  9. /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
  10. /*!40101 SET NAMES utf8 */;
  11. /*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
  12. /*!40103 SET TIME_ZONE='+00:00' */;
  13. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
  14. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
  15. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
  16. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
  17.  
  18. --
  19. -- Table structure for table `items`
  20. --
  21.  
  22. DROP TABLE IF EXISTS `items`;
  23. /*!40101 SET @saved_cs_client     = @@character_set_client */;
  24. /*!40101 SET character_set_client = utf8 */;
  25. CREATE TABLE `items` (
  26.   `id` int(11) NOT NULL AUTO_INCREMENT,
  27.   `name` varchar(32) NOT NULL COMMENT '商品名称',
  28.   `price` float(10,1) NOT NULL COMMENT '商品定价',
  29.   `detail` text COMMENT '商品描述',
  30.   `pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
  31.   `createtime` datetime NOT NULL COMMENT '生产日期',
  32.   PRIMARY KEY (`id`)
  33. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
  34. /*!40101 SET character_set_client = @saved_cs_client */;
  35.  
  36. --
  37. -- Dumping data for table `items`
  38. --
  39.  
  40. LOCK TABLES `items` WRITE;
  41. /*!40000 ALTER TABLE `items` DISABLE KEYS */;
  42. INSERT INTO `items` VALUES (1,'台式机',3000.0,'该电脑质量非常好！！！！',NULL,'2015-02-03 13:22:53'),(2,'笔记本',6000.0,'笔记本性能好，质量好！！！！！',NULL,'2015-02-09 13:22:57'),(3,'背包',200.0,'名牌背包，容量大质量好！！！！',NULL,'2015-02-06 13:23:02');
  43. /*!40000 ALTER TABLE `items` ENABLE KEYS */;
  44. UNLOCK TABLES;
  45.  
  46. --
  47. -- Table structure for table `orderdetail`
  48. --
  49.  
  50. DROP TABLE IF EXISTS `orderdetail`;
  51. /*!40101 SET @saved_cs_client     = @@character_set_client */;
  52. /*!40101 SET character_set_client = utf8 */;
  53. CREATE TABLE `orderdetail` (
  54.   `id` int(11) NOT NULL AUTO_INCREMENT,
  55.   `orders_id` int(11) NOT NULL COMMENT '订单id',
  56.   `items_id` int(11) NOT NULL COMMENT '商品id',
  57.   `items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',
  58.   PRIMARY KEY (`id`),
  59.   KEY `FK_orderdetail_1` (`orders_id`),
  60.   KEY `FK_orderdetail_2` (`items_id`),
  61.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  62.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
  63. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
  64. /*!40101 SET character_set_client = @saved_cs_client */;
  65.  
  66. --
  67. -- Dumping data for table `orderdetail`
  68. --
  69.  
  70. LOCK TABLES `orderdetail` WRITE;
  71. /*!40000 ALTER TABLE `orderdetail` DISABLE KEYS */;
  72. INSERT INTO `orderdetail` VALUES (1,3,1,1),(2,3,2,3),(3,4,3,4),(4,4,2,3);
  73. /*!40000 ALTER TABLE `orderdetail` ENABLE KEYS */;
  74. UNLOCK TABLES;
  75.  
  76. --
  77. -- Table structure for table `orders`
  78. --
  79.  
  80. DROP TABLE IF EXISTS `orders`;
  81. /*!40101 SET @saved_cs_client     = @@character_set_client */;
  82. /*!40101 SET character_set_client = utf8 */;
  83. CREATE TABLE `orders` (
  84.   `id` int(11) NOT NULL AUTO_INCREMENT,
  85.   `user_id` int(11) NOT NULL COMMENT '下单用户id',
  86.   `number` varchar(32) NOT NULL COMMENT '订单号',
  87.   `createtime` datetime NOT NULL COMMENT '创建订单时间',
  88.   `note` varchar(100) DEFAULT NULL COMMENT '备注',
  89.   PRIMARY KEY (`id`),
  90.   KEY `FK_orders_1` (`user_id`),
  91.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
  92. ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
  93. /*!40101 SET character_set_client = @saved_cs_client */;
  94.  
  95. --
  96. -- Dumping data for table `orders`
  97. --
  98.  
  99. LOCK TABLES `orders` WRITE;
  100. /*!40000 ALTER TABLE `orders` DISABLE KEYS */;
  101. INSERT INTO `orders` VALUES (3,1,'','2015-02-04 13:22:35',NULL),(4,1,'','2015-02-03 13:22:41',NULL),(5,10,'','2015-02-12 16:13:23',NULL);
  102. /*!40000 ALTER TABLE `orders` ENABLE KEYS */;
  103. UNLOCK TABLES;
  104.  
  105. --
  106. -- Table structure for table `user`
  107. --
  108.  
  109. DROP TABLE IF EXISTS `user`;
  110. /*!40101 SET @saved_cs_client     = @@character_set_client */;
  111. /*!40101 SET character_set_client = utf8 */;
  112. CREATE TABLE `user` (
  113.   `id` int(11) NOT NULL AUTO_INCREMENT,
  114.   `username` varchar(32) NOT NULL COMMENT '用户名称',
  115.   `birthday` date DEFAULT NULL COMMENT '生日',
  116.   `sex` char(1) DEFAULT NULL COMMENT '性别',
  117.   `address` varchar(256) DEFAULT NULL COMMENT '地址',
  118.   PRIMARY KEY (`id`)
  119. ) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;
  120. /*!40101 SET character_set_client = @saved_cs_client */;
  121.  
  122. --
  123. -- Dumping data for table `user`
  124. --
  125.  
  126. LOCK TABLES `user` WRITE;
  127. /*!40000 ALTER TABLE `user` DISABLE KEYS */;
  128. INSERT INTO `user` VALUES (1,'王五',NULL,'',NULL),(10,'张三','2014-07-10','','北京市'),(16,'张小明',NULL,'','河南郑州'),(22,'陈小明',NULL,'','河南郑州'),(24,'张三丰',NULL,'','河南郑州'),(25,'陈小明',NULL,'','河南郑州'),(26,'王五',NULL,NULL,NULL);
  129. /*!40000 ALTER TABLE `user` ENABLE KEYS */;
  130. UNLOCK TABLES;
  131. /*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
  132.  
  133. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
  134. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
  135. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
  136. /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
  137. /*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
  138. /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
  139. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
  140.  
  141. -- Dump completed on 2017-10-10  0:00:04

sql

  1. package com.harry.entity;
  2.  
  3. import java.util.Date;
  4.  
  5. public class Items {
  6.     private Integer id;
  7.  
  8.     private String name;
  9.  
  10.     private Float price;
  11.  
  12.     private String pic;
  13.  
  14.     private Date createtime;
  15.  
  16.     private String detail;
  17.  
  18.     public Integer getId() {
  19.         return id;
  20.     }
  21.  
  22.     public void setId(Integer id) {
  23.         this.id = id;
  24.     }
  25.  
  26.     public String getName() {
  27.         return name;
  28.     }
  29.  
  30.     public void setName(String name) {
  31.         this.name = name == null ? null : name.trim();
  32.     }
  33.  
  34.     public Float getPrice() {
  35.         return price;
  36.     }
  37.  
  38.     public void setPrice(Float price) {
  39.         this.price = price;
  40.     }
  41.  
  42.     public String getPic() {
  43.         return pic;
  44.     }
  45.  
  46.     public void setPic(String pic) {
  47.         this.pic = pic == null ? null : pic.trim();
  48.     }
  49.  
  50.     public Date getCreatetime() {
  51.         return createtime;
  52.     }
  53.  
  54.     public void setCreatetime(Date createtime) {
  55.         this.createtime = createtime;
  56.     }
  57.  
  58.     public String getDetail() {
  59.         return detail;
  60.     }
  61.  
  62.     public void setDetail(String detail) {
  63.         this.detail = detail == null ? null : detail.trim();
  64.     }
  65. }

Items.java

  1. package com.harry.entity;
  2.  
  3. import java.util.Date;
  4. import java.util.List;
  5.  
  6. public class Orders {
  7.     private Integer id;
  8.  
  9.     private Integer userId;
  10.  
  11.     private String number;
  12.  
  13.     private Date createtime;
  14.  
  15.     private String note;
  16.  
  17.     //用户信息
  18.     private User user;
  19.  
  20.     //订单明细
  21.     private List<Orderdetail> orderdetails;
  22.  
  23.     public Integer getId() {
  24.         return id;
  25.     }
  26.  
  27.     public void setId(Integer id) {
  28.         this.id = id;
  29.     }
  30.  
  31.     public Integer getUserId() {
  32.         return userId;
  33.     }
  34.  
  35.     public void setUserId(Integer userId) {
  36.         this.userId = userId;
  37.     }
  38.  
  39.     public String getNumber() {
  40.         return number;
  41.     }
  42.  
  43.     public void setNumber(String number) {
  44.         this.number = number == null ? null : number.trim();
  45.     }
  46.  
  47.     public Date getCreatetime() {
  48.         return createtime;
  49.     }
  50.  
  51.     public void setCreatetime(Date createtime) {
  52.         this.createtime = createtime;
  53.     }
  54.  
  55.     public String getNote() {
  56.         return note;
  57.     }
  58.  
  59.     public void setNote(String note) {
  60.         this.note = note == null ? null : note.trim();
  61.     }
  62.  
  63.     public User getUser() {
  64.         return user;
  65.     }
  66.  
  67.     public void setUser(User user) {
  68.         this.user = user;
  69.     }
  70.  
  71.     public List<Orderdetail> getOrderdetails() {
  72.         return orderdetails;
  73.     }
  74.  
  75.     public void setOrderdetails(List<Orderdetail> orderdetails) {
  76.         this.orderdetails = orderdetails;
  77.     }
  78.  
  79.     @Override
  80.     public String toString() {
  81.         return "Orders [id=" + id + ", userId=" + userId + ", number=" + number + ", createtime=" + createtime
  82.                 + ", note=" + note + ", user=" + user + ", orderdetails=" + orderdetails + "]";
  83.     }
  84.  
  85. }

Orders.java

  1. package com.harry.entity;
  2.  
  3. public class Orderdetail {
  4.     private Integer id;
  5.  
  6.     private Integer ordersId;
  7.  
  8.     private Integer itemsId;
  9.  
  10.     private Integer itemsNum;
  11.  
  12.     //明细对应的商品信息
  13.     private Items items;
  14.  
  15.     public Integer getId() {
  16.         return id;
  17.     }
  18.  
  19.     public void setId(Integer id) {
  20.         this.id = id;
  21.     }
  22.  
  23.     public Integer getOrdersId() {
  24.         return ordersId;
  25.     }
  26.  
  27.     public void setOrdersId(Integer ordersId) {
  28.         this.ordersId = ordersId;
  29.     }
  30.  
  31.     public Integer getItemsId() {
  32.         return itemsId;
  33.     }
  34.  
  35.     public void setItemsId(Integer itemsId) {
  36.         this.itemsId = itemsId;
  37.     }
  38.  
  39.     public Integer getItemsNum() {
  40.         return itemsNum;
  41.     }
  42.  
  43.     public void setItemsNum(Integer itemsNum) {
  44.         this.itemsNum = itemsNum;
  45.     }
  46.  
  47.     public Items getItems() {
  48.         return items;
  49.     }
  50.  
  51.     public void setItems(Items items) {
  52.         this.items = items;
  53.     }
  54.  
  55.     @Override
  56.     public String toString() {
  57.         return "Orderdetail [id=" + id + ", ordersId=" + ordersId
  58.                 + ", itemsId=" + itemsId + ", itemsNum=" + itemsNum + "]";
  59.     }
  60.  
  61. }

Orderdetail.java

  1. package com.harry.entity;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Date;
  5. import java.util.List;
  6.  
  7. @SuppressWarnings("serial")
  8. public class User implements Serializable {
  9.  
  10.     //属性名和数据库表的字段对应
  11.     private int id;
  12.     private String username;// 用户姓名
  13.     private String sex;// 性别
  14.     private Date birthday;// 生日
  15.     private String address;// 地址
  16.  
  17.     //用户创建的订单列表
  18.     private List<Orders> ordersList;
  19.     public int getId() {
  20.         return id;
  21.     }
  22.     public void setId(int id) {
  23.         this.id = id;
  24.     }
  25.     public String getUsername() {
  26.         return username;
  27.     }
  28.     public void setUsername(String username) {
  29.         this.username = username;
  30.     }
  31.     public String getSex() {
  32.         return sex;
  33.     }
  34.     public void setSex(String sex) {
  35.         this.sex = sex;
  36.     }
  37.     public Date getBirthday() {
  38.         return birthday;
  39.     }
  40.     public void setBirthday(Date birthday) {
  41.         this.birthday = birthday;
  42.     }
  43.     public String getAddress() {
  44.         return address;
  45.     }
  46.     public void setAddress(String address) {
  47.         this.address = address;
  48.     }
  49.     @Override
  50.     public String toString() {
  51.         return "User [id=" + id + ", username=" + username + ", sex=" + sex
  52.                 + ", birthday=" + birthday + ", address=" + address + "]";
  53.     }
  54.     public List<Orders> getOrdersList() {
  55.         return ordersList;
  56.     }
  57.     public void setOrdersList(List<Orders> ordersList) {
  58.         this.ordersList = ordersList;
  59.     }
  60.  
  61. }

User.java

　　2.导入spring ioc, aop, mvc, log4j...的jar包,这里使用maven　

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd
  3.    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  4.    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  5.         http://www.springframework.org/schema/cache http://www.springframework.org/schema/jdbc/spring-cache.xsd
  6.         ">
  7.   <modelVersion>4.0.0</modelVersion>
  8.   <groupId>com.harry</groupId>
  9.   <artifactId>harry-ssm</artifactId>
  10.   <packaging>war</packaging>
  11.   <version>0.0.1-SNAPSHOT</version>
  12.   <name>harry-ssm Maven Webapp</name>
  13.   <url>http://maven.apache.org</url>
  14.   <dependencies>
  15.   <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  16. <dependency>
  17.     <groupId>org.mybatis</groupId>
  18.     <artifactId>mybatis</artifactId>
  19.     <version>3.4.1</version>
  20. </dependency>
  21. <!-- https://mvnrepository.com/artifact/log4j/log4j -->
  22. <dependency>
  23.     <groupId>log4j</groupId>
  24.     <artifactId>log4j</artifactId>
  25.     <version>1.2.17</version>
  26. </dependency>
  27.  
  28.   <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
  29. <dependency>
  30.     <groupId>org.springframework</groupId>
  31.     <artifactId>spring-core</artifactId>
  32.     <version>4.3.11.RELEASE</version>
  33. </dependency>
  34. <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
  35. <dependency>
  36.     <groupId>org.springframework</groupId>
  37.     <artifactId>spring-aop</artifactId>
  38.     <version>4.3.11.RELEASE</version>
  39. </dependency>
  40. <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
  41. <dependency>
  42.     <groupId>org.springframework</groupId>
  43.     <artifactId>spring-webmvc</artifactId>
  44.     <version>4.3.11.RELEASE</version>
  45. </dependency>
  46.  
  47.     <!-- https://mvnrepository.com/artifact/junit/junit -->
  48. <dependency>
  49.     <groupId>junit</groupId>
  50.     <artifactId>junit</artifactId>
  51.     <version>4.12</version>
  52.     <scope>test</scope>
  53. </dependency>
  54. <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  55. <dependency>
  56.     <groupId>mysql</groupId>
  57.     <artifactId>mysql-connector-java</artifactId>
  58.     <version>5.1.40</version>
  59. </dependency>
  60.  
  61. <!-- https://mvnrepository.com/artifact/taglibs/standard -->
  62. <dependency>
  63.     <groupId>taglibs</groupId>
  64.     <artifactId>standard</artifactId>
  65.     <version>1.1.2</version>
  66. </dependency>
  67.  
  68. <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
  69. <dependency>
  70.     <groupId>javax.servlet</groupId>
  71.     <artifactId>jstl</artifactId>
  72.     <version>1.2</version>
  73. </dependency>
  74.  
  75.   </dependencies>
  76.   <build>
  77.     <finalName>harry-ssm</finalName>
  78.   </build>
  79. </project>

pom.xml　　

　　3.配置前端控制器,springmvc的入口组件

  1. <!--
  2. contextConfigLocation指定springmvc的主配置文件地址,如不指定则默认为WEB-INF/[DispatcherServlet 的Servlet 名字]-servlet.xml
  3.  
  4. <load-on-startup>1</load-on-startup> 服务器启动时创建
  5.  
  6. <url-pattern>*.action</url-pattern> 拦截地址指明所有.action结尾的地址
  7.  -->
  8.  
  9. <servlet>
  10. <servlet-name>springmvc</servlet-name>
  11. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  12. <init-param>
  13. <param-name>contextConfigLocation</param-name>
  14. <param-value>classpath:springmvc.xml</param-value>
  15. </init-param>
  16. <load-on-startup>1</load-on-startup>
  17. </servlet>
  18. <servlet-mapping>
  19. <servlet-name>springmvc</servlet-name>
  20. <url-pattern>*.action</url-pattern>
  21. </servlet-mapping>

web.xml

　　4.配置处理器适配器

  1. <!--
  2. 配置处理器适配器:简单处理器适配器
  3. 所有实现了org.springframework.web.servlet.mvc.Controller 接口的Bean作为Springmvc的后端控制器。
  4. -->
  5. <bean        class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

springmvc.xml

　　5.配置处理器

  1. package com.harry.controller;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8.  
  9. import org.springframework.web.servlet.ModelAndView;
  10. import org.springframework.web.servlet.mvc.Controller;
  11.  
  12. import com.harry.entity.Items;
  13.  
  14. /***
  15.  * @author harry
  16.  *    用于处理页面请求,
  17.  *    数据来源是通过数据库ORM映射至实体类来获取,
  18.  *    这里使用静态获取数据进行简单演示.
  19.  */
  20. public class ItemList_1 implements Controller {
  21.  
  22.     @Override
  23.     public ModelAndView handleRequest(HttpServletRequest request,
  24.             HttpServletResponse response) throws Exception {
  25.  
  26.         //调用service查找 数据库，查询商品列表，这里使用静态数据模拟
  27.         List<Items> itemsList = new ArrayList<Items>();
  28.         //向list中填充静态数据
  29.  
  30.         Items items_1 = new Items();
  31.         items_1.setName("联想笔记本");
  32.         items_1.setPrice(6000f);
  33.         items_1.setDetail("ThinkPad T430 联想笔记本电脑！");
  34.  
  35.         Items items_2 = new Items();
  36.         items_2.setName("苹果手机");
  37.         items_2.setPrice(5000f);
  38.         items_2.setDetail("iphone6苹果手机！");
  39.  
  40.         itemsList.add(items_1);
  41.         itemsList.add(items_2);
  42.  
  43.         //返回ModelAndView
  44.         ModelAndView modelAndView =  new ModelAndView();
  45.         //相当 于request的setAttribut，在jsp页面中通过itemsList取数据
  46.         modelAndView.addObject("itemsList", itemsList);
  47.  
  48.         //指定视图
  49.         modelAndView.setViewName("Items/itemList");
  50.  
  51.         return modelAndView;
  52.     }
  53.  
  54. }

ItemList_1.java

  1. <!-- controller配置 -->
  2.     <bean name="/items1.action" id="itemList1"
  3. class="cn.itcast.springmvc.controller.first.ItemList1"/>

springmvc.xml

　　6.配置处理器映射器

  1. <!-- 处理器映射器 -->
  2.     <!-- 根据bean的name进行查找Handler 将action的url配置在bean的name中 -->
  3.     <bean
  4.         class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

springmvc.xml

　　7.配置视图解析器

  1. <!--
  2. ViewResolver配置
  3. JstlView 指视图使用jstl类库支持
  4. prefix,前缀
  5. suffix,后缀
  6. -->
  7. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  8.     <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
  9.     <property name="prefix" value="/WEB-INF/jsp/"/>
  10.     <property name="suffix" value=".jsp"/>
  11. </bean>

springmvc.xml

　　8.编写视图

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <%@ page isELIgnored ="false" %>
  4. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  5. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
  6.  
  7. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  8. <html>
  9. <head>
  10. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  11. <title>查询商品列表</title>
  12. </head>
  13. <body>
  14. 商品列表：
  15. <table width="100%" border=1>
  16. <tr>
  17.     <td>商品名称</td>
  18.     <td>商品价格</td>
  19.     <td>商品描述</td>
  20. </tr>
  21. <c:forEach items="${itemsList }" var="item">
  22. <tr>
  23.     <td>${item.name}</td>
  24.     <td>${item.price}</td>
  25.     <td>${item.detail}</td>
  26. </tr>
  27. </c:forEach>
  28.  
  29. </table>
  30. </body>
  31. </html>

itemList.jsp

　　9.访问http://localhost:8080/harry-ssm/items1.action

　　　　

源码工作流

　　描述的工作流与上面画的图一致,只不过这次使用源码来进行流程分析.

　　1.读取context中的配置,初始化各大组件

　　

　　2.客户端发来请求,DispatchServlet接收请求,触发doService方法,doService方法调用doDispatch方法

　　

　　

　　3.doDispatch调用getHandler获取Handler,调用getHandlerAdapter获取Adapter

　　

　　

　　4.getHandler通过HandlerMapping对象返回HandlerExecutionChain

　　

　　5.从HandlerExecutionChain中获取Handler并交由HandlerAdapter执行

　　

　　6.获取的ModelAndView对象,调用render方法渲染　　

　　

　　7.render方法通过调用视图解析器来获取视图

　　

　　

　　8.DispatchServlet渲染视图,将Model数据放在request域中

　　

　　9.客户端读取响应

整合SSM

　　Spring整合Mybatis这个ORM框架已经在 框架应用：Mybatis  - 开发详述 整合过了,现在三个框架进行整合.

　　需要完成的工作其实就是处理这关系线:

　　　　User　<-->　View　<-->　Action　<-->　Service　<-->　DAO <--> DB

　　　　　　　　　　　　　　　　---------------------Spring-------------------

　　DAO层连接数据库需要要数据源信息db.properties,框架需要log4j.properties,mybatis的总配置文件sqlMapConfig.xml,使用spring来配置数据源,管理事务,配置SqlSessionFactory和mapper扫描器的applicationContext-dao.xml,Mapper对象的配置文件XXXMapper.xml.

　　Service层用spring配置service接口applicationContext-service.xml,配置事务管理applicationContext-transaction.xml,Service接口　

　　Action层springmvc配置文件springmvc.xml,web.xml中配置DispatchServlet,配置编码转换器,加载spring容器,Controller类

　　　　

　　　　DAO

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/mybatis
  3. jdbc.username=XXXX
  4. jdbc.password=XXXX

db.properties

  1. # Global logging configuration，建议开发环境中要用debug
  2. log4j.rootLogger=DEBUG, stdout
  3. # Console output...
  4. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  5. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  6. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

log4j.properties

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6.  
  7. <!—使用自动扫描器时，mapper.xml文件如果和mapper.java接口在一个目录则此处不用定义mappers -->
  8. <mappers>
  9. <package name="com.harry.ssm.mapper" />
  10. </mappers>
  11. </configuration>

sqlMapConfig.xml

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  3.     xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.         http://www.springframework.org/schema/mvc
  8.         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
  9.         http://www.springframework.org/schema/context
  10.         http://www.springframework.org/schema/context/spring-context-3.2.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  13.         http://www.springframework.org/schema/tx
  14.         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
  15. <!-- 加载配置文件 -->
  16. <context:property-placeholder location="classpath:db.properties"/>
  17. <!-- 数据库连接池 -->
  18. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  19.        <property name="driverClassName" value="${jdbc.driver}"/>
  20.         <property name="url" value="${jdbc.url}"/>
  21.         <property name="username" value="${jdbc.username}"/>
  22.         <property name="password" value="${jdbc.password}"/>
  23.         <property name="maxActive" value="30"/>
  24.         <property name="maxIdle" value="5"/>
  25. </bean>    
  26.  
  27. <!-- 让spring管理sqlsessionfactory 使用mybatis和spring整合包中的 -->
  28.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  29.         <!-- 数据库连接池 -->
  30.         <property name="dataSource" ref="dataSource" />
  31.         <!-- 加载mybatis的全局配置文件 -->
  32.         <property name="configLocation" value="classpath:mybatis/SqlMapConfig.xml" />
  33.     </bean>
  34. <!-- mapper扫描器 -->
  35. <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  36.  <property name="basePackage" value="com.harry.ssm.mapper"></property>
  37. <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  38.     </bean>
  39.  
  40. </beans>

applicationContext-dao.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.harry.ssm.mapper.ItemsMapper">
  6.  
  7.     <!-- sql片段 -->
  8.     <!-- 商品查询条件 -->
  9.     <sql id="query_items_where">
  10.         <if test="items!=null">
  11.             <if test="items.name!=null and items.name!=''">
  12.                 and items.name like '%${items.name}%'
  13.             </if>
  14.         </if>
  15.     </sql>
  16.  
  17.     <!-- 查询商品信息 -->
  18.     <select id="findItemsList" parameterType="queryVo" resultType="items">
  19.         select * from items
  20.         <where>
  21.             <include refid="query_items_where"/>
  22.         </where>
  23.     </select>
  24.  
  25. </mapper>

ItemsMapper.xml

  1. public interface ItemsMapper {
  2.     //商品列表
  3.     public List<Items> findItemsList(QueryVo queryVo) throws Exception;
  4. }

ItemsMapper.java

　　　　Service

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  3.     xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.         http://www.springframework.org/schema/mvc
  8.         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
  9.         http://www.springframework.org/schema/context
  10.         http://www.springframework.org/schema/context/spring-context-3.2.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  13.         http://www.springframework.org/schema/tx
  14.         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
  15. <!-- 商品管理的service -->
  16. <bean id="itemsService" class="com.harry.ssm.service.impl.ItemsServiceImpl"/>
  17. </beans>

applicationContext-service.xml

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  3.     xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.         http://www.springframework.org/schema/mvc
  8.         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
  9.         http://www.springframework.org/schema/context
  10.         http://www.springframework.org/schema/context/spring-context-3.2.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  13.         http://www.springframework.org/schema/tx
  14.         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
  15.  
  16. <!-- 事务管理器
  17.     对mybatis操作数据库事务控制，spring使用jdbc的事务控制类
  18. -->
  19. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  20.     <!-- 数据源
  21.     dataSource在applicationContext-dao.xml中配置了
  22.      -->
  23.     <property name="dataSource" ref="dataSource"/>
  24. </bean>
  25.  
  26. <!-- 通知 -->
  27. <tx:advice id="txAdvice" transaction-manager="transactionManager">
  28.     <tx:attributes>
  29.         <!-- 传播行为 -->
  30.         <tx:method name="save*" propagation="REQUIRED"/>
  31.         <tx:method name="delete*" propagation="REQUIRED"/>
  32.         <tx:method name="insert*" propagation="REQUIRED"/>
  33.         <tx:method name="update*" propagation="REQUIRED"/>
  34.         <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
  35.         <tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
  36.         <tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
  37.     </tx:attributes>
  38. </tx:advice>
  39. <!-- aop -->
  40. <aop:config>
  41.     <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.harry.ssm.service.impl.*.*(..))"/>
  42. </aop:config>
  43.  
  44. </beans>

applicationContext-transaction.xml

  1. package com.harry.ssm.service;
  2.  
  3. import java.util.List;
  4.  
  5. import com.harryt.ssm.po.ItemsCustom;
  6. import com.harry.ssm.po.ItemsQueryVo;
  7.  
  8. public interface ItemsService {
  9.  
  10.     //商品查询列表
  11.     public List<ItemsCustom> findItemsList(ItemsQueryVo itemsQueryVo) throws Exception;
  12.  
  13.     //根据id查询商品信息
  14.     /**
  15.      *
  16.      * <p>Title: findItemsById</p>
  17.      * <p>Description: </p>
  18.      * @param id 查询商品的id
  19.      * @return
  20.      * @throws Exception
  21.      */
  22.     public ItemsCustom findItemsById(Integer id) throws Exception;
  23.  
  24.     //修改商品信息
  25.     /**
  26.      *
  27.      * <p>Title: updateItems</p>
  28.      * <p>Description: </p>
  29.      * @param id 修改商品的id
  30.      * @param itemsCustom 修改的商品信息
  31.      * @throws Exception
  32.      */
  33.     public void updateItems(Integer id,ItemsCustom itemsCustom) throws Exception;
  34.  
  35. }

IItemsService.java

  1. package com.harry.ssm.service.impl;
  2.  
  3. import java.util.List;
  4.  
  5. import org.springframework.beans.BeanUtils;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7.  
  8. import com.harry.ssm.mapper.ItemsMapper;
  9. import com.harry.ssm.mapper.ItemsMapperCustom;
  10. import com.harry.ssm.po.Items;
  11. import com.harry.ssm.po.ItemsCustom;
  12. import com.harry.ssm.po.ItemsQueryVo;
  13. import com.harry.ssm.service.ItemsService;
  14.  
  15. public class ItemsServiceImpl implements ItemsService{
  16.  
  17.     @Autowired
  18.     private ItemsMapperCustom itemsMapperCustom;
  19.  
  20.     @Autowired
  21.     private ItemsMapper itemsMapper;
  22.  
  23.     @Override
  24.     public List<ItemsCustom> findItemsList(ItemsQueryVo itemsQueryVo)
  25.             throws Exception {
  26.         //通过ItemsMapperCustom查询数据库
  27.         return itemsMapperCustom.findItemsList(itemsQueryVo);
  28.     }
  29.  
  30.     @Override
  31.     public ItemsCustom findItemsById(Integer id) throws Exception {
  32.  
  33.         Items items = itemsMapper.selectByPrimaryKey(id);
  34.         //中间对商品信息进行业务处理
  35.         //....
  36.         //返回ItemsCustom
  37.         ItemsCustom itemsCustom = new ItemsCustom();
  38.         //将items的属性值拷贝到itemsCustom
  39.         BeanUtils.copyProperties(items, itemsCustom);
  40.  
  41.         return itemsCustom;
  42.  
  43.     }
  44.  
  45.     @Override
  46.     public void updateItems(Integer id, ItemsCustom itemsCustom) throws Exception {
  47.         //添加业务校验，通常在service接口对关键参数进行校验
  48.         //校验 id是否为空，如果为空抛出异常
  49.  
  50.         //更新商品信息使用updateByPrimaryKeyWithBLOBs根据id更新items表中所有字段，包括 大文本类型字段
  51.         //updateByPrimaryKeyWithBLOBs要求必须转入id
  52.         itemsCustom.setId(id);
  53.         itemsMapper.updateByPrimaryKeyWithBLOBs(itemsCustom);
  54.     }
  55.  
  56. }

ItemsServiceImpl.java

　　　　Action

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
  3.     xmlns:context="http://www.springframework.org/schema/context"
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.         http://www.springframework.org/schema/mvc
  8.         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
  9.         http://www.springframework.org/schema/context
  10.         http://www.springframework.org/schema/context/spring-context-3.2.xsd
  11.         http://www.springframework.org/schema/aop
  12.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  13.         http://www.springframework.org/schema/tx
  14.         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
  15.  
  16.     <!-- 扫描controller注解,多个包中间使用半角逗号分隔 -->
  17.     <context:component-scan base-package="com.harry.ssm.controller"/>
  18.  
  19.     <!--注解映射器 -->
  20.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
  21.     <!--注解适配器 -->
  22.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>
  23.  
  24.     <!-- ViewResolver -->
  25.     <bean
  26.     class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  27.         <property name="viewClass"
  28.             value="org.springframework.web.servlet.view.JstlView" />
  29.         <property name="prefix" value="/WEB-INF/jsp/" />
  30.         <property name="suffix" value=".jsp" />
  31.     </bean>
  32.  
  33. </beans>

springmvc.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5.     id="WebApp_ID" version="2.5">
  6.     <display-name>springmvc</display-name>
  7.  
  8.     <!-- 加载spring容器 -->
  9.     <context-param>
  10.         <param-name>contextConfigLocation</param-name>
  11.         <param-value>/WEB-INF/classes/spring/applicationContext.xml,/WEB-INF/classes/spring/applicationContext-*.xml</param-value>
  12.     </context-param>
  13.     <listener>
  14.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  15.     </listener>
  16.  
  17.     <!-- 解决post乱码 -->
  18.     <filter>
  19.         <filter-name>CharacterEncodingFilter</filter-name>
  20.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  21.         <init-param>
  22.             <param-name>encoding</param-name>
  23.             <param-value>utf-8</param-value>
  24.         </init-param>
  25.     </filter>
  26.     <filter-mapping>
  27.         <filter-name>CharacterEncodingFilter</filter-name>
  28.         <url-pattern>/*</url-pattern>
  29.     </filter-mapping>
  30.  
  31.     <!-- springmvc的前端控制器 -->
  32.     <servlet>
  33.         <servlet-name>springmvc</servlet-name>
  34.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  35.         <!-- contextConfigLocation不是必须的， 如果不配置contextConfigLocation， springmvc的配置文件默认在：WEB-INF/servlet的name+"-servlet.xml" -->
  36.         <init-param>
  37.             <param-name>contextConfigLocation</param-name>
  38.             <param-value>classpath:spring/springmvc.xml</param-value>
  39.         </init-param>
  40.         <load-on-startup>1</load-on-startup>
  41.     </servlet>
  42.     <servlet-mapping>
  43.         <servlet-name>springmvc</servlet-name>
  44.         <url-pattern>*.action</url-pattern>
  45.     </servlet-mapping>
  46.  
  47.     <welcome-file-list>
  48.         <welcome-file>index.html</welcome-file>
  49.         <welcome-file>index.htm</welcome-file>
  50.         <welcome-file>index.jsp</welcome-file>
  51.         <welcome-file>default.html</welcome-file>
  52.         <welcome-file>default.htm</welcome-file>
  53.         <welcome-file>default.jsp</welcome-file>
  54.     </welcome-file-list>
  55. </web-app>

web.xml

  1. package com.harry.ssm.controller;
  2.  
  3. import java.util.List;
  4.  
  5. import javax.servlet.http.HttpServletRequest;
  6.  
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.stereotype.Controller;
  9. import org.springframework.ui.Model;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RequestMethod;
  12. import org.springframework.web.bind.annotation.RequestParam;
  13. import org.springframework.web.servlet.ModelAndView;
  14.  
  15. import com.harry.ssm.po.ItemsCustom;
  16. import com.harry.ssm.service.ItemsService;
  17.  
  18. @Controller
  19. //为了对url进行分类管理 ，可以在这里定义根路径，最终访问url是根路径+子路径
  20. //比如：商品列表：/items/queryItems.action
  21. @RequestMapping("/items")
  22. public class ItemsController {
  23.  
  24.     @Autowired
  25.     private ItemsService itemsService;
  26.  
  27.     // 商品查询
  28.     @RequestMapping("/queryItems")
  29.     public ModelAndView queryItems(HttpServletRequest request) throws Exception {
  30.         //测试forward后request是否可以共享
  31.  
  32.         System.out.println(request.getParameter("id"));
  33.  
  34.         // 调用service查找 数据库，查询商品列表
  35.         List<ItemsCustom> itemsList = itemsService.findItemsList(null);
  36.  
  37.         // 返回ModelAndView
  38.         ModelAndView modelAndView = new ModelAndView();
  39.         // 相当 于request的setAttribut，在jsp页面中通过itemsList取数据
  40.         modelAndView.addObject("itemsList", itemsList);
  41.  
  42.         // 指定视图
  43.         // 下边的路径，如果在视图解析器中配置jsp路径的前缀和jsp路径的后缀，修改为
  44.         // modelAndView.setViewName("/WEB-INF/jsp/items/itemsList.jsp");
  45.         // 上边的路径配置可以不在程序中指定jsp路径的前缀和jsp路径的后缀
  46.         modelAndView.setViewName("items/itemsList");
  47.  
  48.         return modelAndView;
  49.  
  50.     }
  51.  
  52.     //商品信息修改页面显示
  53.     //@RequestMapping("/editItems")
  54.     //限制http请求方法，可以post和get
  55. //    @RequestMapping(value="/editItems",method={RequestMethod.POST,RequestMethod.GET})
  56. //    public ModelAndView editItems()throws Exception {
  57. //
  58. //        //调用service根据商品id查询商品信息
  59. //        ItemsCustom itemsCustom = itemsService.findItemsById(1);
  60. //
  61. //        // 返回ModelAndView
  62. //        ModelAndView modelAndView = new ModelAndView();
  63. //
  64. //        //将商品信息放到model
  65. //        modelAndView.addObject("itemsCustom", itemsCustom);
  66. //
  67. //        //商品修改页面
  68. //        modelAndView.setViewName("items/editItems");
  69. //
  70. //        return modelAndView;
  71. //    }
  72.  
  73.     @RequestMapping(value="/editItems",method={RequestMethod.POST,RequestMethod.GET})
  74.     //@RequestParam里边指定request传入参数名称和形参进行绑定。
  75.     //通过required属性指定参数是否必须要传入
  76.     //通过defaultValue可以设置默认值，如果id参数没有传入，将默认值和形参绑定。
  77.     public String editItems(Model model,@RequestParam(value="id",required=true) Integer items_id)throws Exception {
  78.  
  79.         //调用service根据商品id查询商品信息
  80.         ItemsCustom itemsCustom = itemsService.findItemsById(items_id);
  81.  
  82.         //通过形参中的model将model数据传到页面
  83.         //相当于modelAndView.addObject方法
  84.         model.addAttribute("itemsCustom", itemsCustom);
  85.  
  86.         return "items/editItems";
  87.     }
  88.  
  89.     //商品信息修改提交
  90.     @RequestMapping("/editItemsSubmit")
  91.     public String editItemsSubmit(HttpServletRequest request,Integer id,ItemsCustom itemsCustom)throws Exception {
  92.  
  93.         //调用service更新商品信息，页面需要将商品信息传到此方法
  94.         itemsService.updateItems(id, itemsCustom);
  95.  
  96.         //重定向到商品查询列表
  97. //        return "redirect:queryItems.action";
  98.         //页面转发
  99.         //return "forward:queryItems.action";
  100.         return "success";
  101.     }
  102.  
  103. }

ItemsController.java

　　　　View

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  4. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
  5. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  6. <html>
  7. <head>
  8. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  9. <title>查询商品列表</title>
  10. </head>
  11. <body>
  12. <form action="${pageContext.request.contextPath }/item/queryItem.action" method="post">
  13. 查询条件：
  14. <table width="100%" border=1>
  15. <tr>
  16. <td><input type="submit" value="查询"/></td>
  17. </tr>
  18. </table>
  19. 商品列表：
  20. <table width="100%" border=1>
  21. <tr>
  22.     <td>商品名称</td>
  23.     <td>商品价格</td>
  24.     <td>生产日期</td>
  25.     <td>商品描述</td>
  26.     <td>操作</td>
  27. </tr>
  28. <c:forEach items="${itemsList }" var="item">
  29. <tr>
  30.     <td>${item.name }</td>
  31.     <td>${item.price }</td>
  32.     <td><fmt:formatDate value="${item.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/></td>
  33.     <td>${item.detail }</td>
  34.  
  35.     <td><a href="${pageContext.request.contextPath }/items/editItems.action?id=${item.id}">修改</a></td>
  36.  
  37. </tr>
  38. </c:forEach>
  39.  
  40. </table>
  41. </form>
  42. </body>
  43.  
  44. </html>

itemsList.jsp

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
  4. <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt"  prefix="fmt"%>
  5. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  6. <html>
  7. <head>
  8. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  9. <title>修改商品信息</title>
  10.  
  11. </head>
  12. <body> 
  13.  
  14. <form id="itemForm" action="${pageContext.request.contextPath }/items/editItemsSubmit.action" method="post" >
  15. <input type="hidden" name="id" value="${itemsCustom.id }"/>
  16. 修改商品信息：
  17. <table width="100%" border=1>
  18. <tr>
  19.     <td>商品名称</td>
  20.     <td><input type="text" name="name" value="${itemsCustom.name }"/></td>
  21. </tr>
  22. <tr>
  23.     <td>商品价格</td>
  24.     <td><input type="text" name="price" value="${itemsCustom.price }"/></td>
  25. </tr>
  26. <tr>
  27.     <td>商品生产日期</td>
  28.     <td><input type="text" name="createtime" value="<fmt:formatDate value="${itemsCustom.createtime}" pattern="yyyy-MM-dd HH:mm:ss"/>"/></td>
  29. </tr>
  30. <%-- <tr>
  31.     <td>商品图片</td>
  32.     <td>
  33.         <c:if test="${item.pic !=null}">
  34.             <img src="/pic/${item.pic}" width=100 height=100/>
  35.             <br/>
  36.         </c:if>
  37.         <input type="file"  name="pictureFile"/>
  38.     </td>
  39. </tr> --%>
  40. <tr>
  41.     <td>商品简介</td>
  42.     <td>
  43.     <textarea rows="3" cols="30" name="detail">${itemsCustom.detail }</textarea>
  44.     </td>
  45. </tr>
  46. <tr>
  47. <td colspan="2" align="center"><input type="submit" value="提交"/>
  48. </td>
  49. </tr>
  50. </table>
  51.  
  52. </form>
  53. </body>
  54.  
  55. </html>

editItems.jsp

@RequestMapping

　　定义于Controller类及其方法上,用于指定访问的url的文件映射路径和访问方法,如

@RequestMapping("/items")
public class ItemsController {

　　@RequestMapping("/queryItems",method={RequestMethod.POST,RequestMethod.GET})
　　public ModelAndView queryItems(HttpServletRequest request) throws Exception {

那么,指定的路径为http://localhost:8080/appName/items/queryitems.action,有POST和GET两种访问方式

Controller方法返回值

　　ModelAndView　　　　对象可添加model数据和指定view

　　void　　　　　　　　　可以利用内部跳转进行响应,或者重定向,或者响应json数据

　　　　　　　　　　　　　request.getRequestDispatcher("页面路径").forward(request, response);

　　　　　　　　　　　　　response.sendRedirect("url")

　　String　　　　　　　　指定逻辑视图名,重定向,内部跳转

　　　　　　　　　　　　　return "item/editItem";

　　　　　　　　　　　　　return "redirect:queryItem.action";

　　　　　　　　　　　　　return "forward:editItem.action";

参数绑定

　  参数绑定可以是客户端数据绑定,也可以是服务端参数绑定;

　　服务端参数绑定就是在request<--controller这个过程之间发生的事,request到达controller控制权就在我们的手上,我们可以运行自己的逻辑代码,然后获取参数,然后再将其绑定在request域中,等着给DispatchServlet渲染.

　　支持的类型:HttpServletRequest,HttpServletResponse,HttpSession,Model/ModelMap

Items item = itemService.findItemById(id);

model.addAttribute("item", item);

modelMap是model接口实现类,实质上都是实例化ModelMap来存储key/value

页面通过${item.xxx}来取值.

　　客户端参数绑定就是request-->controller,将客户填入的数据进行自动获取至方法上

　　支持的类型:基础类型(Bollean,Integer,String,Float/Double),POJO,自定义类型转换器,集合类

public String editItem(Model model,Integer id,Boolean status) throws Exception
http://localhost:8080/springmvc_mybatis/item/editItem.action?id=2&status=false

参数id和status将自动获取

@RequestParam 常用来处理基础类型

public String editItem(@RequestParam(value="item_id",required=true) String id

　　@RequestParam(value="item_status",defaultValue="true") Boolean status) {}

页面定义

<input type="text" name="name"/>

<input type="text" name="price"/>

Controller方法定义,获取items匹配的属性名name,price

@RequestMapping("/editItemSubmit")

public String editItemSubmit(Items items)throws Exception{

System.out.println(items);

自定义类型转换器

  1. public class CustomDateConverter implements Converter<String, Date> {
  2.  
  3.     @Override
  4.     public Date convert(String source) {
  5.         try {
  6.             SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  7.             return simpleDateFormat.parse(source);
  8.         } catch (Exception e) {
  9.             e.printStackTrace();
  10.         }
  11.         return null;
  12.     }
  13.  
  14. }

CustomDateConverter.java

  1. <mvc:annotation-driven conversion-service="conversionService">
  2. </mvc:annotation-driven>
  3. <!-- conversionService -->
  4.     <bean id="conversionService"
  5.         class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
  6.         <!-- 转换器 -->
  7.         <property name="converters">
  8.             <list>
  9.                 <bean class="com.harry.controller.converter.CustomDateConverter"/>
  10.             </list>
  11.         </property>
  12.     </bean>

springmvc.xml

　　

　　集合类

  1. <input type="checkbox" name="item_id" value="001"/>
  2. <input type="checkbox" name="item_id" value="002"/>
  3. <input type="checkbox" name="item_id" value="003"/>
  4.  
  5. -------------------------------------------------------------------------
  6. public String deleteitem(String[] item_id)throws Exception{
  7.         System.out.println(item_id);
  8. ｝

StringArray

  1. <c:forEach items="${itemsList }" var="item" varStatus="s">
  2. <tr>
  3.     <td><input type="text" name="itemsList[${s.index }].name" value="${item.name }"/></td>
  4.     <td><input type="text" name="itemsList[${s.index }].price" value="${item.price }"/></td>
  5.     .....
  6.     .....
  7. </tr>
  8. </c:forEach>
  9. -----------------------------------------------------------------------------------------------------
  10. public class QueryVo {
  11. private List<Items> itemList;//商品列表
  12.  
  13.   //get/set方法..
  14. }
  15.  
  16. -----------------------------------------------------------------------------------------------------
  17. public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
  18. System.out.println(queryVo.getItemList());
  19. }

List

  1. <tr>
  2. <td>学生信息：</td>
  3. <td>
  4. 姓名：<inputtype="text"name="itemInfo['name']"/>
  5. 年龄：<inputtype="text"name="itemInfo['price']"/>
  6. .. .. ..
  7. </td>
  8. </tr>
  9. ----------------------------------------------------------------------------------------
  10. public class QueryVo {
  11. private Map<String, Object> itemInfo = new HashMap<String, Object>();
  12.   //get/set方法..
  13. }
  14. -----------------------------------------------------------------------------------------
  15. public String useraddsubmit(Model model,QueryVo queryVo)throws Exception{
  16. System.out.println(queryVo.getStudentinfo());
  17. }

Map

　　

自定义类与包装类

　　我们在工作中一般使用逆向工程生成工具来进行代码开发,也就是ORM里面的实体部分已经是自动生成的,这部分的代码不能动,因为很容易造成代码混乱,但是我们又经常需要去修改里面的部分属性;

　　我们经常还碰到另外一种情况,就是客户端请求的可能是包含几个类的视图(如多值查询),那么针对这种情况,我们可以使用一个包装类来作为视图类,然后返回视图类来进行响应,而我们上面也是这么做的.

　　鉴于上述原因,我们会使用自定义类来对其进行封装,使用视图类来进行传输,这样,我们就可以在不碰那些代码的前提下任意进行代码修改.

　　

　　

　　

　　

编码问题

　　相信你在开发时一定碰到过乱码问题,SpringMVC也提供了一个统一的编码过滤器,但是只适用于POST编码过滤,这是因为开发中上传表单数据都规定使用POST,所以SpringMVC也就只提供这一种过滤器.

  1. <filter>
  2. <filter-name>CharacterEncodingFilter</filter-name>
  3. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  4. <init-param>
  5. <param-name>encoding</param-name>
  6. <param-value>utf-8</param-value>
  7. </init-param>
  8. </filter>
  9. <filter-mapping>
  10. <filter-name>CharacterEncodingFilter</filter-name>
  11. <url-pattern>/*</url-pattern>
  12. </filter-mapping>

web.xml

　　还有GET的乱码解决方案有两种,

　　1.修改tomcat配置文件添加编码与工程编码一致

　　<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

　　2.对参数进行重新编码　　

　　String userName = new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8");

Validation

　　数据校验一般都会在前端进行,但是有时安全性要求高点的环境下,也会在服务端进行数据校验.

　　服务端校验

　　Controller层　　检验页面请求的合法性,在服务端控制层conroller校验，不区分客户端类型（浏览器、手机客户端、远程调用）

　　Service层　　　不区分客户端类型（浏览器、手机客户端、远程调用）

　　DAO层　　　　 一般不进行校验

　　

　　SpringMVC使用校验框架Validation.

　　校验思路：
　　页面提交请求的参数，请求到controller方法中,使用validation进行校验.如果校验出错,将错误信息展示到页面.

　　1.导入Bean-Validation框架jar包,Hibernate-validator

　　2.配置校验器

  1. <!-- 校验器 -->
  2.     <bean id="validator"
  3.         class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean">
  4.         <!-- hibernate校验器-->
  5.         <property name="providerClass" value="org.hibernate.validator.HibernateValidator" />
  6.         <!-- 指定校验使用的资源文件，在文件中配置校验错误信息，如果不指定则默认使用classpath下的ValidationMessages.properties -->
  7.         <property name="validationMessageSource" ref="messageSource" />
  8.     </bean>
  9. <!-- 校验错误信息配置文件 -->
  10.     <bean id="messageSource"
  11.         class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
  12.         <!-- 资源文件名-->
  13.         <property name="basenames">
  14.             <list>
  15.             <value>classpath:CustomValidationMessages</value>
  16.             </list>
  17.         </property>
  18.         <!-- 资源文件编码格式 -->
  19.         <property name="fileEncodings" value="utf-8" />
  20.         <!-- 对资源文件内容缓存时间，单位秒 -->
  21.         <property name="cacheSeconds" value="120" />
  22.     </bean>
  23.  
  24. <!--注解映射器 -->
  25.     <!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/> -->
  26.     <!--注解适配器 -->
  27.     <!-- <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/> -->
  28.  
  29.     <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置
  30.     mvc:annotation-driven默认加载很多的参数绑定方法，
  31.     比如json转换解析器就默认加载了，如果使用mvc:annotation-driven不用配置上边的RequestMappingHandlerMapping和RequestMappingHandlerAdapter
  32.     实际开发时使用mvc:annotation-driven
  33.      -->
  34.     <mvc:annotation-driven conversion-service="conversionService"
  35.     validator="validator"></mvc:annotation-driven>

springmvc.xml

　　3.在POJO中添加校验规则.

　　

　　4.配置校验时产生的message

　　

　　5.捕获校验错误信息

　　　　

　　在需要校验的pojo前边添加@Validated,在需要校验的pojo后边添加BindingResult bindingResult接收校验出错信息
　　注意：@Validated和BindingResult bindingResult是配对出现,并且形参顺序是固定的（一前一后）.

　　6.controller传递错误信息

　　

　　7.页面显示错误信息

　　

　　8.校验分组

　　在pojo中定义校验规则,而pojo是被多个 controller所共用,当不同的controller方法对同一个pojo进行校验,但是每个controller方法需要不同的校验.可以指定不同的分组来进行校验.

　　

　　9.在校验中添加分组

　　

　　10.在Controller指定分组的校验规则

　　

数据回显

　　数据回显指提交数据后出现错误,将刚才提交的数据回显到刚才的提交页面,比如填一张表,填完后一项错误后重新回到提交前的状态.

　　1.SpringMVC默认对POJO进行回显.

　　pojo数据传入controller方法后,springmvc自动将pojo数据放到request域,key等于pojo类型（首字母小写）

　　

　　

　　2.@ModelAttribute

　　@ModelAttribute可以指定POJO对应的key值,页面获取可以直接使用key值进行获取,还可以将返回值存入request域

　　

　　

　　3.直接使用model.addAttribute

　　

异常处理器

　　异常处理思路很简单,就是DAO,Service,Controller出现异常直接向上抛出,然后在DispatchServlet那一层设置一个异常处理器就处理所有异常.

　　

　　1.创建自定义Exception　　

  1. package com.harry.exception;
  2.  
  3. @SuppressWarnings("serial")
  4. public class ExceptionCustom extends Exception {
  5.  
  6.     //异常信息
  7.     public String message;
  8.  
  9.     public ExceptionCustom(String message){
  10.         super(message);
  11.         this.message = message;
  12.     }
  13.  
  14.     public String getMessage() {
  15.         return message;
  16.     }
  17.  
  18.     public void setMessage(String message) {
  19.         this.message = message;
  20.     }
  21. }

ExceptionCustom.java

　　2.定义全局异常处理器　　

　　全局异常处理器处理思路:
　　　　解析出异常类型;
　　　　如果该异常类型是系统自定义的异常直接取出异常信息,在错误页面展示;
　　　　如果该异常类型不是系统自定义的异常,构造一个自定义的异常类(信息为"未知错误");

　　实现SpringMVC提供的HandlerExceptionResolver接口

  1. package com.harry.exception;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5.  
  6. import org.springframework.web.servlet.HandlerExceptionResolver;
  7. import org.springframework.web.servlet.ModelAndView;
  8.  
  9. public class ExceptionCustomResolver implements HandlerExceptionResolver {
  10.  
  11.     /**
  12.      * （非 Javadoc）
  13.      * <p>Title: resolveException</p>
  14.      * <p>Description: </p>
  15.      * @param request
  16.      * @param response
  17.      * @param handler
  18.      * @param ex 系统 抛出的异常
  19.      * @return
  20.      * @see org.springframework.web.servlet.HandlerExceptionResolver#resolveException(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Object, java.lang.Exception)
  21.      */
  22.     @Override
  23.     public ModelAndView resolveException(HttpServletRequest request,
  24.             HttpServletResponse response, Object handler, Exception ex) {
  25.         //handler就是处理器适配器要执行Handler对象（只有method）
  26.  
  27. //        解析出异常类型
  28. //        如果该 异常类型是系统 自定义的异常，直接取出异常信息，在错误页面展示
  29. //        String message = null;
  30. //        if(ex instanceof ExceptionCustom){
  31. //            message = ((ExceptionCustom)ex).getMessage();
  32. //        }else{
  33. ////            如果该 异常类型不是系统 自定义的异常，构造一个自定义的异常类型（信息为“未知错误”）
  34. //            message="未知错误";
  35. //        }
  36.  
  37.         //上边代码变为
  38.         ExceptionCustom ExceptionCustom = null;
  39.         if(ex instanceof ExceptionCustom){
  40.             ExceptionCustom = (ExceptionCustom)ex;
  41.         }else{
  42.             ExceptionCustom = new ExceptionCustom("未知错误");
  43.         }
  44.  
  45.         //错误信息
  46.         String message = ExceptionCustom.getMessage();
  47.  
  48.         ModelAndView modelAndView = new ModelAndView();
  49.  
  50.         //将错误信息传到页面
  51.         modelAndView.addObject("message", message);
  52.  
  53.         //指向错误页面
  54.         modelAndView.setViewName("error");
  55.  
  56.         return modelAndView;
  57.     }
  58.  
  59. }

ExceptionCustomResolver.java

　　错误页面

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>错误提示</title>
  8. </head>
  9. <body>
  10. ${message }
  11. </body>
  12. </html>

error.jsp

　　springmvc.xml配置全局异常处理器

  1. <!-- 全局异常处理器
  2.     只要实现HandlerExceptionResolver接口就是全局异常处理器
  3.      -->
  4.     <bean class="cn.itcast.ssm.exception.CustomExceptionResolver"></bean>

springmvc.xml

上传图片

　　1.当提交的表单数据混合几种数据格式,比如字符串和图片文件,必须在表单设置提交的压缩类型为multipart/form-data.

　　

　　2.要解析这种压缩格式的数据需要在springmvc配置文件中添加multipart类型解析器.

  1. <!-- 文件上传 -->
  2.     <bean id="multipartResolver"
  3.         class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  4.         <!-- 设置上传文件的最大尺寸为5MB -->
  5.         <property name="maxUploadSize">
  6.             <value>5242880</value>
  7.         </property>
  8.     </bean>

springmvc.xml

　　3.加上springmvc图片组件jar包

　　

　　4.创建图片虚拟目录存储图片

　　

　　或者在tomcat/conf/server.xml下

　　

注意：在图片虚拟目录 中,一定将图片目录分级创建（提高i/o性能）,一般我们采用按日期(年-月-日)进行分级创建.

　　5.上传页面部分代码　　

  1. <tr>
  2.     <td>商品图片</td>
  3.     <td>
  4.         <c:if test="${item.pic !=null}">
  5.             <img src="/pic/${item.pic}" width=100 height=100/>
  6.             <br/>
  7.         </c:if>
  8.         <input type="file"  name="pictureFile"/>
  9.     </td>
  10. </tr>

editItems.jsp

　　6.添加controller映射model,保存图片路径名称

　　

　　

Json数据交互

　　Json数据交互的应用场景广泛,基本上每个网站都会有这样的数据交互,特点是数据交互量小,轻便,可异步刷新.

　　1.json数据交互思路

　　

　　客户端请求json串(或者键值对) <--------> 服务端json对象

　　2.springmvc采用jackson包来转换json串与json对象,所以要添加jar包

　　

　　3.配置json转换器

  1. <!--注解适配器 -->
  2.     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  3.         <property name="messageConverters">
  4.         <list>
  5.         <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
  6.         </list>
  7.         </property>
  8.     </bean>
  9.  
  10. <!--如果使用<mvc:annotation-driven /> 则不用定义上边的内容 -->

springmvc.xml

　　4.测试请求json串和key/value,输出json串

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>json交互测试</title>
  8. <script type="text/javascript" src="${pageContext.request.contextPath }/js/jquery-1.4.4.min.js"></script>
  9. <script type="text/javascript">
  10. //请求json，输出是json
  11. function requestJson(){
  12.  
  13.     $.ajax({
  14.         type:'post',
  15.         url:'${pageContext.request.contextPath }/requestJson.action',
  16.         contentType:'application/json;charset=utf-8',
  17.         //数据格式是json串，商品信息
  18.         data:'{"name":"手机","price":999}',
  19.         success:function(data){//返回json结果
  20.             alert(data);
  21.         }
  22.  
  23.     });
  24.  
  25. }
  26. //请求key/value，输出是json
  27. function requerstKeyValue(){
  28.  
  29.     $.ajax({
  30.         type:'post',
  31.         url:'${pageContext.request.contextPath }/requerstKeyValue.action',
  32.         //请求是key/value这里不需要指定contentType，因为默认就 是key/value类型
  33.         //contentType:'application/json;charset=utf-8',
  34.         //数据格式是json串，商品信息
  35.         data:'name=手机&price=999',
  36.         success:function(data){//返回json结果
  37.             alert(data.name);
  38.         }
  39.  
  40.     });
  41.  
  42. }
  43. </script>
  44. </head>
  45. <body>
  46. <input type="button" onclick="requestJson()" value="请求json，输出是json"/>
  47. <input type="button" onclick="requerstKeyValue()" value="请求key/value，输出是json"/>
  48. </body>
  49. </html>

jsonTest.jsp

  1. package com.harry.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestBody;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.ResponseBody;
  7.  
  8. import com.harry.entity.ItemsCustom;
  9.  
  10. @Controller
  11. public class JsonController {
  12.  
  13.     //请求json串(商品信息)，输出json(商品信息)
  14.     //@RequestBody将请求的商品信息的json串转成itemsCustom对象
  15.     //@ResponseBody将itemsCustom转成json输出
  16.     @RequestMapping("/requestJson")
  17.     public @ResponseBody ItemsCustom requestJson(@RequestBody ItemsCustom itemsCustom){
  18.  
  19.         //@ResponseBody将itemsCustom转成json输出
  20.         return itemsCustom;
  21.     }
  22.  
  23.     //请求key/value，输出json
  24.     @RequestMapping("/responseJson")
  25.     public @ResponseBody ItemsCustom responseJson(ItemsCustom itemsCustom){
  26.  
  27.         //@ResponseBody将itemsCustom转成json输出
  28.         return itemsCustom;
  29.     }
  30.  
  31. }

JsonController.java

　　

RESTful支持

　　RESTful是一种开发理念,并非指具体的技术,理念的阐述具体如下:

　　1.对url进行规范，写RESTful格式的url

　　非REST的url：http://...../queryItems.action?id=001&type=T01

　　REST的url风格：http://..../items/001

特点：url简洁，将参数通过url传到服务端

　　2.http的方法规范

　　不管是删除,添加,更新,使用url是一致的，如果进行删除，需要设置http的方法为delete，同理添加.

　　后台controller方法：判断http方法，如果是delete执行删除，如果是post执行添加。

　　3.对http的contentType规范

　　请求时指定contentType，要json数据，设置成json格式的type.

　　示例

　　1.controller定义映射使用RESTful风格的url,将查询信息的id传入controller.

　　

　　@RequestMapping(value="/ itemsView/{id}")：{×××}占位符,请求的URL可以是“/viewItems/1”或“/viewItems/2”,通过在方法中使用@PathVariable获取{×××}中的×××变量.

　　 @PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上. 如果RequestMapping中表示为"/ itemsView /{id}",id和形参名称一致,@PathVariable不用指定名称.

　　2.配置前端控制器

　　

　　"*.action"的解析在RESTful风格下会导致静态资源无法访问,这里替换成"/";

　　3.springmvc.xml中配置静态资源映射

　　

拦截器

拦截器能设置请求前,响应后进行拦截执行特定的代码,SpringMVC定义拦截器需要实现HandlerInterceptor接口.

接口中提供三个方法分别在handler执行前,后还有ModelAndView返回前执行

  1. package com.harry.interceptor;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5.  
  6. import org.springframework.web.servlet.HandlerInterceptor;
  7. import org.springframework.web.servlet.ModelAndView;
  8.  
  9. public class HandlerInterceptor1 implements HandlerInterceptor {
  10.  
  11.     //进入 Handler方法之前执行
  12.     //用于身份认证、身份授权
  13.     //比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
  14.     @Override
  15.     public boolean preHandle(HttpServletRequest request,
  16.             HttpServletResponse response, Object handler) throws Exception {
  17.  
  18.         System.out.println("HandlerInterceptor1...preHandle");
  19.  
  20.         //return false表示拦截，不向下执行
  21.         //return true表示放行
  22.         return true;
  23.     }
  24.  
  25.     //进入Handler方法之后，返回modelAndView之前执行
  26.     //应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
  27.     @Override
  28.     public void postHandle(HttpServletRequest request,
  29.             HttpServletResponse response, Object handler,
  30.             ModelAndView modelAndView) throws Exception {
  31.  
  32.         System.out.println("HandlerInterceptor1...postHandle");
  33.  
  34.     }
  35.  
  36.     //执行Handler完成执行此方法
  37.     //应用场景：统一异常处理，统一日志处理
  38.     @Override
  39.     public void afterCompletion(HttpServletRequest request,
  40.             HttpServletResponse response, Object handler, Exception ex)
  41.             throws Exception {
  42.  
  43.         System.out.println("HandlerInterceptor1...afterCompletion");
  44.     }
  45.  
  46. }

HanlerInterceptor1.java

　　针对HandlerMapping的拦截器(不推荐使用)

　　完成拦截器编写后需要在HandlerMapping处进行定义,毕竟拦截器是映射阶段进行工作的.

  1. package com.harry.interceptor;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5.  
  6. import org.springframework.web.servlet.HandlerInterceptor;
  7. import org.springframework.web.servlet.ModelAndView;
  8.  
  9. public class HandlerInterceptor1 implements HandlerInterceptor {
  10.  
  11.     //进入 Handler方法之前执行
  12.     //用于身份认证、身份授权
  13.     //比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
  14.     @Override
  15.     public boolean preHandle(HttpServletRequest request,
  16.             HttpServletResponse response, Object handler) throws Exception {
  17.  
  18.         System.out.println("HandlerInterceptor1...preHandle");
  19.  
  20.         //return false表示拦截，不向下执行
  21.         //return true表示放行
  22.         return true;
  23.     }
  24.  
  25.     //进入Handler方法之后，返回modelAndView之前执行
  26.     //应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
  27.     @Override
  28.     public void postHandle(HttpServletRequest request,
  29.             HttpServletResponse response, Object handler,
  30.             ModelAndView modelAndView) throws Exception {
  31.  
  32.         System.out.println("HandlerInterceptor1...postHandle");
  33.  
  34.     }
  35.  
  36.     //执行Handler完成执行此方法
  37.     //应用场景：统一异常处理，统一日志处理
  38.     @Override
  39.     public void afterCompletion(HttpServletRequest request,
  40.             HttpServletResponse response, Object handler, Exception ex)
  41.             throws Exception {
  42.  
  43.         System.out.println("HandlerInterceptor1...afterCompletion");
  44.     }
  45.  
  46. }

springmvc.xml

　　全局性拦截器

  1. <!--拦截器 -->
  2. <mvc:interceptors>
  3.     <!--多个拦截器,顺序执行 -->
  4.     <!-- 登陆认证拦截器 -->
  5.     <mvc:interceptor>
  6.         <mvc:mapping path="/**"/>
  7.         <bean class="com.harry.interceptor.LoginInterceptor"></bean>
  8.     </mvc:interceptor>
  9.     <mvc:interceptor>
  10.         <!-- /**表示所有url包括子url路径 -->
  11.         <mvc:mapping path="/**"/>
  12.         <bean class="com.harry.interceptor.HandlerInterceptor1"></bean>
  13.     </mvc:interceptor>
  14.     <mvc:interceptor>
  15.         <mvc:mapping path="/**"/>
  16.         <bean class="com.harry.interceptor.HandlerInterceptor2"></bean>
  17.     </mvc:interceptor>
  18. </mvc:interceptors>
  19.

springmvc.xml

　　拦截器的应用　

　　比如：统一日志处理拦截器,需要该 拦截器preHandle一定要放行,且将它放在拦截器链接中第一个位置.

　　比如：登陆认证拦截器,放在拦截器链接中第一个位置.权限校验拦截器,放在登陆认证拦截器之后.（因为登陆通过后才校验权限）

　　拦截器实现登陆认证

1.处理逻辑

　　用户请求页面

　　拦截器进行拦截

　　　　如果页面无需访问权限,放行

　　　　页面需要访问权限

　　　　　　session存在校验数据,通过

　　　　　　session无校验数据,转入登陆页面

　2.登陆用Controller方法和请求页面　　

  1. package com.harry.controller;
  2.  
  3. import javax.servlet.http.HttpSession;
  4.  
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7.  
  8. @Controller
  9. public class LoginController {
  10.  
  11.     // 登陆
  12.     @RequestMapping("/login")
  13.     public String login(HttpSession session, String username, String password)
  14.             throws Exception {
  15.  
  16.         // 调用service进行用户身份验证
  17.         // ...
  18.  
  19.         // 在session中保存用户身份信息
  20.         session.setAttribute("username", username);
  21.         // 重定向到商品列表页面
  22.         return "redirect:/items/queryItems.action";
  23.     }
  24.  
  25.     // 退出
  26.     @RequestMapping("/logout")
  27.     public String logout(HttpSession session) throws Exception {
  28.  
  29.         // 清除session
  30.         session.invalidate();
  31.  
  32.         // 重定向到商品列表页面
  33.         return "redirect:/items/queryItems.action";
  34.     }
  35.  
  36. }

LoginController.java

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>系统登陆</title>
  8. </head>
  9. <body>
  10. <form action="${pageContext.request.contextPath }/login.action" method="post">
  11. 用户账号：<input type="text" name="username" /><br/>
  12. 用户密码 ：<input type="password" name="password" /><br/>
  13. <input type="submit" value="登陆"/>
  14. </form>
  15. </body>
  16. </html>

login.jsp

　　　3.登陆拦截器和设置

  1. package com.harry.interceptor;
  2.  
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5. import javax.servlet.http.HttpSession;
  6.  
  7. import org.springframework.web.servlet.HandlerInterceptor;
  8. import org.springframework.web.servlet.ModelAndView;
  9.  
  10. public class LoginInterceptor implements HandlerInterceptor {
  11.  
  12.     //进入 Handler方法之前执行
  13.     //用于身份认证、身份授权
  14.     //比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
  15.     @Override
  16.     public boolean preHandle(HttpServletRequest request,
  17.             HttpServletResponse response, Object handler) throws Exception {
  18.  
  19.         //获取请求的url
  20.         String url = request.getRequestURI();
  21.         //判断url是否是公开 地址（实际使用时将公开 地址配置配置文件中）
  22.         //这里公开地址是登陆提交的地址
  23.         if(url.indexOf("login.action")>=0){
  24.             //如果进行登陆提交，放行
  25.             return true;
  26.         }
  27.  
  28.         //判断session
  29.         HttpSession session  = request.getSession();
  30.         //从session中取出用户身份信息
  31.         String username = (String) session.getAttribute("username");
  32.  
  33.         if(username != null){
  34.             //身份存在，放行
  35.             return true;
  36.         }
  37.  
  38.         //执行这里表示用户身份需要认证，跳转登陆页面
  39.         request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
  40.  
  41.         //return false表示拦截，不向下执行
  42.         //return true表示放行
  43.         return false;
  44.     }
  45.  
  46.     //进入Handler方法之后，返回modelAndView之前执行
  47.     //应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
  48.     @Override
  49.     public void postHandle(HttpServletRequest request,
  50.             HttpServletResponse response, Object handler,
  51.             ModelAndView modelAndView) throws Exception {
  52.  
  53.         System.out.println("HandlerInterceptor1...postHandle");
  54.  
  55.     }
  56.  
  57.     //执行Handler完成执行此方法
  58.     //应用场景：统一异常处理，统一日志处理
  59.     @Override
  60.     public void afterCompletion(HttpServletRequest request,
  61.             HttpServletResponse response, Object handler, Exception ex)
  62.             throws Exception {
  63.  
  64.         System.out.println("HandlerInterceptor1...afterCompletion");
  65.     }
  66.  
  67. }

LoginInterceptor.java

  1.         <!--拦截器 -->
  2. <mvc:interceptors>
  3.     <!--多个拦截器,顺序执行 -->
  4.     <!-- 登陆认证拦截器 -->
  5.     <mvc:interceptor>
  6.         <mvc:mapping path="/**"/>
  7.         <bean class="com.harry.interceptor.LoginInterceptor"></bean>
  8.     </mvc:interceptor>
  9. </mvc:interceptors>

springmvc.xml




框架应用 : Spring MVC - 开发详述的更多相关文章

  1. 用Spring MVC开发简单的Web应用

    这个例子是来自于Gary Mak等人写的Spring攻略(第二版)第八章Spring @MVC中的一个例子,在此以学习为目的进行记录. 问题:想用Spring MVC开发一个简单的Web应用, 学习这 ...

  2. 用Spring MVC开发简单的Web应用程序

    1 工具与环境 借助Eclipse4.3 + Maven3.0.3构建Java Web应用程序.使用Maven内置的servlet 容器jetty,不需手工集成Web服务器到Eclipse.还帮我们自 ...

  3. 使用Spring MVC开发RESTful API

    第3章 使用Spring MVC开发RESTful API Restful简介 第一印象 左侧是传统写法,右侧是RESTful写法 用url描述资源,而不是行为 用http方法描述行为,使用http状 ...

  4. Java框架之Spring MVC（一）

    一.Spring简介 Spring MVC是当前最优秀的 MVC 框架,自从Spring 2.5 版本发布后,由于支持注解配置,易用性有了大幅度的提高.Spring 3.0 更加完善,实现了对 Str ...

  5. Spring企业级程序设计 • 【第6章 深入Spring MVC开发】

    全部章节   >>>> 本章目录 6.1 模型数据解析及控制器返回值 6.1.1 ModelAndView多种用法 6.1.2  Map添加模型数据和返回String类型值 6 ...

  6. Spring MVC开发初体验

    1.目标实现Spring MVC : Hello World! 2.工程创建步骤 new : Dynamic Web Project lib引入Spring框架libs/*.jar touch web ...

  7. 框架应用：Mybatis - 开发详述

    ORM框架 在实际开发中,工程中本质的任务是从数据库中获取数据,然后对数据进行操作,又或者写入数据.开发时语言是大多是面向对象的工程语言,这个时候就必须进行工程语言和数据库连接语言的转换,也就是所谓的 ...

  8. Java框架之Spring MVC（二）

    一.Spring MVC 验证 JSR 303 是ajvaEE6 中的一项子规范 ,叫 Bean Validation 用于对javaBean中的字段进行校验. 官方的参考实现是: Hibernate ...

  9. 二十一、MVC的WEB框架（Spring MVC）

    一.基于注解方式配置 1.首先是修改IndexContoller控制器类 1.1.在类前面加上@Controller:表示这个类是一个控制器 1.2.在方法handleRequest前面加上@Requ ...

随机推荐

  1. CentOS6.5下LNMP环境的搭建

    #写的不好,大牛勿喷 #其实我很努力 OS:CentOS6.5 1.关闭SELinux,关闭防火墙 原因:1.SELinux确实可以提高服务器的安全性,但是对于服务器的性能存在一定的影响,同时它的复杂 ...

  2. SNS团队第五次站立会议（2017.04.26）

    一.当天站立式会议照片 本次会议主要内容:汇报工作进度,根据完成情况调整进度 二.每个人的工作 成员 今天已完成的工作 明天计划完成的工作 罗于婕 完善数据库文件 根据需求完善数据库文件 龚晓婷 编写 ...

  3. Java学习4——java常用命令

    javac  file.java 编译Java文件,生成file.class(字节码) java  file   执行Java程序,不加后缀.class java  -version 查看Java版本 ...

  4. 201521123028 《Java程序设计》第6周学习总结

    1. 本周学习总结 1.1 面向对象学习暂告一段落,请使用思维导图,以封装.继承.多态为核心概念画一张思维导图,对面向对象思想进行一个总结. 2. 书面作业 Q1.clone方法 1.1 Object ...

  5. 201521123053 《Java程序设计》第5周学习总结

    1. 本周学习总结 1.1 尝试使用思维导图总结有关多态与接口的知识点. 1.2 可选:使用常规方法总结其他上课内容. 答:我开始做笔记了,在本周学习中的一些笔记 * abstract关键字是为了实现 ...

  6. 201521123056 《Java程序设计》第1周学习总结

    1. 本周学习总结 java语言结构简单,但功能齐全,同时能够在不同系统平台上编译,但编译的前提是系统要有安装JVM(即java虚拟机),JVM是java实现跨平台的最核心部分.本周还学习了JDK.J ...

  7. 201521145042《Java程序设计》第14周学习总结

    MySql操作视频与数据库相关jar文件请参考QQ群文件. 本次作业参考文件 数据库PPT 0. 本周课程设计发布 Java课程设计 1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总 ...

  8. 201521123104 《Java程序设计》 第12周学习总结

    1. 本周学习总结 1.1 以你喜欢的方式(思维导图或其他)归纳总结多流与文件相关内容. 2. 书面作业 将Student对象(属性:int id, String name,int age,doubl ...

  9. 201521123087《java程序设计》第13周学习总结

    1. 本周学习总结 2. 书面作业 1. 网络基础 1.1 比较ping www.baidu.com与ping cec.jmu.edu.cn,分析返回结果有何不同?为什么会有这样的不同? 答: 往返行 ...

  10. Java并发之synchronized关键字

         上篇文章我们主要介绍了并发的基本思想以及线程的基本知识,通过多线程我们可以实现对计算机资源的充分利用,但是在最后我们也说明了多线程给程序带来的两种典型的问题,针对它们,synchronize ...