@AutoConfigureMockMvc
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ApplicationTests {
    @Autowired
    private MockMvc mvc;

    @Test
    public void testUserController() throws Exception {
        // 测试UserController
        RequestBuilder request;

        // 1、get查一下user列表，应该为空
        request = get("/users/");
        MvcResult result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        String content = result.getResponse().getContentAsString();
        BaseResponse<List<User>> response = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<List<User>>>() {});
        assertThat(response.isSuccess(), is(true));
        assertThat(response.getMsg(), is("查询列表成功"));
        assertThat(((List) response.getData()).size(), is(0));

        // 2、post提交一个user
        request = post("/users/")
                .param("id", "1")
                .param("name", "测试大师")
                .param("age", "20");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<String> response1 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<String>>() {});
        assertThat(response1.isSuccess(), is(true));
        assertThat(response1.getMsg(), is("新增成功"));

        // 3、get获取user列表，应该有刚才插入的数据
        request = get("/users/");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<List<User>> response2 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<List<User>>>() {});
        assertThat(response2.isSuccess(), is(true));
        assertThat(response2.getMsg(), is("查询列表成功"));
        assertThat((response2.getData()).size(), is(1));

        // 4、put修改id为1的user
        request = put("/users/1")
                .param("name", "测试终极大师")
                .param("age", "30");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<String> response3 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<String>>() {});
        assertThat(response3.isSuccess(), is(true));
        assertThat(response3.getMsg(), is("更新成功"));

        // 5、get一个id为1的user
        request = get("/users/1");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<User> response4 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<User>>() {});
        assertThat(response4.isSuccess(), is(true));
        assertThat(response4.getMsg(), is("查询成功"));
        User user = response4.getData();
        assertThat(user.getId(), is(1L));
        assertThat(user.getName(), is("测试终极大师"));

        // 6、del删除id为1的user
        request = delete("/users/1");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<String> response5 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<String>>() {});
        assertThat(response5.isSuccess(), is(true));
        assertThat(response5.getMsg(), is("删除成功"));

        // 7、get查一下user列表，应该为空
        request = get("/users/");
        result = mvc.perform(request)
                .andExpect(status().isOk())
                .andReturn();
        content = result.getResponse().getContentAsString();
        BaseResponse<List<User>> response6 = JacksonUtil.json2Bean(content, new TypeReference<BaseResponse<List<User>>>() {});
        assertThat(response6.isSuccess(), is(true));
        assertThat(response6.getMsg(), is("查询列表成功"));
        assertThat((response6.getData()).size(), is(0));
    }

}

String result= "";
        BufferedReaderin = null;
        try {
            String urlNameString= url +"?" + param;
            URL realUrl= new URL(urlNameString);
            // 打开和URL之间的连接
            URLConnectionconnection = realUrl.openConnection();
            // 设置通用的请求属性
            connection.setRequestProperty("accept","*/*");
            connection.setRequestProperty("connection","Keep-Alive");
            connection.setRequestProperty("user-agent",
                    "Mozilla/4.0(compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            Map<String,List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for(String key : map.keySet()) {
                System.out.println(key+ "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            in =new BufferedReader(newInputStreamReader(
                    connection.getInputStream()));
            String line;
            while ((line = in.readLine())!= null) {
                result += line;
            }
        } catch (Exception e) {
            …
        }
        // 使用finally块来关闭输入流
        finally{
         // 关闭流
        }

ResponseEntity<SsoUrlPrm>result = restTemplate.getForEntity(requestPathUrl,SsoUrlPrm.class);  

public class RestTemplateTest {	public static void main(String[] args) {
    RestTemplate restT = new RestTemplate();
    //通过Jackson JSON processing library直接将返回值绑定到对象
    Quote quote = restT.getForObject("http://gturnquist-quoters.cfapps.io/api/random", Quote.class);
    String quoteString = restT.getForObject("http://gturnquist-quoters.cfapps.io/api/random", String.class);
    System.out.println(quoteString);
}}

