Spring Boot 简单的请求示例（包括请求体验证）

1.先做个最简单的Get请求

新建一个Controller , 并给他添加注解@RestController 它是@Controller和@ResponseBody的组合注解，告诉Spring我是一个Controller，请求过来的时候，记得扫描我

ok，在给他添加@RequestMapping注解，为这个Controler指明路径

@RestController
@RequestMapping("/Demo")
public class DemoController {

    @ResponseBody
    @RequestMapping(value = "/sayHello",method = RequestMethod.GET)
    public Map<String,Object> sayHello(){
        Map<String,Object> res = new HashMap<String,Object>();
        res.put("message", "hello world");
        return res;
    }
}

写个Get方法，返回一个Map

右击启动类 run...

2.POST请求的方法

正常在接口请求过程中，中间会有个过滤器，过滤所有请求的内容，同时做一些安全方面的校验

过滤器注册类

@Configuration
public class WebConfig {

    @Bean
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public FilterRegistrationBean someFilterRegistration1() {
        //新建过滤器注册类
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //添加出事话过滤器
        registration.setFilter( new CustomFilter());
        // 设置过滤器的URL模式
        registration.addUrlPatterns("/*");
        return registration;
    }

}

@Configuration自动配置，由Spring管理

过滤器注册类中，添加过滤器CustomFilter

过滤器的URL模式设置为过滤所有请求

/**
 * 初始化过滤器
* @ClassName: CustomFilter
* @author Mr.Chengjq
* @date 2018年10月16日
* @Description: TODO
 */
@WebFilter(filterName = "sessionFilter",urlPatterns = {"/*"})
public class CustomFilter implements Filter {

	private GeneralConfiguration generalConfiguration;

	@Override
	public void destroy() {
		// TODO Auto-generated method stub

	}

	@SuppressWarnings("unused")
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
			throws IOException, ServletException {
		// TODO Auto-generated method stub
		HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        HttpSession session = request.getSession(false);
        String uri = request.getRequestURI();
        //是否需要过滤
        if(!isNeedFilter(uri)){
        	filterChain.doFilter(request, response);
            return;
        }
        MutableHttpServletRequest requestWrapper = null;
        if(request instanceof HttpServletRequest) {
            requestWrapper = new MutableHttpServletRequest((HttpServletRequest) request);
        }
        String body = getRequestbody(requestWrapper);
        //验证 start
        //验证方式 1.token验证（头部加 token：xxx） 2.秘钥验证（暂定MD5验证  参数 timestamp：xxx key:MD5(xxx+orange)）
        if(requestWrapper.getHeader("valdateType").equals("1")){
        	 String token = requestWrapper.getHeader("token");
        	 System.out.println("token = "+token);
        }else if(requestWrapper.getHeader("valdateType").equals("2")){
        	 String timestamp =  requestWrapper.getHeader("timestamp");
        	 String key = requestWrapper.getHeader("key");
        	 //验证
        }else{
        	//返回验证方式失败信息
        	throw new BaseException("验证失败");
        }
        //end
        requestWrapper.putHeader("userId", "1111");
        if(requestWrapper == null) {
        	filterChain.doFilter(request, response);
        } else {
        	filterChain.doFilter(requestWrapper, response);
        }  

	}

	 private String getRequestbody(HttpServletRequest request) {
	      String param= null;
	      try {
	          BufferedReader streamReader = new BufferedReader( new InputStreamReader(request.getInputStream(), "UTF-8"));
	          StringBuilder responseStrBuilder = new StringBuilder();
	          String inputStr;
	          while ((inputStr = streamReader.readLine()) != null)
	              responseStrBuilder.append(inputStr);  

	          JSONObject jsonObject = JSONObject.parseObject(responseStrBuilder.toString());
	          param= jsonObject.toJSONString();
	      } catch (Exception e) {
	          e.printStackTrace();
	      }
	      return param;
	  } 

	public boolean isNeedFilter(String uri) {
		boolean res = true;
		String url = generalConfiguration.getUrl();
		String[] list = url.split(",");
		for(int i = 0 ; i<list.length;i++){
			if(uri.indexOf(list[i])!=-1){
				res =  false;
				break;
			}
		}
		return res;
    }

	private class MutableHttpServletRequest extends HttpServletRequestWrapper {

	    private final Map<String, String> customHeaders;
	    private byte[] body; 

