public class SpringMVCWebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[]{RootConfig.class};
    }
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[]{WebConfig.class};
    }
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    // 自定义DispatcherServlet配置
    @Override
    protected void customizeRegistration(Dynamic registration) {
        registration.setMultipartConfig(// 指定上传文件目录及限制
                new MultipartConfigElement("/tmp/spittr/uploads", 2097152, 4194304, 0));
    }
    @Override
    protected Filter[] getServletFilters() {
        return new Filter[]{ new MyFilter() };
    }
}

public class MyServletInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) {
        FilterRegistration.Dynamic myFilter = servletContext.addFilter("myFilter", new MyFilter());
        myFilter.addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), false,"/**");

        ServletRegistration.Dynamic myServlet = servletContext.addServlet("myServlet", new MyServlet());
        myServlet.addMapping("/myServlet");
        
        servletContext.addListener(MyListener.class);
    }
}

@Configuration
@EnableWebMvc // 启用注解驱动的Spring MVC。
@ComponentScan("com.xpress.web") // 启动组件扫描
public class WebConfig extends WebMvcConfigurerAdapter {
    @Bean
    public ViewResolver viewResolver() {
        // 配置视图解析器，默认默认会使用BeanNameView-Resolver，这个视图解析器会查找ID与视图名称匹配的bean，并且查找的bean要实现View接口，它以这样的方式来解析视图。
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        // for jstl
        // resolver.setViewClass(JstlView.class);
        return resolver;
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        // 排除静态资源映射
        configurer.enable();
    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        super.addResourceHandlers(registry);
    }
}

@Configuration
@Import(DataConfig.class)
@ComponentScan(basePackages = {"com.xpress"},
        excludeFilters = {
                @Filter(type = FilterType.CUSTOM, value = WebPackage.class)
        })
public class RootConfig {
    public static class WebPackage extends RegexPatternTypeFilter {
        public WebPackage() {
            // 排除DispatcherServlet上下文下的bean
            super(Pattern.compile("com\\.xpress\\.web.*|com\.xpress\.config.*"));
        }
    }
}

public class MyController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        Users user = new Users();
        user.setUsername("admin");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("user", user);
        modelAndView.setViewName("myProfile.jsp");
        return modelAndView;
    }
}

@Controller
@RequestMapping("/spittles")
public class HomeController {
    @RequestMapping(value = "/{spittleId}", method = RequestMethod.GET)
    public String spittle(@PathVariable("spittleId") long spittleId, Model model) {
        model.addAttribute(spittleRepository.findOne(spittleId));
        return "spittle";
    }
}

import static org.hamcrest.Matchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import static org.springframework.test.web.servlet.setup.MockMvcBuilders.*;

@Test
public void testSpittle() throws Exception {
    Spittle expectedSpittle = new Spittle("Hello", new Date());
    SpittleRepository mockRepository = mock(SpittleRepository.class);
    when(mockRepository.findOne(12345)).thenReturn(expectedSpittle);

    SpittleController controller = new SpittleController(mockRepository);
    MockMvc mockMvc = standaloneSetup(controller).build();

    mockMvc.perform(get("/spittles/12345"))
            .andExpect(view().name("spittle"))
            .andExpect(model().attributeExists("spittle"))
            .andExpect(model().attribute("spittle", expectedSpittle));
}

@Override
public boolean supports(Object handler) {
    // 默认是否为Controller
    return (handler instanceof Controller);
}

@Override
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
        throws Exception {
    return ((Controller) handler).handleRequest(request, response);
}

@Controller
public class AnnotationController {
    @RequestMapping("userProfile")
    public ModelAndView userProfile(HttpServletRequest request, HttpServletResponse response) throws Exception {
        Users user = new Users();
        user.setUsername("admin");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("user", user);
        modelAndView.setViewName("myProfile.jsp");
        return modelAndView;
    }
}

