tengo un appveterinarinaria springboot backend y frontend 100% funcional y me falta ingreso con un login agregando JWT podrias ayudarme hazlo lo mas simplificado y optimizado posible base datos: mascotas,clientes,servicios,citas,veterinarios veterinarios tiene columna de password

Claro que sí, te puedo ayudar a implementar un sistema de autenticación con JWT en tu aplicación Spring Boot. Aquí te presento un ejemplo básico de cómo podrías implementarlo.

**Requisitos previos**

* Spring Boot 2.5.3 o superior
* Spring Security 5.6.3 o superior
* Lombok para generar getters y setters automáticamente
* Java 11 o superior

**Configuración de Spring Security**

Primero, debes agregar las dependencias de Spring Security a tu archivo `pom.xml` (si estás utilizando Maven) o `build.gradle` (si estás utilizando Gradle).

**Maven**
```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
```

**Gradle**
```groovy
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'io.jsonwebtoken:jjwt:0.9.1'
}
```

Luego, debes configurar Spring Security en tu archivo `application.properties` o `application.yml`.

**application.properties**
```properties
spring.security.user.name=veterinario
spring.security.user.password=veterinario
```

**application.yml**
```yml
spring:
  security:
    user:
      name: veterinario
      password: veterinario
```

**Configuración de la autenticación**

Crea un archivo `SecurityConfig.java` con la siguiente configuración:
```java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService()).passwordEncoder(passwordEncoder());
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .authorizeRequests()
                .antMatchers("/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .formLogin();
    }
}
```

**Servicio de autenticación**

Crea un archivo `AuthService.java` con la siguiente configuración:
```java
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class AuthService {

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private UserDetailsService userDetailsService;

    public String login(String username, String password) {
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(username, password);
        Authentication authentication = authenticationManager.authenticate(authenticationToken);
        SecurityContextHolder.getContext().setAuthentication(authentication);
        UserDetails userDetails = userDetailsService.loadUserByUsername(username);
        String token = Jwts.builder()
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 86400000)) // 1 día
                .signWith(SignatureAlgorithm.HS512, "miClaveSecreta")
                .compact();
        return token;
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey("miClaveSecreta").parseClaimsJws(token);
            return true;
        } catch (JwtException e) {
            return false;
        }
    }
}
```

**Controlador de autenticación**

Crea un archivo `LoginController.java` con la siguiente configuración:
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

@RestController
public class LoginController {

    @Autowired
    private AuthService authService;

    @PostMapping("/login")
    public ResponseEntity<String> login(@Valid @RequestBody LoginRequest request) {
        String token = authService.login(request.getUsername(), request.getPassword());
        return ResponseEntity.ok(token);
    }
}
```

**Modelo de solicitud de login**

Crea un archivo `LoginRequest.java` con la siguiente configuración:
```java
import javax.validation.constraints.NotBlank;

public class LoginRequest {

    @NotBlank
    private String username;

    @NotBlank
    private String password;

    // getters y setters
}
```

**Uso del token**

Para utilizar el token, debes agregar un encabezado `Authorization` con el valor `Bearer <token>` en tus solicitudes. Por ejemplo:
```java
@GetMapping("/mascotas")
public ResponseEntity<List<Mascota>> getMascotas(@RequestHeader("Authorization") String token) {
    // ...
}
```

Recuerda que debes configurar la seguridad en tu aplicación para que solo permita solicitudes con un token válido.