标签：instanceof return String request 2022 import Java public

instanceof关键字主要用来判断两个对象是否为同一种类型，举个例子如果有猫类、动物类，猫类继承自动物类；

判断某个类是否为动物类，就可以使用instanceof关键字。下面简单介绍几种真实的应用场景.

场景一:工具类中判断某个类是否为null或者是为空；代码如下：

    public static boolean judgmentObjectIsEmpty(Object object) {

        if (object == null) {

            return true;

        }

        if (object instanceof Map) {

            Map map = (Map)object;

            return map.isEmpty();

        } else if (object instanceof List) {

            List list = (List)object;

            return list.isEmpty();

        } else if (object instanceof String) {

            String str = (String)object;

            return "null".equals(str) || "".equals(str);

        }

        return false;

}

Instanceof 主要用于判断任意一个类是否为Map集合、List集合、String字符串。

场景二：过滤器中使用自定义增强的request请求，在强制转换前先判断一下是否属于同一种类型；

public class BodyReaderFilter implements Filter {

    @Override

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {

        ServletRequest requestWrapper = null;

        if (request instanceof HttpServletRequest) {

            requestWrapper = new BodyReaderWrapper((HttpServletRequest)request);

        }

 

        if (requestWrapper == null) {

            filterChain.doFilter(request, response);

        } else {

            filterChain.doFilter(requestWrapper, response);

        }

    }

}

 

import org.springframework.util.StreamUtils;

 

import javax.servlet.ReadListener;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletRequestWrapper;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStreamReader;

 

/**

 * @Description: 自定义 request 增强类，解决在一次请求中输入流只能获取一次请求参数的问题

 * @ClassName: BodyReaderWrapper

 * @author: dengchao

 * @date: 2021/8/18 15:43

 */

 

public class BodyReaderWrapper extends HttpServletRequestWrapper{

    //用于将流保存下来

    private byte[] requestBody;

 

    public BodyReaderWrapper(HttpServletRequest request) throws IOException {

        super(request);

        //2021-10-19 将从请求头中获取的token请求信息放到 请求体中

        String tempToken = request.getHeader("loginToken");

        System.out.println("从请求头中获取的token信息8585--->" + tempToken);

        request.setAttribute("loginToken", tempToken);

        requestBody = StreamUtils.copyToByteArray(request.getInputStream());

    }

 

    @Override

    public ServletInputStream getInputStream() throws IOException {

 

        final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);

 

        return new ServletInputStream() {

 

            @Override

            public int read() throws IOException {

                return bais.read();

            }

 

            @Override

            public boolean isFinished() {

                return false;

            }

 

            @Override

            public boolean isReady() {

                return false;

            }

 

            @Override

            public void setReadListener(ReadListener readListener) {

            }

        };

    }

 

    @Override

    public BufferedReader getReader() throws IOException {

        return new BufferedReader(new InputStreamReader(getInputStream()));

    }

}

场景三: 自定义注解中用于校验时使用；

/**

 * 枚举校验注解

 */

@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})

@Retention(RUNTIME)

@Documented

@Constraint(validatedBy = {EnumValueValidator.class})

public @interface EnumValue {

 

    // 默认错误消息

    String message() default "必须为指定值";

 

    String[] strValues() default {};

 

    int[] intValues() default {};

 

    // 分组

    Class<?>[] groups() default {};

 

    // 负载

    Class<? extends Payload>[] payload() default {};

 

    // 指定多个时使用

    @Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})

    @Retention(RUNTIME)

    @Documented

    @interface List {

        EnumValue[] value();

    }

}

 

public class EnumValueValidator implements ConstraintValidator<EnumValue, Object> {

    private String[] strValues;

    private int[] intValues;

    @Override

    public void initialize(EnumValue constraintAnnotation) {

        strValues = constraintAnnotation.strValues();

        intValues = constraintAnnotation.intValues();

    }

 

    @Override

    public boolean isValid(Object value, ConstraintValidatorContext context) {

        if (value instanceof String) {

            for (String s : strValues) {

                if (s.equals(value)) {

                    return true;

                }

            }

        } else if (value instanceof Integer) {

            for (int s : intValues) {

                if (s == ((Integer) value).intValue()) {

                    return true;

                }

            }

        }

        return false;

    }

}

这个是注解的作用是校验某些固定的参数值，可以是整数或者字符串。注解在处理的时候使用到instanceof这个关键字，

主要用于判断一个Object对象是String字符串类型还是Integer类型，这个注解已经在项目中使用起来；参考文章:

https://www.cnblogs.com/pojo/p/15054698.html

场景四：JSON转换工具类中使用；

    /**

     * 对象转化为json字符串

     * @param obj 待转化对象

     * @return 代表该对象的Json字符串

     */

    public static final String toJson(final Object obj) {

        //当参数为String类型 直接返回该字符串

        if(obj instanceof String){

            return (String)obj;

        }

        return JSON.toJSONString(obj);

}

这个地方使用的时候，先判断一下需要转换的对象是否为String类型，如果是则直接返回，如果不是在使用JSON进行转换。

场景五: 判断某两个异常是否为同一种异常类型；

    @ExceptionHandler(value = Exception.class)

    public ResponseEntity<JsonResult<Object>> baseErrorHandler(Exception ex) {

        JsonResult<Object> r = new JsonResult<>();

        if (ex instanceof BaseException || ex.getClass().isAssignableFrom(BaseException.class)) {

            r.declareFailure((BaseException) ex, null);

            logger.error(((BaseException) ex).getErrorMessage(), ex);

        } else {

            r.declareFailure(MessageConstant.A000001, "系统未知异常，服务无法正常使用", null);

            logger.error(ex.getMessage(), ex);

        }

        return ResponseEntity.ok(r);

    }

场景六：使用JSONObject或者JSONArray的时候，类型转换前先进行类型的判断；

    Object record = data.getRecords();

                    String erCode = "";

                    String erMsg = "";

                    if(record instanceof JSONObject) {

                        erCode = ((JSONObject) record).getString("erCode");

                        erMsg = ((JSONObject) record).getString("erMsg");

                    } else if (record instanceof JSONArray && ((JSONArray) record).size() > 0){

                        Object obj = ((JSONArray) record).get(0);

                        erCode = ((JSONObject) obj).getString("erCode");

                        erMsg = ((JSONObject) obj).getString("erMsg");

                    }

待转换的数据有可能是单个对象，也有可能是数组，这种处理方式可以避免类型转换异常而出现错误。

总结: instanceof关键字一般主要用于包装类在进行强制转换之前，先判断一下需要转换的两个类是否为同一种类型，如果是则

可以进行强制转换，如果不是则做其他处理。这样处理的好处是可以大概率的避免出现类型转换异常，

java.lang.ClassCastException。之前在开发中就曾出现过这个异常，在使用Mybatis中自定义的拦截器的时候，参数转换出现

异常，导致请求时频繁出现异常。大致错误就是就是参数不能直接转换为HashMap，解决办法就是使用instanceof判断一下

参数instanceof HashMap，如果是则转换为HashMap集合，然后直接从集合里面取数据。不是的话就转换为其他类型，这样

就很好的解决掉BUG.

标签：instanceof,return,String,request,2022,import,Java,public
来源： https://www.cnblogs.com/yilangcode/p/16618653.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。