	    public MutableHttpServletRequest(HttpServletRequest request) {
	      super(request);
	      this.customHeaders = new HashMap<String, String>();
	      body = getRequestbody(request).getBytes(Charset.forName("UTF-8"));
	    }

	    public void putHeader(String name, String value) {
	      this.customHeaders.put(name, value);
	    }

	    @Override
	    public String getHeader(String name) {
	      // check the custom headers first
	      String headerValue = customHeaders.get(name);

	      if (headerValue != null) {
	        return headerValue;
	      }
	      // else return from into the original wrapped object
	      return ((HttpServletRequest) getRequest()).getHeader(name);

	    }

	    @Override
	    public Enumeration<String> getHeaders(String name) {

	      if (customHeaders.containsKey(name)) {
	        return new Enumeration<String>() {
	          boolean hasNext = true;

	          @Override
	          public boolean hasMoreElements() {
	            return hasNext;
	          }

	          @Override
	          public String nextElement() {
	            hasNext = false;
	            return customHeaders.get(name);
	          }
	        };
	      }
	      return super.getHeaders(name);
	    }

	    @Override
	    public Enumeration<String> getHeaderNames() {
	      // create a set of the custom header names
	      Set<String> set = new HashSet<String>(customHeaders.keySet());

	      // now add the headers from the wrapped request object
	      Enumeration<String> e = ((HttpServletRequest) getRequest()).getHeaderNames();
	      while (e.hasMoreElements()) {
	        // add the names of the request headers into the list
	        String n = e.nextElement();
	        set.add(n);
	      }

	      // create an enumeration from the set and return
	      return Collections.enumeration(set);
	    }

	    @Override
		public BufferedReader getReader() throws IOException {
			return new BufferedReader(new InputStreamReader(getInputStream()));
		}

		@Override
		public ServletInputStream getInputStream() throws IOException {
			final ByteArrayInputStream bais = new ByteArrayInputStream(body);
			return new ServletInputStream() {

				@Override
				public int read() throws IOException {
					return bais.read();
				}

				@Override
				public boolean isFinished() {
					// TODO Auto-generated method stub
					return false;
				}

				@Override
				public boolean isReady() {
					// TODO Auto-generated method stub
					return false;
				}

				@Override
				public void setReadListener(ReadListener readListener) {
					// TODO Auto-generated method stub

				}
			};
		}

	}

	@Override
	public void init(FilterConfig arg0) throws ServletException {
		// TODO Auto-generated method stub
		//初始化bean 获取公共参数配置
		 ServletContext servletContext = arg0.getServletContext();
	     ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);
	     generalConfiguration = (GeneralConfiguration) ctx.getBean("generalConfiguration");
	}

　　在doFilter方法里具体写过滤的内容以及验证

isNeedFilter方法确认是否要过滤，如果不需要过滤，配置文件里配置不需要过滤的请求名，

/**
* 公共参数配置类
* @ClassName: GeneralConfiguration
* @author Mr.Chengjq
* @date 2018年10月16日
* @Description: TODO
*/
@PropertySource("classpath:conf/generalConfiguration.properties")
@ConfigurationProperties(prefix = "general")
@Configuration
public class GeneralConfiguration {

    //请求地址
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

}

这里添加参数配置类，获取generalConfiguration.properties配置文件，以general开头，当然还可以以@Value的方式

这里就不需要过滤了，直接在配置文件写明不需要处理下面请求的地址，直接进入Controlle方法

general.url = /sayHello,/sayHello2

sayHello2 方法如下，请求数据库的信息

    @ResponseBody
    @RequestMapping(value = "/sayHello2",method = RequestMethod.POST)
    public ResponseMsg sayHello2(@RequestHeader("userId") String userId,@RequestBody RequestMsg requestMsg){
        System.out.println(userId);
        JSONObject jsonobject = JSONObject.fromObject(requestMsg.getRoot());
        System.out.println("jsonobject = "+jsonobject);
        //Map<String,Object> res = new HashMap<String,Object>();
        PageResult<UserBaseDTO> res = null;
        List<UserBaseDTO> list = null;
        UserBaseDTO ubt = new UserBaseDTO();
        try {
            StringBuffer logOut = new StringBuffer();
            logOut.append("\n");
            logOut.append("cjq2测试");
            logOut.append("\n");

            LOGGER.debug(logOut.toString());
            Pagination page = new Pagination();
            page.setPage(1);
            page.setRows(10);;
            res = iUserbaseService.pageUserBase(ubt, page);
            list = res.getList();

        } catch (Exception e) {
            // TODO: handle exception
            throw new BaseException("数据错误");
            //LOGGER.error(e.getMessage());
        }
        return new ResponseMsg(requestMsg.getRoute(), GeneralConstant.SUCCESS, "查询成功", res);
    }