@Controller
@RequestMapping("user")// 配置请求根路径，窄化请求路径
public class AnnotationController {
    @RequestMapping(value = "userProfile", method = {RequestMethod.GET})// 请求方法限定
    public ModelAndView userProfile() throws Exception {
        Users user = new Users();
        user.setUsername("admin");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("user", user);
        modelAndView.setViewName("myProfile");
        return modelAndView;
    }
}

@RequestMapping(value = "/spittle", method = RequestMethod.GET)
public String spittle(Model model) {// Model类型可换为Map
    // 省略key，默认根据类型推断为spittleList
    model.addAttribute(spittleRepository.findOne(spittleId));
    return "spittle";
}
@RequestMapping(value = "/spittle", method = RequestMethod.GET)
public List<Spittle> spittle() {
    // 省略key，默认根据类型推断为spittleList，省略view名字，自动推断为map名spittle
    return spittleRepository.findOne(spittleId);
}

@RequestMapping(value = "userProfile", method = {RequestMethod.GET})
public String userProfile(Model model) throws Exception {
    Users user = new Users();
    user.setUsername("admin");
    model.addAttribute("user", user);
    return "myProfile";// 直接返回逻辑页面名称（最终加上前缀、后缀、Controller根）
}

return "redirect:/index.jsp";

return "forwar:/index.jsp";

return "redirect:/user/" + user.getUsername();

modelAndView.addObject("username",user.getUsername());
modelAndView.addObject("userId",user.getId());
return "redirect:/user/{username}";// user/xpress?userId=1

@RequestMapping(value = "/register", method = POST)
public String processRegistration(@Validated User user,RedirectAttributes redirectAttributes) throws IOException {
    // ...
    redirectAttributes.addFlashAttribute("user",user);
    return "redirect:/user/{username}";
}

// 不同名参数绑定，并要求非必输，默认值为0
@RequestMapping(value = "userProfile", method = {RequestMethod.GET})
public String param(@RequestParam(value = "id", required = false, defaultValue = "0") Integer count) throws Exception {
    System.out.println(count);
    return "myProfile";
}

public class UserCustom extends User {
    Item item;
    //get set ...
}

@RequestMapping(value = "userProfile", method = { RequestMethod.POST})
public String userProfile(Model model, UserCustom userCustom) throws Exception {
    model.addAttribute("userCustom", userCustom);
    return "myProfile";
}

public class UserCustom extends User {
    List<Item> itemList;
    Map itemMap;
    //get set...
}

public class MyDateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String source) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM-dd");
        Date date = null;
        try {
            date = simpleDateFormat.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
     }
}

// UserCustom类，继承自Users
// UserCustom成员
public class UsersCustom extends Users {
    @Valid //成员变量需要校验注解，继而校验该类成员
    Item item;
    // get set...   
}
// Users成员
// 指定一个分组，这样同一filed可以根据分组不同判断是否校验
@Size(min = 1, max = 20, message = "{user.username.error}", groups = OrderGroup.class)
private String username;
// Item类 
// message用于回线错误信息，可以采用类跟路径下的ValidationMessage.properties或者指定关联Spring i8n配置
// message内容可以采用占位符，如{min}或者{max}
@NotEmpty(message = "{item.name.notNull}", groups = OrderGroup.class)
private String name;

// 分组接口
public interface OrderGroup {
}

// @Validated和BindingResult配对使用，顺序一前一后
@RequestMapping("initUserOrder")
public String initUserOrder(Model model, @Validated(OrderGroup.class) UsersCustom usersCustom, BindingResult bindingResult) {
    if (bindingResult.hasErrors()) {
        model.addAttribute("errors", bindingResult.getAllErrors());
        return "userOrder";
    }
    return "order";
}

@Bean
public MultipartResolver multipartResolver() throws IOException {
    CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
    multipartResolver.setUploadTempDir(new FileSystemResource("/temp/file/uploads"));
    multipartResolver.setMaxUploadSize(5242880);
    multipartResolver.setMaxUploadSizePerFile(2097152);
    multipartResolver.setMaxInMemorySize(0);
    return multipartResolver;
}

