学习日程

lh-config:
#  配置缓存字典翻译
  automatic:
    translation:
      redis-cache: true

lh-config:  
  task-pool:
    corePoolSize: 2   #核心线程池大小
    maxPoolSize: 3    # 最大线程数
    keepAliveSeconds: 300   # 活跃时间
    queueCapacity: 4   #队列容量
    prefixName: customize-thread- #前缀名

lh-config: 
  flyway-config:
    switch: true  #自定义注解,配置开启关闭全自动数据库版本管理
    locations: classpath:db/migration 
    baseline-on-migrate: true
    validate-on-migrate: true
    table: sys_flyway_history   # 自定义数据表名

lh-config: 
  swagger-config: #swagger扫包路径
    base-package: com.schedule.zyjshopping

        <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

@Aspect
@Component
@Slf4j
public class DSAspect {

}

@Component
public class DictCache implements DictCacheService {
    @Override
    public BiMap<String, String> getDictMapByName(String dictName) {
        //举例，通过字典名称返回所有的字典项
        BiMap<String, String> map = HashBiMap.create();
        switch (dictName) {
            case "sex":
                map.put("1", "男");
                map.put("2", "女");
                break;
            case "car:color":
                map.put("1", "芭比粉");
                map.put("2", "烈焰红");
                break;
            case "license:type":
                map.put("A1","大型汽车");
                map.put("C1","小型汽车");
                map.put("C2","小型自动挡汽车");
                map.put("D","普通三轮摩托车");
                break;
        }
        return map;
    }
}

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

spring：
  # redis 配置
  redis:
    # 地址
    host: localhost
    # 端口，默认为6379
    port: 6379
    # 密码
    password:
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms

/**
 * redis配置类
 **/
