SpringMVC

SpringMVC包括导入坐标依赖、MVC基本配置、SpringMVC注解、SpringMVC数据响应、SpringMVC异常处理机制等。

SpringMVC

• Spring是基于java实现的 MVC设计模式，请求驱动轻量级的Web框架 MVC框架，通过一套注解，让一个见得java类成为处理请求的控制器，而无需实现任何接口，同时还支持RESTful 编程风格 处理器映射器，处理器适配器，视图解析器 是三大组件
• MVC基本配置
  • 需要导入 Spring 、 SpringMvc 、Servlet 、 jsp 坐标 <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.5.RELEASE</version> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.0.5.RELEASE</version> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.0.1</version> <scope>provided</scope> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.2.1</version> <scope>provided</scope>
  • SpringMVC组件解析 黑马Day03 P22
    • 前端控制器： DispatcherServlet 处理器映射器：HandlerMapping 处理器适配器：HandlerAdapter 处理：Handler 视图解析器：View Resolver 视图：View
  • 导入 SpringMvc坐标
    • <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.0.5.RELEASE</version>
  • 配置MVC 核心控制器 DispathcerServlet
    • <!--配置SpringMVC的前端控制器--> <servlet> <servlet-name>DispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <!-- 指明配置文件在哪 --> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>DispatcherServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
  • 创建Controller 类和视图页面
  • 使用注解配置SpringMVC 核心文件 spring-mvc.xml
    • 开启组件扫描 <!--Controller的组件扫描--> <context:component-scan base-package="com.itheima"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>
