Home

@NoArgsConstructor
public class User {
    private String username;
    private String password;
}
// 编译后：
public class User {
    private String username;
    private String password;

    public User() { }
}

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class User {
    private String username;
    private String password;
}
// 编译后：
public class User {
    private String username;
    private String password;

    private User() {
    }
}

@NoArgsConstructor(force = true)
public class User {
    private final String gender;
    private String username;
    private String password;
}
// 编译后：
public class User {
    private final String gender = null;
    private String username;
    private String password;

    public User() { }
}

@NoArgsConstructor(force = true)
public class User {
    private final String gender;
    @NonNull
    private String username;
    private String password;
}
// 编译后：
public class User {
    private final String gender = null;
    @NonNull
    private String username;
    private String password;

    public User() {
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface NoArgsConstructor {

	String staticName() default "";
    // 在构造方法的入参上添加注解。e.g. @NonNull
    // up to JDK7: @EqualsAndHashCode(onParam=@__({@AnnotationsGoHere}))
    // from JDK8: @EqualsAndHashCode(onParam_={@AnnotationsGohere})
	AnyAnnotation[] onConstructor() default {};
	// 设置构造方法的访问权限，默认是 public
	AccessLevel access() default lombok.AccessLevel.PUBLIC;
	// 是否强制对未赋值的final字段初始化值。
	boolean force() default false;

	@Deprecated
	@Retention(RetentionPolicy.SOURCE)
	@Target({})
	@interface AnyAnnotation {}
}

@NoArgsConstructor(staticName = "UserHa")
public class User {
    private String username;
    private String password;
}
// 编译后：
public class User {
    private String username;
    private String password;

    private User() { }

    public static User UserHa() {
        return new User();
    }
}

@RequiredArgsConstructor
public class User {
    private final String gender;
    @NonNull
    private String username;
    private String password;
}

// 编译后：
public class User {
    private final String gender;
    @NonNull
    private String username;
    private String password;

    public User(String gender, @NonNull String username) {
        if (username == null) {
            throw new NullPointerException("username is marked @NonNull but is null");
        } else {
            this.gender = gender;
            this.username = username;
        }
    }
}

@RequiredArgsConstructor
public class User {
    private final String gender = "男";
    private String username;
    private String password;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface RequiredArgsConstructor {
	// 是否使用静态构造器，并制定静态构造器的名称
	String staticName() default "";
	// 构造器入参添加注解
	AnyAnnotation[] onConstructor() default {};

	@Deprecated
	@Retention(RetentionPolicy.SOURCE)
	@Target({})
	@interface AnyAnnotation {}
}

@AllArgsConstructor
public class User {
    private final String gender;
    private String username;
    private String password;
}
// 编译后
public class User {
    private final String gender;
    private String username;
    private String password;

    public User(String gender, String username, String password) {
        this.gender = gender;
        this.username = username;
        this.password = password;
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface AllArgsConstructor {
	// 是否使用静态构造器，并制定静态构造器的名称
	String staticName() default "";
	// 构造器入参添加注解
	AnyAnnotation[] onConstructor() default {};
	// 设置构造器的访问权限
	AccessLevel access() default lombok.AccessLevel.PUBLIC;

	@Deprecated
	@Retention(RetentionPolicy.SOURCE)
	@Target({})
	@interface AnyAnnotation {}
}

@AllArgsConstructor
public class User {
    private String username;
    private String password;
}
// 编译后：
public class User {
    private String username;
    private String password;

    @ConstructorProperties({"username", "password"})		// 被添加
    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }
}

@RequestMapping("/file-upload")
public ModelAndView upload(@RequestParam(value = "file", required = false) MultipartFile file,
　　　　　　HttpServletRequest request, HttpSession session) {
    // 文件不为空
    if(!file.isEmpty()) {
        // 文件存放路径
        String path = request.getServletContext().getRealPath("/");
        // 文件名称
        String name = String.valueOf(new Date().getTime()+"_"+file.getOriginalFilename());
        File destFile = new File(path,name);
        // 转存文件
        try {
            file.transferTo(destFile);
        } catch (IllegalStateException | IOException e) {
            e.printStackTrace();
        }
        // 访问的url
        String url = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
　　　　　　+ request.getContextPath() + "/" + name;
    }        
    ModelAndView mv = new ModelAndView();
    mv.setViewName("other/home");
    return mv;
}

@Override
public MultipartHttpServletRequest resolveMultipart(final HttpServletRequest request) throws MultipartException {
    Assert.notNull(request, "Request must not be null");
    if (this.resolveLazily) {
        //懒加载，当调用DefaultMultipartHttpServletRequest的getMultipartFiles()方法时才解析请求数据
        return new DefaultMultipartHttpServletRequest(request) {
            @Override //当getMultipartFiles()方法被调用时，如果还未解析请求数据，则调用initializeMultipart()方法进行解析 protected void initializeMultipart() {
                MultipartParsingResult parsingResult = parseRequest(request);
                setMultipartFiles(parsingResult.getMultipartFiles());
                setMultipartParameters(parsingResult.getMultipartParameters());
                setMultipartParameterContentTypes(parsingResult.getMultipartParameterContentTypes());
            }
        };
    } else {
        //立即解析请求数据，并将解析结果封装到DefaultMultipartHttpServletRequest对象中
        MultipartParsingResult parsingResult = parseRequest(request);
        return new DefaultMultipartHttpServletRequest(request, parsingResult.getMultipartFiles(),
              parsingResult.getMultipartParameters(), parsingResult.getMultipartParameterContentTypes());
    }
}

protected MultipartParsingResult parseRequest(HttpServletRequest request) throws MultipartException {
    // 获取请求的编码类型
    String encoding = determineEncoding(request);
    FileUpload fileUpload = prepareFileUpload(encoding);
    try {
        List<FileItem> fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);
        return parseFileItems(fileItems, encoding);
    } catch (...) {}
}

@RequestMapping("/file-upload")
public ModelAndView upload(@RequestParam(value = "file", required = false) MultipartFile file,
　　　　　　HttpServletRequest request, HttpSession session) {
    // 文件不为空
    if(!file.isEmpty()) {
        // 文件存放路径
        String path = request.getServletContext().getRealPath("/");
        // 文件名称
        String name = String.valueOf(new Date().getTime()+"_"+file.getOriginalFilename());
        File destFile = new File(path,name);
        // 转存文件
        try {
            file.transferTo(destFile);
        } catch (IllegalStateException | IOException e) {
            e.printStackTrace();
        }
        // 访问的url
        String url = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
　　　　　　+ request.getContextPath() + "/" + name;
    }        
    ModelAndView mv = new ModelAndView();
    mv.setViewName("other/home");
    return mv;
}

@RequestMapping("/file-upload")
public ModelAndView upload(MultipartHttpServletRequest request, HttpSession session) {
    // 根据页面input标签的name
    MultipartFile file = request.getFile("file");
    // 文件不为空
    if(!file.isEmpty()) {
        // 文件存放路径
        String path = request.getServletContext().getRealPath("/");
        // 文件名称
        String name = String.valueOf(new Date().getTime()+"_"+file.getOriginalFilename());
        File destFile = new File(path,name);
        // 转存文件
        try {
            file.transferTo(destFile);
        } catch (IllegalStateException | IOException e) {
            e.printStackTrace();
        }
        // 访问的url
        String url = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
　　　　　　+ request.getContextPath() + "/" + name;
    }        
    ModelAndView mv = new ModelAndView();
    mv.setViewName("other/home");
    return mv;
}

public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException {
    return new StandardMultipartHttpServletRequest(request, this.resolveLazily);
}
public StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing) throws MultipartException {
    super(request);
    // 判断是否立即解析
    if (!lazyParsing) {
        parseRequest(request);
    }
}

private void parseRequest(HttpServletRequest request) {
    try {
        Collection<Part> parts = request.getParts();
        this.multipartParameterNames = new LinkedHashSet<String>(parts.size());
        MultiValueMap<String, MultipartFile> files = new LinkedMultiValueMap<String, MultipartFile>(parts.size());
        for (Part part : parts) {
            String disposition = part.getHeader(CONTENT_DISPOSITION);
            String filename = extractFilename(disposition);
            if (filename == null) {
                filename = extractFilenameWithCharset(disposition);
            }
            if (filename != null) {
                files.add(part.getName(), new StandardMultipartFile(part, filename));
            } else {
                this.multipartParameterNames.add(part.getName());
            }
        }
        setMultipartFiles(files);
    } catch (Throwable ex) {}
}

package sc.whorl.system.config.swagger2;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.ResponseEntity;

import java.time.LocalDate;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class Swagger2Config {
	/**
	 * 通过 createRestApi函数来构建一个DocketBean
	 * 函数名,可以随意命名,喜欢什么命名就什么命名
	 */
	@Bean
    public Docket createRestApi() {
    	return new Docket(DocumentationType.SWAGGER_2)
				.apiInfo(apiInfo())
				.select()
				.apis(RequestHandlerSelectors.basePackage("sc.whorl.logic.rmiservice.units.service"))
				.paths(PathSelectors.any())
				.build()
				.pathMapping("/")
				.directModelSubstitute(LocalDate.class, String.class)
				.genericModelSubstitutes(ResponseEntity.class)
				.useDefaultResponseMessages(false)
				.enableUrlTemplating(true);
    }
    //构建 api文档的详细信息函数
	@SuppressWarnings("deprecation")
	private ApiInfo apiInfo() {
		return new ApiInfoBuilder()
				//页面标题
				.title("RESTful API")
				//创建人
				.contact("sc-whorl")
				//版本号
				.version("1.0")
				//描述
				.description("初始化api")
				.build();
	}
}

public class MyArgumentsResolver implements HandlerMethodArgumentResolver {
    /**
     * 解析器是否支持当前参数
     */
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        // 指定参数如果被应用MyParam注解，则使用该解析器。
        // 如果直接返回true，则代表将此解析器用于所有参数
        return parameter.hasParameterAnnotation(MyParam.class);
    }

