swagger：

swagger 引入

        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>

swagger引入到spring容器

 

 

 /** 
     * 创建API应用 
     * apiInfo() 增加API相关信息 
     * 通过select()函数返回一个ApiSelectorBuilder实例,用来控制哪些接口暴露给Swagger来展现， 
     * 本例采用指定扫描的包路径来定义指定要建立API的目录。 
     *  
     */
    @Bean
    public Docket createRestApi() {  
        return new Docket(DocumentationType.SWAGGER_2)  
                .apiInfo(apiInfo())  
                .select()  
                .apis(RequestHandlerSelectors.basePackage(swagerPackage)) //swagget扫描目录
                .paths(PathSelectors.any())  
                .build();  
    }  


    /**
     * 创建该API的基本信息（这些基本信息会展现在文档页面中） 
     * 访问地址：http://项目实际地址/swagger-ui.html
     * demo
     */
    protected  ApiInfo apiInfo() {
        return new ApiInfoBuilder()  
                .title("Swagger2构建RESTful APIs")
                .description("China DaaS Technology Corp., Ltd")
                .termsOfServiceUrl("http://www.chinadaas.com/")
                .version("1.0")
                .build();  
    }

 

 

 

 

 

Validator

spring-cloud-starter-eureka中包含spring-boot-starter-web中包含Validator，不需要重复引入依赖

 

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.3.5.Final</version>
        </dependency>

 

 

引入到spring容器

    // 一次不通过就停止校验

    @Bean
    public Validator validator() {
        ValidatorFactory validatorFactory = Validation.byProvider(HibernateValidator.class).configure().addProperty("hibernate.validator.fail_fast", "true").buildValidatorFactory();
        Validator validator = validatorFactory.getValidator();

        return validator;
    }

参考：https://www.cnblogs.com/mr-yang-localhost/p/7812038.html

 

kafka

kafka引入依赖

 

		<!--kafka-->
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
		</dependency>

kafka生产者配置项：

 

 

kafka:
    producer:
        max-request-size: 10485760
        bootstrap-servers: 10.80.111.214:9092
        request-required-acks: 1
        retries: 5
        batch-size: 16384
        linger: 1
        buffer-memory: 134217728
        block-on-buffer-full: false
        key-serializer: org.apache.kafka.common.serialization.StringSerializer
        value-serializer: org.apache.kafka.common.serialization.StringSerializer

kafka生产者配置到spring 容器

 

 

 @Value("${kafka.producer.max-request-size}")
    private String maxRequestSize;

    @Value("${kafka.producer.bootstrap-servers}")
    private String servers;

    @Value("${kafka.producer.request-required-acks}")
    private String requiredAcks;

    @Value("${kafka.producer.retries}")
    private String retries;

    @Value("${kafka.producer.batch-size}")
    private String batchSize;

    @Value("${kafka.producer.linger}")
    private String linger;

    @Value("${kafka.producer.buffer-memory}")
    private String bufferMemory;

    @Value("${kafka.producer.key-serializer}")
    private String key;

    @Value("${kafka.producer.value-serializer}")
    private String value;

    @Bean("kafkaTemplate")
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<String, String>(producerFactory());
    }

    public ProducerFactory<String, String> producerFactory() {
        Map<String, Object> properties = new HashMap<>();

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);

	//重试次数 如果请求失败，生产者会自动重试，如果启用重试，则会有重复消息的可能性
        properties.put(ProducerConfig.RETRIES_CONFIG, retries);//重试次数 如果请求失败，生产者会自动重试，如果启用重试，则会有重复消息的可能性
        properties.put(ProducerConfig.RETRIES_CONFIG, retries);

	//最大消息大小
        properties.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG, maxRequestSize);//最大消息大小
        properties.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG, maxRequestSize);

        /**
         * Server完成 producer request 前需要确认的数量。 acks=0时，producer不会等待确认，直接添加到socket等待发送；
         * acks=1时，等待leader写到local log就行； acks=all或acks=-1时，等待isr中所有副本确认 （注意：确认都是 broker
         * 接收到消息放入内存就直接返回确认，不是需要等待数据写入磁盘后才返回确认，这也是kafka快的原因）
         */
        properties.put(ProducerConfig.ACKS_CONFIG, requiredAcks);

        /**
         * Producer可以将发往同一个Partition的数据做成一个Produce
         * Request发送请求，即Batch批处理，以减少请求次数，该值即为每次批处理的大小。
         * 另外每个Request请求包含多个Batch，每个Batch对应一个Partition，且一个Request发送的目的Broker均为这些partition的leader副本。
         * 若将该值设为0，则不会进行批处理
         */
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);

        /**
         * 默认缓冲可立即发送，即遍缓冲空间还没有满，但是，如果你想减少请求的数量，可以设置linger.ms大于0。
         * 这将指示生产者发送请求之前等待一段时间，希望更多的消息填补到未满的批中。这类似于TCP的算法，例如上面的代码段，
         * 可能100条消息在一个请求发送，因为我们设置了linger(逗留)时间为1毫秒，然后，如果我们没有填满缓冲区，
         * 这个设置将增加1毫秒的延迟请求以等待更多的消息。 需要注意的是，在高负载下，相近的时间一般也会组成批，即使是
         * linger.ms=0。在不处于高负载的情况下，如果设置比0大，以少量的延迟代价换取更少的，更有效的请求。
         */
        properties.put(ProducerConfig.LINGER_MS_CONFIG, linger);

        /**
         * 控制生产者可用的缓存总量，如果消息发送速度比其传输到服务器的快，将会耗尽这个缓存空间。
         * 当缓存空间耗尽，其他发送调用将被阻塞，阻塞时间的阈值通过max.block.ms设定， 之后它将抛出一个TimeoutException。
         */
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, key);
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, value);
        return new DefaultKafkaProducerFactory<String, String>(properties);
    }

参考博客：http://blog.csdn.net/yy756127197/article/details/78252432 、http://blog.csdn.net/suifeng3051/article/details/48053965

 

 

 

feign

/**
     * 启动feign日志
     * @return
     */
    @Bean
    public Logger.Level feignLoggerLevel() {
        return feign.Logger.Level.FULL;
    }

配置具体的类开启debug

 

logging.level.com.**.demo.feign.**: debug

 

 

Log

logging: 
    path: ${user.dir}/logs
    file: ${logging.path}/cloud-demo.log
    level:
      root: info
      com.**: debug