在正常开发过程中，对请求参数提和返回参数体会有统一的格式和加密方式，例如上面的的RequestMsg和ResponseMsg

ok 这样就完成了简单的GET和POST请求

原文地址：https://www.cnblogs.com/qiyuan880794/p/9829587.html

时间： 2024-10-12 19:19:03

Spring Boot 简单的请求示例（包括请求体验证）的相关文章

Spring Boot全局支持CORS(跨源请求)

1 import org.springframework.context.annotation.Configuration; 2 import org.springframework.web.servlet.config.annotation.CorsRegistry; 3 import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter; 4 5 /** 6 * @Author:CoderZZ 7

Spring Boot实现一个监听用户请求的拦截器

项目中需要监听用户具体的请求操作,便通过一个拦截器来监听,并继续相应的日志记录 项目构建与Spring Boot,Spring Boot实现一个拦截器很容易. Spring Boot的核心启动类继承WebMvcConfigurerAdapter // 增加拦截器 @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new RequestLog()); } //这

Spring Boot使用AOP在控制台打印请求、响应信息

AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等. AOP简介 AOP全称Aspect Oriented Programming,面向切面,AOP主要实现的目的是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段,以获得逻辑过程中各部分之间低耦合性的隔离效果.其与设计模式完成的任务差不多,是提供另一种角度来思考程序的结构,来弥补面向对象编程的不足. 通俗点讲就是提供一个为一个业务实现提供切面注入的机制,通过这种方式,在业务运行中将

spring boot 通过AOP防止API重复请求

实现思路 基于Spring Boot 2.x 自定义注解,用来标记是哪些API是需要监控是否重复请求 通过Spring AOP来切入到Controller层,进行监控 检验重复请求的Key:Token + ServletPath + SHA1RequestParas Token:用户登录时,生成的Token ServletPath:请求的Path SHA1RequestParas:将请求参数使用SHA-1散列算法加密 使用以上三个参数拼接的Key作为去判断是否重复请求 使用Redis存储Key,

Vue+axios+spring boot遇到的问题(跨域请求)

一.点击一次按钮 会发送两次请求的问题 第一个请求 Method是OPTIONS 第二个请求 Method是POST 后台过滤器也是检测出访问了两次,但是是偶尔才会重复访问. 这是因为 跨域请求导致 每次请求前都会先发送一个空的请求检查服务器, 可以在后台过滤器加个这个: @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOExce

Spring Boot文件上传示例（Ajax和REST）

本文介绍如何使用Ajax请求在Spring Boot Web应用程序(REST结构)中上传文件. 本文中使用的工具: Spring Boot 1.4.3.RELEASE Spring 4.3.5.RELEASE Thymeleaf jQuery (webjars) Maven Embedded Tomcat 8.5.6 Google Chrome浏览器 1. 项目结构 一个标准的Maven项目结构.如下图所示 - 2. 项目依赖 声明一个额外的jQuery webjar依赖关系,适用于HTML格

Spring Boot 简单的打包部署

Spring Boot 支持使用 Jar 内嵌 Web 服务器(Tomcat)的方式发布,也支持生成 war 包放在外置的 web 服务器运行. 1.使用 Jar 发布应用 配置步骤: ① pom.xml 要显示加入插件 org.springframework.boot,否则无法产生 jar 清单文件,导致打出来的 jar 无法使用命令运行. 1 <build> 2 <plugins> 3 <plugin> 4 <groupId>org.springfram

spring boot简单的小demo(适合于初学者)

import com.example.demo2.com.example.dao.ShopDao; import com.example.demo2.com.example.entity.Shops; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframew

spring boot 登录注册 demo （四） -- 体验小结

之前没有折腾过Spring,直接上来怼Spring Boot异常痛苦,参考着官网的guide(https://spring.io/guides)写了几个demo: spring boot 跑起来确是方便,有种python的感觉,几行代码就可以起一个web服务,还不用自己去配置tomcat之类的: 于是尝试学习一下,目标就是写了一个注册登录的web页面出来,数据需要存放在DB中,这么一个简单的需求: 就是这么一个简单的demo折腾了好几天,虽然spring的资料很多,但零零碎碎的,本以为有很多登录