@Configuration
@EnableCaching//开启注解式缓存
//继承CachingConfigurerSupport，为了自定义生成KEY的策略。可以不继承。
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * 生成key的策略 根据类名+方法名+所有参数的值生成唯一的一个key
     *
     * @return
     */
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    /**
     * 管理缓存
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //通过Spring提供的RedisCacheConfiguration类，构造一个自己的redis配置类，从该配置类中可以设置一些初始化的缓存命名空间
        // 及对应的默认过期时间等属性，再利用RedisCacheManager中的builder.build()的方式生成cacheManager：
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();  // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
        config = config.entryTtl(Duration.ofMinutes(1))     // 设置缓存的默认过期时间，也是使用Duration设置
                .disableCachingNullValues();     // 不缓存空值

        // 设置一个初始化的缓存空间set集合
        Set<String> cacheNames = new HashSet<>();
        cacheNames.add("my-redis-cache1");
        cacheNames.add("my-redis-cache2");

        // 对每个缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("my-redis-cache1", config);
        configMap.put("my-redis-cache2", config.entryTtl(Duration.ofSeconds(120)));

        RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)     // 使用自定义的缓存配置初始化一个cacheManager
                .initialCacheNames(cacheNames)  // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                .withInitialCacheConfigurations(configMap)
                .build();
        return cacheManager;
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);

        template.setValueSerializer(serializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }

}

 <!-- SpringBoot Web容器 -->
 <dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
	 <exclusions>
		 <exclusion>
			 <artifactId>spring-boot-starter-tomcat</artifactId>
			 <groupId>org.springframework.boot</groupId>
		 </exclusion>
	 </exclusions>
</dependency>

<!-- web 容器使用 undertow -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-undertow</artifactId>
</dependency>

# 开发环境配置
server:
  # 服务器的HTTP端口，默认为80
  port: 80
  servlet:
    # 应用的访问路径
    context-path: /
  # undertow 配置
  undertow:
    # HTTP post内容的最大大小。当值为-1时，默认值为大小是无限的
    max-http-post-size: -1
    # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    # 每块buffer的空间大小,越小的空间被利用越充分
    buffer-size: 512
    # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    io-threads: 8
    # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    worker-threads: 256
    # 是否分配的直接内存
    direct-buffers: true

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoint:
    shutdown:
      enabled: true
  endpoints:
    web:
      exposure:
        include: "shutdown"
      base-path: /monitor

        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
        </dependency>

spring:
  flyway:
    # 数据库名称
    schemas: yjx
    # flyway自动配置 true 开启
    enabled: true
    #设定 SQL 脚本的目录,多个路径使用逗号分隔, 比如取值为 classpath:db/migration,filesystem:/sql-migrations
    locations:
      - classpath:db/migration
    # 如果数据库不是空表，需要设置成 true，否则启动报错
    baseline-on-migrate: true
    # 与 baseline-on-migrate: true 搭配使用
    baseline-version: 0
    encoding: UTF-8
    # 开发环境最好开启 outOfOrder, 生产环境关闭 outOfOrder .
    out-of-order: false
    # 禁止清理数据库表
    clean-disabled: true
    # 校验
    validate-on-migrate: true
    # 版本控制日志表，默认flyway_schema_history,不同系统建议修改改数据
    table: flyway_schema_history

@Configuration
@Slf4j
public class FlywayConfig {

    @Autowired
    private DataSource dataSource;

    @PostConstruct
    public void migrate() {
        log.info("开始校验数据库版本信息");

        Flyway flywayInit = Flyway.configure()
                .dataSource(dataSource)
                .locations("db/migration")
                .baselineOnMigrate(true)
                .load();
        try{

            flywayInit.migrate();
            log.info("数据库版本更新完成");

        }catch (Exception e) {
            flywayInit.repair();
            log.error("遇到错误,启用备用方案");

            Flyway flywayInitTow = Flyway.configure()
                    .dataSource(dataSource)
                    .locations("db/migration")
                    .baselineOnMigrate(true)
                    .outOfOrder(true)
                    .load();
            flywayInitTow.migrate();

            log.info("解决成功");
        }
    }

}

ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
    final int index = i;

    // 每次发布任务前根据奇偶不同等待一段时间，如1s，这样就会创建两个线程
    if (i % 2 == 0) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 执行任务
    cachedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + ":" + index));

ExecutorService executorService = Executors.newFixedThreadPool(5);

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
// 三秒后执行
scheduledExecutorService.schedule(() -> System.out.println(Thread.currentThread().getName() + ": 我会在3秒后执行。"),
                3, TimeUnit.SECONDS);

ExecutorService executorService = Executors.newSingleThreadExecutor();

<dependency>
	<groupId>io.springfox</groupId>
	<artifactId>springfox-swagger2</artifactId>
	<version>2.9.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<!-- 官方给出的一个ui界面，这个界面可以自定义，默认是官方的 -->
<dependency>
	<groupId>io.springfox</groupId>
	<artifactId>springfox-swagger-ui</artifactId>
	<version>2.9.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.github.xiaoymin/knife4j-spring-boot-starter -->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>knife4j-spring-boot-starter</artifactId>
    <version>3.0.3</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.github.xiaoymin/swagger-bootstrap-ui -->
<dependency>
    <groupId>com.github.xiaoymin</groupId>
    <artifactId>swagger-bootstrap-ui</artifactId>
    <version>1.9.6</version>
</dependency>

@Configuration
@EnableSwagger2
@EnableKnife4j//UI增强注解
public class Swagger2Config {
    @Bean
    public Docket buildDocket(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(buildApiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.dragonsoft.dataManage.controller"))
                .paths(PathSelectors.any())
                .build();
    }
    private ApiInfo buildApiInfo(){
        return new ApiInfoBuilder()
                //页面标题，导入postman时必须有该项配置
                .title("模拟创建仿真数据")
                //版本号，导入postman时必须有该项配置
                .version("1.0")
                .description("视频大数据平台基线V1.1-区域分析-业务数据构造")
                //创建人
                 .contact(new Contact("jiangmy","http://localhost:9999/swagger-ui.html","jiangmy@dragoninfo.com.cn"))
                .build();
    }
}

@RestController
@PostMapping(value = "/ryxx")
@Api(description = "人员基础信息")
public class PeopleApiController {
    @ResponseBody
    @GetMapping(value = "/ryjcxx", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiOperation(value = "人员基础信息",notes = "人员基础信息生成")
    public Map<String,Object> ryjcxx() {
        Map<String,Object> returnResult = null;
        try {
            returnResult = CzrkComponet.ryJcxx();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return returnResult;
    }

@ApiResponse用在@ApiResponses中，常用于表示一组错误的信息的响应

<dependency>
    <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-validation</artifactId>
</dependency>

public class ValidateGroup {
    public interface FirstGroup {
    }

    public interface SecondeGroup {
    }

    public interface ThirdGroup {
    }
}

import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;
import lombok.Data;

@Data
public class User {
	@NotEmpty(message = "用户名不能为空")
	@Size(message = "用户名长度 [1-3] ", min = 1, max = 3,groups = ValidateGroup.FirstGroup.class)
	private String username;
	@Min(message = "id不得小于0", value = 0)
	private Integer id;

}

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import com.nbpicc.controller.ValidateGroup.FirstGroup;

@RestController
@PostMapping("/")
public class TestController {

	@PostMapping("test3")
	public User test3(@RequestBody @Validated({ FirstGroup.class }) User u) {
		System.out.println(u);
		return u;
	}

	@PostMapping("test4")
	public User test4(@Validated User u) {
		System.out.println(u);
		return u;
	}

}

import java.util.List;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

	@ExceptionHandler(value = BindException.class)
	public JsonResult exceptionHandle(BindException exception) {

		BindingResult result = exception.getBindingResult();
		StringBuilder errorMsg = new StringBuilder();

		List<FieldError> fieldErrors = result.getFieldErrors();
		fieldErrors.forEach(error -> {
			log.error("field: " + error.getField() + ", msg:" + error.getDefaultMessage());
			errorMsg.append(error.getDefaultMessage()).append("!");
		});
		return JsonResult.failure(errorMsg.toString());
	}

	@ExceptionHandler(value = MethodArgumentNotValidException.class)
	public JsonResult MyExceptionHandle(MethodArgumentNotValidException exception) {

		BindingResult result = exception.getBindingResult();
		StringBuilder errorMsg = new StringBuilder();

		List<FieldError> fieldErrors = result.getFieldErrors();
		fieldErrors.forEach(error -> {
			log.error("field: " + error.getField() + ", msg:" + error.getDefaultMessage());
			errorMsg.append(error.getDefaultMessage()).append("!");
		});

		return JsonResult.failure(errorMsg.toString());
	}

	// 处理运行时异常
	@ExceptionHandler(RuntimeException.class)
	public JsonResult doHandleRuntimeException(RuntimeException e) {
		log.error(e.getMessage(), e);
		e.printStackTrace();
		return JsonResult.failure(e.getMessage());
	}
}

import com.fasterxml.jackson.annotation.JsonInclude;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 *@author wang 
 *@Date 2020-9-14
 * 
 **/

