Spring 角度HTTP请求问题

我在使用http请求获取rest api服务器的用户信息时遇到了问题，我不知道出了什么问题

当用户单击“登录”按钮时，使用用户名和密码向服务器发送请求，如果正确，则返回用户信息，否则返回null。问题是，尽管用户名和密码正确，但用户服务中的变量user仍然为null

我不知道如何解决这个问题，所以如果你帮我，我会很高兴的！谢谢你的帮助

REST API：

package cz.flay.fellcms.http;

import cz.flay.fellcms.dao.UsersRepository;
import cz.flay.fellcms.entities.User;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@CrossOrigin
@RestController
@RequestMapping(path = "/api/users")
public class UsersRestController {

    @Autowired
    private UsersRepository usersRepository;
    Logger logger = LoggerFactory.getLogger(UsersRestController.class);

    @CrossOrigin
    @GetMapping(path = "/all")
    public @ResponseBody Iterable<User> getAll(){
        return usersRepository.findAll();
    }

    @CrossOrigin
    @GetMapping(path = "/verify", params = {"username", "password"})
    public @ResponseBody User verify(@RequestParam(value = "username") String username, @RequestParam(value = "password") String password){
        logger.info("t");
        return usersRepository.verify(username, password);
    }
}

包cz.flay.fellcms.http；
导入cz.flay.fellcms.dao.UsersRepository；
导入cz.flay.fellcms.entities.User；
导入org.slf4j.Logger；
导入org.slf4j.LoggerFactory；
导入org.springframework.beans.factory.annotation.Autowired；
导入org.springframework.web.bind.annotation.*；
@交叉起源
@RestController
@请求映射（path=“/api/users”）
公共类UsersRestController{
@自动连线
私人用户Repository用户Repository；
Logger Logger=LoggerFactory.getLogger（UsersRestController.class）；
@交叉起源
@GetMapping（path=“/all”）
public@ResponseBody Iterable getAll（）{
返回usersRepository.findAll（）；
}
@交叉起源
@GetMapping（path=“/verify”，params={“username”，“password”}）
public@ResponseBody用户验证（@RequestParam（value=“username”）字符串用户名，@RequestParam（value=“password”）字符串密码）{
logger.info（“t”）；
返回usersRepository.verify（用户名、密码）；
}
}

用户服务

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { User } from '../entities/User';

@Injectable()
export class UserService {

  private usersUrl: 'http://localhost:8080/api/users';

  user: User;
  verifyUrl: string;

  constructor(private http: HttpClient) {}

  isLoggedIn() {
    return this.user != null;
  }

  isAdmin() {
    return this.user.isAdmin;
  }

  unLoggin() {
    this.user = null;
  }

  login(username: string, password: string) {
    this.verifyUrl = 'http://localhost:8080/api/users/verify?username=' + username + '&password=' + password;
    this.http.get<User>(this.verifyUrl).subscribe(data => this.user = data);
    if (this.user != null) {
      return true;
    } else {
      return false;
    }
  }

}

从'@angular/core'导入{Injectable}；
从'@angular/common/http'导入{HttpClient}；
从“../entities/User”导入{User}；
@可注射（）
导出类用户服务{
私有用户surl:'http://localhost:8080/api/users';
用户：用户；
verifyUrl:string；
构造函数（私有http:HttpClient）{}
伊斯洛格丁（）{
返回this.user！=null；
}
伊萨明（）{
返回this.user.isAdmin；
}
解开{
this.user=null；
}
登录（用户名：string，密码：string）{
此.verifyUrl='0http://localhost:8080/api/users/verify?username=“+用户名+”&密码=“+密码；
this.http.get（this.verifyUrl）.subscribe（data=>this.user=data）；
如果（this.user！=null）{
返回true；
}否则{
返回false；
}
}
}

如果（this.user！==null）太快，您正在调用

。该评估将在请求离开和返回之前调用。试试这个：

login(username: string, password: string) {
    this.verifyUrl = `http://localhost:8080/api/users/verify?username=${username}&password=${password}`;
    return this.http.get<User>(this.verifyUrl)
        .map(data => {
            this.user = data
            if (this.user != null) {
               return true;
            } else {
                return false;
            }
        });
}

登录（用户名：字符串，密码：字符串）{
this.verifyUrl=`http://localhost:8080/api/users/verify?username=${username}&password=${password}`；
返回this.http.get（this.verifyUrl）
.map（数据=>{
this.user=数据
如果（this.user！=null）{
返回true；
}否则{
返回false；
}
});
}

但问题是，无论你在哪里调用这个
登录
方法，它现在都是你必须订阅的一个可观察的方法，而不是一个同步方法。
可能重复或不同角度的其他方法。HTTP方法是异步的，因此需要使用可观察对象，并且需要
.subscribe
。请再读一遍，这都是错的。将http内容移动到服务。将用户名和pwd移到正文，而不是url。不要将它们存储在本地
verifyUrl
上。让休息服务恢复完整。等等等等等等。