Spring 学习小记（十二）

最新推荐文章于 2021-12-16 15:18:43 发布
最新推荐文章于 2021-12-16 15:18:43 发布
阅读量391 收藏
点赞数
分类专栏： 编程 Java 文章标签： spring springmvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/advent_java/article/details/111146513
版权
编程 同时被 2 个专栏收录
101 篇文章 0 订阅
订阅专栏
Java
67 篇文章 0 订阅
订阅专栏
Spring MVC的Controller
 
本小记学习目标
  1. 基于注解的控制器使用
  2. 请求处理方法的编写
  3. Controller接收的请求参数介绍
  4. 重定向与转发的实现
  5. 其它相关的注解
 
一、基于注解的控制器使用
        在前面我们入门Spring MVC应用中，我们控制器它是通过实现Controller接口类来实现的，它的局限性在于通过这种方式实现的控制器需要在Spring的配置文件中对控制器进行映射配置并且对于控制器来说一个控制器的实现类只能编写一个处理方法。于是Spring MVC中控制器一般是使用注解的方式来指定。使用注解的控制器具有如下优点：
  1. 基于注解的控制器类可以编写多个处理方法，所以它可以处理多个请求。这样可以把相关的操作编写到同一个控制器类中做归类处理，这样可以明显地减少控制器的数量，方便以后的维护。
  2. 基于注解的控制器不需要在配置文件中进行配置。（仅需要在配文件中指定Spring的扫描包即可）
 
这里有两个重要的注解：Controller、RequestMapping
Controller注解
在Spring MVC中，它用来声明某个类的实例是一个控制器。它对应的注解类型是：org.springframework.stereotype.Controller
这个控制器的注解存在默认的value值，它是类名的首字母小写的方式
 
RequestMapping注解
在Spring MVC中，它用来在控制器为类中为每个请求编写声明处理方法，它对应的注解类型是：org.springframework.web.bind.annotation.RequestMapping
 
二、请求处理方法的编写
在controller包中新增一个Controller实现类：UserController
package com.xiaoxie.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/*
 * @Controller:表示UserController的实例就是一个控制器
 * 它相当于如下两个写法
 * @Controller(userController)/@Controller(value="userController")
 */
@Controller
@RequestMapping( "/user")
public class UserController {
       @RequestMapping( "/login")
       public String login() {
             return "login";
      }
       @RequestMapping( "/register")
       public String register() {
             return "register";
      }
}
注意：上面在类上有@RequestMapping，在具体的处理方法上也有@RequestMapping，这样做的目的就是对于类上的注解指定它是哪个模块的请求，比如上面的user，在处理的处理方法上则指定明确的请求
那行对于login（）这个方法它实际请求的则是/user/login
 
在Spring的配置文件中，指定Spring扫描Controller包其子包的位置，需要添加如下配置
<!-- 指定Spring扫描Controller包及其子包 -->
< context:component-scan base-package= "com.xiaoxie.controller" />
 
请求处理方法中常见的参数介绍
  1. 如果希望在请求处理方法中使用Servlet API类型，那么可以把这些类型作为请求处理方法的参数
        比如在UserController中新增一个请求处理方法
    @RequestMapping( "/param1")
       public String param1(HttpSession session,HttpServletRequest request) {
             session.setAttribute( "session_key", "session的值");
             request.setAttribute( "request_key", "request的值");
             return "param";
      }
    这个时候返回到视图中去的时候则可以获取到这些类所绑定的参数
    2.可以使用Model类型（org.springframework.ui.Model）作参数
    比如在UserController中新增一个请求处理方法
     @RequestMapping( "/param2")
       public String param2(Model model) {
             model.addAttribute( "model_key", "model类型绑定的值");
             return "param";
      }
    这个时候在在model参数中则绑定了相应的值，在JSP视图中可以使用EL表达式来获取这个绑定的值${model_key}
    3.除了上达的参数外，参数还可以是输入/出流、表单实体类、注解类型……与Spring框架相关的类型
 
请求处理方法的返回值类型
    1.一般来说返回值类型为String，它代表了逻辑视图的名称
    2.返回值也可以是ModelAndView、Model、View或其它Java类型
 
