@SpringBootApplication
@EnableScheduling // 启动类添加 @EnableScheduling 注解
public class ScheduleDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(ScheduleDemoApplication.class, args);
    }

}

@Component // 类上添加 @Component 注解
public class TaskDemo {

    private static final Logger logger = LoggerFactory.getLogger(TaskDemo.class);

    @Scheduled(cron = "0/5 * * * * ? ") // 方法上添加 @Scheduled 注解
    public void job1(){
        try {
            logger.info("job1");
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Scheduled(cron = "0/5 * * * * ? ")
    public void job2(){
        try {
            logger.info("job2");
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

@Component
@EnableAsync // 类上添加 @EnableAsync 注解
public class TaskDemo {

    ... ...

    @Async // 方法上添加 @Async 注解
    @Scheduled(cron = "0/5 * * * * ? ")
    public void job1(){
        ... ...
    }

    ... ...
}

@Configuration
public class SchedulerConfig implements SchedulingConfigurer {

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();

        threadPoolTaskScheduler.setPoolSize(2);
        threadPoolTaskScheduler.setThreadNamePrefix("my-pool-");
        threadPoolTaskScheduler.initialize();

        scheduledTaskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
    }
}

public class NettyClient implements Runnable {

    private final String host;
    private final int port;
    private final int reconnectSleepSeconds;

    public NettyClient(String host, int port, int reconnectSleepSeconds){
        this.host = host;
        this.port = port;
        this.reconnectSleepSeconds = reconnectSleepSeconds;
    }

    @Override
    public void run() {
        connect();
    }

    private void connect(){
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            b.group(workerGroup);
            b.channel(NioSocketChannel.class);
            b.option(ChannelOption.SO_KEEPALIVE, true);
            b.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {

                    // TODO: 添加 Handler
                }
            });

            ChannelFuture f = b.connect(host, port).sync();

            f.channel().closeFuture().sync();
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();

            try {
                TimeUnit.SECONDS.sleep(reconnectSleepSeconds);

                connect(); // 断线重连

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

public LengthFieldBasedFrameDecoder(ByteOrder byteOrder, 
    int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment, 
    int initialBytesToStrip, boolean failFast) {
    ... ...
}

+--------------+--------------+------------+------------+----------+---------------+----------+
| ResponseCode | FunctionCode | ParamType  | StatusCode | Length   | Data          | EOF      |
| (2 Byte)     | (2 Byte)     | (1 Byte)   | (1 Byte)   | (2 Byte) | (Length Byte) | (2 Byte) |
+--------------+--------------+------------+------------+----------+---------------+----------+

@Component // 1. 添加 @Component 注解
public class TestHandler extends ChannelInboundHandlerAdapter {

    private static TestHandler testHandler; // 2. 定义本类的静态对象

    @Autowired
    TestService testService;

    @PostConstruct // 3. 添加 @PostConstruct 注解的方法
    public void init(){
        testHandler = this;
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {

        ByteBuf buf = (ByteBuf) msg;

        byte[] bytes = new byte[buf.readableBytes()];
        buf.readBytes(bytes);

        testHandler.testService.handlerMessage(bytes); // 4. 使用

    }

}

@RunWith(SpringRunner.class)
@SpringBootTest
public class TvSeriesServiceTest {

    @MockBean
    TvSeriesDao tvSeriesDao;
    @MockBean
    TvCharacterDao tvCharacterDao;

    @Autowired
    TvSeriesService tvSeriesService;
    
    @Test
    public void testGetAll() {

        List<TvSeries> list = new ArrayList<>();
        TvSeries ts = new TvSeries();
        ts.setName("POI");
        list.add(ts);
        
        // 告诉 mock 当执行 getAll 方法时，返回上面创建的 list
        Mockito.when(tvSeriesDao.getAll()).thenReturn(list);

        List<TvSeries> result = tvSeriesService.getAllTvSeries();

        Assert.assertTrue(result.size() == list.size());
        Assert.assertTrue("POI".equals(result.get(0).getName()));   
    }
    
    @Test
    public void testGetOne() {
        //根据不同的传入参数，被 mock 的 bean 返回不同的数据的例子
        String newName = "Person Of Interest";
        BitSet mockExecuted = new BitSet();
        Mockito.doAnswer(new Answer<Object>() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                Object[] args = invocation.getArguments();
                TvSeries bean = (TvSeries) args[0];
                //传入的值，应该和下面调用 tvSeriesService.updateTvSeries() 方法时的参数中的值相同
                Assert.assertEquals(newName, bean.getName());
                mockExecuted.set(0);
                return 1;
            }
        }).when(tvSeriesDao).update(any(TvSeries.class));
        
        TvSeries ts = new TvSeries();
        ts.setName(newName);
        ts.setId(111);
        
        tvSeriesService.updateTvSeries(ts);
        Assert.assertTrue(mockExecuted.get(0));
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc // 初始化一个 mvc 环境用于测试
public class TvSeriesControllerTest {

    @MockBean
    TvSeriesDao tvSeriesDao;
    @MockBean
    TvCharacterDao tvCharacterDao;

    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private TvSeriesController tvSeriesController;

    @Test
    public void testGetAll() throws Exception {
        List<TvSeries> list = new ArrayList<>();
        TvSeries ts = new TvSeries();
        ts.setName("POI");
        list.add(ts);

        Mockito.when(tvSeriesDao.getAll()).thenReturn(list);

        // 相当于在启动项目后，执行 GET /tvseries，被测模块是 web 控制层，因为 web 控制层会调用业务逻辑层，所以业务逻辑层也会被测试
        // 业务逻辑层调用了被 mock 出来的数据访问层桩模块。
        //如果想仅仅测试 web 控制层，（例如业务逻辑层尚未编码完毕），可以 mock 一个业务逻辑层的桩模块
        mockMvc.perform(MockMvcRequestBuilders.get("/tvseries"))
                .andDo(MockMvcResultHandlers.print())
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string(Matchers.containsString("POI")));
    }
    
    @Test
    public void testAddSeries() throws Exception{
        BitSet bitSet = new BitSet(1);
        bitSet.set(0, false);

        Mockito.doAnswer(new Answer<Object>() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                Object[] args = invocation.getArguments();
                TvSeries ts = (TvSeries) args[0];
                Assert.assertEquals(ts.getName(), "疑犯追踪");
                ts.setId(5432);
                bitSet.set(0, true);
                return 1;
            }
        }).when(tvSeriesDao).insert(Mockito.any(TvSeries.class));

        Mockito.doAnswer(new Answer<Object>() {
            @Override
            public Object answer(InvocationOnMock invocation) throws Throwable {
                Object[] args = invocation.getArguments();
                TvCharacter tc = (TvCharacter) args[0];
                // json 中传递过来的剧中角色名字
                Assert.assertEquals(tc.getName(), "芬奇");
                Assert.assertTrue(tc.getTvSeriesId() == 5432);
                bitSet.set(0, true);
                return 1;
            }
        }).when(tvCharacterDao).insert(Mockito.any(TvCharacter.class));
        
        String jsonData = "{\"name\":\"疑犯追踪\",\"seasonCount\":5,\"originRelease\":\"2011-09-22\",\"tvCharacters\":[{\"name\":\"芬奇\"}]}";
        this.mockMvc.perform(MockMvcRequestBuilders.post("/tvseries")
                .contentType(MediaType.APPLICATION_JSON).content(jsonData))
                .andDo(MockMvcResultHandlers.print())
                .andExpect(MockMvcResultMatchers.status().isOk());

        Assert.assertTrue(bitSet.get(0));
    }
    
    @Test
    public void testFileUpload() throws Exception{
        String fileFolder = "target/files/";
        File folder = new File(fileFolder);
        if(!folder.exists()) {
            folder.mkdirs();
        }
        // 设置 bean 里面通过 @Value 获得的数据
        ReflectionTestUtils.setField(tvSeriesController, "uploadFolder", folder.getAbsolutePath());
        
        InputStream is = getClass().getResourceAsStream("/testfileupload.jpg");
        if(is == null) {
            throw new RuntimeException("需要先在src/test/resources目录下放置一张jpg文件，名为testfileupload.jpg然后运行测试");
        }
        
        //模拟一个文件上传的请求
        MockMultipartFile imgFile = new MockMultipartFile("photo", "testfileupload.jpg", "image/jpeg", IOUtils.toByteArray(is));
        
        ResultActions result = mockMvc.perform(MockMvcRequestBuilders.multipart("/tvseries/1/photos")
                        .file(imgFile))
                        .andExpect(MockMvcResultMatchers.status().isOk());
        
        //解析返回的 JSON
        ObjectMapper mapper = new ObjectMapper();
        Map<String, Object> map = mapper.readValue(result.andReturn().getResponse().getContentAsString(), new TypeReference<Map<String, Object>>(){});
       
        String fileName = (String) map.get("photo");
        File f2 = new File(folder, fileName);
        //返回的文件名，应该已经保存在 filFolder 文件夹下
        Assert.assertTrue(f2.exists());
    }
}

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.3.2</version>
</dependency>

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>5.1.41</version>
</dependency>

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/tvseries?useSSL=false
    username: root
    password: root
    
    
mybatis:
  configuration:
    map-underscore-to-camel-case: true # 下划线转驼峰命名
  mapper-locations: classpath:com.karonda.restapi.dao/*.xml # 配置 mapper xml 文件所在路径

@MapperScan("com.karonda.restapi.dao")

public interface TvSeriesDao {

    @Select("select * from tv_series where id=#{id}")
    TvSeries getOneById(int id);

    @Select("select * from tv_series")
    List<TvSeries> getAll();

    int update(TvSeries tvSeries);
    int insert(TvSeries tvSeries);

    @Delete("delete from tv_series where id=#{id}")
    int delete(int id);

    @Update("update tv_series set status=-1, reason=#{reason} where id=#{id}")
    int logicDelete(int id, String reason);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.karonda.restapi.dao.TvSeriesDao" >
  
  <insert id="insert" parameterType="com.karonda.restapi.pojo.TvSeries"
  			useGeneratedKeys="true" keyProperty="id">
    insert into tv_series (name, season_count, origin_release )
    		values (#{name}, #{seasonCount}, #{originRelease} )
  </insert>
  
  <update id="update" parameterType="com.karonda.restapi.pojo.TvSeries">
    update tv_series set name=#{name}, season_count=#{seasonCount}, origin_release=#{originRelease} where id=#{id}
  </update>
  
</mapper>

@Service
public class TvSeriesService {
    @Autowired
    TvSeriesDao tvSeriesDao;

    public List<TvSeries> getAllSeries(){
        return tvSeriesDao.getAll();
    }
}

@Autowired
TvSeriesService tvSeriesService;

@GetMapping
public List<TvSeries> getAll() {
    if(log.isTraceEnabled()) {
        log.trace("getAll() ");
    }
    List<TvSeries> list = tvSeriesService.getAllSeries();
    
    return list;
}

public Object doSomething(@Validated @RequestBody OneDto oneDto) {
    // 通不过校验的参数，不会执行这个方法
}


public Object doSomething(@Validated @RequestBody OneDto oneDto, BindingResult result) {
    // 参数通不过校验也会进入方法执行，校验结果会通过result参数传递进来
    if (result.hasErrors()){
        // 没通过校验
    }
}

// 装载验证器
@Autowired Validator validator;

// 验证某个类，下面是执行默认的验证组，如果需要指定验证组，多传一个 class 参数
Set<ConstraintViolation<?>> result = validator.validate(obj);
 
// 通不过校验 result 的集合会有值，可以通过 size() 判断