@Bean
public MultipartResolver multipartResolver() throws IOException {
    return new StandardServletMultipartResolver();
}

@RequestMapping(method = RequestMethod.POST)
    public String processUpload(@RequestPart("file") byte[] file) {
        return "redirect:/";
    }

public interface MultipartFile {
    String getName();
    String getOriginalFilename();
    String getContentType();
    boolean isEmpty();
    long getSize();
    byte[] getBytes() throws IOException;
    InputStream getInputStream() throws IOException;
    void transferTo(File dest) throws IOException, IllegalStateException;
}

// 自定义校验器
public class ContentTypeMultipartFileValidator implements ConstraintValidator<ContentType, MultipartFile> {
    private String[] acceptedContentTypes;
    @Override
    public void initialize(ContentType constraintAnnotation) {
        this.acceptedContentTypes = constraintAnnotation.value();
    }
    @Override
    public boolean isValid(MultipartFile value, ConstraintValidatorContext context) {
        if (value == null || value.isEmpty()) {
            return false;
        }
        return ContentTypeMultipartFileValidator.acceptContentType(value.getContentType(), acceptedContentTypes);
    }
    private static boolean acceptContentType(String contentType, String[] acceptedContentTypes) {
        for (String accept : acceptedContentTypes) {
            if (contentType.equalsIgnoreCase(accept)) {
                return true;
            }
        }
        return false;
    }
}

// 自定义校验注解
@Documented
@Retention(RUNTIME)
// 校验类
@Constraint(validatedBy = {ContentTypeMultipartFileValidator.class})
@Target({METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER})
public @interface ContentType {
    String message() default "{fileUpload.error.type}";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
    String[] value();
}

public class UploadVO {
    // 自定义校验注解
    @ContentType({"image/jpeg","image/png","image/jpg","image/gif"})
    private MultipartFile multipartFile;
    public MultipartFile getMultipartFile() {
        return multipartFile;
    }
    public void setMultipartFile(MultipartFile multipartFile) {
        this.multipartFile = multipartFile;
    }
}

// 在springmvc加载的properties中注入属性
@Value("${fileUpload.image.dir}")
private String imageSaveDir;

@RequestMapping("uploadLogo")
public String uploadLogo(Model model, @Validated UploadVo vo, BindingResult bindingResult) throws ServiceException, IOException {
    if (bindingResult.hasErrors()) {
        model.addAttribute("errors", bindingResult.getAllErrors());
        return "upload";
    }
    String originalFilename = vo.getMultipartFile().getOriginalFilename();
    String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
    File file = new File(imageSaveDir + UUID.randomUUID().toString() + suffix);
    vo.getMultipartFile().transferTo(file);
    return "success";
}

@RequestMapping(value = "/register", method = POST)
public String processRegistration(
        @RequestPart(value = "profilePictures", required = false) Part fileBytes,
        Errors errors) throws IOException {
    fileBytes.write("path/filename.suffix");
    return "redirect:/xpress/";
}

// POJO直接映射，可以使用注解改变key
public String userProfile(Model model, @ModelAttribute("user") @Validated(UserGroup.class) UserCustom userCustom, BindingResult bindingResult) throws Exception

// 直接放置方法返回值至request,key为userInfo
@ModelAttribute("userInfo")
public UsersCustom userInfo() {
    UsersCustom usersCustom = new UsersCustom();
    usersCustom.setId(110);
    return usersCustom;
}

@Controller
@RequestMapping("/json")
public class JsonController {
    // 上送json返回json
    @RequestMapping("requestJson")
    @ResponseBody
    public Item requestJson(@RequestBody Item item) {
        item.setOrderDetailId(item.getId() + 1);
        return item;
    }
    // 上送普通表单数据返回json
    @RequestMapping("responseJson")
    @ResponseBody
    public Item responseJson(Item item) {
        item.setOrderDetailId(item.getId() + 1);
        return item;
    }
}
// 空值转化
@JsonSerialize(include=JsonSerialize.Inclusion.NON_NULL)
class Item{
    String id;
    String orderDetailId;
    //...
}

