精华内容
下载资源
问答
  • java自定义注解实现请求参数校验创建自定义注解通过Java反射获取entity属性AOP切面用法示例 创建自定义注解 // 加在属性字段上 @Traget(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface ...

    创建自定义注解

    // 加在属性字段上
    @Traget(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface NotNullField {
    	
    	// 最小值
    	int min() default 0;
    	
    	// 最大值
    	int max() default 0;
    
    	// 最大长度
    	int length() default 0;
    
    	// 返回提示语
    	String message() default "";
    	
    	// 正则表达式
    	String pattern() default "";
    }
    
    // 加在需要校验参数的controller层方法上
    @Traget(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ValidParams {
    
    	boolean require() defaut true;
    		
    	Class clazz();
    }
    

    通过Java反射获取entity属性

    我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客:

    public class ParamValidUtil<T> {
    	public static <T> void checkParam(Class<T> clazz, Object obj) throws Illegalaccessexception  {
    		Field field;
    		NotNullField notNullField;
    		Field[] fields = getAllFields(clazz);
    		for(int i = 0; i < fields.length; i++) {
    			field = fields[i];
    			field.setAccessible(true);
    			notNullField = field.getAnnotation(NotNullField.Class);
    			if(null == notNullField ) {
    				// 没有加注解的属性直接continue
    				continue;
    			}
    			// 开始校验属性值
    			checkValue(field.getType().getName(), field.getName(), notNullField);
    		}
    	}
    	
    	/**
    	 * 获取所有属性(getSuperclass:获取父类属性)
    	 * @param clazz
    	 * @param <T>
    	 * @return
    	 */
    	private static <T> Field[] getAllFields(Class<T> clazz) {
    	    Class superClazz = clazz;
    	    List<Field> fieldList = new ArrayList<>();
    	    while (null != superClazz) {
    	        fieldList.addAll(new ArrayList<>(Arrays.asList(superClazz.getDeclaredFields())));
    	        superClazz = superClazz.getSuperclass();
    	    }
    	    Field[] fields = new Field[fieldList.size()];
    	    fieldList.toArray(fields);
    	    return fields;
    	}
    	
    	/**
    	 * 校验属性值
    	 * 初稿
    	 */
    	private static void checkValue(String fieldType, String fieldName, Object value, NotNullField notNullField) {
    		switch(fieldType) {
    			case "java.lang.String":
    				if(null == value || "".equals(value.toString())) {
    					logger.error("{},field:{}", notNullField.message(), fieldName);
    					// 返回自定义统一异常
    					throw BusinessException.paramsError(notNullField.message());
    				}
    				break;
    			case "java.lang.Integer":
    			case "java.lang.Long":
    			case "java.lang.Boolean":
    			case "java.lang.Double":
    			case "java.lang.Object":
    				if (null == value) {
    					logger.error("{},field:{}", notNullField.message(), fieldName);
    					// 返回自定义统一异常
    					throw BusinessException.paramsError(notNullField.message());
    				}
    				break;
    			case "java.util.List":
    				List<?> list = (List<?>) value;
    				// 导入springframework包的CollectionUtils类
    				if (CollectionUtils.isEmpty(list)) {
    					logger.error("{},field:{}", notNullField.message(), fieldName);
    					// 返回自定义统一异常
    					throw BusinessException.paramsError(notNullField.message());
    				}
    				break;
    			case "java.util.Map":
    				Map<?, ?> map= (Map<?, ?> ) value;
    				// 导入springframework包的CollectionUtils类
    				if (CollectionUtils.isEmpty(map)) {
    					logger.error("{},field:{}", notNullField.message(), fieldName);
    					// 返回自定义统一异常
    					throw BusinessException.paramsError(notNullField.message());
    				}
    				break;
    			default:
    				if (null == value) {
    					logger.error("{},field:{}", notNullField.message(), fieldName);
    					// 返回自定义统一异常
    					throw BusinessException.paramsError(notNullField.message());
    				}
    				break;
    		}
    	}
    }
    

    AOP切面

    创建AOP切面,在方法执行之前校验所有加了@NotNullField注解属性的值

    @Aspect
    @Componet
    public class ValidParamsAspect {
    
    	private Logger logger = Logger.getLogger(ValidParamsAspect.class);
    	
    	@Pointcut("@annotation(org.com.annotation.ValidParams)")
    	public void asValidParamsAnnotation() {}
    
    	@Before("asValidParamsAnnotation() && @annotation(validParams)")
    	public void before(JoinPoint joinPoint, ValidParams validParams) {
    		if (validParams.require()) {
    			logger.info("开始校验请求参数");
    			Object[] args = joinPoint.getArgs();
    			if (args.length > 0) {
    				try {
    					ParamValidUtil.checkParam(validParams.clazz(), args[0]);
    				} catch(Exception e) {
    					logger.error("参数校验异常,参数类型不是entity类", e);
    					throw BusinessException.runtimeError("参数校验异常,参数类型不是entity类", e);
    				} 
    			}
    		} else {
    			logger.info("当前请求不需要校验参数");
    		}
    	}
    }
    

    用法示例

    在实体类的属性加上@NotNullField注解,代码:

    public class TestEntity {
    	
    	private Integer id;
    	@NotNullField(message = "名称不能为空")
    	private String name;
    	
    	public Integer getId() {
    		return id;
    	}
    	
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	
    	public void setId(String name) {
    		this.name = name;
    	}
    }
    

    在controller层的方法加上@ValidParams注解

    @RestController
    @RequestMapping("test")
    public class TestController {
    
    	@PostMapping("myTest")
    	@ValidParams(clazz = TestEntity.class)
    	public void myTest(@RequestBody TestEntity testEntity) {
    		System.out.println("hello world");
    	}
    }
    
    展开全文
  • Springboot之自定义参数验证

    千次阅读 2019-01-26 18:38:51
    针对表单提交时,我们需要对参数进行校验,然而验证的种类不能符合我们的需求,需要自定义参数验证。 自定义参数验证依赖注解实现,所有我们需要自定义一个自己的注解 手机号的验证注解 import javax.validation....

    针对表单提交时,我们需要对参数进行校验,然而验证的种类不能符合我们的需求,需要自定义参数验证。

    自定义参数验证依赖注解实现,所有我们需要自定义一个自己的注解

    手机号的验证注解

    import javax.validation.Constraint;
    import javax.validation.Payload;
    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    import java.lang.annotation.Target;
    
    import static java.lang.annotation.ElementType.*;
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
    @Retention(RUNTIME)
    @Documented
    @Constraint(validatedBy = PhoneValidator.class)
    public @interface Phone {
    
        boolean required() default true;
    	// 这个地方修改错误提示字符,其他地方不要修改
        String message() default "手机号码格式错误";
    
        Class<?>[] groups() default { };
    
        Class<? extends Payload>[] payload() default { };
    
    }
    

    接着实现参数验证的类

    import org.apache.commons.lang3.StringUtils;
    
    import javax.validation.ConstraintValidator;
    import javax.validation.ConstraintValidatorContext;
    import java.util.regex.Pattern;
    
    /**
     * 手机号验证的实现类
     * @author molong
     * @date 2018/1/26
     */
    public class PhoneValidator implements ConstraintValidator<Phone, String> {
    
        private boolean required = false;
    	// 定义的手机号验证正则表达式
        private Pattern pattern = Pattern.compile("1(([38]\\d)|(5[^4&&\\d])|(4[579])|(7[0135678]))\\d{8}");
    
        @Override
        public void initialize(Phone constraintAnnotation) {
            required = constraintAnnotation.required();
        }
    
        @Override
        public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) {
            if(required) {
                return pattern.matcher(s).matches();
            }else {
                if(StringUtils.isEmpty(s)) {
                    return false;
                }else{
                    return pattern.matcher(s).matches();
                }
            }
        }
    }
    

    在实体类上添加

    public class Login {
    
        @NotNull
        @Phone
        private String mobile;
    
        @NotNull
        @Length(min=12)
        private String password;
    
        // ... set/get省略
    }
    

    当发送Post请求的时候

    @PostMapping("/login")
    public Object login(@Valid Login login) {
        System.out.println(login);
        // 省略...,只做测试
        return login;
    }
    

    返回的json字符串

    {
        "timestamp": "2019-01-26T10:28:16.400+0000",
        "status": 400,
        "error": "Bad Request",
        "errors": [
            {
                "codes": [
                    "Length.login.password",
                    "Length.password",
                    "Length.java.lang.String",
                    "Length"
                ],
                "arguments": [
                    {
                        "codes": [
                            "login.password",
                            "password"
                        ],
                        "arguments": null,
                        "defaultMessage": "password",
                        "code": "password"
                    },
                    2147483647,
                    12
                ],
                "defaultMessage": "长度需要在12和2147483647之间",
                "objectName": "login",
                "field": "password",
                "rejectedValue": "123456",
                "bindingFailure": false,
                "code": "Length"
            },
            {
                "codes": [
                    "Phone.login.mobile",
                    "Phone.mobile",
                    "Phone.java.lang.String",
                    "Phone"
                ],
                "arguments": [
                    {
                        "codes": [
                            "login.mobile",
                            "mobile"
                        ],
                        "arguments": null,
                        "defaultMessage": "mobile",
                        "code": "mobile"
                    },
                    true
                ],
                "defaultMessage": "手机号码格式错误",
                "objectName": "login",
                "field": "mobile",
                "rejectedValue": "23445678909",
                "bindingFailure": false,
                "code": "Phone"
            }
        ],
        "message": "Validation failed for object='login'. Error count: 2",
        "path": "/miaosha/login"
    }
    

    defaultMessage 中就包含了我们定义的错误返回信息。接着我们可以定义全局的异常类对错误进行处理。

    展开全文
  • java 自定义状态码

    千次阅读 2018-08-13 12:28:03
    比如说, 我们提供了太多的 Query 参数,以至于超过了服务器的限制,这时候可以返回 414。  */  _414("414", "请求的 URI 太长了"),  /**  * 不支持的媒体类型。比如说, 我们上传了一张七娃的 GIF 动图, ...

    说明用中文而已,对应springframework的状态码的类

    org.springframework.http.HttpStatus
    

    参考  https://blog.csdn.net/razeSpirit/article/details/78030947  的状态码定义

    /**
     * PRODUCT_NAME: IntelliJ IDEA
     * PROJECT_NAME: ztrace
     * PACKAGE_NAME: com.demo
     * AUTHOR: Choj
     * DATE: 2018-08-13 10:32
     * NAME: IExceptionEnum
     * TODO: 状态码
     **/
    public interface IExceptionEnum {
        /**
         * 获取状态码
         *
         * @return 状态码
         */
        public String getCode();
    
        /**
         * 获取提示信息
         *
         * @return 提示信息
         */
        public String getMessage();
    }
    

    /**
    * PRODUCT_NAME: IntelliJ IDEA
    * PROJECT_NAME: ztrace
    * PACKAGE_NAME: com.demo
    * AUTHOR: Choj
    * DATE: 2018-08-13 10:33
    * NAME: ExceptionEnum
    * TODO: 自定义异常
    **/
    public enum ExceptionEnum implements IExceptionEnum {
        /**
         * 正确的请求返回正确的结果
         */
        _200("200", "请求成功"),
        /**
         * 表示资源被正确的创建。比如说,我们 POST 用户名、密码正确创建了一个用户就可以返回 201。
         */
        _201("201", "资源被正确的创建"),
        /**
         * 请求是正确的,但是结果正在处理中,没法返回对应的结果。比如说,我们请求一个需要大量计算的结果,但是并没有计算结束时,可以返回这个,这时候客户端可以通过轮询等机制继续请求。
         */
        _202("202", "结果正在处理中"),
        /**
         * 请求的代理服务器修改了源服务器返回的 200 中的内容,一般用不到。比如说,我们通过代理服务器向服务器 A 请求用户信息,服务器 A 正常响应,但代理服务器命中了缓存并返回了自己的缓存内容,这时候它返回 203 告诉我们这部分信息不一定是最新的,我们可以自行判断并处理。
         */
        _203("203", "返回缓存内容"),
        /**
         * 请求正确,但是没有需要返回的内容。比如说,我们请求删除某个用户,删除成功可以返回 204。
         */
        _204("204", "请求成功,但是没有需要返回的内容"),
        /**
         * 类似 204,但是要求请求者重置视图,一般也用不到。比如说,我们请求删除某个用户,服务器返回 205的话,我们就刷新现在的用户列表。
         */
        _205("205", "请求成功,重新请求获取最新内容"),
        /**
         * 请求成功,但根据请求头只返回了部分内容。比如说,我们下载一部片,共有 10部分,我们把请求也分成了 10次(防止一次请求过大),这时候服务器就可以返回 206并在其头部告诉我们这是哪一部分,然后再根据这个信息进行拼装。
         */
        _206("206", "请求成功,只返回了部分内容"),
        /**
         * 请求成功,但结果有多种选择。比如说,我们下载一部片,服务器有 avi、mp4 等格式,这时候可以返回 300,并在 body里告知有哪些格式,然后用户可以根据这些格式再次请求。
         */
        _300("300", "请求成功,根据返回内容选择"),
        /**
         * 请求成功,但是资源被永久转移。比如说,我们要下载葫芦娃,但是由于旧的存储服务商涨价了,现在要使用新的存储服务了,要去新地址下载,这时候可以返回 301,并在 header的 Location中告知新的地址,以后也应当到这个地址下载。
         */
        _301("301", "请求成功,但是资源被永久转移"),
        /**
         * 请求成功,但是资源被临时转移了。和 301不同的是, 除非是 HEAD请求,否则新地址的信息应当在 body中返回,并且资源只是临时转移,以后不应当通过新地址来下载。
         */
        _302("302", "请求成功,但是资源被临时转移"),
        /**
         * 类似 302, 但要求使用 GET 来访问新的地址来获取资源。
         */
        _303("303", "请求成功,GET来访问新的地址来获取资源"),
        /**
         * 请求的资源并没有被修改过。比如说,我们发送请求想看看 5.20后的情侣信息,服务器查询没有新的情侣信息产生,这时候可以返回 304,然后客户端可以继续用旧的数据。
         */
        _304("304", "请求成功,请求的资源并没有被修改过"),
        /**
         * 请求的资源必须通过代理访问。比如说,我们想请求服务器 A 上新的 iPhone 的信息,但是需要通过代理服务器才能访问, 如果直接请求了服务器 A,没有经过代理服务器,这时候服务器 A 就可以返回 305从而告诉我们应当访问代理服务器。
         */
        _305("305", "请求成功,请求的资源必须通过代理访问"),
        /**
         * 不用了
         */
        _306("306", "请求成功,不用了"),
        /**
         * 类似 302,但要求使用原有的请求方式来通过新地址获取资源。
         */
        _307("307", "请求成功,使用原有的请求方式来通过新地址获取资源"),
        /**
         * 类似 301,但要求使用原有的请求方式来通过新地址获取资源。
         */
        _308("308", "请求成功,使用原有的请求方式来通过新地址获取资源"),
        /**
         * 请求出现错误,比如请求头不对等,所有不想明确区分的客户端请求出错都可以返回 400。
         */
        _400("400", "请求出现错误"),
        /**
         * 没有提供认证信息。比如说, 请求的时候没有带上 Token 等。
         */
        _401("401", "没有提供认证信息"),
        /**
         * 为将来的需要所保留的状态码
         */
        _402("402", "为将来的需要所保留的状态码"),
        /**
         * 请求的资源不允许访问。比如说, 你使用普通用户的 Token 去请求管理员才能访问的资源。
         */
        _403("403", "请求的资源不允许访问"),
        /**
         * 请求的内容不存在
         */
        _404("404", "请求的内容不存在"),
        /**
         * 请求的方法不允许使用。比如说, 服务器只实现了 PATCH 了局部更新资源,并没有实现 PUT来替换资源, 而我们使用了 PUT,这时候服务器可以返回 405 来告知并没有实现对 PUT     的相关处理。
         */
        _405("405", "请求的方法不允许使用"),
        /**
         * 请求的资源并不符合要求。比如说, 我们 header 里请求 JSON 格式的数据, 但是服务器只有 XML 格式的数据,这时候可以返回 406告知。
         */
        _406("406", "请求的资源并不符合要求"),
        /**
         * 类似 401,但是要求必须去同代理服务器进行认证。
         */
        _407("407", "必须去同代理服务器进行认证"),
        /**
         * 客户端请求超时。我们想 POST\创建一个用户,虽然建立了连接,但是网络不好,服务器在规定时间内没有得到我们的请求信息,这时候服务器可以返回 408告诉我们超时了。然后我们可以重新发送请求。
         */
        _408("408", "客户端请求超时"),
        /**
         * 请求冲突。比如说,服务器要求不同用户不能重名,服务器已经有了一个名叫小伟的用户,这时候我们又想创建一个名叫小伟的用户,服务器可以返回 409,告诉我们冲突了,也可以在 body 中明确告知是什么冲突了。
         */
        _409("409", "请求冲突"),
        /**
         * 请求资源曾经存在,但现在不存在了。比如说,我们下载葫芦娃,但是因为版权被删了,下载不了了,这时候服务器返回 410,告诉我们洗洗早点睡。
         */
        _410("410", "请求冲突"),
        /**
         * 没有提供请求资源的长度。比如说,我们下载葫芦娃,服务器只允许我们分部分下载,我们如果不告诉服务器我们要下载哪部分,服务器就返回 411警告我们。
         */
        _411("411", "没有提供请求资源的长度"),
        /**
         * 请求的资源不符合请求头中的 IF-*的某些条件。比如说,我们下载葫芦娃,然后在请求头告知服务器要 5.20后更新过的,服务器没有,于是返回了 412。
         */
        _412("412", "请求的资源不符合请求头中的IF-*的某些条件"),
        /**
         * 请求体过大。比如说,服务器要求上传文件不能超过 5M, 但是我们 POST 了 10M,这时候就返回 413。
         */
        _413("413", "请求体过大"),
        /**
         * 请求的 URI 太长了。比如说, 我们提供了太多的 Query 参数,以至于超过了服务器的限制,这时候可以返回 414。
         */
        _414("414", "请求的 URI 太长了"),
        /**
         * 不支持的媒体类型。比如说, 我们上传了一张七娃的 GIF 动图, 而服务器只允许你上传 PNG 图片,这时候就返回 415。
         */
        _415("415", "不支持的媒体类型"),
        /**
         * 请求的区间无效。比如说,我们分部分下载时请求葫芦娃的 10分钟到 12分钟的内容,但是这部葫芦娃只有 1分钟的内容,这时候就返回 416。
         */
        _416("416", "请求的区间无效"),
        /**
         * 预期错误。指服务器没法满足我们在请求头里的 Expect 相关的信息。
         */
        _417("417", "预期错误"),
        /**
         * 不需要的状态码
         */
        _418("418", "不需要的状态码"),
        /**
         * 服务器错误。没法明确定义的服务器错误都可以返回这个。
         */
        _500("500", "服务器错误"),
        /**
         * 请求还没有被实现。比如说,我们请求一个接口来自动拒绝项目经理的要求,但是这个接口只是美好的想象,并没有被实现,这时候可以返回 501。
         */
        _501("501", "请求还没有被实现"),
        /**
         * 网关错误。比如说,我们向服务器 A 请求下载葫芦娃,但是 A 其实只是一个代理服务器,他得向 B 请求葫芦娃,但是不知道为啥 B 不理他或者给他错误,这时候哦可以 A 返回 502 用来表示 B 这家伙傲娇了。
         */
        _502("502", "网关错误"),
        /**
         * 服务暂时不可用。比如说,服务器正好在更新代码重启。
         */
        _503("503", "服务暂时不可用"),
        /**
         * 类似 502, 但是这时候是 B 不理 A,超时了 。
         */
        _504("504", "服务暂时不可用"),
        /**
         * 请求的 HTTP 版本不支持。比如说, 现在强行根据 HTTP 1000来请求。;
         */
        _505("505", "服务暂时不可用");

        /**
         * 状态码
         */
        private String code;
        /**
         * 提示信息
         */
        private String message;

        /**
         * 构造函数
         *
         * @param code    状态码
         * @param message 提示信息
         */
        ExceptionEnum(String code, String message) {
            this.code = code;
            this.message = message;
        }

        /**
         * 获取状态码
         *
         * @return 状态码
         */
        @Override
        public String getCode() {
            return this.code;
        }

        /**
         * 获取提示信息
         *
         * @return 提示信息
         */
        @Override
        public String getMessage() {
            return this.message;
        }
    }

     

    展开全文
  • 今天去面试,上机题,第一题就给我难住了求助各位大佬。。。 ![图片说明](https://img-ask.csdn.net/upload/201912/05/1575528872_963094.jpg)
  • java自定义http请求

    千次阅读 2016-05-31 23:12:28
    HttpResponser.java package com.cg.scoket.httpscodket; import java.util.Vector; /** * 响应对象 */ public class HttpResponser { String urlString; int defaultPort; String file; String ...

    HttpResponser.java

    package com.cg.scoket.httpscodket;
    import java.util.Vector;
     
    /**
     * 响应对象
     */
    public class HttpResponser {
     
    	String urlString;
     
    	int defaultPort;
     
    	String file;
     
    	String host;
     
    	String path;
     
    	int port;
     
    	String protocol;
     
    	String query;
     
    	String ref;
     
    	String userInfo;
     
    	String contentEncoding;
     
    	String content;
     
    	String contentType;
     
    	int code;
     
    	String message;
     
    	String method;
     
    	int connectTimeout;
     
    	int readTimeout;
     
    	Vector<String> contentCollection;
     
    	public String getContent() {
    		return content;
    	}
     
    	public String getContentType() {
    		return contentType;
    	}
     
    	public int getCode() {
    		return code;
    	}
     
    	public String getMessage() {
    		return message;
    	}
     
    	public Vector<String> getContentCollection() {
    		return contentCollection;
    	}
     
    	public String getContentEncoding() {
    		return contentEncoding;
    	}
     
    	public String getMethod() {
    		return method;
    	}
     
    	public int getConnectTimeout() {
    		return connectTimeout;
    	}
     
    	public int getReadTimeout() {
    		return readTimeout;
    	}
     
    	public String getUrlString() {
    		return urlString;
    	}
     
    	public int getDefaultPort() {
    		return defaultPort;
    	}
     
    	public String getFile() {
    		return file;
    	}
     
    	public String getHost() {
    		return host;
    	}
     
    	public String getPath() {
    		return path;
    	}
     
    	public int getPort() {
    		return port;
    	}
     
    	public String getProtocol() {
    		return protocol;
    	}
     
    	public String getQuery() {
    		return query;
    	}
     
    	public String getRef() {
    		return ref;
    	}
     
    	public String getUserInfo() {
    		return userInfo;
    	}
     
    }
    
    	    			
    HttpUtils.java

    package com.cg.scoket.httpscodket;  
          
        import java.io.BufferedReader;  
        import java.io.ByteArrayOutputStream;  
        import java.io.IOException;  
        import java.io.InputStream;  
        import java.io.InputStreamReader;  
        import java.io.OutputStream;  
        import java.net.HttpURLConnection;  
        import java.net.InetAddress;  
        import java.net.Socket;  
        import java.net.URL;  
        import java.net.URLConnection;  
        import java.net.URLEncoder;  
        import java.nio.charset.Charset;  
        import java.util.HashMap;  
        import java.util.Map;  
        import java.util.Map.Entry;  
        import java.util.Set;  
        import java.util.Vector;  
          
        /** 
         * @author JetChen
         * @date 2016-5-31 晚上23:08 
         * @version 1.0-SNAPSHOT 
         */  
        public class HttpUtils {  
          
            private String defaultContentEncoding;  
          
            public HttpUtils() {  
                this.defaultContentEncoding = Charset.defaultCharset().name();  
            }  
          
            /** 
             * 发送GET请求 
             *  
             * @param urlString  URL地址 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendGet(String urlString) throws IOException {  
                return this.send(urlString, "GET", null, null);  
            }  
          
            /** 
             * 发送GET请求 
             *  
             * @param urlString  URL地址 
             * @param params 参数集合 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendGet(String urlString, Map<String, String> params) throws IOException {  
                return this.send(urlString, "GET", params, null);  
            }  
          
            /** 
             * 发送GET请求 
             *  
             * @param urlString URL地址 
             * @param params 参数集合 
             * @param propertys 请求属性 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendGet(String urlString, Map<String, String> params, Map<String, String> propertys)  
                    throws IOException {  
                return this.send(urlString, "GET", params, propertys);  
            }  
          
            /** 
             * 发送POST请求 
             *  
             * @param urlString URL地址 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendPost(String urlString) throws IOException {  
                return this.send(urlString, "POST", null, null);  
            }  
          
            /** 
             * 发送POST请求 
             *  
             * @param urlString URL地址 
             * @param params 参数集合 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendPost(String urlString, Map<String, String> params) throws IOException {  
                return this.send(urlString, "POST", params, null);  
            }  
          
            /** 
             * 发送POST请求 
             *  
             * @param urlString URL地址 
             * @param params 参数集合 
             * @param propertys 请求属性 
             * @return 响应对象 
             * @throws IOException 
             */  
            public HttpResponser sendPost(String urlString, Map<String, String> params, Map<String, String> propertys)  
                    throws IOException {  
                return this.send(urlString, "POST", params, propertys);  
            }  
          
            /** 
             * 发送HTTP请求 
             *  
             * @param urlString 地址 
             * @param method  get/post 
             * @param parameters  添加由键值对指定的请求参数 
             * @param propertys  添加由键值对指定的一般请求属性 
             * @return 响映对象 
             * @throws IOException 
             */  
            private HttpResponser send(String urlString, String method, Map<String, String> parameters,  
                    Map<String, String> propertys) throws IOException {  
                HttpURLConnection urlConnection = null;  
          
                if (method.equalsIgnoreCase("GET") && parameters != null) {  
                    StringBuffer param = new StringBuffer();  
                    int i = 0;  
                    for (String key : parameters.keySet()) {  
                        if (i == 0)  
                            param.append("?");  
                        else  
                            param.append("&");  
                        param.append(key).append("=").append(parameters.get(key));  
                        i++;  
                    }  
                    urlString += param;  
                }  
          
                URL url = new URL(urlString);  
                urlConnection = (HttpURLConnection) url.openConnection();  
                urlConnection.setRequestMethod(method);  
                urlConnection.setDoOutput(true);  
                urlConnection.setDoInput(true);  
                urlConnection.setUseCaches(false);  
          
                if (propertys != null)  
                    for (String key : propertys.keySet()) {  
                        urlConnection.addRequestProperty(key, propertys.get(key));  
                    }  
          
                if (method.equalsIgnoreCase("POST") && parameters != null) {  
                    StringBuffer param = new StringBuffer();  
                    for (String key : parameters.keySet()) {  
                        param.append("&");  
                        param.append(key).append("=").append(parameters.get(key));  
                    }  
                    urlConnection.getOutputStream().write(param.toString().getBytes());  
                    urlConnection.getOutputStream().flush();  
                    urlConnection.getOutputStream().close();  
                }  
                return this.makeContent(urlString, urlConnection);  
            }  
          
            /** 
             * 得到响应对象 
             *  
             * @param urlConnection 
             * @return 响应对象 
             * @throws IOException 
             */  
            private HttpResponser makeContent(String urlString, HttpURLConnection urlConnection) throws IOException {  
                HttpResponser HttpResponserer = new HttpResponser();  
                try {  
                    InputStream in = urlConnection.getInputStream();  
                    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));  
                    HttpResponserer.contentCollection = new Vector<String>();  
                    StringBuffer temp = new StringBuffer();  
                    String line = bufferedReader.readLine();  
                    while (line != null) {  
                        HttpResponserer.contentCollection.add(line);  
                        temp.append(line).append("\r\n");  
                        line = bufferedReader.readLine();  
                    }  
                    bufferedReader.close();  
                    String ecod = urlConnection.getContentEncoding();  
                    if (ecod == null)  
                        ecod = this.defaultContentEncoding;  
                    HttpResponserer.urlString = urlString;  
                    HttpResponserer.defaultPort = urlConnection.getURL().getDefaultPort();  
                    HttpResponserer.file = urlConnection.getURL().getFile();  
                    HttpResponserer.host = urlConnection.getURL().getHost();  
                    HttpResponserer.path = urlConnection.getURL().getPath();  
                    HttpResponserer.port = urlConnection.getURL().getPort();  
                    HttpResponserer.protocol = urlConnection.getURL().getProtocol();  
                    HttpResponserer.query = urlConnection.getURL().getQuery();  
                    HttpResponserer.ref = urlConnection.getURL().getRef();  
                    HttpResponserer.userInfo = urlConnection.getURL().getUserInfo();  
                    HttpResponserer.content = new String(temp.toString().getBytes(), ecod);  
                    HttpResponserer.contentEncoding = ecod;  
                    HttpResponserer.code = urlConnection.getResponseCode();  
                    HttpResponserer.message = urlConnection.getResponseMessage();  
                    HttpResponserer.contentType = urlConnection.getContentType();  
                    HttpResponserer.method = urlConnection.getRequestMethod();  
                    HttpResponserer.connectTimeout = urlConnection.getConnectTimeout();  
                    HttpResponserer.readTimeout = urlConnection.getReadTimeout();  
                    return HttpResponserer;  
                } catch (IOException e) {  
                    throw e;  
                } finally {  
                    if (urlConnection != null)  
                        urlConnection.disconnect();  
                }  
            }  
          
            /** 
             * 默认的响应字符集 
             */  
            public String getDefaultContentEncoding() {  
                return this.defaultContentEncoding;  
            }  
          
              
            /** 
             * 发送GET请求 
             * @param url 
             * @param params 
             * @param headers 
             * @return 
             * @throws Exception 
             */  
            public static URLConnection sendGetRequest(String url,  
                    Map<String, String> params, Map<String, String> headers)  
                    throws Exception {  
                StringBuilder buf = new StringBuilder(url);  
                Set<Entry<String, String>> entrys = null;  
                // 如果是GET请求,则请求参数在URL中  
                if (params != null && !params.isEmpty()) {  
                    buf.append("?");  
                    entrys = params.entrySet();  
                    for (Map.Entry<String, String> entry : entrys) {  
                        buf.append(entry.getKey()).append("=")  
                                .append(URLEncoder.encode(entry.getValue(), "UTF-8"))  
                                .append("&");  
                    }  
                    buf.deleteCharAt(buf.length() - 1);  
                }  
                URL url1 = new URL(buf.toString());  
                HttpURLConnection conn = (HttpURLConnection) url1.openConnection();  
                conn.setRequestMethod("GET");  
                // 设置请求头  
                if (headers != null && !headers.isEmpty()) {  
                    entrys = headers.entrySet();  
                    for (Map.Entry<String, String> entry : entrys) {  
                        conn.setRequestProperty(entry.getKey(), entry.getValue());  
                    }  
                }  
                conn.getResponseCode();  
                return conn;  
            }  
            /** 
             * 发送POST请求 
             * @param url    
             * @param params 
             * @param headers 
             * @return  
             * @throws Exception 
             */  
            public static URLConnection sendPostRequest(String url,  
                    Map<String, String> params, Map<String, String> headers)  
                    throws Exception {  
                StringBuilder buf = new StringBuilder();  
                Set<Entry<String, String>> entrys = null;  
                // 如果存在参数,则放在HTTP请求体,形如name=aaa&age=10  
                if (params != null && !params.isEmpty()) {  
                    entrys = params.entrySet();  
                    for (Map.Entry<String, String> entry : entrys) {  
                        buf.append(entry.getKey()).append("=")  
                                .append(URLEncoder.encode(entry.getValue(), "UTF-8"))  
                                .append("&");  
                    }  
                    buf.deleteCharAt(buf.length() - 1);  
                }  
                URL url1 = new URL(url);  
                HttpURLConnection conn = (HttpURLConnection) url1.openConnection();  
                conn.setRequestMethod("POST");  
                conn.setDoOutput(true);  
                OutputStream out = conn.getOutputStream();  
                out.write(buf.toString().getBytes("UTF-8"));  
                if (headers != null && !headers.isEmpty()) {  
                    entrys = headers.entrySet();  
                    for (Map.Entry<String, String> entry : entrys) {  
                        conn.setRequestProperty(entry.getKey(), entry.getValue());  
                    }  
                }  
                conn.getResponseCode(); // 为了发送成功  
                return conn;  
            }  
            /** 
             * 直接通过HTTP协议提交数据到服务器,实现如下面表单提交功能: 
             *   <FORM METHOD=POST ACTION="http://192.168.0.200:8080/ssi/fileload/test.do" enctype="multipart/form-data"> 
                    <INPUT TYPE="text" NAME="name"> 
                    <INPUT TYPE="text" NAME="id"> 
                    <input type="file" name="imagefile"/> 
                    <input type="file" name="zip"/> 
                 </FORM> 
             * @param path 上传路径(注:避免使用localhost或127.0.0.1这样的路径测试,因为它会指向手机模拟器,你可以使用http://www.itcast.cn或http://192.168.1.10:8080这样的路径测试) 
             * @param params 请求参数 key为参数名,value为参数值 
             * @param file 上传文件 
             */  
            public static boolean uploadFiles(String path, Map<String, String> params, FormFile[] files) throws Exception{       
                final String BOUNDARY = "---------------------------7da2137580612"; //数据分隔线  
                final String endline = "--" + BOUNDARY + "--\r\n";//数据结束标志  
                  
                int fileDataLength = 0;  
                if(files!=null&&files.length!=0){  
                    for(FormFile uploadFile : files){//得到文件类型数据的总长度  
                        StringBuilder fileExplain = new StringBuilder();  
                        fileExplain.append("--");  
                        fileExplain.append(BOUNDARY);  
                        fileExplain.append("\r\n");  
                        fileExplain.append("Content-Disposition: form-data;name=\""+ uploadFile.getParameterName()+"\";filename=\""+ uploadFile.getFilname() + "\"\r\n");  
                        fileExplain.append("Content-Type: "+ uploadFile.getContentType()+"\r\n\r\n");  
                        fileExplain.append("\r\n");  
                        fileDataLength += fileExplain.length();  
                        if(uploadFile.getInStream()!=null){  
                            fileDataLength += uploadFile.getFile().length();  
                        }else{  
                            fileDataLength += uploadFile.getData().length;  
                        }  
                    }  
                }  
                StringBuilder textEntity = new StringBuilder();  
                if(params!=null&&!params.isEmpty()){  
                    for (Map.Entry<String, String> entry : params.entrySet()) {//构造文本类型参数的实体数据  
                        textEntity.append("--");  
                        textEntity.append(BOUNDARY);  
                        textEntity.append("\r\n");  
                        textEntity.append("Content-Disposition: form-data; name=\""+ entry.getKey() + "\"\r\n\r\n");  
                        textEntity.append(entry.getValue());  
                        textEntity.append("\r\n");  
                    }  
                }  
                //计算传输给服务器的实体数据总长度  
                int dataLength = textEntity.toString().getBytes().length + fileDataLength +  endline.getBytes().length;  
                  
                URL url = new URL(path);  
                int port = url.getPort()==-1 ? 80 : url.getPort();  
                Socket socket = new Socket(InetAddress.getByName(url.getHost()), port);          
                OutputStream outStream = socket.getOutputStream();  
                //下面完成HTTP请求头的发送  
                String requestmethod = "POST "+ url.getPath()+" HTTP/1.1\r\n";  
                outStream.write(requestmethod.getBytes());  
                String accept = "Accept: image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*\r\n";  
                outStream.write(accept.getBytes());  
                String language = "Accept-Language: zh-CN\r\n";  
                outStream.write(language.getBytes());  
                String contenttype = "Content-Type: multipart/form-data; boundary="+ BOUNDARY+ "\r\n";  
                outStream.write(contenttype.getBytes());  
                String contentlength = "Content-Length: "+ dataLength + "\r\n";  
                outStream.write(contentlength.getBytes());  
                String alive = "Connection: Keep-Alive\r\n";  
                outStream.write(alive.getBytes());  
                String host = "Host: "+ url.getHost() +":"+ port +"\r\n";  
                outStream.write(host.getBytes());  
                //写完HTTP请求头后根据HTTP协议再写一个回车换行  
                outStream.write("\r\n".getBytes());  
                //把所有文本类型的实体数据发送出来  
                outStream.write(textEntity.toString().getBytes());           
                //把所有文件类型的实体数据发送出来  
                if(files!=null&&files.length!=0){  
                    for(FormFile uploadFile : files){  
                        StringBuilder fileEntity = new StringBuilder();  
                        fileEntity.append("--");  
                        fileEntity.append(BOUNDARY);  
                        fileEntity.append("\r\n");  
                        fileEntity.append("Content-Disposition: form-data;name=\""+ uploadFile.getParameterName()+"\";filename=\""+ uploadFile.getFilname() + "\"\r\n");  
                        fileEntity.append("Content-Type: "+ uploadFile.getContentType()+"\r\n\r\n");  
                        outStream.write(fileEntity.toString().getBytes());  
                        if(uploadFile.getInStream()!=null){  
                            byte[] buffer = new byte[1024];  
                            int len = 0;  
                            while((len = uploadFile.getInStream().read(buffer, 0, 1024))!=-1){  
                                outStream.write(buffer, 0, len);  
                            }  
                            uploadFile.getInStream().close();  
                        }else{  
                            outStream.write(uploadFile.getData(), 0, uploadFile.getData().length);  
                        }  
                        outStream.write("\r\n".getBytes());  
                    }  
                }  
                //下面发送数据结束标志,表示数据已经结束  
                outStream.write(endline.getBytes());  
                BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
                if(reader.readLine().indexOf("200")==-1){//读取web服务器返回的数据,判断请求码是否为200,如果不是200,代表请求失败  
                    return false;  
                }  
                outStream.flush();  
                outStream.close();  
                reader.close();  
                socket.close();  
                return true;  
            }  
            /**  
             * 提交数据到服务器  
             * @param path 上传路径(注:避免使用localhost或127.0.0.1这样的路径测试,因为它会指向手机模拟器,你可以使用http://www.itcast.cn或http://192.168.1.10:8080这样的路径测试)  
             * @param params 请求参数 key为参数名,value为参数值  
             * @param file 上传文件  
             */  
            public static boolean uploadFile(String path, Map<String, String> params, FormFile file) throws Exception{  
               return uploadFiles(path, params, new FormFile[]{file});  
            }  
            /** 
             * 将输入流转为字节数组 
             * @param inStream 
             * @return 
             * @throws Exception 
             */  
            public static byte[] read2Byte(InputStream inStream)throws Exception{  
                ByteArrayOutputStream outSteam = new ByteArrayOutputStream();  
                byte[] buffer = new byte[1024];  
                int len = 0;  
                while( (len = inStream.read(buffer)) !=-1 ){  
                    outSteam.write(buffer, 0, len);  
                }  
                outSteam.close();  
                inStream.close();  
                return outSteam.toByteArray();  
            }  
            /** 
             * 将输入流转为字符串 
             * @param inStream 
             * @return 
             * @throws Exception 
             */  
            public static String read2String(InputStream inStream)throws Exception{  
                ByteArrayOutputStream outSteam = new ByteArrayOutputStream();  
                byte[] buffer = new byte[1024];  
                int len = 0;  
                while( (len = inStream.read(buffer)) !=-1 ){  
                    outSteam.write(buffer, 0, len);  
                }  
                outSteam.close();  
                inStream.close();  
                return new String(outSteam.toByteArray(),"UTF-8");  
            }  
            /** 
             * 发送xml数据 
             * @param path 请求地址 
             * @param xml xml数据 
             * @param encoding 编码 
             * @return 
             * @throws Exception 
             */  
            public static byte[] postXml(String path, String xml, String encoding) throws Exception{  
                byte[] data = xml.getBytes(encoding);  
                URL url = new URL(path);  
                HttpURLConnection conn = (HttpURLConnection)url.openConnection();  
                conn.setRequestMethod("POST");  
                conn.setDoOutput(true);  
                conn.setRequestProperty("Content-Type", "text/xml; charset="+ encoding);  
                conn.setRequestProperty("Content-Length", String.valueOf(data.length));  
                conn.setConnectTimeout(5 * 1000);  
                OutputStream outStream = conn.getOutputStream();  
                outStream.write(data);  
                outStream.flush();  
                outStream.close();  
                if(conn.getResponseCode()==200){  
                    return read2Byte(conn.getInputStream());  
                }  
                return null;  
            }  
            //测试函数  
            public static void main(String args[]) throws Exception {  
                Map<String, String> params = new HashMap<String, String>();  
                params.put("name", "xiazdong");  
                params.put("age", "10");  
                HttpURLConnection conn = (HttpURLConnection)  
                        sendGetRequest(  
                                "http://192.168.0.103:8080/Server/PrintServlet",  
                                params, null);  
                int code = conn.getResponseCode();  
                InputStream in = conn.getInputStream();  
                byte[]data = read2Byte(in);  
            }  
              
            /** 
             * 设置默认的响应字符集 
             */  
            public void setDefaultContentEncoding(String defaultContentEncoding) {  
                this.defaultContentEncoding = defaultContentEncoding;  
            }  
        }  

    FormFile.java

    package com.cg.scoket.httpscodket;
    
    import java.io.File;  
    import java.io.FileInputStream;  
    import java.io.FileNotFoundException;  
    import java.io.InputStream;  
      
    /** 
     * 上传文件 
     */  
    public class FormFile {  
        /* 上传文件的数据 */  
        private byte[] data;  
        private InputStream inStream;  
        private File file;  
        /* 文件名称 */  
        private String filname;  
        /* 请求参数名称*/  
        private String parameterName;  
        /* 内容类型 */  
        private String contentType = "application/octet-stream";  
          
        /** 
         * 此函数用来传输小文件 
         * @param filname 
         * @param data 
         * @param parameterName 
         * @param contentType 
         */  
        public FormFile(String filname, byte[] data, String parameterName, String contentType) {  
            this.data = data;  
            this.filname = filname;  
            this.parameterName = parameterName;  
            if(contentType!=null) this.contentType = contentType;  
        }  
        /** 
         * 此函数用来传输大文件 
         * @param filname 
         * @param file 
         * @param parameterName 
         * @param contentType 
         */  
        public FormFile(String filname, File file, String parameterName, String contentType) {  
            this.filname = filname;  
            this.parameterName = parameterName;  
            this.file = file;  
            try {  
                this.inStream = new FileInputStream(file);  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            }  
            if(contentType!=null) this.contentType = contentType;  
        }  
          
        public File getFile() {  
            return file;  
        }  
      
        public InputStream getInStream() {  
            return inStream;  
        }  
      
        public byte[] getData() {  
            return data;  
        }  
      
        public String getFilname() {  
            return filname;  
        }  
      
        public void setFilname(String filname) {  
            this.filname = filname;  
        }  
      
        public String getParameterName() {  
            return parameterName;  
        }  
      
        public void setParameterName(String parameterName) {  
            this.parameterName = parameterName;  
        }  
      
        public String getContentType() {  
            return contentType;  
        }  
      
        public void setContentType(String contentType) {  
            this.contentType = contentType;  
        }  
          
    }  



    展开全文
  • java自定义注解 Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。 注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang....
  • java 自定义实现Base64编码

    千次阅读 2018-03-28 18:20:28
    //TODO 修改Decoder的静态方法,禁止提供返回String的方法,原因:在AES加密时才发现自己一直的一个误区,new String()和getBytes()两者操作得到的字节数组不一定都是一样的,应该先getBytes(),才能去new String(),在测试...
  • Java自定义注解及应用

    千次阅读 2018-06-27 15:12:54
    Java目前只内置了三种标准注解 注解 解释 @Override 表示当前的方法定义将覆盖超类中的方法。如果你不小心拼写错误,或者方法签名对不上被覆盖的方法,编译器就会发出错误提示 @Deprecated 如果程序员使用...
  • Java自定义框架初步(一)

    千次阅读 2017-09-02 19:38:59
    最近想自己学习写框架,看过一些资料,决定从JavaWeb开始。...2.自定义注解; 3.资源文件的读写。一般框架常用xml文件做配置,也可以使用properties属性文件。 我是用Idea做工具。 一、首先创建一个Ja
  • Spring MVC中参数校验器的使用和自定义参数校验器 项目案例代码:https://github.com/IndustriousSnail/learning-notes/tree/master/springboot/SpringMvc自定义参数校验器/validator 目录 一、参数校验器简介 二、...
  • java 自定义注解验证 原理基于java的反射和映射 可自己添加所需要的注解,本案例中只写了三个自定义注解类 本案例只花了半天时间,如有不好之处请多提提意见。谢谢!
  • 1.首先定义NotNull注解 ...import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Targ...
  • Java自定义注解和运行时靠反射获取注解 java自定义注解 Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。 注解不会也不能影响代码的实际逻辑,...
  • JAVA自定义注解和提取注解信息

    万次阅读 2016-08-23 19:58:37
    (如果没有注释直接存在于此元素上,则返回长度为零的一个数组。) 5. boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) 功能:判断该程序元素上是否存在指定类型的注解,如果存在则返回...
  • java自定义注解 Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。 注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation...
  • Java 8 自定义流Collector实现

    千次阅读 2019-04-21 17:05:19
    Java 8 自定义 流的 Collector实现 前文我们看到 Java 8 Collectors提供了很多...加入我们的字符串流,每个字符串对象有方法length()————返回单词长度。我们想创建自定义Collector,实现reduce操作,计算流中所...
  • Spring boot自定义参数校验注解 如果Spring boot是2.3.0之后的版本,需要引入新的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sprin
  • 参数返回类型_自定义tuple

    千次阅读 2012-09-02 21:52:28
    // Java 中可以使用Object[] 方式用于返回多个值的函数,因为Java可以使用Object[] objs = fun()的方式接收, // 最重要的是,objs的长度Java程序中是可知的,而如果C++中却不行! // public static Obje
  • 本篇博客主要是实现自定义注解,通过在方法中使用该注解,打印出该方法的请求参数以及返回参数,用于排查问题。减少日志的打印。 方法枚举: package cn.eric.jdktools.annotation; /** * 方法返回参数枚举 * @...
  • 主要是针对基本数据类型和级联对象进行参数校验的演示,但是在实际中我们往往需要更为复杂的校验规则,比如注册用户的密码和确认密码进行校验,这个时候基本的注解就无法满足我们的要求了,需要去按照业务需求去...
  • Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。  注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。 1...
  • 为什么要自定义注解通过了解注解的基本概念我们知道,注解是对程序做出解释,同时可以被其他程序(例如:编译器)所读取的,Java中有很多内置注解来方方便我们开发程序,那我们当然也可以自定义注解,来开发程序或者...
  • Java中的自定义注解

    千次阅读 2016-07-03 18:12:46
    可以看到,使用@Column是需要带参数的,参考上面自定义注解的代码,比如name,没有使用默认值,那么他就是必须设置值的,如果有设置default那么就是可以不写的。 OK,配置会配了,那么如何通过代码获取到配置呢?...
  • Java在做接收参数使用javax.validation注解时,有时候不能返回给前端理想的提示信息(要在项目中添加jar包 这里我就不做说明) 示例: 请求一个新增接口 1.接口 /** * 运营管理-产品管理-产品列表-添加产品 *...
  • 自定义注解实现接口参数校验

    千次阅读 2019-05-23 14:41:47
    javax.validation.* 包下提供了部分现成的API可供参数校验使用,但并不能完全满足我们的需求。 validation[,vælɪ'deɪʃən]确认;批准;验证 constraint[kən'streint]约束;限制;约束条件 自定义注解使用步骤...
  • @interface @interface用来声明一个注解,其中的每一个方法实际上是声明了一个配置参数。 方法的名称就是参数的...Java注解就是一种特殊的接口,使用@interface自定义注解时,自动继承了java.lang.annotation.An...
  • JAVA简单自定义类实现与测试

    千次阅读 2014-02-24 15:59:16
    日常做项目中为避免重复性... 本文不涉及Java平台的搭建,不涉及操作系统环境,不涉及Maven以及Junit用法。  目的:实现自己的inputstream类。  类说明:类包括一个属性path,一个构造函数,一个read方法。  

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 93,222
精华内容 37,288
关键字:

java自定义参数返回长度

java 订阅