    /**
     * 将request中的请求参数解析到当前Controller参数上
     * @param parameter 需要被解析的Controller参数，此参数必须首先传给{@link #supportsParameter}并返回true
     * @param mavContainer 当前request的ModelAndViewContainer
     * @param webRequest 当前request
     * @param binderFactory 生成{@link WebDataBinder}实例的工厂
     * @return 解析后的Controller参数
     */
    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

        return null;
    }
}

@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyParam {
}

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    // 解析器中的自定义逻辑——urldecode
    Object arg = URLDecoder.decode(webRequest.getParameter(parameter.getParameterName()), "UTF-8");

    // 将解析后的值绑定到对应的Controller参数上，利用DataBinder提供的方法便捷的实现类型转换
    if (binderFactory != null) {

        // 生成参数绑定器，第一个参数为request请求对象，第二个参数为需要绑定的目标对象，第三个参数为需要绑定的目标对象名
        WebDataBinder binder = binderFactory.createBinder(webRequest, null, parameter.getParameterName());

        try {

            // 将参数转到预期类型，第一个参数为解析后的值，第二个参数为绑定Controller参数的类型，第三个参数为绑定的Controller参数
            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);

        } catch (ConversionNotSupportedException ex) {
            throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
                    parameter.getParameterName(), parameter, ex.getCause());
        } catch (TypeMismatchException ex) {
            throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
                    parameter.getParameterName(), parameter, ex.getCause());
        }
    }
    return arg;
}

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    String name = parameter.getParameterName();

    // 查找是否已有名为name的参数值的映射，如果没有则创建一个
    Object attribute = mavContainer.containsAttribute(name)
        ? mavContainer.getModel().get(name)
        : this.createAttribute(name, parameter, binderFactory, webRequest);

    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);

        if (binder.getTarget() != null) {
            // 进行参数绑定
            this.bindRequestParameters(binder, webRequest);
        }

        // 将参数转到预期类型，第一个参数为解析后的值，第二个参数为绑定Controller参数的类型，第三个参数为绑定的Controller参数
        attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
    }

    return attribute;
}

protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request) throws UnsupportedEncodingException {
    // 将key-value封装为map，传给bind方法进行参数值绑定
    Map<String, String> map = new HashMap<>();
    Map<String, String[]> params = request.getParameterMap();

    for (Map.Entry<String, String[]> entry : params.entrySet()) {
        String name = entry.getKey();
        // 执行urldecode
        String value = URLDecoder.decode(entry.getValue()[0], "UTF-8");
        map.put(name, value);
    }

    PropertyValues propertyValues = new MutablePropertyValues(map);

    // 将K-V绑定到binder.target属性上
    binder.bind(propertyValues);
}

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                              NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    String name = parameter.getParameterName();

    // 查找是否已有名为name的参数值的映射，如果没有则创建一个
    Object attribute = mavContainer.containsAttribute(name)
        ? mavContainer.getModel().get(name)
        : this.createAttribute(name, parameter, binderFactory, webRequest);

    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);

        if (binder.getTarget() != null) {
            // 进行参数绑定，此方法实现不再赘述，可到上节查看
            this.bindRequestParameters(binder, webRequest);

// -----------------------------------对@Valid做兼容----------------------------------------------------

            // 如果使用了validation校验, 则进行相应校验
            if (parameter.hasParameterAnnotation(Valid.class)) {
                // 如果有校验报错，会将结果放在binder.bindingResult属性中
                binder.validate();
            }

            // 如果参数中不包含BindingResult参数，直接抛出异常
            if (binder.getBindingResult().hasErrors() && this.isBindExceptionRequired(binder, parameter)) {
                throw new BindException(binder.getBindingResult());
            }
        }

        // 关键,使Controller中接下来的BindingResult参数可以接收异常
        Map bindingResultModel = binder.getBindingResult().getModel();
        mavContainer.removeAttributes(bindingResultModel);
        mavContainer.addAllAttributes(bindingResultModel);

// -----------------------------------对@Valid做兼容----------------------------------------------------

        // 将参数转到预期类型，第一个参数为解析后的值，第二个参数为绑定Controller参数的类型，第三个参数为绑定的Controller参数
        attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
    }

    return attribute;
}