// http://localhost:8080/json/item/1/1
// 可以使用POJO接收或者使用基础数据类型和注解@PathVariable接收
@RequestMapping("item/{id}/{orderDetailId}")
@ResponseBody
public List<Items> item(@Validated ItemVO itemVO, @PathVariable Integer orderDetailId) throws Exception {
    ItemsExample itemsExample = new ItemsExample();
    itemsExample.createCriteria().andIdEqualTo(itemVO.getId()).andOrderDetailIdEqualTo(orderDetailId);
    List<Items> itemsList = itemsMapper.selectByExample(itemsExample);
    return itemsList;
}

public class ItemVO {
    Items items;
    Integer id;
    // get set...
}

@Bean
public ViewResolver viewResolver() {
    return new ContentNegotiatingViewResolver();
}

@Configuration
@EnableWebMvc
@ComponentScan("spittr.web")
public class WebConfig extends WebMvcConfigurerAdapter {
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    /*
     * Configures content-negotiation.
     */
    @Configuration
    public static class ContentNegotiationConfig extends WebMvcConfigurerAdapter {
        @Bean
        public ViewResolver cnViewResolver(ContentNegotiationManager contentNegotiationManager) {
            ContentNegotiatingViewResolver contentNegotiatingViewResolver = new ContentNegotiatingViewResolver();
            contentNegotiatingViewResolver.setContentNegotiationManager(contentNegotiationManager);
            return contentNegotiatingViewResolver;
        }
        @Override
        public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
            configurer.defaultContentType(MediaType.TEXT_HTML);
        }
        @Bean
        public ViewResolver beanNameViewResolver() {
            return new BeanNameViewResolver();
        }
        @Bean
        public View spittles() {
            return new MappingJackson2JsonView();
        }
    }
}

@RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = "application/json")
public @ResponseBody Spittle spittleById(@PathVariable Long id) {
    return spittleRepository.findOne(id);
}

@RequestMapping(method = RequestMethod.POST, consumes = "application/json")
public Spittle saveSpittle(@RequestBody Spittle spittle) {
    return spittleRepository.save(spittle);
}

@RestController
@RequestMapping("/spittles")
public class SpittleApiController {
}

@RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = "application/json")
public ResponseEntity<Spittle> spittleById(@PathVariable Long id) {
    Spittle spittle = spittleRepository.findOne(id);
    HttpStatus httpStatus = spittle == null ? HttpStatus.NOT_FOUND : HttpStatus.OK;
    return new ResponseEntity<>(spittle, httpStatus);
}

public @ResponseBody Error spittleNotFound(SpittleNotFoundException e) {
    long spittleId = e.getSpittleId();
    return new Error(4, "Spittle [" + spittleId + "] not found");
}

@RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = "application/json")
public ResponseEntity<?> spittleById(@PathVariable Long id) {
    Spittle spittle = spittleRepository.findOne(id);
    if (spittle == null) {
        Error error = new Error(4, "Spittle [" + id + "] not found");
        return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
    }
    return new ResponseEntity<>(spittle, HttpStatus.OK);
}

public class SpittleNotFoundException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    private long spittleId;
    public SpittleNotFoundException(long spittleId) {
        this.spittleId = spittleId;
    }
    public long getSpittleId() {
        return spittleId;
    }
}

