spring-boot
Usługi REST

Parametry

Tworzenie usługi REST

1. Utwórz projekt za pomocą STS (Spring Starter Project) lub Spring Initializr (na https://start.spring.io ).
2. Dodaj zależność sieciową w pliku pom.xml:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

lub wpisz sieć w polu wyszukiwania Search for dependencies , dodaj zależność sieci i pobierz skompresowany projekt.

3. Utwórz klasę domeny (tj. Użytkownika)

 public class User {
    
        private Long id;
    
        private String userName;
    
        private String password;
    
        private String email;
    
        private String firstName;
    
        private String lastName;
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getEmail() {
            return email;
        }
    
        public void setEmail(String email) {
            this.email = email;
        }
    
        public String getFirstName() {
            return firstName;
        }
    
        public void setFirstName(String firstName) {
            this.firstName = firstName;
        }
    
        public String getLastName() {
            return lastName;
        }
    
        public void setLastName(String lastName) {
            this.lastName = lastName;
        }
    
        @Override
        public String toString() {
            return "User [id=" + id + ", userName=" + userName + ", password=" + password + ", email=" + email
                    + ", firstName=" + firstName + ", lastName=" + lastName + "]";
        }
    
        public User(Long id, String userName, String password, String email, String firstName, String lastName) {
            super();
            this.id = id;
            this.userName = userName;
            this.password = password;
            this.email = email;
            this.firstName = firstName;
            this.lastName = lastName;
        }
    
        public User() {}
    }

4. Utwórz klasę UserController i dodaj adnotacje @Controller , @RequestMapping

    @Controller
    @RequestMapping(value = "api")
    public class UserController {
    }

5. Zdefiniuj statyczną zmienną Lista użytkowników, aby symulować bazę danych i dodaj 2 użytkowników do listy

    private static List<User> users = new ArrayList<User>();

    public UserController() {
        User u1 = new User(1L, "shijazi", "password", "[email protected]", "Safwan", "Hijazi");
        User u2 = new User(2L, "test", "password", "[email protected]", "test", "test");
        users.add(u1);
        users.add(u2);
    }

6. Utwórz nową metodę, aby zwrócić wszystkich użytkowników na liście statycznej (getAllUsers)

    @RequestMapping(value = "users", method = RequestMethod.GET)
    public @ResponseBody List<User> getAllUsers() {
         return users;
    }

7. Uruchom aplikację [przez mvn clean install spring-boot:run ] i wywołaj ten adres URL http://localhost:8080/api/users

8. Możemy dodać adnotację do klasy za pomocą @RestController , aw tym przypadku możemy usunąć ResponseBody ze wszystkich metod w tej klasie (@RestController = @Controller + ResponseBody) , jeszcze jeden punkt możemy kontrolować zwrotny kod http, jeśli użyjemy ResponseEntity , zaimplementujemy te same poprzednie funkcje, ale przy użyciu @RestController i ResponseEntity

@RestController
@RequestMapping(value = "api2")
public class UserController2 {

    private static List<User> users = new ArrayList<User>();

    public UserController2() {
        User u1 = new User(1L, "shijazi", "password", "[email protected]", "Safwan", "Hijazi");
        User u2 = new User(2L, "test", "password", "[email protected]", "test", "test");
        users.add(u1);
        users.add(u2);
    }
    
    @RequestMapping(value = "users", method = RequestMethod.GET)
    public ResponseEntity<?> getAllUsers() {
       try {
           return new ResponseEntity<>(users, HttpStatus.OK);
       } catch (Exception e) {
           return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
       }
    }
}

teraz spróbuj uruchomić aplikację i nazwij ten adres URL http: // localhost: 8080 / api2 / users

Tworzenie usługi odpoczynku za pomocą JERSEY i Spring Boot

Jersey jest jednym z wielu dostępnych ram do tworzenia Usług Rest. W tym przykładzie pokazano, jak utworzyć Usługi Rest przy użyciu Jersey i Spring Boot

1. Konfiguracja projektu

Możesz utworzyć nowy projekt za pomocą STS lub za pomocą strony Spring Initializr . Podczas tworzenia projektu uwzględnij następujące zależności:

1. Jersey (JAX-RS)
2. Sieć

2. Tworzenie kontrolera

Utwórzmy kontroler dla naszej usługi Jersey Web

@Path("/Welcome")
@Component
public class MyController {
    @GET
    public String welcomeUser(@QueryParam("user") String user){
        return "Welcome "+user;
    }    
}

@Path("/Welcome") wskazuje na środowisko, że ten kontroler powinien odpowiedzieć na ścieżkę URI / Welcome

@QueryParam("user") wskazuje środowisku, że oczekujemy jednego parametru zapytania o nazwie user

3. Konfiguracje koszulki przewodowej

Skonfigurujmy teraz Jersey Framework za pomocą Spring Boot: Utwórz klasę, a nie składnik wiosenny, który rozszerza org.glassfish.jersey.server.ResourceConfig :

@Component
@ApplicationPath("/MyRestService")
public class JerseyConfig extends ResourceConfig {
    /**
     * Register all the Controller classes in this method 
     * to be available for jersey framework
     */
    public JerseyConfig() {
        register(MyController.class);
    }

}

@ApplicationPath("/MyRestService") wskazuje frameworkowi, że tylko żądania skierowane do ścieżki /MyRestService mają być obsługiwane przez framework jersey, inne żądania powinny być nadal obsługiwane przez framework wiosna.

Dobrym pomysłem jest @ApplicationPath adnotacji do klasy konfiguracji za pomocą @ApplicationPath , w przeciwnym razie wszystkie żądania będą obsługiwane przez Jersey i nie będziemy w stanie jej ominąć i pozwolić sterownikowi sprężynowemu na obsługę, jeśli to konieczne.

4. Gotowe

Uruchom aplikację i uruchom przykładowy adres URL, taki jak (Zakładając, że skonfigurowałeś Spring Boot do uruchomienia na porcie 8080):

http://localhost:8080/MyRestService/Welcome?user=User

W przeglądarce powinien pojawić się komunikat:

Witaj użytkowniku

Skończyłeś z Jersey Web Service z Spring Boot

Korzystanie z interfejsu API REST za pomocą RestTemplate (GET)

Aby korzystać z interfejsu API REST z RestTemplate , utwórz projekt rozruchu wiosennego z inicjatorem rozruchu wiosennego i upewnij się, że dodano zależność sieci Web :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Po skonfigurowaniu projektu utwórz RestTemplate bean RestTemplate . Możesz to zrobić w klasie głównej, która została już wygenerowana, lub w oddzielnej klasie konfiguracji (klasa opatrzona adnotacją @Configuration ):

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

Następnie utwórz klasę domeny, podobnie jak w przypadku tworzenia usługi REST .

public class User {
    private Long id;
    private String username;
    private String firstname;
    private String lastname;

    public Long getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstname) {
        this.firstname = firstname;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastname) {
        this.lastname = lastname;
    }
}

W swoim kliencie uruchom automatycznie RestTemplate :

@Autowired
private RestTemplate restTemplate;

Aby korzystać z interfejsu API REST zwracającego pojedynczego użytkownika, możesz teraz użyć:

String url = "http://example.org/path/to/api";
User response = restTemplate.getForObject(url, User.class);

Korzystając z interfejsu API REST, który zwraca listę lub tablicę użytkowników, masz dwie opcje. Zużyj go jako tablicę:

String url = "http://example.org/path/to/api";
User[] response = restTemplate.getForObject(url, User[].class);

Lub wykorzystaj go za pomocą ParameterizedTypeReference :

String url = "http://example.org/path/to/api";
ResponseEntity<List<User>> response = restTemplate.exchange(url, HttpMethod.GET, null, new ParameterizedTypeReference<List<User>>() {});
List<User> data = response.getBody();

Pamiętaj, że używając ParameterizedTypeReference , będziesz musiał użyć bardziej zaawansowanej metody RestTemplate.exchange() i będziesz musiał utworzyć jej podklasę. W powyższym przykładzie użyto anonimowej klasy.