三、Controller接收请求参数的介绍
通过实体Bean接收请求参数
通过实体Bean来接收请求参数，适用于get和post请求，这里有一个要求就是Bean的属性名称必须要与请求参数的名称保持一致
 
新增一个pojo实体类：UserForm，它的目的是用来接收请求过来的参数（注意：UserForm中的属性需要与提交的请求参数名称保持一致）
package com.xiaoxie.pojo;
public class UserForm {
       private String uname;
       private String upass;
       private String reupass;
       public String getUname() {
             return uname;
      }
       public void setUname(String uname) {
             this. uname = uname;
      }
       public String getUpass() {
             return upass;
      }
       public void setUpass(String upass) {
             this. upass = upass;
      }
       public String getReupass() {
             return reupass;
      }
       public void setReupass(String reupass) {
             this. reupass = reupass;
      }
}
 
改造UserController类中的登录请求处理及注册请求处理方法（改造后的UserController类如下）
package com.xiaoxie.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import com.xiaoxie.pojo.UserForm;
/*
 * @Controller:表示UserController的实例就是一个控制器
 * 它相当于如下两个写法
 * @Controller(userController)/@Controller(value="userController")
 */
@Controller
@RequestMapping( "/user")
public class UserController {
       //使用记录日志的对象
       private static final Log logger = LogFactory. getLog(UserController. class);
      