// 1-getForObject()
User user1 = this.restTemplate.getForObject(uri, User.class);
// 2-getForEntity()
ResponseEntity<User> responseEntity1 = this.restTemplate.getForEntity(uri, User.class);HttpStatus statusCode = responseEntity1.getStatusCode();HttpHeaders header = responseEntity1.getHeaders();User user2 = responseEntity1.getBody();  
// 3-exchange()
RequestEntity requestEntity = RequestEntity.get(new URI(uri)).build();ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);User user3 = responseEntity2.getBody();

// 1-postForObject()
User user1 = this.restTemplate.postForObject(uri, user, User.class);
// 2-postForEntity()
ResponseEntity<User> responseEntity1 = this.restTemplate.postForEntity(uri, user, User.class);
// 3-exchange()
RequestEntity<User> requestEntity = RequestEntity
.post(new URI(uri))
    .body(user);
ResponseEntity<User> responseEntity2 = this.restTemplate.exchange(requestEntity, User.class);

// 1-Content-TypeRequest
Entity<User> requestEntity = RequestEntity        
.post(new URI(uri))        
    .contentType(MediaType.APPLICATION_JSON)        
    .body(user);
// 2-AcceptRequest
Entity<User> requestEntity = RequestEntity
.post(new URI(uri))
    .accept(MediaType.APPLICATION_JSON)
    .body(user);
// 3-OtherRequest
Entity<User> requestEntity = RequestEntity
.post(new URI(uri))        
    .header("Authorization", "Basic " + base64Credentials)        
    .body(user);

try {    
    responseEntity = restTemplate.exchange(requestEntity, String.class);} catch (HttpServerErrorException e) {
    // log error
}

public class CustomErrorHandler extends DefaultResponseErrorHandler {    
    @Override    
    public void handleError(ClientHttpResponse response) throws IOException {
    // todo    
}}

@Configurationpublic class RestClientConfig {
    @Bean    
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setErrorHandler(new CustomErrorHandler());
        return restTemplate;
    }
}

/**
 * - Supports both HTTP and HTTPS
 * - Uses a connection pool to re-use connections and save overhead of creating connections.
 * - Has a custom connection keep-alive strategy (to apply a default keep-alive if one isn't specified)
 * - Starts an idle connection monitor to continuously clean up stale connections.
 */
