精华内容
下载资源
问答
  • Activity在顶部自定义返回箭头并对NavigationIcon设置点击返回事件。

    主要步骤:

    1. LinearLayout中放置一个ToolBar,其app:navigationIcon属性设置成自定义的图标。图标建议在阿里巴巴矢量图标库中直接下载SVG文件,然后利用“SVG to VectorDrawable”插件以xml文件导入到drawable文件夹下。
    2. 对ToolBar的navigationIcon设置点击事件,点击后返回上层界面。
    toolbar.setNavigationOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    finish();       //返回
                }
            });
    

    布局文件:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        tools:context=".StudentActivity.SignatureActivity">
    
    
        <androidx.appcompat.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent"
            app:navigationIcon="@drawable/back_arrow"
            android:textAlignment="center"
            app:contentInsetStart="0dp"
            app:title="" >
    
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_centerInParent="true"
                android:layout_gravity="center"
                android:text="个性签名"
                android:textColor="@color/bg_black"
                android:textSize="20sp"
                android:textStyle="bold">
    
            </TextView>
    
        </androidx.appcompat.widget.Toolbar>
    
    
        <EditText
            android:layout_width="match_parent"
            android:layout_height="50dp">
    
        </EditText>
    
    </LinearLayout>
    

    Activity.java文件:

    package com.example.edm.StudentActivity;
    
    
    import androidx.appcompat.app.AppCompatActivity;
    import androidx.appcompat.widget.Toolbar;
    
    import android.os.Bundle;
    import android.view.View;
    
    import com.example.edm.R;
    
    public class SignatureActivity extends AppCompatActivity {
    
        private Toolbar toolbar;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_signature);
    
            toolbar = findViewById(R.id.toolbar);
    
            toolbar.setNavigationOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    finish();       //返回
                }
            });
        }
    
    }
    
    

    效果:
    在这里插入图片描述

    展开全文
  • 场景:在微服务中,一般返回数据都会有个返回码、返回信息和返回消息体,但是每次返回时候调用或者是封装,太过麻烦,有没有什么办法不用每次都封装呢? 答案是有的。 返回值对象 package ...

    场景:在微服务中,一般返回数据都会有个返回码返回信息返回消息体,但是每次返回时候调用或者是封装,太过麻烦,有没有什么办法不用每次都封装呢?

    答案是有的。

    返回值对象 ResponseData

    package com.study.auth.comm;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.annotation.JSONField;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    
    import java.io.Serializable;
    
    /**
     * @Package: com.study.auth.comm
     * @Description: <返回数据>
     * @Author: MILLA
     * @CreateDate: 2018/4/8 9:10
     * @UpdateUser: MILLA
     * @UpdateDate: 2018/4/8 9:10
     * @Version: 1.0
     */
    public final class ResponseData<T> implements Serializable {
        private static final long serialVersionUID = 7824278330465676943L;
    
        private static final String SUCCESS_CODE = "1000";
    
        private static final String SUCCESS_MSG = "success";
        /**
         * 响应编码
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 1)
        private String code;
    
        /**
         * 响应提示
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 2)
        private String msg;
    
        /**
         * 返回的数据
         */
        @JSONField(serialzeFeatures = {SerializerFeature.WriteMapNullValue}, ordinal = 10)
        private T data;
    
        public static ResponseData success() {
            return initData(SUCCESS_CODE, SUCCESS_MSG, null);
        }
    
        public static ResponseData error(String code) {
            String msg = PropertiesReaderUtil.getProperty(code, null);
            return initData(code, msg, null);
        }
    
        public static ResponseData error(String code, String msg) {
            return initData(code, msg, null);
        }
    
        public static <T> ResponseData success(T t) {
            return initData(SUCCESS_CODE, SUCCESS_MSG, t);
        }
    
        public static <T> ResponseData errorData(String code, T data) {
            String msg = PropertiesReaderUtil.getProperty(code, null);
            return initData(code, msg, data);
        }
    
        public static <T> ResponseData errorData(String code, String msg, T data) {
            return initData(code, msg, data);
        }
    
        private static <T> ResponseData initData(String code, String msg, T t) {
            ResponseData data = new ResponseData(SUCCESS_CODE);
            if (!isBlank(msg)) {
                data.setMsg(msg);
            }
            if (!isBlank(code)) {
                data.setCode(code);
            }
            if (t != null) {
                data.setData(t);
            }
            return data;
        }
    
        private static boolean isBlank(CharSequence cs) {
            int strLen;
            if (cs != null && (strLen = cs.length()) != 0) {
                for (int i = 0; i < strLen; ++i) {
                    if (!Character.isWhitespace(cs.charAt(i))) {
                        return false;
                    }
                }
                return true;
            } else {
                return true;
            }
        }
    
        public ResponseData() {
        }
    
        public ResponseData(String code) {
            this.code = code;
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        @Override
        public String toString() {
            return JSON.toJSONString(this);
        }
    }

     

    如上图的包装,还是太繁琐了。 

     装饰者模式使用-增强类InitializingAdviceDecorator 

    通过实现InitializingBean和装饰者模式对Controller层的返回值进行包装,大致思路:

    1. 通过RequestMappingHandlerAdapter获取所有的返回值处理对象HandlerMethodReturnValueHandler
    2. 创建一个新的集合存储上一步获取的集合(因为上一步的结果是unmodifiableList类型的
    3. 遍历该集合找到HandlerMethodReturnValueHandler对象,将这个位置的handler替换程自定义的handler
    4. 将新获到的集合重新设置到RequestMappingHandlerAdapter的setReturnValueHandlers方法中

     

    package com.study.auth.config;
    
    import com.study.auth.comm.ResponseData;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.MethodParameter;
    import org.springframework.web.context.request.NativeWebRequest;
    import org.springframework.web.method.support.HandlerMethodReturnValueHandler;
    import org.springframework.web.method.support.ModelAndViewContainer;
    import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
    import org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @Package: com.study.auth.config.core
     * @Description: <增强controller层返回值>
     * @Author: milla
     * @CreateDate: 2020/09/04 14:42
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 14:42
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    @Configuration
    public class InitializingAdviceDecorator implements InitializingBean {
        @Autowired
        private RequestMappingHandlerAdapter adapter;
    
        @Override
        public void afterPropertiesSet() {
            //获取所有的handler对象
            List<HandlerMethodReturnValueHandler> returnValueHandlers = adapter.getReturnValueHandlers();
            //因为上面返回的是unmodifiableList,所以需要新建list处理
            List<HandlerMethodReturnValueHandler> handlers = new ArrayList(returnValueHandlers);
            this.decorateHandlers(handlers);
            //将增强的返回值回写回去
            adapter.setReturnValueHandlers(handlers);
        }
    
    
        /**
         * 使用自定义的返回值控制类
         *
         * @param handlers
         */
        private void decorateHandlers(List<HandlerMethodReturnValueHandler> handlers) {
            for (HandlerMethodReturnValueHandler handler : handlers) {
                if (handler instanceof RequestResponseBodyMethodProcessor) {
                    //找到返回值的handler并将起包装成自定义的handler
                    ControllerReturnValueHandler decorator = new ControllerReturnValueHandler((RequestResponseBodyMethodProcessor) handler);
                    int index = handlers.indexOf(handler);
                    handlers.set(index, decorator);
                    break;
                }
            }
        }
    
        /**
         * 自定义返回值的Handler
         * 采用装饰者模式
         */
        private class ControllerReturnValueHandler implements HandlerMethodReturnValueHandler {
            //持有一个被装饰者对象
            private HandlerMethodReturnValueHandler handler;
    
            ControllerReturnValueHandler(RequestResponseBodyMethodProcessor handler) {
                this.handler = handler;
            }
    
            @Override
            public boolean supportsReturnType(MethodParameter returnType) {
                return true;
            }
    
            /**
             * 增强被装饰者的功能
             *
             * @param returnValue  返回值
             * @param returnType   返回类型
             * @param mavContainer view
             * @param webRequest   请求对象
             * @throws Exception 抛出异常
             */
            @Override
            public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
                //如果已经封装了结构体就直接放行
                if (returnValue instanceof ResponseData) {
                    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
                    return;
                }
                //正常返回success
                ResponseData success = ResponseData.success(returnValue);
                handler.handleReturnValue(success, returnType, mavContainer, webRequest);
            }
        }
    }
    

     配置文件读取类PropertiesReaderUtil

     

    package com.study.auth.comm;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.util.Properties;
    
    /**
     * @Package: com.milla.navicat.comm
     * @Description: <读取配置properties工具类>
     * @Author: MILLA
     * @CreateDate: 2018/8/10 10:30
     * @UpdateUser: MILLA
     * @UpdateDate: 2018/8/10 10:30
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public final class PropertiesReaderUtil {
        private static final String ENCODING = "UTF-8";
        private static final Logger logger = LoggerFactory.getLogger(PropertiesReaderUtil.class);
        private static Properties propsZH;
        private static Properties propsCN;
        private static String name = null;
    
        static {
            //加载英文
            //loadProps(false);
            //加载中文
            loadProps(true);
        }
    
        /**
         * 第一种,通过类加载器进行获取properties文件流
         * 第二种,通过类进行获取properties文件流
         * in = PropertyUtil.class.getResourceAsStream("/properties/message_ZH.properties");
         * in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream("properties/message_ZH.properties");
         */
        synchronized static private void loadProps(boolean isZh) {
            logger.debug("start loading properties");
            InputStream in = null;
            if (isZh) {
                propsZH = new Properties();
                name = "properties/message_ZH.properties";
                in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
            } else {
                propsCN = new Properties();
                name = "properties/message_EN.properties";
                in = PropertiesReaderUtil.class.getClassLoader().getResourceAsStream(name);
            }
            try {
                if (isZh) {
                    propsZH.load(new InputStreamReader(in, ENCODING));
                } else {
                    propsCN.load(new InputStreamReader(in, ENCODING));
                }
            } catch (Exception e) {
                logger.debug("loading properties error :{}", e);
            } finally {
                try {
                    if (null != in) {
                        in.close();
                    }
                } catch (IOException e) {
                    logger.debug("closing properties io error :{}", e);
                }
            }
        }
    
        public static String getProperty(String key) {
            return getPropertyZH(key);
        }
    
        public static String getProperty(String key, String defaultValue) {
            return getPropertyZH(key, defaultValue);
        }
    
        public static String getPropertyZH(String key) {
            if (null == propsZH) {
                loadProps(true);
            }
            return propsZH.getProperty(key);
        }
    
        public static String getPropertyZH(String key, String defaultValue) {
            if (null == propsZH) {
                loadProps(true);
            }
            return propsZH.getProperty(key, defaultValue);
        }
    
        public static String getPropertyCN(String key) {
            if (null == propsCN) {
                loadProps(false);
            }
            return propsCN.getProperty(key);
        }
    
        public static String getPropertyCN(String key, String defaultValue) {
            if (null == propsCN) {
                loadProps(false);
            }
            return propsCN.getProperty(key, defaultValue);
        }
    }
    

     配置文件message_ZH.properties

     路径为:properties/message_ZH.properties

    也可添加国家化英文或者是其他语言配置

    1001=用户未登录
    #====非业务返回码=========
    1100=服务器内部错误
    1101=空指针异常
    1102=数据类型转换异常
    1103=IO异常
    1104=该方法找不到异常
    1105=数组越界异常
    1106=请求体缺失异常
    1107=类型匹配异常
    1108=请求参数缺失异常
    1109=请求方法不支持异常
    1110=请求头类型不支持异常
    1111=参数解析异常
    1112=必要参数不能为空
    #=======================

    统一异常捕捉类RestfulExceptionHandler  

    此时,基本能保证增强Controller层的返回值了,如果有需要的话,可能通过@RestControllerAdvice注解,针对抛出的异常使用返回值对象进行包装

    package com.study.auth.exception;
    
    import com.alibaba.fastjson.JSONException;
    import com.study.auth.comm.PropertiesReaderUtil;
    import com.study.auth.comm.ResponseData;
    import com.study.auth.constant.CommonConstant;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.TypeMismatchException;
    import org.springframework.boot.json.JsonParseException;
    import org.springframework.http.converter.HttpMessageNotReadableException;
    import org.springframework.web.HttpMediaTypeNotSupportedException;
    import org.springframework.web.HttpRequestMethodNotSupportedException;
    import org.springframework.web.bind.MethodArgumentNotValidException;
    import org.springframework.web.bind.MissingServletRequestParameterException;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    import javax.security.auth.login.AccountException;
    import java.io.IOException;
    import java.sql.SQLException;
    
    /**
     * @Package: com.study.auth.exception
     * @Description: <所有异常拦截类>
     * @Author: milla
     * @CreateDate: 2020/09/04 15:35
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 15:35
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    @Slf4j
    @RestControllerAdvice
    public class RestfulExceptionHandler {
        private ResponseData responseData(String code, Exception e) {
            log.error("异常代码:{},异常描述:{},异常堆栈:", code, PropertiesReaderUtil.getProperty(code), e);
            return ResponseData.error(code);
        }
    
        private ResponseData<String> responseData(String code, String message, Exception e) {
            log.error("异常代码:{},异常描述:{},异常堆栈:", code, message, e);
            return ResponseData.error(code, message);
        }
    
        /**
         * 运行时异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(Exception.class)
        public ResponseData runtimeExceptionHandler(Exception e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e);
        }
    
        /**
         * 处理SQLSyntaxErrorException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(SQLException.class)
        public ResponseData<String> sqlException(SQLException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
    
        /**
         * 处理CustomerMessageException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(CustomMessageException.class)
        public ResponseData<String> customerMessageException(CustomMessageException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
        /**
         * 处理AccountException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(AccountException.class)
        public ResponseData<String> accountException(AccountException e) {
            return responseData(e.getMessage(), e);
        }
    
    
        //---------------------------------------jdk/spring自带的异常----------------------------------
    
        /**
         * 处理IllegalArgumentException
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IllegalArgumentException.class)
        public ResponseData<String> illegalArgumentException(IllegalArgumentException e) {
            return responseData(CommonConstant.EX_RUN_TIME_EXCEPTION, e.getMessage(), e);
        }
    
        /**
         * 空指针异常
         *
         * @param e 异常
         * @return
         */
        @ResponseStatus
        @ExceptionHandler(NullPointerException.class)
        public ResponseData nullPointerExceptionHandler(NullPointerException e) {
            return responseData(CommonConstant.EX_NULL_POINTER_EXCEPTION, e);
        }
    
        /**
         * 类型转换异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(ClassCastException.class)
        public ResponseData classCastExceptionHandler(ClassCastException e) {
            return responseData(CommonConstant.EX_CLASS_CAST_EXCEPTION, e);
        }
    
        /**
         * IO异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IOException.class)
        public ResponseData iOExceptionHandler(IOException e) {
            return responseData(CommonConstant.EX_IO_EXCEPTION, e);
        }
    
        /**
         * 未知方法异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(NoSuchMethodException.class)
        public ResponseData noSuchMethodExceptionHandler(NoSuchMethodException e) {
            return responseData(CommonConstant.EX_NO_SUCH_METHOD_EXCEPTION, e);
        }
    
        /**
         * 数组越界异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(IndexOutOfBoundsException.class)
        public ResponseData indexOutOfBoundsExceptionHandler(IndexOutOfBoundsException e) {
            return responseData(CommonConstant.EX_INDEX_OUT_OF_BOUNDS_EXCEPTION, e);
        }
    
        /**
         * 请求body缺失异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpMessageNotReadableException.class})
        public ResponseData requestNotReadable(HttpMessageNotReadableException e) {
            return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
        }
    
        /**
         * 类型匹配异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({TypeMismatchException.class})
        public ResponseData requestTypeMismatch(TypeMismatchException e) {
            return responseData(CommonConstant.EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION, e);
        }
    
        /**
         * 方法不支持异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpRequestMethodNotSupportedException.class})
        public ResponseData methodNotSupported(HttpRequestMethodNotSupportedException e) {
            return responseData(CommonConstant.EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION, e);
        }
    
        /**
         * 请求头不支持异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler({HttpMediaTypeNotSupportedException.class})
        public ResponseData mediaTypeNotAcceptable(HttpMediaTypeNotSupportedException e) {
            return responseData(CommonConstant.EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION, e);
        }
    
        /**
         * 参数解析异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(JSONException.class)
        public ResponseData runtimeExceptionHandler(JSONException e) {
            return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
        }
    
        /**
         * 参数解析异常
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(JsonParseException.class)
        public ResponseData runtimeExceptionHandler(JsonParseException e) {
            return responseData(CommonConstant.PARAMS_PARSE_EXCEPTION, e);
        }
    
        /**
         * 请求参数缺失异常
         *
         * @param e 异常
         * @return
         */
    
        @ExceptionHandler({MissingServletRequestParameterException.class})
        public ResponseData requestMissingServletRequest(MissingServletRequestParameterException e) {
            return responseData(CommonConstant.EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION, e);
        }
    
        /**
         * 参数不能为空
         *
         * @param e 异常
         * @return
         */
        @ExceptionHandler(MethodArgumentNotValidException.class)
        public ResponseData exceptionHandler(MethodArgumentNotValidException e) {
            return responseData(CommonConstant.PARAMS_IS_NULL, e);
        }
    }
    

    常量类 CommonConstant 

    package com.study.auth.constant;
    
    /**
     * @Package: com.study.auth.constant
     * @Description: <公共常量类>
     * @Author: milla
     * @CreateDate: 2020/09/04 15:37
     * @UpdateUser: milla
     * @UpdateDate: 2020/09/04 15:37
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public final class CommonConstant {
        /**
         * 当前用户名称
         */
        public static final String C_CURRENT_ACCOUNT = "current_account";
    
        /**
         * 用户未登录
         */
        public static final String EX_NO_TOKEN_EXCEPTION = "1001";
    
        //--------------------------------非业务返回码---------------------------------------
        /**
         * 运行时异常
         */
        public static final String EX_RUN_TIME_EXCEPTION = "1100";
        /**
         * 空指针异常
         */
        public static final String EX_NULL_POINTER_EXCEPTION = "1101";
        /**
         * 数据转换异常
         */
        public static final String EX_CLASS_CAST_EXCEPTION = "1102";
        /**
         * IO异常
         */
        public static final String EX_IO_EXCEPTION = "1103";
        /**
         * 找不到该方法异常
         */
        public static final String EX_NO_SUCH_METHOD_EXCEPTION = "1104";
        /**
         * 数组越界异常
         */
        public static final String EX_INDEX_OUT_OF_BOUNDS_EXCEPTION = "1105";
        /**
         * 请求体缺失异常
         */
        public static final String EX_HTTP_MESSAGE_NOT_READABLE_EXCEPTION = "1106";
        /**
         * TYPE匹配异常
         */
        public static final String EX_TYPE_MISMATCH_EXCEPTION = "1107";
        /**
         * 请求参数丢失
         */
        public static final String EX_MISSING_SERVLET_REQUEST_PARAMETER_EXCEPTION = "1108";
        /**
         * 请求方法类型不支持异常
         */
        public static final String EX_HTTP_REQUEST_METHOD_NOT_SUPPORTED_EXCEPTION = "1109";
        /**
         * MEDIA 类型不支持异常
         */
        public static final String EX_HTTP_MEDIA_TYPE_NOT_ACCEPTABLE_EXCEPTION = "1110";
        /**
         * 参数解析异常
         */
        public static final String PARAMS_PARSE_EXCEPTION = "1111";
        /**
         * 参数不能为空
         */
        public static final String PARAMS_IS_NULL = "1112";
        //-----------------------------------------------------------------------------------
    }

    自定义异常类 CustomMessageException

    package com.study.auth.exception;
    
    /**
     * @Package: com.study.auth.exception
     * @Description: <自定义异常类>
     * @Author: MILLA
     * @CreateDate: 2019/8/15 18:39
     * @UpdateUser: MILLA
     * @UpdateDate: 2019/8/15 18:39
     * @UpdateRemark: <>
     * @Version: 1.0
     */
    public class CustomMessageException extends RuntimeException {
    
        public CustomMessageException() {
            super();
        }
    
        public CustomMessageException(String message) {
            super(message);
        }
    
        public CustomMessageException(String message, Throwable cause) {
            super(message, cause);
        }
    
        public CustomMessageException(Throwable cause) {
            super(cause);
        }
    
        protected CustomMessageException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
            super(message, cause, enableSuppression, writableStackTrace);
        }
    }
    

     

    所需依赖

    因为使用了阿里的fastJson工具类还需要进入该类的依赖

     <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.58</version>
      </dependency>

     至此,可以愉快的使用该返回值的增强类了,在为服务中,还以将该代码重构到comm中,供多个服务共同使用,避免重复早轮子

    展开全文
  • read函数返回立即返回0

    万次阅读 2017-09-13 20:53:19
    最近在测试一个网络程序的时候,每次调用read函数返回立即返回0,read是阻塞函数,没有读到数据竟然立即返回0,有些奇怪。想了一下,和tcp的四次挥手有关,看代码。 服务端: #include #include #include #...

                  ❤️强烈推荐人工智能学习网站❤️

                         最近在测试一个网络程序的时候,每次调用read函数返回立即返回0,read是阻塞函数,没有读到数据竟然立即返回0,有些奇怪。想了一下,和tcp的四次挥手有关,看代码。

    服务端:

    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netdb.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <ctype.h>
    #include <errno.h>
    #include <malloc.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <sys/ioctl.h>
    #include <stdarg.h>
    #include <fcntl.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <signal.h>
    #define MAXLINE 4096
    
    
    
    int main()
    {
       int listenfd,acceptfd,n;
       socklen_t  clilen;
       char recvbuf[30]={0};
       struct sockaddr_in cliaddr,servaddr;
    
       listenfd=socket(AF_INET,SOCK_STREAM,0);
       servaddr.sin_family=AF_INET;
       servaddr.sin_port=htons(8888);
       servaddr.sin_addr.s_addr = INADDR_ANY; 
    
       bind(listenfd,(struct sockaddr *)&servaddr,sizeof(struct sockaddr_in));
       listen(listenfd,5);
    
       clilen=sizeof(cliaddr);
       acceptfd=accept(listenfd,(struct sockaddr *)&cliaddr,&clilen);
    
       while(1)
       {
            sleep(1);
            printf("test\n");
            memset(recvbuf,0,sizeof(recvbuf));
       	n=recv(acceptfd,recvbuf,sizeof(recvbuf)-1,0);
       	printf("recvbuf=%s,n=%d\n",recvbuf,n);
       }
    
       getchar();
       close(listenfd);
       return 0;
    }
    

    客户端:

     

     

    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netdb.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <ctype.h>
    #include <errno.h>
    #include <malloc.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <sys/ioctl.h>
    #include <stdarg.h>
    #include <fcntl.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <signal.h>
    #include <netinet/tcp.h>
    #define MAXLINE 4096
    
    
    int main()
    {
       int sockfd;
       struct sockaddr_in servaddr;
       char sendbuf[66495]="111111111";
    
       sockfd=socket(AF_INET,SOCK_STREAM,0);
       bzero(&servaddr,sizeof(servaddr));
       servaddr.sin_family=AF_INET;
       servaddr.sin_port=htons(8888);
       servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    
    
       int ret=connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
       printf("ret=%d\n",ret);
    
    
       getchar();
       close(sockfd);
       return 0;
    }
    

     

    makefile:

     

    all:server client
    
    server.o:server.cpp
    	g++ -c server.cpp
    client.o:client.cpp
    	g++ -c client.cpp
    server:server.o
    	g++ -o server server.o
    client:client.o
    	g++ -o client client.o
    
    clean:
    	rm -f server client *.o
    

    先启动服务端,再启动客户端,然后再关掉客户端,看打印。

     

     

    [mapan@localhost test]$ 
    [mapan@localhost test]$ ./server 
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0
    test
    recvbuf=,n=0

     

     

    服务端的read函数理解返回,且返回值为0。其原因是,客户端关掉进程后发送FIN到服务端,然后系统给read函数发信号,告知read函数无数据,于是read函数马上返回。随后服务端每次调用read函数时都会收到系统发的这个信号,所以立即返回0。
     


     

     

     

     

     

     

     

    展开全文
  • HTTP请求返回415错误码定位解决

    万次阅读 多人点赞 2017-10-29 11:13:06
    今天在工作中,发现我再调用外部API接口的时候,发现一个奇怪的问题,就是我Eclipse中写代码调用外部API接口时返回HTTP状态码是415,但是我将相同的报文放在HttpRequester里面请求的时候却又可以拿到正常返回结果,...

    今天在工作中,发现我再调用外部API接口的时候,发现一个奇怪的问题,就是我Eclipse中写代码调用外部API接口时返回HTTP状态码是415,但是我将相同的报文放在HttpRequester里面请求的时候却又可以拿到正常返回结果,而不是415错误。

    不知道有没有人跟我一样遇到过这个问题,这里记录一下解决办法。

    首先我们还是看下HTTP的状态码关于415返回码的说明吧。

    415 Unsupported Media Type 服务器无法处理请求附带的媒体格式

    乍看之下,当时并没有看出来是什么意思,后来通过度娘搜索了下,觉得应该是跟发送HTTP报文的请求头中的Content-Type有关。于是,我尝试了下,在Eclipse中的Java代码中,在发送Http请求时带上了相应的头字段,如下所示:

    public class Test {
    	public static void main(String[] args) throws IOException {
    		String url = "http://ip:port/cip-cas/search";
    		String sendData = "{\"appId\":\"***\",\"contentName\":\"人民的名义\",\"equipmentId\":\"***\",\"requestSeq\":\"***\",\"requestType\":\"1\",\"userId\":\"***\"}";
    		StringBuilder resultBuilder = new StringBuilder();
    		Map<String,String> headers = new HashMap<String,String>();
    		headers.put("Content-Type", "application/json; charset=utf-8");
    		UrlConnectionHelper.post(url, sendData, "UTF-8", 8000, headers, resultBuilder);
    		System.out.println(resultBuilder.toString());
    	}
    }

    通过执行测试,发现问题真的解决了。但是为什么我在HttpRequester中没有自己设置头字段却可以正常拿到返回报文,为了解决这个疑问,我决定对HttpRequester发送出去的报文进行抓包分析,下面是抓包的结果。

    这时候才发现原来根本原因在这呢,应该是HttpRequester在发送请求的时候帮我们自己去做了一些处理,如果发送的是json数据自动帮我们加上了Content-Type字段的声明,从而能够正常返回结果。而在Java代码发送的时候,通过抓包我们发现是没有这个头字段的(当然没有,因为我们压根没有给他设置这个头字段)。

    至此,关于这个问题算是解决了,但是回过头来想,415又是什么意思呢?

    个人觉得应该是我们尝试发送的数据是一定数据格式的,比如json,比如xml等等,这时候需要告诉处理方我们发送的是什么样的数据,如果没有告诉的话接收方可能就直接拒识了,这时候我们只要根据实际情况给数据接收方提供发送报文的数据格式应该就可以了。

    展开全文
  • IDEA 快速返回上次查看代码的位置

    万次阅读 多人点赞 2017-08-04 14:19:30
    IDEA 快速返回上次查看代码的位置问题: 在win10系统中,使用IDEA 查看源码的时候,经常跳转代码,这样会让使用者感觉和方便,但是当你想要返回上次跳转的位置时,却不知道怎么办?解决: 在IDEA中可以使用快捷键...
  • Mybatis返回单个实体或者返回List

    万次阅读 2018-04-13 14:49:50
    1.返回某个实体 &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;select id=&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;identification&amp;amp;amp;amp;amp;amp;amp;amp;amp...
  • 服务器返回的14种常见HTTP状态码

    万次阅读 多人点赞 2016-11-13 11:01:58
    服务器向我们返回状态码 状态码就是告诉我们服务器响应的状态 通过它,我们就可以知道当前请求是成功了还是出现了什么问题 状态码是由3位数字和原因短语组成的(比如最常见的:200 OK) 其中第一位数字表示响应...
  • 搭建SSM框架的过程中,发现直接返回String时出现中文乱码问题,但是返回Map、List等不会出现乱码问题…… 经过查阅资料发现,这算是SpringMVC的一个bug吧,spring MVC有一系列HttpMessageConverter去处理用@...
  • 如何监听小程序返回按钮事件?

    万次阅读 2018-08-06 14:27:09
    应用场景: 通常情况下,在关闭当前...翻阅所有小程序的官方文档,尚未给出监听返回按钮的事件,因此如果想让 上述场景1中的刷新其他指定页面、或者请求其他页面接口,不过也可采用其他方法实现这个功能。 ...
  • 使用ResponseEntity处理API返回

    万次阅读 2019-10-29 23:38:20
    最近在做Google AMP mail的时候遇到了一个问题,在调用/unsub(退订)接口的时候需要向google client返回特定的ResponseHeader。但是项目使用的是Springboot 2.x,通常使用@RestController修饰API层,无法做到动态的...
  • Ajax数据返回格式问题解决

    万次阅读 2016-05-11 14:20:09
    Ajax数据返回格式问题解决 服务端返回的数据格式为: response.setContentType("text/xml;charset=utf-8"); 设置发送到客户端的响应的内容类型为xml格式、编码方式为UTF-8的文本内容。 客户端接收代码为:if (req....
  • 话不多说,直接开整!...因为返回的id会自动注入进去,所以得选实体类来接收自增的id。 @Data public class SignIn implements Serializable { private long id;//注意id为long类型 private String owner;
  • 我们使用python开发时,自定义的函数 有时候需要返回多个值,可能是多个数值、字符串也有可能是多个列表,那么如何返回返回之后 在调用该函数时 又应该如何接收呢?例如:我定义了一个函数,传入一个url;解析该...
  • C++返回对象和返回引用

    千次阅读 2017-12-27 23:48:27
    我们发现,在C++中,有些成员函数返回的是对象,而有些函数返回的又是引用。 返回对象和返回引用的最主要的区别就是函数原型和函数头。 Car run(const Car &) //返回对象 Car & run(const Car &) //返回...
  • mybatis resultType返回类型汇总。

    万次阅读 2016-01-13 10:02:40
    1.返回List> 1 2 selectid="getMyCredit"parameterClass="java.util.Map"resultClass="java.util.HashMap"> select> 这样设置返回类型为resultClass="java.util.Ha
  • idea 快速补全返回对象和返回类型

    千次阅读 2019-07-23 09:04:43
    快速补全返回对象和返回类型 ctrl + alt + v
  • sendto成功返回

    万次阅读 2017-12-12 14:21:49
    我们知道TCP中的send成功返回表示应用进程已成功将数据写入发送缓冲区,不表示数据已成功到达对端。而对于sendto成功返回,也只是表明接口输出队列中具有存放所形成IP数据包的空间,UDP是没有发送缓冲区的。来看一段...
  • 刚才是使用redirectTo 方法 /** * 生命周期函数--监听页面卸载 */ onUnload: function () { ...但是这样出现一个问题 就是先返回瞬间返回点击跳转的界面在跳到指定界面,,, 是不是感觉怪怪的,,, ...
  • SpringBoot返回html页面

    万次阅读 2018-06-17 19:56:57
    在之前的一个项目里面,我们组员搭建的后台框架,可以在后台返回一个指定的HTML页面。 我在他搭建的框架基础上照葫芦画瓢,在Controller里面写了返回页面的代码,也是可以返回我想要返回的HTML的页面的。 代码如下...
  • MyBatis在字段返回为null不返回字段

    万次阅读 2017-12-06 00:12:22
    引言 今天前端找到我说,我们返回数据的时候,即使没有值的时候,也需要保持原有的数据结构,也就说即使字段没有值我们应该将字段返回,否则前端在取值的时候会报kongzhi
  • VSCode 返回上一个光标 (上一个浏览位置)

    万次阅读 多人点赞 2018-11-28 11:47:12
    Ctrl + 鼠标左击跳到定义. 返回 Windows: Alt + ← ;或者 鼠标侧键 Linux: Ctrl + Alt + - ;貌似数字键盘的减号没效果 Mac: Ctrl + -
  • Matlab 函数返回多个值--样例

    万次阅读 2018-02-14 19:52:36
    1.第一行写 function [返回值1/返回矩阵1,返回值2/返回矩阵2,...,返回值n/返回矩阵n]=该函数文件名(参数1,参数2,...,参数n) 2.第二行开始写你的函数代码 二、下面是一个简单的例子 现在需要将xx矩阵和yy...
  • js返回上一个页面

    万次阅读 2017-12-20 12:26:09
    当前的url下标为0,所以window.history...//返回上一页: window.history.go(-1);//返回两个页面: window.history.go(-2);window.history.go(-1)和window.location.go(-1)的区别 虽然都跑到上一页,但: window.
  • 微信小程序 检测返回事件 微信小程序暂时来说没有相对应的检测左上角的返回按钮的事件,不过可以利用app.js和onShow事件来完成这个小功能 主要就是在app.js里面为页面设置相对应的值,例如a页面跳到b页面,然后从b...
  • idea自动补全返回类型及变量快捷键

    万次阅读 多人点赞 2018-11-20 13:17:16
    idea自动补全返回类型及变量快捷键 ctrl+alt+v ,如果不行可能与QQ音乐的快捷键冲突.
  • Linux返回上一级目录的命令

    万次阅读 多人点赞 2017-12-06 12:01:00
    cd .. 返回上一级目录 cd ../.. 返回上两级目录 cd或cd ~ 返回home目录 cd - 目录名 返回指定目录
  • 我这例只需要用户的真实姓名和年龄就可以了,结果你们返回了我一大串,好几十个字段…… 前端B: 是呀!是呀!身份证信息是敏感的,这里也不需要用,你们竟然页返回了,还有密码都返回来!幸亏是加密的~ 后端小菜...
  • 场景: 最近在写接口时候,正常使用@RestController返回json串,发现当返回的对象里的属性值为空字符串或者null时候,json返回里就会自动去除这个key,啥意思呢?举个"栗子": /** * 商品评论、回复、点赞【查询】...
  • mybatis返回boolean值时数据库返回null

    千次阅读 2018-06-26 11:50:58
    还有一种情况,就是数据库中返回判断句,比如返回的对错将以1或0表示;但是当返回值为null,或者多个值的时候 会怎么样呢,0 1 还是报错?测试表示这种情况下会报错:希望大家使用 boolean 返回时 也...
  • 有时候我们返回给前端的数据是包含null的,而这些为null的值前端也不需要,我们就没必要吧null值返回给前端。 第一种方法:在类的上面加注解 import com.fasterxml.jackson.annotation.JsonInclude; @JsonInclude...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,296,486
精华内容 518,594
关键字:

返回