@Configuration
@EnableWebSocketMessageBroker
public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {

   @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {

        // 只有用enableSimpleBroker打开的地址前缀才可以在程序中使用，使用没设置enable的前缀时不会出错，但无法传递消息
        // 服务端发送，客户端接收
        config.enableSimpleBroker("/topic");

        // @MessageMapping注解的设置的地址的会和这个前缀一起构成客户端需要声明的地址(stompClient.send()方法的第一个参数）
        // 客户端发送，服务端接收
        config.setApplicationDestinationPrefixes("/app");
    }

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        //客户端调用的URL；
        registry.addEndpoint("/socket");
    }


}

@Controller
public class SocketController {


    /**
     * MessageMapping注解中配置的接收地址和WebScoketConfig中setApplicationDestinationPrefixes()设置的地址前缀
     * 一起构成了客户端向服务器端发送消息时使用地址
     */
    @MessageMapping("/chat")
    public void toAll(ChatMessage message, Principal principal) throws Exception {
        // principal 是当前用户； 如果没有设置用户，则为null
        // message 是发送过来的消息，可以是POJO，也可以用Map接收
    }

}

@MessageMapping("/joinchat")
@ SendToUser("/topic/message")
public ChatMessage joinAndWelcome(ChatMessage message, Principal principal) throws Exception {
    //由于增加了SendToUser注解，返回结果会被convertAndSend给特定用户，调用这个方法发消息的用户principal中的用户
    return new ChatMessage("welcome, "  + principal.getName() + ".");
}


@MessageMapping("/chat")
@SendTo("/topic/message")
public ClockMessage oneMessageToAll(ChatMessage message, Principal principal) throws Exception {
    //发送给所有用户
    return new ChatMessage(""  + principal.getName() + "：" + message.getMessage() + " ");
}

@Autowired
private SimpMessagingTemplate template;

public void sendMessage(){
    // 发送给所有用户
    this.template.convertAndSend("/topic/message",  new ChatMessage("Hello, all!"));
    // 发送给一个用户，用户ID 'xxx-yyy'
    convertAndSendToUser("xxx-yyy", "/topic/message",  new ChatMessage("Hello, xxx-yyy!"));
}

@Configuration
@EnableWebSocketMessageBroker
public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 调用setHandshakeHandler方法设置一个自定义的HandShakeHandler
        registry.addEndpoint("/socket/challenge").setHandshakeHandler(new MyHandshakeHandler());
    }
    
    /**
     * 自定义的 HandshakeHandler， 覆盖了determineUser 方法，返回当前用户
     */
    public class MyHandshakeHandler extends DefaultHandshakeHandler {
    
        @Override
        protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes) {
            // 这里查询当前用户，并返回一个 Principal 类作为当前用户，以后 controller 参数Principal 就是获得这里的返回值
            // 获取当前用户可以通过 request 获得cookie/ token 然后查询获得
            // 如果项目中也使用了 Springsecurity 也可用 SecurityContextHolder.getContext().getAuthentication() 获取当前登录用户
            // 需要把当前用户设置成 Principal 类型，这个接口只有一个方法 getName() 这个name需要是每个用户唯一的，可以使用系统中用户的ID作为此处的name
        }
    }
}

@Configuration
@EnableWebSocketMessageBroker
public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 通过addInterceptors(new MyHandshakeInterceptor()) 登记自定义的 HandshakeInterceptor
        registry.addEndpoint("/socket/challenge").setHandshakeHandler(new MyHandshakeHandler()).addInterceptors(new MyHandshakeInterceptor());
    }
    
    public class MyHandshakeInterceptor implements HandshakeInterceptor {

        @Override
        public boolean beforeHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Map<String, Object> map) throws Exception {
            //返回false表示不接受此连接; 返回true表示接受此连接
            return false;
        }

        @Override
        public void afterHandshake(ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse, WebSocketHandler webSocketHandler, Exception e) {

        }
    }
}

@Configuration
@EnableWebSocketMessageBroker
public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        // 要设置心跳包，需要先设置一个 TaskScheduler
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(1);
        scheduler.setThreadNamePrefix("wss-heartbeat-thread-");
        scheduler.initialize();

        // 只有用enableSimpleBroker打开的地址前缀才可以在程序中使用，使用没设置enable的前缀时不会出错，但无法传递消息
        // 服务端发送，客户端接收
        // 通过setHeartbeatValue(new long[] {10000, 20000})设置心跳包频率，单位毫秒
        config.enableSimpleBroker("/topic").setHeartbeatValue(new long[] {10000, 20000}).setTaskScheduler(scheduler);

        // @MessageMapping注解的设置的地址的会和这个前缀一起构成客户端需要声明的地址(stompClient.send()方法的第一个参数）
        // 客户端发送，服务端接收
        config.setApplicationDestinationPrefixes("/app");
    }
}

