@RequestMapping("/user/{uid}")
public String getUserById(@PathVariable Integer id){
//do something
}

import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;
import org.springframework.ui.Model;
import java.util.HashMap;
import java.util.Map;

/**
 * controller 增强器,作用于所有有效的control
 */
@ControllerAdvice
public class MyControllerAdvice {

    /**
     * 应用到所有@RequestMapping注解方法，在其执行之前初始化数据绑定器
     * @param binder
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {}

    /**
     * 把值绑定到Model中，使全局@RequestMapping可以获取到该值
     * @param model
     */
    @ModelAttribute
    public void addAttributes(Model model) {
        model.addAttribute("author", "Magical Sam");
    }

    /**
     * 全局异常捕捉处理
     * @param ex
     * @return
     */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public Map errorHandler(Exception ex) {
        Map map = new HashMap();
        map.put("code", 100);
        map.put("msg", ex.getMessage());
        return map;
    }

}

@Mapper
public interface UserMapper {
    List<User> findAll();
}

@Configuration //标注为配置类
@EnableSwagger2 //启动Swagger2
public class Swagger2 {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.didispace.web"))
                .paths(PathSelectors.any())
                .build();
    }

//基本信息
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("标题")
                .description("介绍")
                .termsOfServiceUrl("url")
                .contact("name")
                .version("1.0")
                .build();
    }

}

@RestController
@RequestMapping(value="/users")     // 通过这里配置使下面的映射都在/users下，可去除
public class UserController {

    static Map<Long, User> users = Collections.synchronizedMap(new HashMap<Long, User>());

    @ApiOperation(value="获取用户列表", notes="")
    @RequestMapping(value={""}, method=RequestMethod.GET)
    public List<User> getUserList() {
        List<User> r = new ArrayList<User>(users.values());
        return r;
    }

    @ApiOperation(value="创建用户", notes="根据User对象创建用户")
    @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User")
    @RequestMapping(value="", method=RequestMethod.POST)
    public String postUser(@RequestBody User user) {
        users.put(user.getId(), user);
        return "success";
    }

    @ApiOperation(value="获取用户详细信息", notes="根据url的id来获取用户详细信息")
    @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Long")
    @RequestMapping(value="/{id}", method=RequestMethod.GET)
    public User getUser(@PathVariable Long id) {
        return users.get(id);
    }

    @ApiOperation(value="更新用户详细信息", notes="根据url的id来指定更新对象，并根据传过来的user信息来更新用户详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Long"),
            @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User")
    })
    @RequestMapping(value="/{id}", method=RequestMethod.PUT)
    public String putUser(@PathVariable Long id, @RequestBody User user) {
        User u = users.get(id);
        u.setName(user.getName());
        u.setAge(user.getAge());
        users.put(id, u);
        return "success";
    }

    @ApiOperation(value="删除用户", notes="根据url的id来指定删除对象")
    @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Long")
    @RequestMapping(value="/{id}", method=RequestMethod.DELETE)
    public String deleteUser(@PathVariable Long id) {
        users.remove(id);
        return "success";
    }

}

import org.eclipse.paho.client.mqttv3.MqttConnectOptions;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.IntegrationComponentScan;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.integration.channel.DirectChannel;
import org.springframework.integration.endpoint.MessageProducerSupport;
import org.springframework.integration.mqtt.core.DefaultMqttPahoClientFactory;
import org.springframework.integration.mqtt.core.MqttPahoClientFactory;
import org.springframework.integration.mqtt.inbound.MqttPahoMessageDrivenChannelAdapter;
import org.springframework.integration.mqtt.outbound.MqttPahoMessageHandler;
import org.springframework.integration.mqtt.support.DefaultPahoMessageConverter;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;

@Configuration
// spring Integration组件扫描，MessageChannel使用的就是这个组件
@IntegrationComponentScan
public class MqttConfig {

    private String username = "userName";
    private String password = "password";

    /**
     * mqtt 服务地址
     */
    @Value("${mqtt.url}")
    private String hostUrl;

    /**
     * 设备id,用来区分不同的设备连接
     */
    @Value("${mqtt.client.id}")
    private String clientId;

    /**
     * 订阅那个主题
     */
    @Value("${mqtt.topic}")
    private String defaultTopic;

    /**
     * 创建连接的工厂
     * 用于构建MessageHandler
     * @return
     */
    @Bean
    public MqttPahoClientFactory mqttClientFactory() {
        DefaultMqttPahoClientFactory factory = new DefaultMqttPahoClientFactory();
        MqttConnectOptions mqttConnectOptions=new MqttConnectOptions();
        // mqtt服务器url
        mqttConnectOptions.setServerURIs(new String[]{hostUrl});
        // 设置会话心跳时间(秒)
        mqttConnectOptions.setKeepAliveInterval(2);
        // 每次请求是否清空连接记录
        mqttConnectOptions.setCleanSession(false);
        // 可以设置用户名密码
        mqttConnectOptions.setUserName(username);
        mqttConnectOptions.setPassword(password.toCharArray());
        factory.setConnectionOptions(mqttConnectOptions);
        return factory;
    }

    /* --------------------发布配置----------------- */

    /**
     * 1. 发布信息的MessageHandler
     * 订阅 mqttOutboundChannel 通道的信息
     * @param mqttClientFactory
     * @return
     */
    @Bean
    @ServiceActivator(inputChannel = "mqttOutboundChannel")
    public MessageHandler mqttOutbound(MqttPahoClientFactory mqttClientFactory) {
        MqttPahoMessageHandler messageHandler = new MqttPahoMessageHandler(clientId, mqttClientFactory);
        messageHandler.setAsync(true);
        messageHandler.setDefaultQos(0);
        messageHandler.setDefaultRetained(false);
        messageHandler.setAsyncEvents(false);
        return messageHandler;
    }