@Configuration
@EnableScheduling
public class HttpClientConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientConfig.class);

    @Resource
    private HttpClientProperties p;

    @Bean
    public PoolingHttpClientConnectionManager poolingConnectionManager() {
        SSLContextBuilder builder = new SSLContextBuilder();
        try {
            builder.loadTrustMaterial(null, new TrustStrategy() {
                public boolean isTrusted(X509Certificate[] arg0, String arg1) {
                    return true;
                }
            });
        } catch (NoSuchAlgorithmException | KeyStoreException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }

        SSLConnectionSocketFactory sslsf = null;
        try {
            sslsf = new SSLConnectionSocketFactory(builder.build());
        } catch (KeyManagementException | NoSuchAlgorithmException e) {
            LOGGER.error("Pooling Connection Manager Initialisation failure because of " + e.getMessage(), e);
        }

        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
                .<ConnectionSocketFactory>create()
                .register("https", sslsf)
                .register("http", new PlainConnectionSocketFactory())
                .build();

        PoolingHttpClientConnectionManager poolingConnectionManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        poolingConnectionManager.setMaxTotal(p.getMaxTotalConnections());  //最大连接数
        poolingConnectionManager.setDefaultMaxPerRoute(p.getDefaultMaxPerRoute());  //同路由并发数
        return poolingConnectionManager;
    }

    @Bean
    public ConnectionKeepAliveStrategy connectionKeepAliveStrategy() {
        return new ConnectionKeepAliveStrategy() {
            @Override
            public long getKeepAliveDuration(HttpResponse response, HttpContext httpContext) {
                HeaderElementIterator it = new BasicHeaderElementIterator
                        (response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                while (it.hasNext()) {
                    HeaderElement he = it.nextElement();
                    String param = he.getName();
                    String value = he.getValue();
                    if (value != null && param.equalsIgnoreCase("timeout")) {
                        return Long.parseLong(value) * 1000;
                    }
                }
                return p.getDefaultKeepAliveTimeMillis();
            }
        };
    }

    @Bean
    public CloseableHttpClient httpClient() {
        RequestConfig requestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(p.getRequestTimeout())
                .setConnectTimeout(p.getConnectTimeout())
                .setSocketTimeout(p.getSocketTimeout()).build();

        return HttpClients.custom()
                .setDefaultRequestConfig(requestConfig)
                .setConnectionManager(poolingConnectionManager())
                .setKeepAliveStrategy(connectionKeepAliveStrategy())
                .setRetryHandler(new DefaultHttpRequestRetryHandler(3, true))  // 重试次数
                .build();
    }

    @Bean
    public Runnable idleConnectionMonitor(final PoolingHttpClientConnectionManager connectionManager) {
        return new Runnable() {
            @Override
            @Scheduled(fixedDelay = 10000)
            public void run() {
                try {
                    if (connectionManager != null) {
                        LOGGER.trace("run IdleConnectionMonitor - Closing expired and idle connections...");
                        connectionManager.closeExpiredConnections();
                        connectionManager.closeIdleConnections(p.getCloseIdleConnectionWaitTimeSecs(), TimeUnit.SECONDS);
                    } else {
                        LOGGER.trace("run IdleConnectionMonitor - Http Client Connection manager is not initialised");
                    }
                } catch (Exception e) {
                    LOGGER.error("run IdleConnectionMonitor - Exception occurred. msg={}, e={}", e.getMessage(), e);
                }
            }
        };
    }

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("poolScheduler");
        scheduler.setPoolSize(50);
        return scheduler;
    }
}

/**
 * RestTemplate客户端连接池配置
 */
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class RestTemplateConfig {

    @Resource
    private CloseableHttpClient httpClient;

    @Bean
    public RestTemplate restTemplate(MappingJackson2HttpMessageConverter jackson2HttpMessageConverter) {
        RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory());

        List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
        StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(Charset.forName("utf-8"));
        messageConverters.add(stringHttpMessageConverter);
        messageConverters.add(jackson2HttpMessageConverter);
        restTemplate.setMessageConverters(messageConverters);

        return restTemplate;
    }

    @Bean
    public HttpComponentsClientHttpRequestFactory clientHttpRequestFactory() {
        HttpComponentsClientHttpRequestFactory rf = new HttpComponentsClientHttpRequestFactory();
        rf.setHttpClient(httpClient);
        return rf;
    }

}

MultiValueMap<String, Object> multiPartBody = new LinkedMultiValueMap<>();
multiPartBody.add("file", new ClassPathResource("/tmp/user.txt"));
RequestEntity<MultiValueMap<String, Object>> requestEntity = RequestEntity        
.post(uri)        
    .contentType(MediaType.MULTIPART_FORM_DATA)        
    .body(multiPartBody);

// 小文件
RequestEntity requestEntity = RequestEntity.get(uri).build();ResponseEntity<byte[]> responseEntity = restTemplate.exchange(requestEntity, byte[].class);byte[] downloadContent = responseEntity.getBody();  
// 大文件  
ResponseExtractor<ResponseEntity<File>> responseExtractor = new ResponseExtractor<ResponseEntity<File>>() {    
    @Override    
    public ResponseEntity<File> extractData(ClientHttpResponse response) throws IOException {        
        File rcvFile = File.createTempFile("rcvFile", "zip");
        FileCopyUtils.copy(response.getBody(), new FileOutputStream(rcvFile));        
        return ResponseEntity.status(response.getStatusCode()).headers(response.getHeaders()).body(rcvFile);    
    }
};
File getFile = this.restTemplate.execute(targetUri, HttpMethod.GET, null, responseExtractor);