@ExceptionHandler(SpittleNotFoundException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public Error spittleNotFound(SpittleNotFoundException e) {
    long spittleId = e.getSpittleId();
    return new Error(4, "Spittle [" + spittleId + "] not found");
}

@RequestMapping(value = "/{id}", method = RequestMethod.GET, produces = "application/json")
public Spittle spittleById(@PathVariable Long id) {
    Spittle spittle = spittleRepository.findOne(id);
    if (spittle == null) {
        throw new SpittleNotFoundException(id);
    }
    return spittle;
}

@RequestMapping(method = RequestMethod.POST, consumes = "application/json")
@ResponseStatus(HttpStatus.CREATED)// 请求头201显示已创建
public ResponseEntity<Spittle> saveSpittle(@RequestBody Spittle spittle, UriComponentsBuilder ucb) {
    Spittle saved = spittleRepository.save(spittle);
    // 用于返回已创建的资源地址
    HttpHeaders headers = new HttpHeaders();
    URI locationUri = ucb.path("/spittles/")
            .path(String.valueOf(saved.getId()))
            .build()
            .toUri();
    headers.setLocation(locationUri);
    return new ResponseEntity<Spittle>(saved, headers, HttpStatus.CREATED);
}

public Spittle getSpittle(String id) {
    Map<String, String> urlVariables = new HashMap<>();
    urlVariables.put("id", id);
    RestTemplate restTemplate = new RestTemplate();
    return restTemplate.getForObject("http://localhost/spittle/{id}", Spittle.class, urlVariables);
}
public Spittle[] getSpittles(String id) {
    Map<String, String> urlVariables = new HashMap<>();
    urlVariables.put("id", id);
    RestTemplate restTemplate = new RestTemplate();
    return restTemplate.getForObject("http://localhost/spittle/{id}", Spittle[].class, urlVariables);
}

public Spittle getSpittle(String id) {
    Map<String, String> urlVariables = new HashMap<>();
    urlVariables.put("id", id);
    RestTemplate restTemplate = new RestTemplate();
    ResponseEntity<Spittle> entity = restTemplate.getForEntity("http://localhost/spittle/{id}", Spittle.class, urlVariables);
    if (entity.getStatusCode() != HttpStatus.NOT_FOUND) {
        throw new SpittleNotFoundException(id);
    }
    return entity.getBody();
}

public void updateSpittle(Spittle spittle) {
    RestTemplate restTemplate = new RestTemplate();
    // String url = "http://localhost/spittle/" + spittle.getId();
    // restTemplate.put(URI.create(url), spittle);
    restTemplate.put("http://localhost/spittle/{id}", spittle, spittle.getId());
}

public void deleteSpittle(String id) {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.delete("http://localhost/spittle/{id}", id);
}

public Spittle postSpittleForObject(Spittle spittle) {
    RestTemplate restTemplate = new RestTemplate();
    Spittle result = restTemplate.postForObject("http://localhost/spittle/add", spittle, Spittle.class);
    return result;
}

public Spittle postSpittleForObject(Spittle spittle) {
    RestTemplate restTemplate = new RestTemplate();
    ResponseEntity<Spittle> spittleResponseEntity = restTemplate.postForEntity("http://localhost/spittle/add", spittle, Spittle.class);
    if (spittleResponseEntity.getStatusCode() != HttpStatus.CREATED) {
        throw new SpittleAlreadyExistFoundException(spittle.getId());
    }
    URI location = spittleResponseEntity.getHeaders().getLocation();
    return spittleResponseEntity.getBody();
}

public String postSpittleForLocation(Spittle spittle) {
    RestTemplate restTemplate = new RestTemplate();
    return restTemplate.postForLocation("http://localhost/spittle/add", spittle).toString();
}

public Spittle exchangeSpittleForJson(String id) {
    RestTemplate restTemplate = new RestTemplate();
    MultiValueMap<String, String> multiValueMap = new HttpHeaders();
    multiValueMap.add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
    HttpEntity<Object> requestHttpEntity = new HttpEntity<>(multiValueMap);
    ResponseEntity<Spittle> exchange = restTemplate.exchange("http://localhost/spittle/{id}", HttpMethod.GET, requestHttpEntity, Spittle.class, id);
    return exchange.getBody();
}

public class MyInterceptor1 implements HandlerInterceptor {
    // handler执行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println(1);
        // 如果不放行，后面的拦截器所有方法不会执行，handler也不会执行，postHandle也不会执行,前面拦截器的afterCompletion会执行
        return true;
    }
    // 执行结束返回modelAndView之前
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println(2);
    }
    // handler执行之后
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println(3);
    }
}