@Autowired
private SimpUserRegistry userRegistry;

public void isUserOnline(String userId){
    return userRegistry.getUsers().contains(userRegistry.getUser(userId));
}

@Configuration
@EnableWebSocketMessageBroker
public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {
    private static final Logger logger = LoggerFactory.getLogger(WebsocketConfig.class);

    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        // 注册一个自定义的拦截器
        registration.interceptors(new MyChannelInterceptorAdapter());
    }
    
    public class MyChannelInterceptorAdapter implements ChannelInterceptor {

        @Override
        public Message<?> preSend(Message<?> message, MessageChannel channel) {
            StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);

            logger.trace("MyChannelInterceptorAdapter.preSend({}, {})  command is {}", message, channel,
                    (accessor.getCommand() == null ? "command is null" : accessor.getCommand().name()));


            return message;
        }
    }
}

@Component
public class SubscribeEventListener implements ApplicationListener<SessionSubscribeEvent> {
    private static final Logger logger = LoggerFactory.getLogger(SubscribeEventListener.class);

    @Override
    public void onApplicationEvent(SessionSubscribeEvent event) {
        logger.trace("SessionSubscribeEvent {}", event.getSource());
    }
}

@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
    registry.addEndpoint("/socket/challenge").setHandshakeHandler(new MyHandshakeHandler()).setAllowedOrigins("*");
}

public void configureMessageBroker(MessageBrokerRegistry config) {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setPoolSize(1);
    scheduler.setThreadNamePrefix("wss-heartbeat-thread-");
    scheduler.initialize();

    // 只有用enableSimpleBroker打开的地址前缀才可以在程序中使用，使用没设置enable的前缀时不会出错，但无法传递消息
    // 服务端发送，客户端接收
    config.enableSimpleBroker("/topic").setHeartbeatValue(new long[] {20000, 20000})
            .setTaskScheduler(scheduler);

    // @MessageMapping注解的设置的地址的会和这个前缀一起构成客户端需要声明的地址(stompClient.send()方法的第一个参数）
    // 客户端发送，服务端接收
    config.setApplicationDestinationPrefixes("/app");
}

public class WebsocketConfig implements WebSocketMessageBrokerConfigurer {

    //其他部分略去
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        //客户端调用的URL；
        registry.addEndpoint("/socket").setAllowedOrigins("*");
    }

@Service
public class XxxxService{
    @Value("${xxx.yyy}")
    private String xxxYyy;
}

@ConfigurationProperties
public class xxxYyy{
   private String name;
   @NestedConfigurationProperty Address address;

   public void setName(String name){
      this.name = name;
   }
   
   public void setAddress(Address address){
      this.address = address;
   } 
}

public class Address{
    private String province;
    private String city;
   
    //---略过setter方法
}

@EnableConfigurationProperties

@PropertySource("classpath:configprops.properties")

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.io.support.PropertySourceFactory;

import java.io.IOException;
import java.util.Properties;

public class YamlPropertySourceFactory implements PropertySourceFactory {
  private static final Logger logger = LoggerFactory.getLogger(YamlPropertySourceFactory.class);

  @Override
  public PropertySource<?> createPropertySource(String name, EncodedResource encodedResource)
      throws IOException {
    YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean();
    factory.setResources(encodedResource.getResource());
    Properties properties = factory.getObject();
    logger.trace(
        "read from {}, exists:{}",
        encodedResource.getResource().getFile().getAbsoluteFile(),
        encodedResource.getResource().exists());
    return new PropertiesPropertySource(encodedResource.getResource().getFilename(), properties);
  }
}

@PropertySource(factory = YamlPropertySourceFactory.class, value = "classpath:yamlfile.yml")

package cn.devmgr.springcloud;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


@Service
public class ContentEncodingFilter extends OncePerRequestFilter {
    Logger logger = LoggerFactory.getLogger(ContentEncodingFilter.class);

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {

        String conentEncoding = request.getHeader("Content-Encoding");
        if(conentEncoding != null && ("gzip".equalsIgnoreCase(conentEncoding) || "deflate".equalsIgnoreCase(conentEncoding))){
            logger.trace("Content-Encoding: {}", conentEncoding);
            chain.doFilter(new GZIPRequestWrapper(request), response);
            return;
        }

        chain.doFilter(request, response);
    }
}