    @Bean
    public MessageChannel mqttOutboundChannel() {
        return new DirectChannel();
    }

    /* --------------------接收配置-------------------- */

    /**
     * 处理订阅的MessageHandler
     * 订阅 aaInboundChannel 通道的信息
     * @return
     */
    @Bean
    @ServiceActivator(inputChannel = "mqttInboundChannel")
    public MessageHandler newHandler() {
        return message -> System.out.println("收到消息 = " + message.getPayload());
    }

    @Bean
    public MessageChannel mqttInboundChannel() {
        return new DirectChannel();
    }

    /**
     * 1. 订阅主题，可订阅多个主题
     * 2. 将主题返回的内容发布到指定的 MessageChannel 里
     * @param mqttClientFactory
     * @return
     */
    @Bean
    public MessageProducerSupport mqttInbound(MqttPahoClientFactory mqttClientFactory) {
        MqttPahoMessageDrivenChannelAdapter adapter = new MqttPahoMessageDrivenChannelAdapter(clientId, mqttClientFactory, defaultTopic);
        adapter.setConverter(new DefaultPahoMessageConverter());
        adapter.setQos(0);
        adapter.setOutputChannel(mqttInboundChannel());
        return adapter;
    }
}

@Component
@MessagingGateway(defaultRequestChannel = "mqttOutboundChannel")
public interface MsgWriter {
    void sendToMqtt(String data);
    void sendToMqtt(String payload,@Header(MqttHeaders.TOPIC) String topic);
    void sendToMqtt(@Header(MqttHeaders.TOPIC) String topic, @Header(MqttHeaders.QOS) int qos, String payload);
}

//springBoot启动类上开启
@ComponentScan(basePackages = { "com.xwj.controller", "com.xwj.service" })
@EnableAsync //开启异步调用
@EnableAutoConfiguration
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

@Async  //标注使用
public void asyncMethodWithVoidReturnType() {
    System.out.println("获取:"+ Thread.currentThread().getName());
}

//Future接口类型的get方法可以在没有执行之前阻塞，直到获取到值
@Async
public Future<String> asyncMethodWithReturnType() {
    try{
        Thread.sleep(5000);//模拟执行耗时
        return new AsynResult<String>("hello");//返回类型是AsynResult;
    }
    return null;
}

public void test() throws InterruptedException, ExecutionException{
    Future<String> future = asyncMethodWithReturnType();//调用
    future.get();//获取结果，如果工作没结束阻塞线程。
    future.cancel(boolean mayInterruptIfRunning);//停止任务，通过传入值判断是否可以停止。如果可以(在运行)返回true,不可以(运行结束,或无法停止)返回false。
    future.isDone();//判断方法是否完成
    future.isCancel();//是否可以被取消
}

public static void main(String[] args)throws InterruptedException,ExecutionException{
  Callable ca1 = new Callable(){//线程1
    @Override
    public String call() throws Exception{
        return "xxx";
    }
    //使用FutureTask包裹
    FutureTask<String> ft1 = new FutureTask<String>(ca1);
    new Thread(ft1).start();//运行
    System.out.println(ft1.get());//获取值
  }
}

@Configuration
public class RedisListenerConfig {
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory, MyListener mylistener) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        // 添加监听
        container.addMessageListener(mylistener, new ChannelTopic("topicName"));
        return container;
    }
}

@Component
public class MyListener implements MessageListener {
    // 如何处理消息
    @Override
    public void onMessage(Message message, byte[] pattern) {
        final byte[] messageBody = message.getBody();
        String messageStr = new String(messageBody, StandardCharsets.UTF_8);
        System.out.println("messageStr = " + messageStr);
    }
}

@Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory, MyService myService) {
        // 初始化
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        // 添加适配器，使用反射调用myService的dealMess方法处理
        // dealMess方法只有一个入参，参数类型和通道发送时的一致即可
        MessageListenerAdapter transactionAdapter =
            new MessageListenerAdapter(myService, "dealMess");
        // 适配器初始化   
        transactionAdapter.afterPropertiesSet();
        // 监听'myChannel'通道，并用上面的适配器处理
        container.addMessageListener(transactionAdapter, new ChannelTopic("myChannel"));
        return container;
    }

String mess = "发送消息";
redisTemplate.convertAndSend("topicName", mess.getBytes(StandardCharsets.UTF_8));

@Component
@EnableScheduling //定时任务
public class SchedulingTest{
     //每30秒执行一次
    @Scheduled(fixedRate = 1000 * 30)
    public void doSomeThing(){
           //没30秒输出一次
           System.out.println ("定时输出：" + dateFormat ().format (new Date ()));
    }

    //在固定时间执行(当时间匹配规则时输出)
    @Scheduled(cron = "0 */1 *  * * * ")
    public void reportCurrentByCron(){
        System.out.println ("固定时间输出" + dateFormat ().format (new Date()));
    }

     private SimpleDateFormat dateFormat(){
        return new SimpleDateFormat ("HH:mm:ss");
    }
}

// 引入定时调度线程池
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler; 

// 接收线程调度返回的结果获取类
private ScheduledFuture<?> future;

public void test(){
    // 如果已经有任务了就取消原有任务
    if (future != null) {
           future.cancel(true);
       }
    // 每月第一天
    String cron = "0 0 0 1 * ?";
    future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger(cron));
    // Runnable也可以写成lambda
    future = threadPoolTaskScheduler.schedule(()->{
            //do..
        }, new CronTrigger(cron));
    }