public class MyController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        Users user = new Users();
        user.setUsername("admin");
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("user", user);
        modelAndView.setViewName("myProfile.jsp");
        return modelAndView;
    }
}

public class MyHandler implements HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Users user = new Users();
        user.setUsername("admin");
        request.setAttribute("user", user);
        request.getRequestDispatcher("myProfile.jsp").forward(request, response);
        // 这种方式可以修改response返回json数据
    }
}

public interface Controller {
    ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

public interface ViewResolver {
    View resolveViewName(String viewName, Locale locale) throws Exception;
}

public interface View {
    String RESPONSE_STATUS_ATTRIBUTE = View.class.getName() + ".responseStatus";
    String PATH_VARIABLES = View.class.getName() + ".pathVariables";
    String SELECTED_CONTENT_TYPE = View.class.getName() + ".selectedContentType";
    String getContentType();
    void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;
}

@ResponseStatus(value=HttpStatus.NOT_FOUND, reason="User Not Found")
public class UserNotFoundException extends RuntimeException {

}

@Controller
@RequestMapping("/user")
public class UserController {
    @ExceptionHandler(DuplicateUserException.class)
    public String handleNotFound() {
        return "error/duplicate";
    }
}

@ControllerAdvice
public class AppWideExceptionHandler {
    @ExceptionHandler(DuplicateUserException.class)
    public String handleNotFound() {
        return "error/duplicate";
    }
}

// 实现接口被spring加载后自动识别为HandlerExceptionResolver
@Component
public class ServiceExceptionHandler implements HandlerExceptionResolver {
    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceExceptionHandler.class);
    @Resource
    private ResourceBundleMessageSource messageSource;

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        String message;
        if (ex instanceof ServiceException) {
            message = ex.getMessage();
        } else {
            LOGGER.error(ex.getMessage(), ex);
            message = messageSource.getMessage("errorMessage.unknown", null, request.getLocale());
        }
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", message);
        modelAndView.setViewName("message");
        return modelAndView;
    }
}

import org.springframework.security.web.context.AbstractSecurityWebApplicationInitializer;
public class SecurityWebInitializer extends AbstractSecurityWebApplicationInitializer {
}

@Configuration
// @EnableWebSecurity
@EnableWebMvcSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 不做覆盖的实现，要求全部认证
        http
                .authorizeRequests()
                    .anyRequest().authenticated()
                    .and()
                .formLogin().and()
                .httpBasic();
    }
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 配置用户存储
        // 指定哪些请求需要认证，哪些请求不需要认证，以及所需要的权限
        // 提供一个自定义的登录页面，替代原来简单的默认登录页
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
            .inMemoryAuthentication()
            .withUser("user").password("password").roles("USER").and()
            .withUser("admin").password("password").roles("USER","ADMIN");
}

// 等价配置
.withUser("user").password("password").authorities("ROLE_USER").and()

@Resource
private DataSource dataSource;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
            .jdbcAuthentication()// 启动数据库认证
            .dataSource(dataSource)// 指定数据源
            // 自定义认证查询
            .usersByUsernameQuery("select username,password,true from users where username=?")
            // 自定义权限查询
            .authoritiesByUsernameQuery("select username,'ROLE_USER' from users where username=?")
            .passwordEncoder(new StandardPasswordEncoder("53cr3t"));
}

public static final String DEF_USERS_BY_USERNAME_QUERY =
        "select username,password,enabled " +
        "from users " +
        "where username = ?";
public static final String DEF_AUTHORITIES_BY_USERNAME_QUERY =
        "select username,authority " +
        "from authorities " +
        "where username = ?";
