Introduction

The error Cannot convert from [java.lang.String] to [com.example.demo.User] means Java or a framework built on Java was given a string where a User object was required. The real fix is not "force the cast" but decide how a string should become a User, then implement that conversion in the right layer.

Why the Error Happens

Java does not automatically know how to turn arbitrary text into your domain object. A string and a User are unrelated types, so code like this cannot compile:

1public class Demo {
2    static class User {
3        private final String name;
4
5        User(String name) {
6            this.name = name;
7        }
8    }
9
10    public static void main(String[] args) {
11        String raw = "Alice";
12        User user = raw;
13        System.out.println(user);
14    }
15}

The compiler rejects it because no conversion rule exists.

Manual Parsing in Plain Java

If the string contains user data, you need to parse it into a User explicitly.

1public class Demo {
2    static class User {
3        private final String name;
4        private final int age;
5
6        User(String name, int age) {
7            this.name = name;
8            this.age = age;
9        }
10
11        @Override
12        public String toString() {
13            return "User{name='" + name + "', age=" + age + "}";
14        }
15    }
16
17    static User parseUser(String raw) {
18        String[] parts = raw.split(",");
19        return new User(parts[0], Integer.parseInt(parts[1]));
20    }
21
22    public static void main(String[] args) {
23        User user = parseUser("Alice,30");
24        System.out.println(user);
25    }
26}

This is the fundamental idea: convert the text into fields, then construct the object.

The Spring MVC Version of the Problem

This error often appears in Spring applications when a controller expects a User, but the incoming request is only a string or a request parameter.

If the client sends JSON, the cleanest approach is to accept a request body and let Jackson deserialize it.

1package com.example.demo;
2
3import org.springframework.web.bind.annotation.PostMapping;
4import org.springframework.web.bind.annotation.RequestBody;
5import org.springframework.web.bind.annotation.RestController;
6
7@RestController
8public class UserController {
9
10    @PostMapping("/users")
11    public String createUser(@RequestBody User user) {
12        return "Created " + user.getName();
13    }
14}

With this controller, the client should send JSON such as:

1{
2  "name": "Alice",
3  "age": 30
4}

If the request sends a plain string instead, Spring cannot invent a User from it.

Using a Spring Converter

If your application really does want to turn a single string into a User, register a converter. This is useful for request parameters, path variables, or configuration-driven conversion.

1package com.example.demo;
2
3import org.springframework.core.convert.converter.Converter;
4import org.springframework.stereotype.Component;
5
6@Component
7public class StringToUserConverter implements Converter<String, User> {
8    @Override
9    public User convert(String source) {
10        String[] parts = source.split(",");
11        return new User(parts[0], Integer.parseInt(parts[1]));
12    }
13}

Once Spring's conversion system knows about that rule, it can use it where string-to-object conversion is appropriate.

A Request Parameter Example

Here is a controller method that makes sense with such a converter:

1package com.example.demo;
2
3import org.springframework.web.bind.annotation.GetMapping;
4import org.springframework.web.bind.annotation.RequestParam;
5import org.springframework.web.bind.annotation.RestController;
6
7@RestController
8public class UserController {
9
10    @GetMapping("/parse-user")
11    public String parseUser(@RequestParam User user) {
12        return user.getName();
13    }
14}

Now a request parameter like ?user=Alice,30 can be converted into a User if the converter is registered.

Pick the Right Input Shape

The mistake is often conceptual rather than technical. Ask what the API is supposed to receive:

• If the client sends structured user data, use JSON and @RequestBody.
• If the client sends a simple token such as a user id, accept String or Long and load the User yourself.
• If a single string must map to a User, define a Spring Converter.

These are different designs, and mixing them causes confusing binding errors.

Common Pitfalls

The biggest pitfall is trying to cast a string to User. Casting only works when the underlying object is already an instance of the target type.

Another common issue is forgetting that @RequestBody expects the request body to match the object structure. A plain query parameter or raw string is not the same thing as JSON.

Developers also write brittle string converters without validation. If the source format is name,age, the converter should reject malformed input clearly instead of throwing an obscure array or number parsing exception later.

Finally, do not overuse custom converters when the API can simply accept a DTO or JSON body. Explicit request models are usually easier to understand and maintain.

Summary

• Java cannot implicitly convert a String into a custom User object.
• In plain Java, parse the string and construct the object yourself.
• In Spring MVC, use @RequestBody for JSON payloads that already represent a user.
• Use a Spring Converter<String, User> only when string-to-user conversion is truly part of the API design.
• Fix the data contract first, then implement the conversion at the correct layer.