Firefox中的Rest客户端工具未命中JavaSpring4（带注释的）Rest控制器

嗨

我遇到了一个让我非常困惑的问题，因为映射应该可以工作，而且在调试模式下启动Spring引导时它看起来确实映射了。我不知道还能在哪里找到解决这个问题的明显方法

以下是application.properties：

下面是SpringBootInitializer类，它向>Servlet注册添加了进一步的“/api”：

公共类应用程序扩展了SpringBootServletilizer{
@豆子
公共DispatcherServlet DispatcherServlet（）{
返回新的DispatcherServlet（）；
}
@豆子
public ServletRegistrationBean Dispatchers ServletRegistration（）{
最终ServletRegistrationBean注册=新的ServletRegistrationBean（dispatcherServlet（），“/api/*”）；
final Map params=new HashMap（）；
put（“contextClass”，“org.springframework.web.context.support.AnnotationConfigWebApplicationContext”）；
put（“contextConfigLocation”，“org.spring.sec2.spring”）；
参数put（“dispatchOptionsRequest”、“true”）；
registration.setInitParameters（params）；
注册。设置加载启动（1）；
申报登记；
}
//
@凌驾
受保护的SpringApplicationBuilder配置（最终SpringApplicationBuilder应用程序）{
返回application.initializer（新的MyApplicationContextInitializer（））.sources（App.class）；
}
公共静态void main（最终字符串…参数）{
新的SpringApplicationBuilder（App.class）.initializer（新的MyApplicationContextInitializer（））.run（args）；
}
}

这是一个控制器，它向映射中添加了更多的“用户”。我设置了一个调试点的方法>是findAll，不需要进一步的映射来>访问它（即/users/的根）：

@控制器
@请求映射（值=用户）
公共类UserController扩展了AbstractController{
@自动连线
专用IUSERSERSERVICE用户服务；
公共用户控制器（）{
super（User.class）；
}
//原料药
//发现
@RequestMapping（method=RequestMethod.GET）
@应答器
public void getItsWorking（）{
System.out.println（“它正在工作！！！”；
}
}

以下是用户实体：

@实体
公共类用户实现了安全性{
@身份证
@GeneratedValue（策略=GenerationType.AUTO）
@列（name=“user\u id”）
专用长用户标识；
@列（name=“username”，unique=true，nullable=false）
私有字符串名称；
@列（unique=true，nullable=false）
私人字符串电子邮件；
@列（nullable=false）
私有字符串密码；
@列（nullable=false）
私有布尔锁；
公共用户（）{
超级（）；
}
公共用户（最终字符串名称集、最终字符串密码集、/*final
集合角色集合，*/最终布尔锁定集合）{
超级（）；
name=nameToSet；
password=passwordToSet；
锁定=锁定的状态；
}
//原料药
公共长getId（）{
返回用户id；
}
public void setId（最终长idToSet）{
用户id=idToSet；
}
公共字符串getName（）{
返回名称；
}
public void setName（最终字符串名称集合）{
name=nameToSet；
}
公共字符串getEmail（）{
回复邮件；
}
public void setEmail（最终字符串emailToSet）{
email=emailToSet；
}
公共字符串getPassword（）{
返回密码；
}
public void setPassword（最终字符串passwordToSet）{
password=passwordToSet；
}
公共布尔getLocked（）{
返回锁定；
}
公共无效设置锁定（最终布尔锁定设置）{
锁定=锁定的状态；
}
}

以下是Spring启动调试时的输出：

将“{[/users]，methods=[GET]}”映射到public
java.util.List
org.um.web.controller.UserController.findAll（javax.servlet.http.HttpServletRequest）

因此，它看起来映射正确，但当我在Firefox中使用Rest>客户端工具加载项点击它时，在>以下url上执行“获取”时，我得到了以下信息：在标题中使用内容类型：application/json

发生了什么事？非常困惑。

---

您应该在类上放置一个

@RequestMapping（“/api”）

，在方法上放置一个

@RequestMapping（“/users”）

（最好将某些内容返回给客户端）

---

这样，您的端点将被公开为

/api/users

，您将能够轻松地在

/api/*

下向此类添加更多端点。

感谢您的回复，Simon，但仍然是404。我还应该检查什么？原来我有一个来自先前目标构建的SecurityFilterChain类，它阻止了me访问控制器。清除并重建后，它将毫无问题地命中rest控制器方法。请尝试将

@RequestMapping（value=users）

更改为

@RequestMapping（value=“/api/users”）

。

server.port=8082
server.contextPath = /

public class App extends SpringBootServletInitializer {

@Bean
public DispatcherServlet dispatcherServlet() {
    return new DispatcherServlet();
}

@Bean
public ServletRegistrationBean dispatcherServletRegistration() {
    final ServletRegistrationBean registration = new ServletRegistrationBean(dispatcherServlet(), "/api/*");

    final Map<String, String> params = new HashMap<String, String>();
    params.put("contextClass", "org.springframework.web.context.support.AnnotationConfigWebApplicationContext");
    params.put("contextConfigLocation", "org.spring.sec2.spring");
    params.put("dispatchOptionsRequest", "true");
    registration.setInitParameters(params);

    registration.setLoadOnStartup(1);
    return registration;
}

//

@Override
protected SpringApplicationBuilder configure(final SpringApplicationBuilder application) {
    return application.initializers(new MyApplicationContextInitializer()).sources(App.class);
}

public static void main(final String... args) {
    new SpringApplicationBuilder(App.class).initializers(new MyApplicationContextInitializer()).run(args);
}
}

@Controller
@RequestMapping(value = users)
public class UserController extends AbstractController<User> {

@Autowired
private IUserService userService;

public UserController() {
    super(User.class);
}

// API

// find

@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public void getItsWorking() {
    System.out.println("It's Working!!!");
}

}

@Entity
public class User implements IEntity {

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name="user_id")
private Long user_id;

@Column(name = "username", unique = true, nullable = false)
private String name;

@Column(unique = true, nullable = false)
private String email;

@Column(nullable = false)
private String password;

@Column(nullable = false)
private Boolean locked;


public User() {
    super();
}

public User(final String nameToSet, final String passwordToSet, /*final       
Set<Role> rolesToSet,*/ final Boolean lockedToSet) {
    super();

    name = nameToSet;
    password = passwordToSet;
    locked = lockedToSet;
}

// API

public Long getId() {
    return user_id;
}

public void setId(final Long idToSet) {
    user_id = idToSet;
}

public String getName() {
    return name;
}

public void setName(final String nameToSet) {
    name = nameToSet;
}

public String getEmail() {
    return email;
}

public void setEmail(final String emailToSet) {
    email = emailToSet;
}

public String getPassword() {
    return password;
}

public void setPassword(final String passwordToSet) {
    password = passwordToSet;
}

public Boolean getLocked() {
    return locked;
}

public void setLocked(final Boolean lockedToSet) {
    locked = lockedToSet;
}

}

Mapped "{[/users],methods=[GET]}" onto public    
java.util.List<org.um.persistence.model.User> 
     org.um.web.controller.UserController.findAll(javax.servlet.http.HttpServletRequest)