@Servicepublic
class DeviceService {
    @Resource    
    private RestTemplate restTemplate;
}

// 开始推送消息logger.info("解绑成功后推送消息给对应的POS机");
LoginParam loginParam = new LoginParam();
loginParam.setUsername(managerInfo.getUsername());
loginParam.setPassword(managerInfo.getPassword());HttpBaseResponse r = restTemplate.postForObject(        
    p.getPosapiUrlPrefix() + "/notifyLogin", loginParam, HttpBaseResponse.class);
if (r.isSuccess()) {    
    logger.info("推送消息登录认证成功");
    String token = (String) r.getData();
    UnbindParam unbindParam = new UnbindParam();  
    unbindParam.setImei(pos.getImei());   
    unbindParam.setLocation(location);
    // 设置HTTP Header信息   
    URI uri;    
    try {       
        uri = new URI(p.getPosapiUrlPrefix() + "/notify/unbind");  
    } catch (URISyntaxException e) {   
        logger.error("URI构建失败", e);    
        return 1;    
    }  
    RequestEntity<UnbindParam> requestEntity = RequestEntity            .post(uri)  
        .contentType(MediaType.APPLICATION_JSON)     
        .accept(MediaType.APPLICATION_JSON)     
        .header("Authorization", token)     
        .body(unbindParam);
    ResponseEntity<HttpBaseResponse> responseEntity = restTemplate.exchange(requestEntity, HttpBaseResponse.class);
    HttpBaseResponse r2 = responseEntity.getBody();
    if (r2.isSuccess()) {      
        logger.info("推送消息解绑网点成功");
    } else {     
        logger.error("推送消息解绑网点失败，errmsg = " + r2.getMsg());  
    }
} else {
    logger.error("推送消息登录认证失败");
}

public class CloneDemo {

    @Test
    public void t() {
        Cat cat = new Cat();
        Object catClone = cat.clone();
        if (Objects.nonNull(catClone)) {
            System.out.println("catClone:" + catClone.toString());
            ((Cat) catClone).name = "cat";
            System.out.println("cat:" + cat.toString());
            System.out.println("catClone:" + catClone.toString());

        }
    }
}

class Cat implements Cloneable {
    String name = "keep";

