我正在使用Spring Websocket和STOMP,Simple Message Broker.在我的@Controller使用方法级别@SubscribeMapping,它应该将客户端订阅到主题,以便客户端之后将接收该主题的消息.假设客户订阅主题"聊天":
stompClient.subscribe('/app/chat', ...);
当客户订阅"/ app/chat "而不是"/ topic/chat"时,此订阅将转到使用以下方法映射的方法@SubscribeMapping:
@SubscribeMapping("/chat")
public List getChatInit() {
return Chat.getUsers();
}
这是Spring ref.说:
默认情况下,@ SubsscribeMapping方法的返回值作为消息直接发送回连接的客户端,并且不通过代理.这对于实现请求 - 回复消息交互很有用; 例如,在初始化应用程序UI时获取应用程序数据.
好的,这就是我想要的,但只是部分 !! 订阅后发送一些init-data,好吧.但订阅呢？在我看来,这里发生的事情只是一个请求 - 回复,就像一个服务.订阅只是消费.如果是这种情况,请澄清我.
如果在这里客户端没有订阅任何地方,我想知道为什么我们称之为"订阅"; 因为客户端只收到一条消息而不是后续消息.
编辑:
为了确保订阅已经实现,我尝试的内容如下:
服务器端:
组态:
@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/hello").withSockJS();
} …spring stomp messagebroker spring-messaging spring-websocket
当它被点击JLabel,我想明白了,如果点击的是"Icon part",和" Text part"的JLabel,所以不同的可以采取行动.有一个聪明的办法做到这一点？或者只是我必须与坐标相对解决问题图标和文字？
这是一种“什么是@Service注解？” 问题，但采用另一种方法。因为，我不确定这里发生了什么：
我有一个控制器类：
@Controller
public class GreetingController {
@Autowired
SomeBean someBean;
@MessageMapping("/msg")
public String msg() {
someBean.handleMsg();
return "";
}
}
我尝试从内部someBean.handleMsg向目的地发送响应。像这样的事情：
public class SomeBean {
@Autowired
private SimpMessagingTemplate messagingTemplate;
public handleMsg() {
messagingTemplate.convertAndSend("/topic/someTopic", "Response");
}
}
有两个版本的配置。
喜欢：
< bean id="someBean" class="package.SomeBean"></bean>
喜欢：
@Service
public class SomeBean{...}
唯一的 区别是：
SomeBean有@Service注解时，成功响应客户端，但当没有注解时，客户端收不到响应消息，虽然没有任何异常。这是问题：
我需要弄清楚lock和condition_variable是如何工作的.
在这里cminplusreference的-slightly modified-code中
std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;
void worker_thread()
{
// Wait until main() sends data
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return ready;});
// after the wait, we own the lock.
std::cout << "Worker thread is processing data\n";
data += " after processing";
// Send data back to main()
processed = true;
std::cout << "Worker thread signals data processing completed\n";
// Manual unlocking is done before notifying, to avoid waking …我发布了一个继承自QEvent使用的自定义事件QCoreApplication::postEvent.我曾经读过,在使用postEvent它时需要有堆分配的事件.但我不确定谁有责任释放它.
所以,我试着用std::shared_ptr.但是,当我创建我的事件时std::shared_ptr,我收到此错误:
double free or corruption (fasttop)
这是否意味着QEvent可以自由地释放事件,以便我可以创建事件而不必费心删除它？
这是代码的样子:
class MyCustomEvent : public QEvent {...}
std::shared_ptr<MyCustomEvent> evt(new MyCustomEvent(arg1, arg2)); // double free or corruption!
QCoreApplication::postEvent(targetObj, evt.get());
考虑一下:
class TestLambda {
public:
std::vector<char> data;
};
void test_lambda(TestLambda& obj) {
[=]() mutable {
obj.data.push_back(0x01);
}();
}
int main() {
TestLambda tst;
tst.data.push_back(0x99);
test_lambda(tst);
// tst.data is unchanged at this point
return 0;
}
在调用test_lambda我所期望的是看到变化之后tst.data,但事实并非如此.要查看更改,我必须创建lambda再次传递一个引用obj,即.[&obj]().
我们为什么需要这个？我的意思是,再一次参考？
obj已经是一个参考.然后,通过复制lambda捕获obj.因此,obj在中lambda本身就不是一个参考？为什么？
有人能解释一下吗？谢谢.
我有这个代码来复制一个整数:
int parseInt(const char* data, unsigned int* ind) {
int i;
std::copy(&data[*ind], &data[*ind+sizeof(int)], &i); // i) STD::COPY
// memcpy(&i, &data[*ind], sizeof(int)); // ii) MEMCPY
std::cout << "--> " << i << std::endl;
*ind += sizeof(int);
std::cout << "OK" << std::endl;
return i;
}
在debian这段代码工作没有有问题的我)的std :: COPY.
然后,我编译并运行嵌入式Arm上的代码(sizeof(int)也是4).带有i)的代码似乎也在运行,在函数内打印预期.
但是,从函数返回时会导致问题.
我也试过return 1;而不是i,但同样的.它没有抛出异常,也没有给出任何线索.我无法调试,因为我无法添加调试器,因为我有限制.
它只是在这个功能之后才会继续,即:
std::cout << "PARSING..." << std::endl;
parseInt(data, &ind);
std::cout << "PARSED!" << std::endl;
... …想象一下,我开始std::thread运行一个对象的成员函数.如果该对象在我创建线程的main函数中超出范围会发生什么？
class ThreadClass {
public:
ThreadClass(int i) : _a(i) {
}
void foo() {
sleep(10);
std::cout << "Is it safe here? " << _a << std::endl;
}
int _a;
};
int main() {
{
ThreadClass obj(3);
std::thread t(&ThreadClass::foo, &obj);
t.detach();
}
// Here obj goes out of scope
// What about thread?
sleep(20);
return 0;
}
这是一个未定义的行为吗？
我有一个具有指针作为成员的结构：
struct MyStruct {
char *ptr;
}
我想在一个范围内初始化 ptr，然后能够在该范围之外使用它：
{ // scope 0
{ //scope 1
{ // scope 2
mystruct.ptr = new char[100];
}
// mystruct.ptr still lives here
}
// i dont need mystruct anymore
delete[] mystruct.ptr;
}
但后来我必须删除它，这很容易出错，我宁愿避免这样做。所以我想到使用std::shared_ptr.
{ // scope 0
{ //scope 1
{ // scope 2
auto a = std::make_shared<char>(new char[100]);
mystruct.ptr = a.get(); // ??????? HOW TO ASSIGN
}
// mystruct.ptr still SHOULD live here
}
}
那么，我该怎么办呢？我应该如何将shared_ptr分配给mystruct.ptr以使所有权计数变为2？我看到 get() 不起作用，因为它只是传递指针但不给出所有权，因此它被删除。
如您所见，这里的主要动机是延长寿命，因此我对其他做法持开放态度。也许我在这里使用shared_ptr的想法是错误的？
我想我做了所有事情,但HashMap.get返回null.hashCode返回相同的整数,equals返回true,key是不可变的,但现在仍在工作.
我错过了什么？
这是我的代码:
public enum MyEnum_1 `AA1, AA2, AA3, AA4`;
public enum MyEnum_2 `BB1, BB2, BB3, BB4`;
public void MyClass()
{
...
final MyEnum_1 enum1;
final MyEnum_2 enum2;
public int hashCode()
{
return (enum1.ordinal() * 100 + enum2.ordinal());
}
public boolean equals(MyClass obj2)
{
if (obj2 == null) return false;
else return (enum1.equals(obj2.getEnum1()) && enum2.equals(obj2.getEnum2()));
}
...
}
...
Map<MyClass, MyOtherClass> mappp = new HashMap<MyClass, MyOtherClass>();
...
mappp.put(obj1, other_obj1);
MyClass obj2 = new MyClass(obj1.getEnum1(), obj1.getEnum2());
System.out.println("hashCode: " + (obj1.hashCode() == …