package cn.devmgr.springcloud;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.zip.DeflaterInputStream;
import java.util.zip.GZIPInputStream;

public class GZIPRequestWrapper extends HttpServletRequestWrapper {
    private final static Logger logger = LoggerFactory.getLogger(GZIPRequestWrapper.class);

    protected HttpServletRequest request;

    public GZIPRequestWrapper(HttpServletRequest request){
        super(request);
        this.request = request;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        ServletInputStream sis = request.getInputStream();
        InputStream is = null;
        String conentEncoding = request.getHeader("Content-Encoding");
        if("gzip".equalsIgnoreCase(conentEncoding)){
            is = new GZIPInputStream(sis);
        }else if("deflate".equalsIgnoreCase(conentEncoding)){
            is = new DeflaterInputStream(sis);
        }else{
            throw new UnsupportedEncodingException(conentEncoding + " is not supported.");
        }
        final InputStream compressInputStream = is;
        return new ServletInputStream(){
            ReadListener readListener;

            @Override
            public int read() throws IOException {
                int b = compressInputStream.read();
                if(b == -1 && readListener != null) {
                    readListener.onAllDataRead();
                }
                return b;
            }

            @Override
            public boolean isFinished(){
                try {
                    return compressInputStream.available() == 0;
                } catch (IOException e) {
                    logger.error("error", e);
                    if(readListener != null) {
                        readListener.onError(e);
                    }
                    return false;
                }
            }

            @Override
            public boolean isReady() {
                try {
                    return compressInputStream.available() > 0;
                } catch (IOException e) {
                    logger.error("error", e);
                    if(readListener != null) {
                        readListener.onError(e);
                    }
                    return false;
                }
            }

            @Override
            public void setReadListener(final ReadListener readListener) {
                this.readListener = readListener;
                sis.setReadListener(new ReadListener() {
                    @Override
                    public void onDataAvailable() throws IOException {
                        logger.trace("onDataAvailable");
                        if(readListener != null){
                            readListener.onDataAvailable();
                        }
                    }

                    @Override
                    public void onAllDataRead() throws IOException {
                        logger.trace("onAllDataRead");
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        logger.error("onError", throwable);
                        if(readListener != null){
                            readListener.onError(throwable);
                        }
                    }
                });
            }
        };
    }
}

package cn.devmgr.springcloud;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.util.CollectionUtils;
import org.springframework.web.client.RestTemplate;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.GZIPOutputStream;

@Configuration
public class RestClientConfig {
    private final static Logger logger = LoggerFactory.getLogger(RestClientConfig.class);

    /**
     * request body超过1M时，自动开启压缩模式；（需要服务端支持）
     * 压缩和解压会增加程序处理时间，一般内网调用不压缩速度会更快；压缩只是在网络环境较差的情况下有使用意义。
     * @return
     */
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();

        List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
        if (CollectionUtils.isEmpty(interceptors)) {
            interceptors = new ArrayList<>();
        }
        interceptors.add(new RestTemplateCompressInterceptor());

        restTemplate.setInterceptors(interceptors);
        return restTemplate;
    }


    class RestTemplateCompressInterceptor implements ClientHttpRequestInterceptor {

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body,
                                            ClientHttpRequestExecution execution) throws IOException {
            logger.trace("RestTemplateCompressInterceptor:intercept() body-length: {}", body == null ? 0 : body.length);
            byte[] newBody = null;
            if(body == null || body.length < 1024 * 1024){
                // 小于1M不开启压缩模式
                logger.trace("{}不需要压缩", body == null ? 0 : body.length);
                newBody = body;
            }else{
                logger.trace("{}开启压缩模式", body.length);
                request.getHeaders().add("Content-Encoding", "gzip");
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                GZIPOutputStream gzip;
                try {
                    gzip = new GZIPOutputStream(baos);
                    gzip.write(body);
                    gzip.close();
                } catch (IOException e) {
                    logger.error("压缩request body出错.", e);
                    throw(e);
                }
                newBody = baos.toByteArray();
                logger.trace("压缩后大小 {}", newBody.length);
            }
            ClientHttpResponse response = execution.execute(request, newBody);
            return response;
        }
    }
}