    static {
        System.out.println("load Cat");
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class CloneDemo {
    @Test
    public void t() {
        Cat cat = new Cat();
        cat.dog = new Dog();
        Object catClone = cat.clone();
        if (Objects.nonNull(catClone)) {
            System.out.println("catClone:" + catClone.toString());
            ((Cat) catClone).name = "cat";
            ((Cat) catClone).dog.name = "xiao dog";
            System.out.println("改变Clone后的对象值=>");
            System.out.println("cat:" + cat.toString());
            System.out.println("catClone:" + catClone.toString());
        }
    }
}

class Cat implements Cloneable {
    String name = "keep";
    Dog dog;

    static {
        System.out.println("load Cat");
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", dog=" + dog +
                '}';
    }
}

class Dog {
    String name = "dog";

    static {
        System.out.println("load Dog");
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class CloneDemo {
    @Test
    public void t() {
        Cat cat = new Cat();
        cat.dog = new Dog();
        Object catClone = cat.clone();
        if (Objects.nonNull(catClone)) {
            System.out.println("catClone:" + catClone.toString());
            ((Cat) catClone).name = "cat";
            ((Cat) catClone).dog.name = "xiao dog";
            System.out.println("改变Clone后的对象值=>");
            System.out.println("cat:" + cat.toString());
            System.out.println("catClone:" + catClone.toString());

        }
    }
}

class Cat implements Cloneable {
    String name = "keep";
    Dog dog;

    static {
        System.out.println("load Cat");
    }

    @Override
    protected Object clone() {
        try {
            return super.clone();
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", dog=" + dog +
                '}';
    }
}

class Dog implements Cloneable {
    String name = "dog";

    static {
        System.out.println("load Dog");
    }

    @Override
    protected Object clone() {
        System.out.println("   Dog  clone ");
        try {
            return super.clone();
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
        return null;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

@Configuration
public class RabbitConfig {
    /**
     * 声明 Direct 交换机 支持持久化.
     *
     * @return the exchange
     */
    @Bean("directExchange")
    public Exchange directExchange() {
        return ExchangeBuilder.directExchange("DIRECT_EXCHANGE").durable(true).build();
    }

    /**
     * 声明 fanout 交换机.
     *
     * @return the exchange
     */
    @Bean("fanoutExchange")
    public FanoutExchange fanoutExchange() {
        return (FanoutExchange) ExchangeBuilder.fanoutExchange("FANOUT_EXCHANGE").durable(true).build();
    }

    /**
     * 声明一个队列 支持持久化.
     *
     * @return the queue
     */
    @Bean("queueA")
    public Queue directQueue() {
        return QueueBuilder.durable("QUEUE_A").build();
    }

    @Bean("queueB")
    public Queue directQueue2() {
        return QueueBuilder.durable("QUEUE_B").build();
    }

    @Bean("queueC")
    public Queue directQueue3() {
        return QueueBuilder.durable("QUEUE_C").build();
    }

    /**
     * 绑定队列A 到 direct 交换机.
     *
     * @param queue          the queue
     * @param directExchange the  exchange
     * @return the binding
     */
    @Bean
    public Binding bindingA(@Qualifier("queueA") Queue queue,
                            @Qualifier("directExchange") Exchange directExchange) {
        return BindingBuilder.bind(queue).to(directExchange).with("DIRECT_ROUTING_KEY_A").noargs();
    }

    @Bean
    public Binding bindingB(@Qualifier("queueB") Queue queue,
                            @Qualifier("directExchange") Exchange directExchange) {
        return BindingBuilder.bind(queue).to(directExchange).with("DIRECT_ROUTING_KEY_B").noargs();
    }

    /**
     * 绑定队列A 到 fanout 交换机.
     *
     * @param queue          the queue
     * @param fanoutExchange the  exchange
     * @return the binding
     */
    @Bean
    public Binding bindingA1(@Qualifier("queueA") Queue queue,
                             @Qualifier("fanoutExchange") Exchange fanoutExchange) {
        return BindingBuilder.bind(queue).to(fanoutExchange).with("FANOUT_ROUTING_KEY_A").noargs();
    }

    @Bean
    public Binding bindingA2(@Qualifier("queueB") Queue queue,
                             @Qualifier("fanoutExchange") Exchange fanoutExchange) {
        return BindingBuilder.bind(queue).to(fanoutExchange).with("FANOUT_ROUTING_KEY_B").noargs();
    }

    @Bean
    public Binding bindingA3(@Qualifier("queueC") Queue queue,
                             @Qualifier("fanoutExchange") Exchange fanoutExchange) {
        return BindingBuilder.bind(queue).to(fanoutExchange).with("FANOUT_ROUTING_KEY_C").noargs();
    }

}

@Service
public class SenderService {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Resource
    private RabbitTemplate rabbitTemplate;

    /**
     * 测试广播模式.
     *
     * @param p the p
     * @return the response entity
     */
    public void broadcast(String p) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend("FANOUT_EXCHANGE", "", p, correlationData);
    }

    /**
     * 测试 Direct 模式.
     *
     * @param p the p
     * @return the response entity
     */
    public void directA(String p) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend("DIRECT_EXCHANGE", "DIRECT_ROUTING_KEY_A", p, correlationData);
    }
    public void directB(String p) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend("DIRECT_EXCHANGE", "DIRECT_ROUTING_KEY_B", p, correlationData);
    }
    public void directNull(String p) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend("DIRECT_EXCHANGE", "", p, correlationData);
    }

}

@Component
public class Receiver {
    private static final Logger log = LoggerFactory.getLogger(Receiver.class);

    /**
     * FANOUT广播队列监听一.
     *
     * @param message the message
     * @param channel the channel
     * @throws IOException the io exception  这里异常需要处理
     */
    @RabbitListener(queues = {"QUEUE_A"})
    public void on(Message message, Channel channel) throws IOException {
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        log.debug("FANOUT_QUEUE_A " + new String(message.getBody()));
    }
    @RabbitListener(queues = {"QUEUE_B"})
    public void t(Message message, Channel channel) throws IOException {
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        log.debug("FANOUT_QUEUE_B " + new String(message.getBody()));
    }
    @RabbitListener(queues = {"QUEUE_C"})
    public void t(Message message, Channel channel) throws IOException {
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        log.debug("FANOUT_QUEUE_C " + new String(message.getBody()));
    }

    /**
     * DIRECT模式.
     *
     * @param message the message
     * @param channel the channel
     * @throws IOException the io exception  这里异常需要处理
     */
    @RabbitListener(queues = {"DIRECT_QUEUE"})
    public void message(Message message, Channel channel) throws IOException {
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        log.debug("DIRECT_QUEUE " + new String(message.getBody()));
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class SenderServiceTest {
    @Autowired
    private SenderService senderService;

    @Test
    public void testCache() throws InterruptedException {
        // 测试广播模式
        senderService.broadcast("   Test    同学们集合啦！");
        // 测试Direct模式
        senderService.directA("   Test    定点消息 A ");
        senderService.directB("   Test    定点消息 B ");
        senderService.directNull("   Test    定点消息 null key ");
        Thread.sleep(5000L);
    }
}

@Bean
public JmsListenerContainerFactory<?> jmsListenerContainerTopic(ConnectionFactory activeMQConnectionFactory) {
	DefaultJmsListenerContainerFactory bean = new  DefaultJmsListenerContainerFactory();
	bean.setPubSubDomain(true);
	bean.setConnectionFactory(activeMQConnectionFactory);
	return bean;
}

 /**
 - 生产者的组名
 */
 @Value("${apache.rocketmq.producer.producerGroup}")
 private String producerGroup;
 /**
- NameServer 地址
 */
 @Value("${apache.rocketmq.namesrvAddr}")
 private String namesrvAddr;
 private DefaultMQProducer producer ;
 public DefaultMQProducer getProducer(){
     return this.producer;
 }

 @PostConstruct
 public void defaultMQProducer() {
 //生产者的组名
 	producer = new DefaultMQProducer(producerGroup);
 //指定NameServer地址，多个地址以 ; 隔开
 //如 producer.setNamesrvAddr("192.168.100.141:9876;192.168.100.142:9876;192.168.100.149:9876");
     producer.setNamesrvAddr(namesrvAddr);
     producer.setVipChannelEnabled(false);
 try {

 /**
 - Producer对象在使用之前必须要调用start初始化，只能初始化一次
 */
 	producer.start();
 } catch (Exception e) {
 	e.printStackTrace();
 }

 // producer.shutdown(); 一般在应用上下文，关闭的时候进行关闭，用上下文监听器

 }

foo.fori

for(int i=0;i<foo; i++){
        }

public class Foo {
    public Foo(int arg) {
        arg.field
    }
}

public class Foo {
    private int foo;

    public Foo(int arg) {
        foo = arg;
    }

m().try

try{
        m();
        }catch(CheckedException e){
        e.printStackTrace();
        }

#if(${PACKAGE_NAME}&&${PACKAGE_NAME}!="")package ${PACKAGE_NAME};#end
        #parse("File Header.java")

/**
 * ${NAME}
 *
 * @author ${USER}
 * @date ${YEAR}-${MONTH}-${DAY} ${HOUR}:${MINUTE}
 */
public class $ {NAME} {
}