public static final String DEF_GROUP_AUTHORITIES_BY_USERNAME_QUERY =
        "select g.id, g.group_name, ga.authority " +
        "from groups g, group_members gm, group_authorities ga " +
        "where gm.username = ? " +
        "and g.id = ga.group_id " +
        "and g.id = gm.group_id";

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth
            .ldapAuthentication()
            .userSearchBase("ou=people")
            .userSearchFilter("(uid={0})")
            .groupSearchBase("ou=groups")
            .groupSearchFilter("member={0}")
            // 密码比对
            // .passwordCompare()
            // .passwordEncoder(new Md5PasswordEncoder())
            // .passwordAttribute("passcode");
            //嵌入式
            .contextSource().root("dc=habuma,dc=com")
            .ldif("classpath:users.ldif");
            //远程
            // .contextSource().url("ldap://habuma.com:389/dc=hubuma,dc=com");
}

public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    UsedrRepository UsedrRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Usedr Usedr = UsedrRepository.findByUsername(username);
        if (Usedr != null) {
            List<GrantedAuthority> grantedAuthorities = new ArrayList<>();
            grantedAuthorities.add(new SimpleGrantedAuthority("ROLE_USER"));
            return new User(Usedr.getUsername(), Usedr.getPassword(), grantedAuthorities);
        }
        throw new UsernameNotFoundException("user not found");
    }
}

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    auth.userDetailsService(new UserDetailsServiceImpl());
}

@Override
protected void configure(HttpSecurity http) throws Exception {
    http
            .formLogin()
            .loginPage("/login")
            .and()
            .logout()
            .logoutSuccessUrl("/")
            .and()
            .rememberMe()
            .tokenRepository(new InMemoryTokenRepositoryImpl())
            .tokenValiditySeconds(2419200)
            .key("spittrKey")
            .and()
            .httpBasic()
            .realmName("Spittr")
            .and()
            .authorizeRequests()
            .antMatchers("/").authenticated()
            .antMatchers("/spitter/me").authenticated()
            .antMatchers(HttpMethod.POST, "/spittles").authenticated()
            .anyRequest().permitAll();
}

// 等价配置
authorizeRequests()
    .antMatchers("/spitters/**").authenticated();
    .regexMatchers("/spitters/.*").authenticated();
    // 配置多个
    .antMatchers("/spitters/**","/spitters/mine").authenticated();

http
    .authorizeRequests()
    .antMatchers("/spitter/me").hasRole("SPITTER")
    .antMatchers(HttpMethod.POSt,"/spitles").hasRole("SPITTER")
    .anyRequest().permitAll();

.antMatchers("/spitter/me").access("hasRole('ROLE_SPITTER') and hasIpAddress('127.0.0.1')");

http
    .authorizeRequests()
        .antMatchers("/spitter/me").hasRole("SPITTER")
    .and()
    .requiresChannel()
    .antMatchers("/spitter/form").requiresSecure();

http
    .csrf().disable();

http
        .formLogin()// 启用默认的登录页
        .loginPage("/login")

@Bean
public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
    ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
    viewResolver.setTemplateEngine(templateEngine);
    return viewResolver;
}
@Override
public void addViewControllers(ViewControllerRegistry registry) {
    // 映射login路径和login页面，使自定义页面生效
    registry.addViewController("/login").setViewName("customLoginView");
}

http
        .formLogin()// 启用默认的登录页
        .loginPage("/login")
        .and()
        .httpBasic()
        .realmName("Spittr")
        ...

http
        .formLogin()
        .loginPage("/login")
        .and()
        .rememberMe()
        .tokenRepository(new InMemoryTokenRepositoryImpl())
        .tokenValiditySeconds(2419200)
        .key("spittrKey")
        ...

http
        .logout()
        .logoutUrl("signout")
        .logoutSuccessUrl("/index")
        ...