@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor 
@JsonInclude(JsonInclude.Include.NON_NULL)
public class JsonResult<T>  {
		/** 成功 */	
		public static final int SUCCESS=200;
		/**内部服务器错误**/
		public static final int failure=500;
	    /** 没有登录 */
	    public static final int NOT_LOGIN = 400;
	    /** 发生异常 */
	    public static final int EXCEPTION = 401;
	    /** 系统错误 */
	    public static final int SYS_ERROR = 402;
	    /** 参数错误 */
	    public static final int PARAMS_ERROR = 403;
	    /** 不支持或已经废弃 */
	    public static final int NOT_SUPPORTED = 410;
	    /** AuthCode错误 */
	    public static final int INVALID_AUTHCODE = 444;
	    /** 太频繁的调用 */
	    public static final int TOO_FREQUENT = 445;
	    /** 未知的错误 */
	    public static final int UNKNOWN_ERROR = 499;
		
		private Integer code;  
        private String msg;
        private T data;
        
        public static JsonResult failure() {
            return new JsonResult(failure, "请求处理失败",null);
        }
        public static JsonResult failure(String msg) {
            return new JsonResult(failure, msg,null);
        }
        public static JsonResult failure(Integer code,String msg) {
            return new JsonResult(code, msg,null);
        }
        public static JsonResult success() {
            return new JsonResult(SUCCESS,"请求处理成功",null);
        }
        public static JsonResult success(String msg) {
            return new JsonResult(SUCCESS,msg,null);
        }
        public static <T> JsonResult success(T data) {
            return new JsonResult<T> (SUCCESS,"请求处理成功",data);
        }
        public static <T>  JsonResult success(String msg,T data) {
            return new JsonResult<T>(SUCCESS, msg,data);
        }
        

        
        public static JsonResult err() {
            return build(EXCEPTION);
        }
        public static JsonResult err(String msg) {
            return build(EXCEPTION, msg);
        }
        
	
        public JsonResult<T> code(int code) {
            this.code = code;
            return this;
        }
        public JsonResult<T> msg(String msg) {
            this.msg = msg;
            return this;
        }
        public JsonResult<T> data(T data) {
            this.data = data;
            return this;
        }
        
        
        public static JsonResult build() {
            return new JsonResult();
        }
        public static JsonResult build(int code) {
            return new JsonResult().code(code);
        }
        public static JsonResult build(int code, String msg) {
            return new JsonResult<String>().code(code).msg(msg);
        }
        public static <T> JsonResult<T> build(int code, T data) {
            return new JsonResult<T>().code(code).data(data);
        }
        public static <T> JsonResult<T> build(int code, String msg, T data) {
            return new JsonResult<T>().code(code).msg(msg).data(data);
        }
        
        
}

@Data
@Accessors(fluent = true)
public class User {
    private Long id;
    private String name;
    
    // 生成的getter和setter方法如下，方法体略
    public Long id() {}
    public User id(Long id) {}
    public String name() {}
    public User name(String name) {}
}

@Data
@Accessors(chain = true)
public class User {
    private Long id;
    private String name;
    // 生成的setter方法如下，方法体略
    public User setId(Long id) {}
	public User setName(String name) {}
	
}

@Data
@Accessors(prefix = "p")
class User {
	private Long pId;
	private String pName;
	// 生成的getter和setter方法如下，方法体略
    public Long getId() {}
    public void setId(Long id) {}
    public String getName() {}
    public void setName(String name) {}
    
}