/**
 * 检查参数中是否包含BindingResult参数
 */
protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter methodParam) {
    int i = methodParam.getParameterIndex();
    Class[] paramTypes = methodParam.getMethod().getParameterTypes();
    boolean hasBindingResult = paramTypes.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]);
    return !hasBindingResult;
}

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

package io.fredia.femicro.common.context;

import static org.junit.Assert.assertEquals;

import java.util.HashMap;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.fredia.femicro.common.constant.CommonConstants;
import io.fredia.femicro.common.util.StringHelper;

/**
 * 上下文处理基类
 *
 * @author : Fredia
 * @since : 2018年6月1日
 * @version : v1.0.0
 */
public class BaseContextHandler {
    public static ThreadLocal<Map<String, Object>> threadLocal = new ThreadLocal<Map<String, Object>>();

    public static void set(String key, Object value) {
        Map<String, Object> map = threadLocal.get();
        if (map == null) {
            map = new HashMap<String, Object>();
            threadLocal.set(map);
        }
        map.put(key, value);
    }

    public static Object get(String key){
        Map<String, Object> map = threadLocal.get();
        if (map == null) {
            map = new HashMap<String, Object>();
            threadLocal.set(map);
        }
        return map.get(key);
    }

    public static String getUserID(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_ID);
        return returnObjectValue(value);
    }

    public static String getUsername(){
        Object value = get(CommonConstants.CONTEXT_KEY_USERNAME);
        return returnObjectValue(value);
    }


    public static String getName(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_NAME);
        return StringHelper.getObjectValue(value);
    }

    public static String getToken(){
        Object value = get(CommonConstants.CONTEXT_KEY_USER_TOKEN);
        return StringHelper.getObjectValue(value);
    }
    public static void setToken(String token){set(CommonConstants.CONTEXT_KEY_USER_TOKEN,token);}

    public static void setName(String name){set(CommonConstants.CONTEXT_KEY_USER_NAME,name);}

    public static void setUserID(String userID){
        set(CommonConstants.CONTEXT_KEY_USER_ID,userID);
    }

    public static void setUsername(String username){
        set(CommonConstants.CONTEXT_KEY_USERNAME,username);
    }

    private static String returnObjectValue(Object value) {
        return value==null?null:value.toString();
    }

    public static void remove(){
        threadLocal.remove();
    }

}

package io.fredia.femicro.auth.client.interceptor;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import io.fredia.femicro.auth.client.annotation.IgnoreUserToken;
import io.fredia.femicro.auth.client.config.UserAuthConfig;
import io.fredia.femicro.auth.client.jwt.UserAuthUtil;
import io.fredia.femicro.auth.common.util.jwt.IJWTInfo;
import io.fredia.femicro.common.context.BaseContextHandler;

/**
 * 用户授权拦截器
 *
 * @author : Fredia
 * @since : 2018年3月16日
 * @version : v1.0.0
 */
public class UserAuthRestInterceptor extends HandlerInterceptorAdapter {
    private Logger logger = LoggerFactory.getLogger(UserAuthRestInterceptor.class);

    @Autowired
    private UserAuthUtil userAuthUtil;

    @Autowired
    private UserAuthConfig userAuthConfig;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        //此处为业务代码，可以忽略
        String token = request.getHeader(userAuthConfig.getTokenHeader());
        if (StringUtils.isEmpty(token)) {
            if (request.getCookies() != null) {
                for (Cookie cookie : request.getCookies()) {
                    if (cookie.getName().equals(userAuthConfig.getTokenHeader())) {
                        token = cookie.getValue();
                    }
                }
            }
        }
        IJWTInfo infoFromToken = userAuthUtil.getInfoFromToken(token);
        //上下文属性保存
        BaseContextHandler.setUsername(infoFromToken.getUniqueName());
        BaseContextHandler.setName(infoFromToken.getName());
        BaseContextHandler.setUserID(infoFromToken.getId());
        return super.preHandle(request, response, handler);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //上下文属性值清除，防止内存泄漏
        BaseContextHandler.remove();
        super.afterCompletion(request, response, handler, ex);
    }
}

package io.fredia.femicro.common.rest;

import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import io.fredia.femicro.common.biz.BaseBiz;
import io.fredia.femicro.common.context.BaseContextHandler;
import io.fredia.femicro.common.msg.ObjectRestResponse;
import io.fredia.femicro.common.msg.TableResultResponse;
import io.fredia.femicro.common.util.Query;
import lombok.extern.slf4j.Slf4j;

/**
 * controller基类
 *
 * @author : Fredia
 * @since : 2018年6月1日
 * @version : v1.0.0
 */
@Slf4j
public class BaseController<Biz extends BaseBiz,Entity> {

    public String getCurrentUserName(){
        return BaseContextHandler.getUsername();
    }
}