@Configuration
@EnableWebMvc
@ComponentScan("spittr.web")
public class WebConfig extends WebMvcConfigurerAdapter {
    @Bean
    public ViewResolver viewResolver(SpringTemplateEngine templateEngine) {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setTemplateEngine(templateEngine);
        return viewResolver;
    }
    @Bean
    public SpringTemplateEngine templateEngine(TemplateResolver templateResolver) {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver);
        templateEngine.addDialect(new SpringSecurityDialect());// 注册方言
        return templateEngine;
    }
    @Bean
    public TemplateResolver templateResolver() {
        TemplateResolver templateResolver = new ServletContextTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode("HTML5");
        return templateResolver;
    }
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/login").setViewName("login");
    }
}

@Configuration
@EnableGlobalMethodSecurity(securedEnabled = true)
public class SecuredConfig extends GlobalMethodSecurityConfiguration {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

@Override
@Secured({"ROLE_SPITTER", "ROLE_ADMIN"})
public void addSpittle(Spittle spittle) {
}

@Configuration
@EnableGlobalMethodSecurity(jsr250Enabled = true)
public class JSR250Config extends GlobalMethodSecurityConfiguration {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

@Override
@RolesAllowed("ROLE_SPITTER")
public void addSpittle(Spittle spittle) {
}

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ExpressionSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
}

@Override
@PreAuthorize("(hasRole('ROLE_SPITTER') and #spittle.text.length() le 140) or hasRole('ROLE_PREMIUM')")
public void addSpittle(Spittle spittle) {
}

@Override
@PostAuthorize("returnObject.spitter.username == principal.username")
public Spittle getSpittleById(Spittle spittle) {
    return null;
}

@Override
@PreAuthorize("hasRole('ROLE_SPITTER')  or hasRole('ROLE_ADMIN')")
@PostFilter("hasRole('ROLE_ADMIN') || filterObject.spitter.username == principal.username")
public List<Spittle> getHotSpittleList() {
    return null;
}

@Override
@PreAuthorize("hasRole('ROLE_SPITTER')  or hasRole('ROLE_ADMIN')")
@PreFilter("hasRole('ROLE_ADMIN') || filterObject.spitter.username == principal.username")
public void deleteSpittleList(List<Spittle> spittleList) {
}

import org.springframework.security.access.PermissionEvaluator;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import spittr.domain.Spittle;
import java.io.Serializable;
public class SpittlePermissionEvaluator implements PermissionEvaluator {
    private static final GrantedAuthority ADMIN_AUTHORITY = new SimpleGrantedAuthority("ROLE_ADMIN");
    @Override
    public boolean hasPermission(Authentication authentication, Object targetDomainObject, Object permission) {
        if (targetDomainObject instanceof Spittle) {
            Spittle spittle = (Spittle) targetDomainObject;
            String username = spittle.getSpitter().getUsername();
            if ("delete".equals(permission)) {
                return isAdmin(authentication) || username.equals(authentication.getName());
            }
        }
        return false;
    }
    @Override
    public boolean hasPermission(Authentication authentication, Serializable targetId, String targetType, Object permission) {
        throw new UnsupportedOperationException();
    }
    private boolean isAdmin(Authentication authentication) {
        return authentication.getAuthorities().contains(ADMIN_AUTHORITY);
    }
}

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ExpressionSecurityConfig extends GlobalMethodSecurityConfiguration {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                .inMemoryAuthentication()
                .withUser("user").password("password").roles("USER");
    }
    @Override
    protected MethodSecurityExpressionHandler createExpressionHandler() {
        DefaultMethodSecurityExpressionHandler defaultMethodSecurityExpressionHandler = (DefaultMethodSecurityExpressionHandler) super.createExpressionHandler();
        defaultMethodSecurityExpressionHandler.setPermissionEvaluator(new SpittlePermissionEvaluator());
        return defaultMethodSecurityExpressionHandler;
    }
}

@Override
@PreAuthorize("hasRole({'ROLE_ADMIN','ROLE_SPITTER'})")
@PreFilter(value = "hasPermission(filterObject,'delete')")
public void deleteSpittleList(List<Spittle> spittleList) {
}