精华内容
下载资源
问答
  • 基于 axios 的二次封装,方便程序员开发 功能 取消重复请求,可关闭 请求数据缓存,可关闭 因网络波动导致的请求失败而自动发请求,可关闭 封装调用方式统一的 REQUEST/GET/POST/PUT/DELETE/FORMDATA 方法,其中 ...
  • 前后端分离优雅的返回Json数据统一返回数据格式背景测试环境springboot2.2.4需要依赖(测试用,与格式规范无关)一、实现步骤1、创建一个存放公共返回码的枚举类型2、创建一个Result类封装返回数据2、分页展示工具类...
  • 结论: 当 setData 更新 data 里未定义的数据时,会把数据添加进 data 里。 1

     

     

     

    结论: 当 setData 更新 data 里未定义的数据时,会把数据添加进 data 里。

     

    1

    展开全文
  • 作者:小魏小魏我们去那里呀blog.csdn.net/qq_34347620/article/details/102239179无侵入式 统一返回JSON格式其实本没有没打算写这篇博客的...

    作者:小魏小魏我们去那里呀

    blog.csdn.net/qq_34347620/article/details/102239179

    无侵入式 统一返回JSON格式

    其实本没有没打算写这篇博客的,但还是要写一下写这篇博客的起因是因为,现在呆着的这家公司居然没有统一的API返回格式,询问主管他居然告诉我用HTTP状态码就够用了(fxxk),天哪HTTP状态码真的够用吗?在仔细的阅读了项目源码后发现,在API请求的是居然没有业务异常(黑人问好)。好吧 居然入坑了只能遵照项目风格了,懒得吐槽了。

    因为项目已经开发了半年多了, 要是全部接口都做修改工作量还是挺大的, 只能用这种无侵入式的方案来解决.

    定义JSON格式

    定义返回JSON格式

    后端返回给前端一般情况下使用JSON格式, 定义如下

    {
     "code": 200, "message": "OK", "data": { }
     }
    

    code: 返回状态码

    message: 返回信息的描述

    data: 返回值

    定义JavaBean字段

    定义状态码枚举类

    @ToString
    @Getter
    @ToString
    @Getter
    public enum ResultStatus {
    
        SUCCESS(HttpStatus.OK, 200, "OK"),
        BAD_REQUEST(HttpStatus.BAD_REQUEST, 400, "Bad Request"),
        INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, 500, "Internal Server Error"),;
    
        /** 返回的HTTP状态码,  符合http请求 */
        private HttpStatus httpStatus;
        /** 业务异常码 */
        private Integer code;
        /** 业务异常信息描述 */
        private String message;
    
        ResultStatus(HttpStatus httpStatus, Integer code, String message) {
            this.httpStatus = httpStatus;
            this.code = code;
            this.message = message;
        }
    }
    

    状态码和信息以及http状态码就能一一对应了便于维护, 有同学有疑问了为什么要用到http状态码呀,因为我要兼容项目以前的代码, 没有其他原因, 当然其他同学不喜欢http状态码的可以吧源码中HttpStatus给删除了定义返回体类

    @Getter
    @ToString
    public class Result<T> {
        /** 业务错误码 */
        private Integer code;
        /** 信息描述 */
        private String message;
        /** 返回参数 */
        private T data;
    
        private Result(ResultStatus resultStatus, T data) {
            this.code = resultStatus.getCode();
            this.message = resultStatus.getMessage();
            this.data = data;
        }
    
        /** 业务成功返回业务代码和描述信息 */
        public static Result<Void> success() {
            return new Result<Void>(ResultStatus.SUCCESS, null);
        }
    
        /** 业务成功返回业务代码,描述和返回的参数 */
        public static <T> Result<T> success(T data) {
            return new Result<T>(ResultStatus.SUCCESS, data);
        }
    
        /** 业务成功返回业务代码,描述和返回的参数 */
        public static <T> Result<T> success(ResultStatus resultStatus, T data) {
            if (resultStatus == null) {
                return success(data);
            }
            return new Result<T>(resultStatus, data);
        }
    
        /** 业务异常返回业务代码和描述信息 */
        public static <T> Result<T> failure() {
            return new Result<T>(ResultStatus.INTERNAL_SERVER_ERROR, null);
        }
    
        /** 业务异常返回业务代码,描述和返回的参数 */
        public static <T> Result<T> failure(ResultStatus resultStatus) {
            return failure(resultStatus, null);
        }
    
        /** 业务异常返回业务代码,描述和返回的参数 */
        public static <T> Result<T> failure(ResultStatus resultStatus, T data) {
            if (resultStatus == null) {
                return new Result<T>(ResultStatus.INTERNAL_SERVER_ERROR, null);
            }
            return new Result<T>(resultStatus, data);
        }
    }
    
    

    因为使用构造方法进行创建对象太麻烦了, 我们使用静态方法来创建对象这样简单明了

    Result实体返回测试

    @RestController
    @RequestMapping("/hello")
    public class HelloController {
    
        private static final HashMap<String, Object> INFO;
    
        static {
            INFO = new HashMap<>();
            INFO.put("name", "galaxy");
            INFO.put("age", "70");
        }
    
        @GetMapping("/hello")
        public Map<String, Object> hello() {
            return INFO;
        }
    
        @GetMapping("/result")
        @ResponseBody
        public Result<Map<String, Object>> helloResult() {
            return Result.success(INFO);
        }
    }
    

    到这里我们已经简单的实现了统一JSON格式了, 但是我们也发现了一个问题了,想要返回统一的JSON格式需要返回Result Object才可以, 我明明返回Object可以了, 为什么要重复劳动, 有没有解决方法, 当然是有的啦, 下面我们开始优化我们的代码吧

    统一返回JSON格式进阶-全局处理(@RestControllerAdvice)

    我师傅经常告诉我的一句话: “你就是一个小屁孩, 你遇到的问题都已经不知道有多少人遇到过了, 你会想到的问题, 已经有前辈想到过了. 你准备解决的问题, 已经有人把坑填了”。是不是很鸡汤, 是不是很励志, 让我对前辈们充满着崇拜, 事实上他对我说的是: “自己去百度”, 这五个大字, 其实这五个大字已经说明上明的B话了, 通过不断的百度和Google发现了很多的解决方案.

    我们都知道使用@ResponseBody注解会把返回Object序列化成JSON字符串,就先从这个入手吧, 大致就是在序列化前把Object赋值给Result Object就可以了, 大家可以观摩org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice和org.springframework.web.bind.annotation.ResponseBody
    @ResponseBody继承类
    我们已经决定从@ResponseBody注解入手了就创建一个注解类继承@ResponseBody, 很干净什么都没有哈哈,@ResponseResultBody 可以标记在类和方法上这样我们就可以跟自由的进行使用了

    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD})
    @Documented
    @ResponseBody
    public @interface ResponseResultBody {
    
    }
    

    ResponseBodyAdvice继承类

    @RestControllerAdvice
    public class ResponseResultBodyAdvice implements ResponseBodyAdvice<Object> {
    
        private static final Class<? extends Annotation> ANNOTATION_TYPE = ResponseResultBody.class;
    
        /**
         * 判断类或者方法是否使用了 @ResponseResultBody
         */
        @Override
        public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
            return AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ANNOTATION_TYPE) || returnType.hasMethodAnnotation(ANNOTATION_TYPE);
        }
    
        /**
         * 当类或者方法使用了 @ResponseResultBody 就会调用这个方法
         */
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
            // 防止重复包裹的问题出现
            if (body instanceof Result) {
                return body;
            }
            return Result.success(body);
        }
    }
    
    

    RestControllerAdvice返回测试

    @RestController
    @RequestMapping("/helloResult")
    @ResponseResultBody
    public class HelloResultController {
    
        private static final HashMap<String, Object> INFO;
    
        static {
            INFO = new HashMap<String, Object>();
            INFO.put("name", "galaxy");
            INFO.put("age", "70");
        }
    
        @GetMapping("hello")
        public HashMap<String, Object> hello() {
            return INFO;
        }
    
        /** 测试重复包裹 */
        @GetMapping("result")
        public Result<Map<String, Object>> helloResult() {
            return Result.success(INFO);
        }
    
        @GetMapping("helloError")
        public HashMap<String, Object> helloError() throws Exception {
            throw new Exception("helloError");
        }
    
        @GetMapping("helloMyError")
        public HashMap<String, Object> helloMyError() throws Exception {
            throw new ResultException();
        }
    }
    
    

    是不是很神奇, 直接返回Object就可以统一JSON格式了, 就不用每个返回都返回Result对象了,直接让SpringMVC帮助我们进行统一的管理, 简直完美

    只想看接口哦, helloError和helloMyError是会直接抛出异常的接口,我好像没有对异常返回进行统一的处理哦

    统一返回JSON格式进阶-异常处理(@ExceptionHandler))

    卧槽, 异常处理, 差点把这茬给忘了, 这个异常处理就有很多方法了,先看看我师傅的处理方式, 我刚拿到这个代码的时候很想吐槽, 对异常类的处理这么残暴的吗, 直接用PrintWriter直接输出结果, 果然是老师傅, 我要是有100个异常类, 不得要写100个 if else了. 赶紧改改睡吧

    @Configuration
    public class MyExceptionHandler implements HandlerExceptionResolver {
    
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response,
                                             Object handler, Exception ex) {
            PrintWriter out = getPrintWrite(response);
            if (ex instanceof XXXException) {
                out.write(JsonUtil.formatJson(ResultEnum.PAY_ERROR.getCode(), ex.getMessage()));
            } else {
                out.write(JsonUtil.formatJson(ResultEnum.FAIL.getCode(), "服务器异常"));
            }
            if (null != out) {
                out.close();
            }
            return mav;
        }
    
        private PrintWriter getPrintWrite(HttpServletResponse response) {
            PrintWriter out = null;
            try {
                response.setHeader("Content-type", "text/html;charset=UTF-8");
                response.setCharacterEncoding("UTF-8");
                out = response.getWriter();
            } catch (IOException e) {
                log.error("PrintWriter is exception", e);
            }
            return out;
        }
    }
    

    上面的代码看看还是没有问题的, 别学过去哦,

    异常处理@ResponseStatus(不推荐)@ResponseStatus用法如下,可用在Controller类和Controller方法上以及Exception类上但是这样的工作量还是挺大的

    @RestController
    @RequestMapping("/error")
    @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR, reason = "Java的异常")
    public class HelloExceptionController {
    
        private static final HashMap<String, Object> INFO;
    
        static {
            INFO = new HashMap<String, Object>();
            INFO.put("name", "galaxy");
            INFO.put("age", "70");
        }
    
        @GetMapping()
        public HashMap<String, Object> helloError() throws Exception {
            throw new Exception("helloError");
        }
    
        @GetMapping("helloJavaError")
        @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR, reason = "Java的异常")
        public HashMap<String, Object> helloJavaError() throws Exception {
            throw new Exception("helloError");
        }
    
        @GetMapping("helloMyError")
        public HashMap<String, Object> helloMyError() throws Exception {
            throw new MyException();
        }
    }
    
    @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR, reason = "自己定义的异常")
    class MyException extends Exception {
    
    }
    
    

    全局异常处理@ExceptionHandler(推荐)把ResponseResultBodyAdvice类进行改造一下,代码有点多了 主要参考了org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler#handleException()方法, 有空可以看一下

    @Slf4j
    @RestControllerAdvice
    public class ResponseResultBodyAdvice implements ResponseBodyAdvice<Object> {
    
        private static final Class<? extends Annotation> ANNOTATION_TYPE = ResponseResultBody.class;
    
        /** 判断类或者方法是否使用了 @ResponseResultBody */
        @Override
        public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
            return AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ANNOTATION_TYPE) || returnType.hasMethodAnnotation(ANNOTATION_TYPE);
        }
    
        /** 当类或者方法使用了 @ResponseResultBody 就会调用这个方法 */
        @Override
        public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
            if (body instanceof Result) {
                return body;
            }
            return Result.success(body);
        }
    
    
        /**
         * 提供对标准Spring MVC异常的处理
         *
         * @param ex      the target exception
         * @param request the current request
         */
        @ExceptionHandler(Exception.class)
        public final ResponseEntity<Result<?>> exceptionHandler(Exception ex, WebRequest request) {
            log.error("ExceptionHandler: {}", ex.getMessage());
            HttpHeaders headers = new HttpHeaders();
            if (ex instanceof ResultException) {
                return this.handleResultException((ResultException) ex, headers, request);
            }
            // TODO: 2019/10/05 galaxy 这里可以自定义其他的异常拦截
            return this.handleException(ex, headers, request);
        }
    
        /** 对ResultException类返回返回结果的处理 */
        protected ResponseEntity<Result<?>> handleResultException(ResultException ex, HttpHeaders headers, WebRequest request) {
            Result<?> body = Result.failure(ex.getResultStatus());
            HttpStatus status = ex.getResultStatus().getHttpStatus();
            return this.handleExceptionInternal(ex, body, headers, status, request);
        }
    
        /** 异常类的统一处理 */
        protected ResponseEntity<Result<?>> handleException(Exception ex, HttpHeaders headers, WebRequest request) {
            Result<?> body = Result.failure();
            HttpStatus status = HttpStatus.INTERNAL_SERVER_ERROR;
            return this.handleExceptionInternal(ex, body, headers, status, request);
        }
    
        /**
         * org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler#handleExceptionInternal(java.lang.Exception, java.lang.Object, org.springframework.http.HttpHeaders, org.springframework.http.HttpStatus, org.springframework.web.context.request.WebRequest)
         * <p>
         * A single place to customize the response body of all exception types.
         * <p>The default implementation sets the {@link WebUtils#ERROR_EXCEPTION_ATTRIBUTE}
         * request attribute and creates a {@link ResponseEntity} from the given
         * body, headers, and status.
         */
        protected ResponseEntity<Result<?>> handleExceptionInternal(
                Exception ex, Result<?> body, HttpHeaders headers, HttpStatus status, WebRequest request) {
    
            if (HttpStatus.INTERNAL_SERVER_ERROR.equals(status)) {
                request.setAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE, ex, WebRequest.SCOPE_REQUEST);
            }
            return new ResponseEntity<>(body, headers, status);
        }
    }
    

    参考https://www.toutiao.com/i6694404645827117572/ https://blog.csdn.net/qq_36722039/article/details/80825117 http://www.imooc.com/article/260354 https://my.oschina.net/wangkang80/blog/1519189

    
    

    好文章,我在看
    点击阅读原文,获免费JVM+MySQL+设计模式+分布式+微服务完整面试资料
    

    展开全文
  • Vue项目搭建常用的配置文件,request.js和vue.config.js

    千次阅读 多人点赞 2021-06-29 09:28:06
    笔记

    request.js用来请求数据,封装的代码如下:

    import axios from 'axios'
    
    const request = axios.create({
    	baseURL: '/api',
        timeout: 5000
    })
    
    // request 拦截器
    // 可以自请求发送前对请求做一些处理
    // 比如统一加token,对请求参数统一加密
    request.interceptors.request.use(config => {
        config.headers['Content-Type'] = 'application/json;charset=utf-8';
      
     // config.headers['token'] = user.token;  // 设置请求头
        return config
    }, error => {
        return Promise.reject(error)
    });
    
    // response 拦截器
    // 可以在接口响应后统一处理结果
    request.interceptors.response.use(
        response => {
            let res = response.data;
            // 如果是返回的文件
            if (response.config.responseType === 'blob') {
                return res
            }
            // 兼容服务端返回的字符串数据
            if (typeof res === 'string') {
                res = res ? JSON.parse(res) : res
            }
            return res;
        },
        error => {
            console.log('err' + error) // for debug
            return Promise.reject(error)
        }
    )
    
    
    export default request
    
    

    vue.config.js:

    // 跨域配置
    module.exports = {
        devServer: {                //记住,别写错了devServer//设置本地默认端口  选填
            port: 9876,
            proxy: {                 //设置代理,必须填
                '/api': {              //设置拦截器  拦截器格式   斜杠+拦截器名字,名字可以自己定
                    target: 'http://localhost:9999',     //代理的目标地址
                    changeOrigin: true,              //是否设置同源,输入是的
                    pathRewrite: {                   //路径重写
                        '/api': ''                     //选择忽略拦截器里面的单词
                    }
                }
            }
        }
    }
    
    展开全文
  • mybatis-plus是对mybatis的扩展,在保留了mybatis灵活使用sql语句的基础上,又扩展了基本的CRUD功能调用,大大提高了开发效率,程序员不用在编写、调试基本的CRUD映射sql语句。 4.json 前后端分离后,采用json格式作

    一、知识准备

    1.springboot
    springboot简化了配置编写,可以快速开发web应用,已经成为java主流的开发框架。
    2.vue
    前端开发也进入框架时代,vue能够满足前后端开发分离的需要,快速独立构建前端应用。
    3.mybatis-plus
    mybatis-plus是对mybatis的扩展,在保留了mybatis灵活使用sql语句的基础上,又扩展了基本的CRUD功能调用,大大提高了开发效率,程序员不用在编写、调试基本的CRUD映射sql语句。
    4.json
    前后端分离后,采用json格式作为前后端数据交互标准。
    5.Restful API设计规范
    RESTFUL是一种网络应用程序的设计风格和开发方式,客户端使用GET、POST、PUT、DELETE4个表示操作方式的动词对服务端资源进行操作:GET用来获取资源,POST用来新建资源(也可以用于更新资源),PUT用来更新资源,DELETE用来删除资源。

    二、前后端集成

    1、使用Maven创建springboot项目
    2、引入pom配置,添加mybatis-plus、druid、mysql依赖

    <dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-devtools</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<!-- Mysql-Connector -->
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    		</dependency>
    
    		<!-- Fastjson -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    		</dependency>
    		<!-- Druid -->
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>druid-spring-boot-starter</artifactId>
    		</dependency>
    		<!-- Mybatis-plus -->
    		<dependency>
    			<groupId>com.baomidou</groupId>
    			<artifactId>mybatis-plus-boot-starter</artifactId>
    		</dependency>
    		<!-- Pagehelper -->
    		<dependency>
    			<groupId>com.github.pagehelper</groupId>
    			<artifactId>pagehelper-spring-boot-starter</artifactId>
    		</dependency>
    		
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    		</dependency>
    	</dependencies>
    

    3、添加application.yml配置

    server:
        port: 8081
    
    spring:
        datasource:
            name: ShiroJwt
            url: jdbc:mysql://127.0.0.1:3306/jwt_shirodb?useSSL=false&useUnicode=true&characterEncoding=UTF-8
            username: root
            password: root
            # 使用Druid数据源
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class-name: com.mysql.jdbc.Driver
            druid:
                filters: stat
                maxActive: 20
                initialSize: 1
                maxWait: 60000
                minIdle: 1
                timeBetweenEvictionRunsMillis: 60000
                minEvictableIdleTimeMillis: 300000
                validationQuery: select 'x'
                testWhileIdle: true
                testOnBorrow: false
                testOnReturn: false
                poolPreparedStatements: true
                maxOpenPreparedStatements: 20   
    mybatis:
        # Mybatis配置Mapper路径
        mapper-locations: classpath:mapper/*.xml
        # Mybatis配置Model类对应
        type-aliases-package: xzy.yyk.entity
    

    4、添加启动类

    @MapperScan("xzy.yyk.mapper") //扫描映射器
    @SpringBootApplication
    public class WebApp {	
    	public static void main(String[] args) {
    		SpringApplication.run(WebApp.class, args);
    	}
    }
    

    5、构建框架
    Controller:接口定义层,主要用于响应请求,不做业务逻辑处理;
    Dao:Mybatise接口层
    Service:业务处理层
    Repository:Spring Data JPA对应层
    entity:JavaBean层
    Domain:数据映射层,与数据库对应;
    Dto:数据传输层,用于接受请求数据
    Vo:视图层,用于封装界面数据
    Po:mybatise映射对象
    Mapper:mapper.xml
    创建统一消息返回类ResponseBean

    public class ResponseBean {
        /**
         * HTTP状态码
         */
        private Integer code;
    
        /**
         * 返回信息
         */
        private String msg;
    
        /**
         * 返回的数据
         */
    private Object data;
    }
    

    6.添加LoginController,处理用户登录
    @RestController注解,具有Controller和ResponseBody两个注解的功能,把类标注为控制器,且方法返回数据处理为json格式。按RESTFullApi规范,@GetMapping注解用于处理get请求,@PostMapping处理post请求。

    @RestController
    public class LoginController {
    	@Resource
    	private LoginService loginService;
    	@GetMapping("hello")
    	public String hello(){
    		return "hello springboot 启动成功!";
    	}		
    	@PostMapping("/api/user/login")
    	public ResponseBean login(@RequestParam String username,@RequestParam String password) {
    		System.out.println(username+":"+password);
    		User userTemp=new User();
    		userTemp.setPhone(username);
    		userTemp.setPwd(password);
    		ResponseBean responseBean=new ResponseBean(-1,"登录失败,错误的用户名称或密码",null);
    		User loginUser=loginService.get(userTemp);
    		if(loginUser==null){			
                 //-1,登录失败,用户不存在
                return responseBean;
            }else {
                if (!loginUser.getPwd().equals(userTemp.getPwd())){
                	responseBean.setCode(-2);//-1,登录失败,密码错误
                	responseBean.setMsg("登录失败,密码错误");
                    return responseBean;
                }else {            	
                	responseBean.setCode(0);//0,登录成功
                	responseBean.setMsg("登录成功!");
                	responseBean.setData(loginUser);
                    return responseBean;
                }
            }			
    	}
    }
    

    服务层处理

    @Service
    public class LoginServiceImpl implements LoginService{
    
    	@Resource
    	private UserMapper userMapper;
    
    	@Override
    	public User getById(Long id) {
    		User user=userMapper.selectById(id);
    		return user;
    	}
    	@Override
    	public User get(User obj) {
    		QueryWrapper<User> query=new QueryWrapper<>();
    		query.eq("phone",obj.getPhone());
    		User user=userMapper.selectOne(query);
    		System.out.println(user);
    		return user;
    	}	
    }
    

    mapper接口

    @Repository
    public interface UserMapper extends BaseMapper<User> {
    
    }
    

    7.Vue框架登录处理,登录表单

    <el-form :model="loginForm" :rules="rules" ref="login" label-width="0px" class="ms-content">
                    <el-form-item prop="username">
                        <el-input v-model="loginForm.username" placeholder="username">
                            <el-button slot="prepend" icon="el-icon-lx-people"></el-button>
                        </el-input>
                    </el-form-item>
                    <el-form-item prop="password">
                        <el-input
                            type="password"
                            placeholder="password"
                            v-model="loginForm.password"
                            @keyup.enter.native="submitForm()"
                        >
                            <el-button slot="prepend" icon="el-icon-lx-lock"></el-button>
                        </el-input>
                    </el-form-item>
                    <div class="login-btn">
                        <el-button type="primary" @click="submitForm()">登录</el-button>
                    </div>
                    <p class="login-tips">Tips : 用户名和密码随便填。</p>
                </el-form>
    8.表单提交事件submitForm()处理
    submitForm() {
            	//this.interceptor()  //拦截请求        	
            	let that=this; //改变this指向
                that.$refs.login.validate(valid => {
                    if (valid) {    
                  	let formData=new FormData()
     					//把json数据转换为FormData格式
    					formData.append("username",that.loginForm.username)
    					formData.append("password",that.loginForm.password)
    					console.log(that.loginForm)					
                		axios({
                			method:'post',
                		     url:'/api/user/login', //不带token的验证
                			data:formData  //提交form表单数据
                		}).then(res=>{//请求成功时
                			if (res.status==200 && res.data.code==-1){ //返回对象不空时
                				that.$message.success('用户名称或密码错误,请重新登陆');
                			}else if(res.status==200 && res.data.code==-2){
                				that.$message.success('登录失败,密码错误');
                			} else if (res.status==200 && res.data.code==0){
              				console.log("成功保存token,准备跳转路由")
                            	that.$router.push('/');//发送跳转路由,登陆页面
                			}else{//返回空对象时
                				console.log(res)
                				that.$message.error('用户名称或密码错误,请重新登陆');	
                			}            			
                		}).catch(err=>{
                			console.log(err)
                			that.$message.error('登陆失败!')
                		}) 
                    } else {
                        that.$message.error('请输入账号和密码');
                        console.log('error submit!!');
                        return false;
                    }
                });
            },
    

    9.跨域处理
    由于前后端运行在不同的进程中,至少端口号不相同,分别代表不同的网站,而浏览器不能执行其他网站的脚本(浏览器的同源策略)因此产生了跨域问题,
    具体表现是http请求时,会产生异常:
    XMLHttpRequest cannot load http://localhost:8081/user/login. No ‘Access-Control-Allow-Origin’ header is present on the requested resource. Origin ‘http://localhost:9520’ is therefore not allowed access. The response had HTTP status code 404.
    测试如下:

    axios({
           method:'post',
          baseURL: 'http://localhost:8081',
          url:'/user/login', //不带token的验证
          data:formData
          })
    

    跨域解决方法:修改vue.config.js

    devServer: {
           	host: 'localhost',
        	port: 9520,
               proxy: {//设置代理
                   '/api':{  //将域名映射到/api,请求时url以/api开头
                       //target:'http://jsonplaceholder.typicode.com',
                       target: 'http://localhost:8081',  //后端请求服务域名和端口
                       changeOrigin:true,//设置是否允许跨域,默认为false
                       pathRewrite:{
                           '^/api':'/'  //路径重写后,就代理到对应后端
                       }
                   }
               }
           }
    在用户登录时,url中添加前缀/url
    axios({
                			method:'post',
                		     url:'/api/user/login', //不带token的验证
                			data:formData  //提交form表单数据
                		})
    

    三、 小结

    springboot与vue整合时,数据交互格式采用json,后端springboot需要采用RESTfullApI规范。由于前后端分离,事实成为2个独立运行的网络应用进程,需要注意解决跨域问题。

    展开全文
  • Vue项目搭建

    2019-02-18 15:40:07
    下面是在IDEA代码编辑器下Vue项目的简单搭建过程: 1、vue-cli脚手架的搭建步骤 <1>检查是否安装nodejs,以及安装的版本 打开cmd命令窗口,切换到你要新建项目的文件夹下,输入命令:node -v ...
  • Vue跨域问题

    千次阅读 2019-10-12 09:13:41
    随着项目前后端分离的趋势,跨域始终是一个绕不开的问题,一个本可以正常访问的接口,但在项目中请求就是发不出去,是什么原因导致的呢? 存在即合理,既然跨域那么烦人,那它存在的理由是什么呢?...
  • Java 脚手架

    2020-06-12 16:18:07
    https://maven.apache.org/archetype/maven-archetype-plugin/advanced-usage.html https://www.jianshu.com/p/724a9fa7b37a
  • application.properties大家都不陌生,我们在开发的时候,经常使用它来配置一些可以手动修改而且不用编译的变量,这样的作用在于,打成war包或者jar用于生产环境时,我们可以手动修改环境变量而不用再重新编译。...
  • 前后端分离,封装返回工具类Result

    千次阅读 2020-08-03 09:58:38
    系统出现前后端分离项目,封装返回工具类 public class Result<T> { private static final long serialVersionUID = 1L; /** * 成功标志 */ private boolean success; /** ... priv
  • SpringBoot解决跨域问题

    2021-10-25 10:29:04
    解决浏览器跨域访问问题
  • 关于程序员的言论

    2008-07-08 21:35:56
    所以,我很反感什么30岁就不能做程序员,30岁就要转行的悲观论调,有这样想法的人根本就不适合做程序员,转行还是趁早的好。 一个有美好前途的程序员,应该具备如下的素质: 1、对技术始终保持浓厚的兴趣,不...
  • 文章目录 系统简介 主要技术与框架... 我是程序员青戈,一个逗比、搞笑、爱分享的90后程序员‍ 感谢您的阅读,最后再麻烦您点一点底下的一键三连支持一下我好吗?真的是太谢谢您啦祝您身体健康,家庭幸福,我们下期再见
  • jsonp
  • springCloud config本地配置

    千次阅读 2019-01-09 15:22:54
    一般很多项目不是在springcloud的环境中使用的,但是需要用到分布式配置中心来管理一些外部或者项目的配置,这个时候我们可以使用springcloud-config的本地配置。 配置config-server服务端 使用springboot.io创建一...
  • 程序员的表白文,加点不一样的料!

    万次阅读 多人点赞 2021-02-17 21:24:45
    目录 岁月可期,待你如归——诗词版 浮世三千,吾爱有三,日月与卿,日为朝,月为暮,卿为...相信很多小伙伴在CSDN上面已经看到了无数的炫酷表白代码案例了,我也看了不少,直呼:“程序员果然还是属于浪漫主义”,
  • 干货!推荐一个github上超过5万star的Java学习宝典

    千次阅读 多人点赞 2020-11-30 11:40:10
    大家好,我是程序员青戈,一个被Bug耽误了才艺的程序员专注于Java领域的知识分享和技术交流,每天会给大家带来Java学习的干货教程 微信搜索公众号 Java学习指南,回复 面试 领取一线大厂面试题一套加号主微信 xia_...
  • 大家好,我是程序员青戈,一个被Bug耽误了才艺的程序员专注于Java领域的知识分享和技术交流,每天会给大家带来Java学习的干货教程 微信搜索公众号 Java学习指南,回复 面试 领取一线大厂面试题一套加号主微信 xia_...
  • 用ValidCodeUtils生成验证码

    千次阅读 2019-05-08 16:09:59
    用ValidCodeUtils生成验证码 开发工具与关键技术:VS 作者:唐俊祥 撰写时间:2019.5.4 如何使用ValidCodeUtils生成验证码,下面我们来看下图生成验证码的的代码的公共静态, 首先是他的静态的方法让他产生随机数...
  • 程序员应该读的书籍

    2011-04-03 19:55:00
    程序员最多做到30岁,30+还在辛苦写程序人生事业就废了,程序员最终会回到管理阶层上,所以,我们应该多读一些管理和心理类的书。 1、一般管理 《经理的职能》————(1938) 巴纳德 《动态的行政管理》————...
  • 荀子给程序员的启示

    2010-04-14 10:33:37
    ,取之於蓝而於蓝;冰,水为之而寒於水。木直中绳,輮以为轮,其曲中规,虽有槁暴,不复挺者,輮使之然也。故木受绳则直,金就砺则利,君子博学而日参省乎己,则知明而行无过矣。故不登高山,不知天之高也;不.....
  • from turtle import * screensize(500,500) #【头部轮廓】 pensize(5) home() seth(0) pd() color('black') circle(20,80)#0 circle(200,30)#1 circle(30,60)#2 circle(200,29.5)#3 color('black') ...done()
  • nginx解决前端跨域问题
  •   最近在读荀子,虽然以前上学的时候学过,但是没有这次给我的感觉这么震憾。...,取之於蓝而於蓝;冰,水为之而寒於水。木直中绳,輮以为轮,其曲中规,虽有槁暴,不复挺者,輮使之然也。故木受绳则直,...
  • springboot中tk.mapper代码生成器的使用

    千次阅读 2019-03-07 22:13:36
    pom中引入依赖,这里引入tk.mybatis.mapper的版本依赖是因为在mapper-spring-boot-starter的新版本中没有MapperPlugin这个类,无法提供代码生成的功能,在老版本中有: &amp;amp;amp;amp;lt;...
  • ​ Python高性能编程 作者: 【美】 雷利克 (Micha Gorelick) 欧日沃尔德(Ian Ozsvald) 译者: 胡世杰 ,徐旭彬 内容简介: 本书针对有一定基础的Python程序员,将指导读者实现代码优化的各种方法。...
  • http 请求头

    2017-03-09 12:35:08
    http请求头

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 772
精华内容 308
关键字:

程序员青戈