• SpringMVC注解
  • 第一部分
    • @Controller 注入Spting容器
    • @RequestMapping 请求映射 建立请求URL 和处理方法之间的关系
      • 类上，请求URL 的第一级访问目录。此处不写的话，相当于应用的根目录 方法上，请求URL 的二级访问目录，与类上的使用 @ReqquesMapping 标注的一级目录一起组成访问虚拟路径 @RequestMapping("/user") public class UserController { 类上面加的 会在8080/user + 方法上面的地址 // 请求地址 http://localhost:8080/user/quick @RequestMapping(value="/quick",method = RequestMethod.GET,params = {"username"}) public String save(){
      • value 指定请求的URL，和path属性作用一样
      • method 指定请求方式
      • params 指定限制请求参数条件，支持简单表达式，需请求参数的key 和value必须一样
        • 例如 params = {"accountName"}，表示请求参数必须有accountName params = {"moeny!100"}，表示请求参数中money不能是100
    • @requestParam 请求参数名称与 Controller 业务参数名 不一致使用此注解来绑定
      • @RequestMapping(value="/quick16") @ResponseBody public void save16(@RequestParam(value="name",required = false,defaultValue = "itcast") String username) throws IOException { System.out.println(username); }
      • value 与请求参数名
      • required 在此指定请求参数名是否必须包括，默认值 true 提交时如果没有此参数则报错
      • defaultValue 当没有指定请求参数时，则使用指定的默认参数赋值
      • @PathVariable 将URL 中占位符参数绑定到控制器处理方法中
        • @RequestMapping("/del/{userId}") public String del(@PathVariable("userId") Long userId){ userService.del(userId); return "redirect:/user/list"; } @RequestMapping("地址{id}") @PathVariable 获取id
    • @RequestHeader 获取请求头信息 属性：value 请求头名称 required 必须携带此请求头
      • @RequestMapping(value="/quick20") @ResponseBody public void save20(@RequestHeader(value = "User-Agent",required = false) String user_agent) throws IOException { System.out.println(user_agent); }
    • @CookieValue 专门获取请求头Cookie 的值 属性：value 指定cookie名称 required 是否必须携带此 cookie
      • @RequestMapping(value="/quick21") @ResponseBody public void save21(@CookieValue(value = "JSESSIONID") String jsessionId) throws IOException { System.out.println(jsessionId); }
  • spring.xml 文件内配置
    • SpringMVC的扫描只扫描MVC 要和Spring区分开 避免重复扫描
      • <!--Controller的组件扫描--> <context:component-scan base-package="com.itheima"> <!-- 只扫描包下的 Controller 注解--> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan> <!--开放资源的访问--> <!--<mvc:resources mapping="/js/**" location="/js/"/> <mvc:resources mapping="/img/**" location="/img/"/>--> //如果mvc 没找到资源，就让 原始容器继续寻找 如：Tomcat <mvc:default-servlet-handler/> 列如二： <!--4、组件扫描 扫描Controller--> <context:component-scan base-package="com.itheima.controller"/>
    • 配置组件 或对内部功能增强 黑马Day03 P29
      • <!--配置内部资源视图解析器--> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!-- /jsp/success.jsp --> <property name="prefix" value="/jsp/"></property> <property name="suffix" value=".jsp"></property> </bean>
• SpringMVC数据响应
  • 页面跳转
    • 直接返回字符串 转发 forward: 重定向 redirect:
      • 回将返回的字符串与视图解析器的前后缀拼接后跳转 @RequestMapping("/quick") public String quickMethod(){ return "index"; } <property name="prefix" value="/WEB-INF/"/> <property name="suffix" value=".jsp"/> 转发资源地址： /WEB-INF/index.jsp
    • 返回ModelAndView对象
      • @RequestMapping("/quick2") public ModelAndView quickMethod2(){ //Model 模型 作用封装数据 View 视图作用展示数据 一般是拆解开的 ModelAndView modelAndView = new ModelAndView(); //设置模型数据 modelAndView.addObject("id","值"); //设置视图名 页面名 modelAndView.setViewName("Aa"); 此方式不常用 @RequestMapping(value="/quick5") //形参 springMVC 自动注入 http请求数据都在 request中 public String save5(HttpServletRequest request){ request.setAttribute("username","酷丁鱼"); return "success"; }
  • 回写数据 不需要事务跳转 void
    • @RequestMapping(value = "/quick5") public void save(HttpServletRequest request){ request.setAttribute("id","值");
    • Web基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用， response.getWriter().pnint("xxx ") 即可， 在Controller 中返回字符串 需要 通过SpringMVC框架注入response对象 在使用 response.getWriter().print(""xxx) 回写数据，此时不需要视图跳转，业务方法返回值为void
    • @ResponseBody 方法上 注解告知 springMVC 框架， 返回的字符串不是跳转是直接在http响应体中返回
      • @RequestMapping(value="/quick7") @ResponseBody //告知SpringMVC框架 不进行视图跳转 直接进行数据响应 public String save7() throws IOException { return "hello itheima"; }
  • 返回对象或集合
    • 通过 json工具将对象转换为json格式字符串
      • 核心 <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.9.0</version> 数据绑定 <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.0</version> 一般注解相关 <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>2.9.0</version>
      • objectMapper 类 writeValueAsSteing( 对象 ) 转换成字符串
        • @RequestMapping(value="/quick9") @ResponseBody public String save9() throws IOException { User user = new User(); user.setUsername("lisi"); user.setAge(30); //使用json的转换工具将对象转换成json格式字符串在返回 ObjectMapper objectMapper = new ObjectMapper(); String json = objectMapper.writeValueAsString(user); return json; }
      • 通过SpringMVC 自动实现对象转换字符串
        • <!--配置处理器映射器--> <<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"> <property name="messageConverters"> <list> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/> </list> </property> </bean> @RequestMapping(value="/quick10") @ResponseBody //期望SpringMVC自动将User转换成json格式的字符串 public User save10() throws IOException { User user = new User(); user.setUsername("lisi2"); user.setAge(32); return user; }
      • 通过MVC注解实现 自动类型装换
        • 使用 <mvc:annotation-driven> 自动加载 RequestMappingHandleMapping (处理器映射器) ReqestMappingHandlerAdapter(处理适配器) 在Spring-xml.xml 文件中 替代注解处理器和适配器配置，<mvc:annotation-driven> 默认底层就会集成 jackson 进行对象或集合的 json格式字符串转换
        • 具体实现
          • <!--mvc的注解驱动--> <mvc:annotation-driven conversion-service="conversionService"/> @RequestMapping(value="/quick10") @ResponseBody //期望SpringMVC自动将User转换成json格式的字符串 public User save10() throws IOException { User user = new User(); user.setUsername("lisi2"); user.setAge(32); return user; }
• SpringMVC 获得数据请求
  • 服务请求格式 ： name=valeue&name=value...
  • 基本类型参数
    • Controller中的业务方法的参数名称要与请求参数的name 一致，参数值会自动映射匹配 服务器端 http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12 后台： @RequestMapping(value="/quick11") @ResponseBody public void save11(String username,int age) throws IOException { System.out.println(username); System.out.println(age); }
  • POJO类型参数
    • Controller中业务方法的POJO参数的属性名与请求参数的name一直，参数会自动映射 客户端 http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12 后端： get set 方法 public class User { private String username; private int age; @RequestMapping(value="/quick12") @ResponseBody public void save12(User user) throws IOException { System.out.println(user); }
  • 数组类型参数 默认打印地址，要转换List集合输出
    • Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。 客户端 http://localhost:8080/itheima_springmvc1/quick11?strs=111&strs=222&strs=333 后端 @RequestMapping(value="/quick13") @ResponseBody public void save13(String[] strs) throws IOException { System.out.println(Arrays.asList(strs)); }
  • 集合类型参数
    • 将集合封装到POJO对象中
      • <form action="${pageContext.request.contextPath}/user/quick14" method="post"> <%--表明是第几个User对象的username age--%> <input type="text" name="userList[0].username"><br/> <input type="text" name="userList[0].age"><br/> <input type="text" name="userList[1].username"><br/> <input type="text" name="userList[1].age"><br/> <input type="submit" value="提交"> </form> @RequestMapping(value="/quick14") @ResponseBody public void save14(VO vo) throws IOException { System.out.println(vo); } public class VO { private List<User> userList;
    • 当使用 ajax 提交时，可以指定 contenType 为json形式，name在方法参数位置使用 @RequestBody 可以直接手集合数据而无需使用POJO进行包装 注意： 需要配置抓包
      • @RequestMapping(value="/quick15") @ResponseBody public void save15(@RequestBody List<User> userList) throws IOException { System.out.println(userList); } $.ajax({ type:"POST", url:"${pageContext.request.contextPath}/user/quick15", data:JSON.stringify(userList), contentType:"application/json;charset=utf-8" });
      • @RequestBody 把请求体直接封装到 集合当中
      • POST请求 出现中文乱码问题 在web.xml 中配置
        • <!--配置全局过滤的filter--> <filter> <filter-name>CharacterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> </init-param> </filter> <filter-mapping> <filter-name>CharacterEncodingFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> /* 代表所有的请求
  • 获取Restful风格的参数
    • Restful 是一种软件 架构风格，设计风格，而不是标准只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更间接，更层次，更易于实现缓存机制等。 Restful 风格的请求是使用 "url+请求方式" 表示一次请求的目的，HTTP 协议里面四个表示操作方式的动词如下 GET: 用于获取资源 POST: 用于新建资源 PUT: 用于更新资源 DELETE: 用于删除资源 列如： /user/1 GET: 得到 id= 1 的user /user/1 DELETE: 删除 id= 1 的user /user/1 PUT： 更新 id=1 的user /user POST: 新增 user url地址中 /user/1 中的 1 就是要获取的请求参数在SpringMVC中可以使用占位符进行参数绑定。地址 /user/1 可以写成 /user/{id} 占位符 {id} 对应的就是1的值，在业务方法中我们可以使用 @PathVariable 注解进行占位符的匹配获取工作 
    • 例子
      • // localhost:8080/user/quick17/zhangsan @RequestMapping(value="/quick17/{name}") @ResponseBody public void save17(@PathVariable(value="name") String username) throws IOException { System.out.println(username); }
  • 自定义类型转换器 定义转换器实现类 Converter 接口
    • SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置
    • 2.在配置文件中声明转换器 3.在 <annotation-deiven> 中引用转换器
      • 例如 日期的转换 1.创建实现类 //泛型参数 字符串String 格式Date public class DateConverter implements Converter<String, Date> { public Date convert(String dateStr) { //将日期字符串转换成日期对象 返回 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); Date date = null; try { date = format.parse(dateStr); } catch (ParseException e) { e.printStackTrace(); } return date; } } 2. spring-mvc.xml 文件 <!--声明转换器--> <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"> <property name="converters"> <list> <!-- 自定义转换器的 路径--> <bean class="com.itheima.converter.DateConverter"></bean> </list> </property> </bean> 3. 通过属性 conversion-service 来引用 <!--mvc的注解驱动--> <mvc:annotation-driven conversion-service="conversionService"/>
  • 获取Servlet 相关API
    • HttpServletRequest HttpServletResponse HttpSession @RequestMapping(value="/quick19") @ResponseBody public void save19(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException { System.out.println(request); System.out.println(response); System.out.println(session); }
  • 获取请求头 @RequestHeader @CookieValue
    • @RequestMapping(value="/quick20") @ResponseBody public void save20(@RequestHeader(value = "User-Agent",required = false) String user_agent) throws IOException { System.out.println(user_agent); }
  • 文件上传
    • 表单项目 type="file" 表单提交方式 post 表单enctype 属性是多部分表单形式，及 enctype="multipart/form-data" 
    • 单文件上传 1.导入fileupload 和io坐标 2.配置文件上传解析器 3.编写文件上传代码 MVC会把文件封装成对象 MultipartFlie 名字必须和上传的表单名一致
      • 1.导入依赖 <groupId>commons-fileupload</groupId> <artifactId>commons-fileupload</artifactId> <version>1.3.1</version> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.3</version> </dependency> 2.配置文件上传解析器 <!--配置文件上传解析器--> <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> <!-- 设置字符集--> <property name="defaultEncoding" value="UTF-8"/> <!-- 上传文件大小--> <property name="maxUploadSize" value="500000"/> </bean> 3.文件上传代码 MVC 会把文件封装 @RequestMapping(value="/quick22") @ResponseBody //参数 文件名 文件1 文件2 public void save22(String username, MultipartFile uploadFile,MultipartFile uploadFile2) throws IOException { System.out.println(username); //获得上传文件的名称 || 服务器|| String originalFilename = uploadFile.getOriginalFilename(); uploadFile.transferTo(new File("C:\\upload\\"+originalFilename)); String originalFilename2 = uploadFile2.getOriginalFilename(); uploadFile2.transferTo(new File("C:\\upload\\"+originalFilename2)); }
      • MultipartFile 对象提供了 transferTo() 方法来保存文件
• 导入坐标依赖
  • <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.5.RELEASE</version> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.0.5.RELEASE</version> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.0.5.RELEASE</version> groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.0.5.RELEASE</version> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.0.1</version> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.2.1</version> <scope>provided</scope>
  • Spring集成web环境
    • new的方式获取 配置文件，会多次加载配置文件 在Web项目中，使用 ServletContextListener 监听Web应用的启动，可以在Web启动 时，加载Spring配置文件，创建应用上下文对象 ApplicationContrxt，在将其存储到最大的 servletContext 域中，这样就可以在任意位从域中获得应用上下文 ApplicationContext 对象、
    • 配置 全局初始化参数 监视器
      • web.xml <!--全局初始化参数--> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param> <!--配置监听器--> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>
    • 工具类配置文件的名
      • public class WebApplicationContextUtils { public static ApplicationContext getWebApplicationContext(ServletContext servletContext){ return (ApplicationContext) servletContext.getAttribute("app"); } }
    • 服务器启动时加载Spring文件，创建应用上下文对象 ApplicationContext, 并且把他储存到servletContext域中
      • public class ContextLoaderListener implements ServletContextListener { public void contextInitialized(ServletContextEvent servletContextEvent) { ServletContext servletContext = servletContextEvent.getServletContext(); //读取web.xml中的全局参数 String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation"); ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation); //将Spring的应用上下文对象存储到ServletContext域中 servletContext.setAttribute("app",app); System.out.println("spring容器创建完毕...."); } public void contextDestroyed(ServletContextEvent servletContextEvent) { } }
    • 调用时代码
      • public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { //ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); ServletContext servletContext = this.getServletContext(); //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app"); //ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext); ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext); UserService userService = app.getBean(UserService.class); userService.save(); } }
    • Spring提供了一个监听器 ContextLoaderListener ，来监听Spring文件，创建应用上下文对象，储存到 ServletContext 域中，提供一个客户端工具 WebApplicationContextUtils 使用获得上下文对象 使用中： 在web.xml中配置 ConTextLoaderListener 监听器（导入spring-web) 、 使用WebApplicationContextUtils 获取应用上下文对象 ApplicationContext
      • pom.xml配置文件 <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.0.5.RELEASE</version> web.xml配置文件 <!--全局初始化参数--> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param> <!--配置监听器--> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <!--开放资源的访问--> <!--<mvc:resources mapping="/js/**" location="/js/"/> <mvc:resources mapping="/img/**" location="/img/"/>--> //如果mvc 没找到资源，就让 原始容器继续寻找 如：Tomcat <mvc:default-servlet-handler/> 直接使用 public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ServletContext servletContext = this.getServletContext(); ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext); UserService userService = app.getBean(UserService.class); userService.save(); } }
• SpringMVC异常处理机制
  • Dao - service - Controller -前端控制器MVC来处理
  • 使用SpringMVC 提供的简单异常处理器 SimpleMappingExcptionResolver
    • spring-mvc.xml <!--配置异常处理器--> <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"> <property name="defaultErrorView" value="error"/>//默认错误 跳转视图 <property name="exceptionMappings"> <map> <entry key="java.lang.ClassCastException" value="error1"/>//key 异常类型 value 跳转到 视图 <entry key="com.itheima.exception.MyException" value="error2"/> </map> </property> </bean>
  • 实现 Spring 的异常处理接口 HandlerExceptionResolver 自定义的异常处理器
    • 1.创建异常处理 HandlerExceptionResolver 实现类 2.配置异常处理器 3.编写异常页面
      • Spring-mvc.xml <!--自定义异常处理器--> <bean class="com.itheima.resolver.MyExceptionResolver"/>//实现类路径 public class MyExceptionResolver implements HandlerExceptionResolver { /* 参数Exception：异常对象 返回值ModelAndView：跳转到错误视图信息 */ public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) { ModelAndView modelAndView = new ModelAndView(); if(e instanceof MyException){ modelAndView.addObject("info","自定义异常"); }else if(e instanceof ClassCastException){ modelAndView.addObject("info","类转换异常"); } modelAndView.setViewName("error"); return modelAndView; } }
• SpringMVC拦截器
  • 类似于 Servlet 开发过程中的过滤器 Filter 用于对处理器进行预处理 和 后处理 拦截器按一定顺序联结成一条链，这条链称为 拦截器（Interceptor Chain） ，在访问被拦截的方法或字段时，拦截器就会按之前定义的顺序调用，拦截器是AOP思想的具体体现
  • 自定义拦截器步骤： 1.创建拦截器实现 Handlerinterceptor 接口 2.配置拦截器
    • public class MyInterceptor1 implements HandlerInterceptor { Spring-mvc.xml 中 <!--配置拦截器--> <mvc:interceptors> <mvc:interceptor> <!--对哪些资源执行拦截操作--> <mvc:mapping path="/**"/> <bean class="com.itheima.interceptor.MyInterceptor2"/> </mvc:interceptor> <mvc:interceptor> <!--对哪些资源执行拦截操作--> <mvc:mapping path="/**"/> <bean class="com.itheima.interceptor.MyInterceptor1"/> //class="地址 指向实现类" </mvc:interceptor> </mvc:interceptors> 拦截器配置过滤 部分 <mvc:interceptors> <mvc:interceptor> <!--配置对哪些资源执行拦截操作--> <mvc:mapping path="/**"/> <!--配置哪些资源排除拦截操作--> <mvc:exclude-mapping path="/user/login"/>//请求 <bean class="com.itheima.interceptor.PrivilegeInterceptor"/>//排除实现类 </mvc:interceptor> </mvc:interceptors>
    • HandlerInterceptor 中方法返回 false 就不往下执行
      • 目标方法执行之前 执行 default boolean preHandle（） 目标方法执行之后 视图对象返回之前 执行 public void postHandle() 在流程都执行完毕之后 执行 public void afterCompletion() //在目标方法执行之前 执行 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException { System.out.println("preHandle....."); String param = request.getParameter("param"); if("yes".equals(param)){ return true; }else{ request.getRequestDispatcher("/error.jsp").forward(request,response); return false;//返回true代表放行 返回false代表不放行 } }
    • 配置多个拦截器时 执行顺序
      • 拦截器A 拦截B A1 执行 B1 执行 目标方法执行 B1 视图前 A1 视图前 B1 结束方法 A1 结束方法
    • 例子
      • public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException { //逻辑：判断用户是否登录 本质：判断session中有没有user HttpSession session = request.getSession(); User user = (User) session.getAttribute("user"); if(user==null){ //没有登录 response.sendRedirect(request.getContextPath()+"/login.jsp"); return false; } //放行 访问目标资源 return true; }
• JdbcTemplate
  • spring 框架中提供的一个对象，是对原始繁琐的 jdbc API 对象的简单封装，spring框架为我们提供了很多操作模板，例如：操作关系型数据的 JdbcTemplate 和 HibernateTemplate 操作nosql数据库的 Redis Template 操作消息队列的 JmsTemplate 等等
  • 导入坐标 依赖
    • Spring-jdbc 和spring-tx 坐标、 <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.0.5.RELEASE</version> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>5.0.5.RELEASE</version>
  • 通过spring 产生数据源对象
    • xml 配置文件 <!--数据源对象--> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="${jdbc.driver}"/> <property name="jdbcUrl" value="${jdbc.url}"/> <property name="user" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <!--jdbc模板对象--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"/> </bean> 得到 JdbcTempLate 对象 //测试Spring产生jdbcTemplate对象 public void test2() throws PropertyVetoException { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); JdbcTemplate jdbcTemplate = app.getBean(JdbcTemplate.class); int row = jdbcTemplate.update("insert into account values(?,?)", "lisi", 5000); System.out.println(row); }
    • 方式二： 需要创建数据源对象 jdbcTemplate.setDateSource(datasource) 设置数据源
      • @Test //测试JdbcTemplate开发步骤 public void test1() throws PropertyVetoException { //创建数据源对象 ComboPooledDataSource dataSource = new ComboPooledDataSource(); dataSource.setDriverClass("com.mysql.jdbc.Driver"); dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test"); dataSource.setUser("root"); dataSource.setPassword("root"); JdbcTemplate jdbcTemplate = new JdbcTemplate(); //设置数据源对象 知道数据库在哪 jdbcTemplate.setDataSource(dataSource); //执行操作 int row = jdbcTemplate.update("insert into account values(?,?)", "tom", 5000); System.out.println(row); }
  • 修改 .update(sql语句，参数) 增删改
    • public void testUpdate(){ jdbcTemplate.update("update account set money=? where name=?",10000,"tom"); } public void testDelete(){ jdbcTemplate.update("delete from account where name=?","tom"); }
  • 查询 .query(sql语句，返回对象) 返回的List<T> 集合 .queryForObjcet() 返回单个结果
    • @Test//泛型是 数据库 对应实现类 public void testQueryAll(){ List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class)); System.out.println(accountList); } public void testQueryOne(){ Account account = jdbcTemplate.queryForObject("select * from account where name=?", new BeanPropertyRowMapper<Account>(Account.class), "tom"); System.out.println(account); } 查询总条数 public void testQueryCount(){ Long count = jdbcTemplate.queryForObject("select count(*) from account", Long.class); System.out.println(count); }

MVC

• JdbcTemplate
  • 导入 spring-jdbc 和 spring-tx 坐标 创建数据库表和实体 创建JdbcTempalte 对象 JdbcTemplate jdbcTemplate=new JdbcTemplate(); JdbcTemplate.setDataSource(dataSource); 数据库操作 .update() 增删改 .queryForObjcet(); 查询