       /**
       * 处理用户登录请求
       * @param user UserForm对象，接收登录页面提交的请求参数
       * @param session
       * @param model
       * @return
       */
       @RequestMapping( "/login")
       public String login(UserForm user,HttpSession session,Model model) {
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( user.getUname()) && "123456".equals( user.getUpass())) {
                   session.setAttribute( "login_user", user);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
      
       /**
       * 处理用户注册请求
       * @param user user UserForm对象，接收注册页面提交的请求参数
       * @param model
       * @return
       */
       @RequestMapping( "/register")
       public String register(UserForm user,Model model) {
             //对注册提交的信息进行后端校验
             if( "xiaoxie".equals( user.getUname()) && "123456".equals( user.getUpass())) {
                   logger.info( "注册成功！");
                   return "login";    //注册成功后跳转到login.jsp
            } else {
                   logger.info( "注册失败！");
                   model.addAttribute( "error_tips", "用户名：" + user.getUname() + "注册失败！");
                   return "register";
            }
      }
      
       @RequestMapping( "/param1")
       public String param1(HttpSession session,HttpServletRequest request) {
             session.setAttribute( "session_key", "session的值");
             request.setAttribute( "request_key", "request的值");
             return "param";
      }
      
       @RequestMapping( "/param2")
       public String param2(Model model) {
             model.addAttribute( "model_key", "model类型绑定的值");
             return "param";
      }
}
 
对index.jsp页面进行设计，这里主要是提供两个连接可以跳转到login.jsp页面和register.jsp页面
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
      未注册用户，请 < a href= "${pageContext.request.contextPath } /register" >注册 </ a >！ < br />
      已注册用户，请 < a href= "${pageContext.request.contextPath } /login" >登录 </ a >！
       < hr />
       Servlet API类型作为Controller中处理方法的参数： < a href= "${pageContext.request.contextPath } /user/param1" >访问,Servlet_API参数 </ a >< br >
       < hr />
      Model类型作为Controller中处理方法的参数： < a href= "${pageContext.request.contextPath } /user/param2" >访问,Model参数 </ a >
</ body >
</ html >
 
新增login.jsp、register.jsp、main.jsp,它们都在WEB-INF/jsp下
login.jsp
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
       < form action= "${pageContext.request.contextPath } /user/login" method= "post" >
             < table border= "1" bgcolor= "lightblue" align= "center" >
                   < tr >
                         < td >姓名： </ td >
                         < td >< input type= "text" name= "uname" ></ td >
                   </ tr >
                   < tr >
                         < td >密码： </ td >
                         < td >< input type= "password" name= "upass" ></ td >
                   </ tr >
                   < tr >< td colspan= "2" align= "center" >< input type= "submit" value= "登录" ></ td ></ tr >
             </ table >
             < span style=" color: red;" >${error_tips } </ span >
       </ form >
</ body >
</ html >
 
register.jsp
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
       < form action= "${pageContext.request.contextPath } /user/register" method= "post" >
             < table border= "1" bgcolor= "lightblue" align= "center" >
                   < tr >
                         < td >姓名： </ td >
                         < td >< input type= "text" name= "uname" ></ td >
                   </ tr >
                   < tr >
                         < td >密码： </ td >
                         < td >< input type= "password" name= "upass" ></ td >
                   </ tr >
                   < tr >
                         < td >确认密码： </ td >
                         < td >< input type= "password" name= "reupass" ></ td >
                   </ tr >
                   < tr >< td colspan= "2" align= "center" >< input type= "submit" value= "注册" ></ td ></ tr >
             </ table >
             < span style=" color: red;" >${error_tips } </ span >
       </ form >
</ body >
</ html >
 
main.jsp
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
      欢迎管理员：${login_user.uname }
</ body >
</ html >
 
通过处理方法的形参来接收请求参数
这种方式就是直接把请求参数写到控制器类相应请求处理方法的形参中，这里要求形参的名称要与请求参数的名称完全一致。适用于get和post请求。
把上面的login处理方法进行改造
@RequestMapping( "/login")
public String login(String uname,String upass,HttpSession session,Model model) {
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( uname) && "123456".equals( upass)) {
                   session.setAttribute( "login_user", uname);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
第二个改造的地方就是main.jsp,因为这个时候当登录成功时login_user中绑定的不是一个pojo对象而是一个字符串的值
在<body>标签中直接展示登录成功的名称
欢迎管理员：${login_user }
 
通过HttpServletRequest接收请求参数
这种方式支持get和post的请求，它直接是使用HttpServletRequest来作为参数接收请求的信息
把login处理方法再做如下改造
      @RequestMapping( "/login")
       public String login(HttpServletRequest request,Model model) {
             //获取请求参数
            String uname = request.getParameter( "uname");
            String upass = request.getParameter( "upass");
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( uname) && "123456".equals( upass)) {
                   request.getSession().setAttribute( "login_user", uname);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
 
通过@PathVariable接收URL中的请求参数
对login的处理方法做如下改造
@RequestMapping(value= "/login/{uname}/{upass}",method=RequestMethod. GET)
       public String login( @PathVariable String uname, @PathVariable String upass,HttpSession session, Model model) {
             //获取请求参数
             //String uname = request.getParameter(" uname ");
             //String upass = request.getParameter(" upass ");
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( uname) && "123456".equals( upass)) {
                   session.setAttribute( "login_user", uname);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
这里要注意是：@RequestMapping中对于请求的地址需要把请求的参数做模板配置上，并且需要指定method
这个时候请求类似于：http://localhost:8088/SSM_12/login/xiaoxie/123456
 
通过@RequestParam接收请求
它可以支持get和post请求
@RequestMapping( "/login")
       public String login( @RequestParam String uname, @RequestParam String upass,HttpSession session, Model model) {
             //获取请求参数
             //String uname = request.getParameter(" uname ");
             //String upass = request.getParameter(" upass ");
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( uname) && "123456".equals( upass)) {
                   session.setAttribute( "login_user", uname);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
这里要注意，如果我们在指定@RequestParam的时候形参与请求时提交的参数名称不一样会报404的错误，而如果我们直接使用形参来接收请求时提交的参数当名称不一致时只是接收到不请求的信息并不会报404的错误
 
通过@ModelAttribute接收请求参数
当把它放到处理方法的形参上的时候，会把多个请求封装为一个实体对象，并且会自己动暴露模型数据，不需要使用model.addAttribute,可以直接在jsp中使用EL表达式获取到模型对象的数据
改造login的处理方法
@RequestMapping( "/login")
       public String login( @ModelAttribute( "user") UserForm user) {
             //获取请求参数
             //String uname = request.getParameter(" uname ");
             //String upass = request.getParameter(" upass ");
             //对提交的请求参数进行判断
             if( "xiaoxie".equals( user.getUname()) && "123456".equals( user.getUpass())) {
                   //session.setAttribute("login_user", uname1);
                   logger.info( "登录成功！");
                   return "main";     //登录成功后跳转到main.jsp
            } else {
                   logger.info( "登录失败！");
                   //model.addAttribute("error_tips", "用户名或密码错误！");
                   return "login";
            }
      }
在登录失败后在jsp页面中显示失败的提示，所以改造login.jsp如下
<%@ page language= "java" contentType= "text/html; charset=UTF-8"
    pageEncoding= "UTF-8" %>
<%@ taglib uri= "http://java.sun.com/jsp/jstl/core" prefix= "c" %>
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" >
< html >
< head >
< meta http-equiv= "Content-Type" content= "text/html; charset=UTF-8" >
< title >Insert title here </ title >
</ head >
< body >
       < form action= "${pageContext.request.contextPath } /user/login" method= "get" >
             < table border= "1" bgcolor= "lightblue" align= "center" >
                   < tr >
                         < td >姓名： </ td >
                         < td >< input type= "text" name= "uname" ></ td >
                   </ tr >
                   < tr >
                         < td >密码： </ td >
                         < td >< input type= "password" name= "upass" ></ td >
                   </ tr >
                   < tr >< td colspan= "2" align= "center" >< input type= "submit" value= "登录" ></ td ></ tr >
             </ table >
             <%-- <span style="color: red;">用户：${user.uname }登录失败！</span> --%>
             < c:if test= "${user.uname!=null and user.uname!='' } " >
                   < span style=" color: red;" >用户：${user.uname }登录失败！ </ span >
             </ c:if >
            
       </ form >
</ body >
</ html >
注意：这里使用了jstl的标签，需要依赖相应的标签库jar包，在pom.xml中添加相应的依赖
< dependency >
    < groupId >javax.servlet </ groupId >
    < artifactId > jstl </ artifactId >
    < version >1.2 </ version >
</ dependency >
 
四、重定向与转发
重定向：把当前处理请求定向一另一个视图或处理请求，之前的请求中存放的信息将全部失效，并进入到一个新的Request作用域。
转发：把当前处理请求转给到另一个视图或处理请求，之前的请求reques中存放的信息不会失效。
重定向是客户端的行为，转为则是服务器行为。
 
转发的过程：
浏览器---->http请求---->Web服务器---->调用内部方法在容器内完成请求处理和转发动作---->处理后的目标资源发送给客户
注意：转发是在容器内完成的，必须是同一个web容器下的URL,不可以转发到其它的Web路径上去（这其中请求的信息会是第一次请求上的request），在外在来看客户的浏览器地址栏中显示的信息一值为保存为第一次访问的路径，也就是说客户端是不感知的它是服务器内容的行为。
 
重定向的过程：
浏览器---->http请求---->web服务器接收请求后发送302状态码响应和对应的新的location给浏览器---->浏览器发现302响应，则会自动发送一个新的http请求---->web服务器根据这个新的请求寻找资源返回给到浏览器
注意：这里新的location要以是任意的URL不局限在web容器内部，重定向后浏览器地址栏也会做相应的变化，浏览器在这个过程中至少做了两次请求。
 
前面的例子中我们在Spring MVC中Controller中请求处理方法return的都是默认使用转发来实现的，如果我们需要指明是转发还是重定向则需要在retrun返回的字符串前加缀加上 forward: 或 redirect:
如：return "forward:/user/login";    //转发到一个请求方法
    return "redirect:/user/register";    //重定向到一个请求方法
注意：上述的转发和重定向中的内容都会受到配置视图解析器的处理，如果需要直接转到到一个资源（如：某个静态资源页面）而不需要DispatcherServlet的处理，则需要在配置文件中使用mvc:resource配置，其配置如下：
     <!-- css 目录下的所有文件可见 -->
       < mvc:resources location= "/css/" mapping= "/css/**" />
       <!-- html 目录下的所有文件可见 -->
       < mvc:resources location= "/html/" mapping= "/html/**" />
       <!-- images目录下的所有文件可见 -->
       < mvc:resources location= "/images/" mapping= "/images/**" />
 
五、其它相关注解
 
@Autowired注解
在前面所有的例子及说明中我们看到了MVC中的V、和C,这里的M层由控制一并充当了，这样的设计是不够合理的，应该把M层的实际作用从C层中剥离出来。这个时候可以使用Spring的依赖注入的优点，把相应的M层定义出来并自动注入到C层中，这样的话则M层的逻辑则从C层中剥离出来了，只保留了他们之前的依赖关系。
使用@Service注解来注解一个M，同时要在Spring的配置文件中指定自动扫描包<context:component-scan base-package="包路径"/>(这个时候包路径及其子包都会被spring自动扫描)
 
新增service的接口及实现类com.xiaoxie.service.UserService、com.xiaoxie.service.impl.UserserviceImpl
package com.xiaoxie.service;
import com.xiaoxie.pojo.UserForm;
/*
 * 这里service的接口：指定M层提供的服务有哪些
 */
public interface UserService {
       boolean login(UserForm user);
       boolean register(UserForm user);
}
 
package com.xiaoxie.service.impl;
import org.springframework.stereotype.Service;
import com.xiaoxie.pojo.UserForm;
import com.xiaoxie.service.UserService;
//@Service指定这是一个服务M层
@ Service
public class UserServiceImpl implements UserService {
       /**
       * 用户登录服务
       */
       @Override
       public boolean login(UserForm user) {
             if( "xiaoxie".equals( user.getUname()) && "123456".equals( user.getUpass())) {
                   return true;
            } else {
                   return false;
            }
      }
       /**
       * 用户注册服务
       */
       @Override
       public boolean register(UserForm user) {
             if( "xiaoxie".equals( user.getUname()) && "123456".equals( user.getUpass())) {
                   return true;
            } else {
                   return false;
            }
      }
}
这里注意使用了@Service注解指定实现类为一个service服务M层
 
对UserController类中的login及register方法进行调整，调整后的类如下
package com.xiaoxie.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import com.xiaoxie.pojo.UserForm;
import com.xiaoxie.service.UserService;
/*
 * @Controller:表示UserController的实例就是一个控制器
 * 它相当于如下两个写法
 * @Controller(userController)/@Controller(value="userController")
 */
@Controller
@RequestMapping( "/user")
public class UserController {
       //使用记录日志的对象
       private static final Log logger = LogFactory. getLog(UserController. class);
       @Autowired
       public UserService userService;
       /**
       * 处理用户登录请求
       * @param user UserForm对象，接收登录页面提交的请求参数
       * @param session
       * @param model
       * @return
       */
       @RequestMapping( "/login")
       public String login(UserForm user, HttpSession session, Model model) {
             if( userService.login( user)) {
                   //验证成功
                   session.setAttribute( "login_user", user);
                   logger.info( "登录成功！");
                   return "main";     //转发到main.jsp
            } else {
                   logger.info( "登录失败！");
                   model.addAttribute( "error_tips", "用户名：" + user.getUname() + "登录失败！");
                   return "login";
            }
      }
      
       /**
       * 处理用户注册请求
       * @param user user UserForm对象，接收注册页面提交的请求参数
       * @param model
       * @return
       */
       @RequestMapping( "/register")
       public String register(UserForm user,Model model) {
             //对注册提交的信息进行后端校验
             if( userService.register( user)) {
                   logger.info( "注册成功！");
                   return "login";    //转发到login.jsp
            } else {
                   logger.info( "注册失败！");
                   model.addAttribute( "error_tips", "用户名：" + user.getUname() + "注册失败！");
                   return "register";      
            }
      }
      
       @RequestMapping( "/param1")
       public String param1(HttpSession session,HttpServletRequest request) {
             session.setAttribute( "session_key", "session的值");
             request.setAttribute( "request_key", "request的值");
             return "param";
      }
      
       @RequestMapping( "/param2")
       public String param2(Model model) {
             model.addAttribute( "model_key", "model类型绑定的值");
             return "param";
      }
}
这里注意：使用了@Autowired把service的实现类自动注入进来
同时在配置文件中需要指定扫描service包
<context:component-scan base-package= "com.xiaoxie.service"/>
 
在实验过程中不小心把工程src目录下的内容删除掉了，解决办法
在硬盘中找到项目的目录，在目录下的WebContent/WEB-INF/jsp下有对应最新的src目录，拷贝到项目目录上，同时在Eclipse中刷新工程即可。
 
@ModelAttribute注解
这个注解有两个功能：
第一，当把它放到处理方法的形参上的时候，会把多个请求封装为一个实体对象，并且会自己动暴露模型数据，不需要使用model.addAttribute,可以直接在jsp中使用EL表达式获取到模型对象的数据（在前面已经说过）
第二，被它注解的方法会在每次调用控制器类之前先调用这个方法，这样就可以在这个方法中处理一些共用的需地前置处理的功能（比如：权限的检查）
 
比如：新增一个BaseController类
package com.xiaoxie.controller;
import org.springframework.web.bind.annotation.ModelAttribute;
public class BaseController {
       @ModelAttribute
       public void checkAndInit() {
            System. out.println( "----------加载初始化资源--------");
            System. out.println( "----------检查执行权限---------");
      }
}
 
在UserController类上加上extends BaseController，这样在每次执行UserController中的请求处理方法之前都会在控掉台打印出上面的两个语句。
xiaoxie_advent
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC实战（四）-处理模型数据
Ricky
05-08 1万+
Spring MVC 提供了以下几种途径输出模型数据： ModelAndView：处理方法返回值类型为 ModelAndView时, 方法体即可通过该对象添加模型数据 Map及Model：入参为org.springframework.ui.Model、org.springframework.ui.ModelMap或 java.uti.Map时，处理方法返回时，Map 中的数据会自动添加到模型中。 @
nginx rewrite不生效_Nginx实现URL重写
weixin_39722692的博客
01-04 1300
本文利用Nginx实现URL重写，本文使用Nginx与静态页面配合重写URL。1.准备工作。结合本文场景，需要安装Nginx。1.1 关于Linux系统安装Nginx可以参考我的文章—(传送门)。2.什么是URL重写？URL重写是指将一个URL请求重新写成网站可以处理的另一个URL的过程。这样说可能不是很好理解，举个例子来说明一下，在开发中可能经常遇到这样的需求，比如通过浏览器请求的http://...
Nginx rewrite
limy_yi的博客
05-07 1377
rewirte规则也称为规则重写,主要功能是实现浏览器访问 Http URL的跳转,其正 则表达式是基于Perl语言。通常而言,几乎所有的Web服务器均可以支持URL重写。 rewrite URL规则重写的用途如下 1、对搜索引擎优化( search engine optimization,SEO)友好,利于搜索引擎抓取网站页面 2、隐藏网站URL真实地址,浏览器显示更加美观; 3、网站更换新域名...
Spring MVC中Controller如何将数据返回给页面
热门推荐
yh_zeng2的博客
07-12 5万+
要实现Controller返回数据给页面，Spring MVC 提供了以下几种途径： ModelAndView：将视图和数据封装成ModelAndView对象，作为方法的返回值，数据最终会存到HttpServletRequest对象中！ Model对象：通过给方法添加引用Model对象入参，直接往Model对象添加属性值。那么哪些类型的入参才能够引用Model对象，有三种类型，分别是  org...
SpringBoot OA自动化办公系统
Zyw907155124的博客
12-16 4268
OA办公自动化系统http://121.40.112.207:8081/oa自动化办公系统源码及需求文档https://download.csdn.net/download/Zyw907155124/64741549 1、产品介绍 OA系统是将现代办公和计算机网络的功能相结合的一中新型办公方式，是针对日常工作，改变传统手工办公效率低下现状的一种变革。omation的简称。 OFFIC ： AUTOMATION的缩写，本意为利用技术的手段提高办公的效率，进而实现办公的自动化...
Spring框架学习指南
最新发布
06-20
这是一份专门针对Spring框架的中文学习教程，旨在帮助读者深入了解Spring的核心概念、特性和用法。无论是初学者还是有一定经验的开发者，都能从中获得宝贵的指导和参考。教程内容全面，涵盖了Spring的基础配置、核心...
Spring详细学习资料下载
03-04
1 什么是spring ? Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架. spring的设计思想是，单例模式和工厂模式 2 spring的四大特点...
spring学习笔记1
03-16
spring学习笔记1
狂神springcloud学习笔记加代码
03-24
狂神springcloud学习笔记加代码 笔记可以看：https://www.kuangstudy.com/bbs/1374942542566551554#header4 视频链接：https://www.bilibili.com/video/BV1jJ411S7xr
spring第一天学习
02-15
spring学习第一天讲义
redirect重定向中可以带参数吗_之前在nginx配置rewrite重写中遇到的坑
weixin_39942726的博客
12-04 632
正则表达式匹配，其中：* ~ 为区分大小写匹配* ~* 为不区分大小写匹配* !~和!~*分别为区分大小写不匹配及不区分大小写不匹配文件及目录匹配，其中：* -f和!-f用来判断是否存在文件* -d和!-d用来判断是否存在目录* -e和!-e用来判断是否存在文件或目录* -x和!-x用来判断文件是否可执行flag标记有：* last 相当于Apache里的[L]标记，表示完成rewrite* br...
nginx ngx_http_rewrite_module 模块填坑小记
Chappi
04-21 9445
在使用rewrite模块进行uri重写时，得先补充几个知识点nginx常用的变量推荐给nginx安装一个Echo Module，能够非常方便的将我们的请求产生的变量打印出来，nginx选用nginx/1.11.10版本最好，再高一点的版本编译Echo模块会报错。nginx编译成功后添加如下配置。 server { root /usr/local/nginx/html/;
SpringBoot+MyBatis登录案例
weixin_45967375的博客
06-18 373
1.创建一个SpringBoot项目
SpringMVC(六)_处理模型数据方式整理
风清扬
08-13 239
        前言：本文主要介绍SpringMVC处理模型数据的方式，包括以Map、Model、ModelAndView作为模型数据，介绍指定响应页面的方式。   前台测试界面(type、username、password用来接收后台传来的数据，以检验后台模型数据的正确性 )：   1. 测试页面传参(ModelAndView——构造函数设置view) 　　Spring Web...
SpringBoot get/post请求详解
做Java整整10年，目前是教别人写代码，嘿嘿
11-05 6998
目录 一、普通参数形式 基本数据类型（以int为例） 包装类型参数绑定 自定义对象类型参数绑定 自定义复合对象类型参数绑定 List参数绑定 Map参数绑定 @RequestParam注解解析 1）参数限制（可用required=false关闭） 2）设置参数默认值 3）自定义参数名称 数组类型参数绑定 1）基本数组类型接收参数 2）List类型接收参数 本文介绍基于SpringBoot下get/post请求 一、普通参数形式 基本数据类型（以int为例） 在contr.
前端判断登陆页面输入是否符合要求
杨杨杨~~的博客
09-19 3460
前端判断登陆页面输入是否符合要求   &lt;script type="text/javascript" src="js/login.js"&gt;&lt;/script&gt; &lt;script language="javaScript"&gt;     function rec(){                   alert("欢迎登入家庭管理系统"); 
关于${pageContext.request.contextPath}的理解 （转载）
weixin_34197488的博客
12-03 2997
${pageContext.request.contextPath}是JSP取得绝对路径的方法，等价于<%=request.getContextPath()%> . (url路径接参数：'${pageContext.reuqest.contextPath}+url?变量名='+变量名+'&变量名='+变量名) 也就是取出部署的应用程序名或者是当前的项目名称 比...
简单的用户注册登录
jingtianxiaozhi的专栏
12-27 1787
总结 启动MySQL  services.msc pageContext.request.contextPath request.getRequestDispatcher.forward() reponse.sendRedirest() statement.excuteQuery() statement.executeUpdate() printStackTrace()   in
Spring Boot 2.1.5 原版学习指南
"Spring Boot 2.1.5 原版学习向导，适合对Spring Boot 2.x技术有追求的学习者作为离线学习资料使用。文档由多位作者共同创作，版权归属2012-2018年。" Spring Boot参考指南是一个详细的学习资源，旨在帮助开发者更...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值