La location longue durée (LLD) de véhicules est devenue une option de plus en plus populaire pour les particuliers et les entreprises. Cependant, obtenir un devis d’assurance fiable pour ce type de contrat peut s’avérer complexe. Les spécificités de la LLD, telles que la durée du contrat et les responsabilités partagées entre le locataire et le loueur, influencent grandement le calcul des primes. Il est donc crucial de comprendre les éléments qui entrent en jeu dans l’élaboration d’un devis précis et les méthodes utilisées par les assureurs pour évaluer les risques propres à la LLD.
Composantes d’un devis d’assurance LLD fiable
Un devis d’assurance LLD fiable doit prendre en compte plusieurs éléments clés pour refléter avec précision le risque assuré. Parmi ces composantes essentielles, on trouve la valeur du véhicule, la durée du contrat de location, le kilométrage prévu, ainsi que le profil du conducteur. Ces facteurs permettent à l’assureur d’évaluer le risque potentiel et de calculer une prime adaptée.
La valeur du véhicule est particulièrement importante car elle détermine le montant maximal que l’assureur pourrait avoir à débourser en cas de sinistre total. Dans le cadre d’une LLD, cette valeur peut être différente de celle d’un véhicule acheté, car elle tient compte de la dépréciation prévue sur la durée du contrat.
La durée du contrat influence également le calcul du risque. Plus la période de location est longue, plus le risque d’accident ou de dommage augmente statistiquement. Les assureurs ajustent donc leurs tarifs en conséquence, ce qui peut se traduire par des primes plus élevées pour les contrats de longue durée.
Le kilométrage prévu est un autre facteur crucial. Un véhicule qui parcourt de grandes distances est plus susceptible d’être impliqué dans un accident ou de subir une usure mécanique. Les devis d’assurance LLD intègrent donc cette donnée pour affiner leur évaluation du risque.
Facteurs influençant la précision des devis LLD
Kilométrage annuel et durée du contrat
Le kilométrage annuel et la durée du contrat sont deux variables interdépendantes qui jouent un rôle majeur dans la précision des devis d’assurance LLD. Un contrat de longue durée avec un kilométrage annuel élevé présente un profil de risque différent d’un contrat court avec un faible kilométrage. Les assureurs utilisent des modèles statistiques sophistiqués pour analyser ces données et ajuster leurs tarifs en conséquence.
Par exemple, un conducteur qui opte pour une LLD de 36 mois avec un kilométrage annuel de 30 000 km pourra se voir proposer un devis différent de celui qui choisit une location de 24 mois pour 15 000 km par an. L’assureur prend en compte l’exposition accrue au risque liée à une utilisation plus intensive du véhicule sur une période plus longue.
Modèle et valeur résiduelle du véhicule
Le modèle du véhicule et sa valeur résiduelle estimée à la fin du contrat LLD sont des éléments déterminants pour obtenir un devis fiable. Certains modèles sont statistiquement plus sujets aux accidents ou au vol, ce qui impacte directement le calcul de la prime d’assurance. De même, la valeur résiduelle influence le montant que l’assureur devra potentiellement rembourser en cas de perte totale du véhicule.
Les assureurs disposent de bases de données détaillées sur les différents modèles de véhicules, leurs taux de sinistralité et leurs courbes de dépréciation. Ces informations leur permettent d’affiner leurs devis et de proposer des tarifs qui reflètent au mieux le risque réel associé à chaque modèle en LLD.
Profil du conducteur et historique de sinistres
Le profil du conducteur principal et son historique de sinistres sont des facteurs cruciaux dans l’élaboration d’un devis d’assurance LLD fiable. L’âge, l’expérience de conduite, le lieu de résidence et l’utilisation prévue du véhicule (personnelle ou professionnelle) sont autant d’éléments pris en compte par les assureurs.
Un conducteur expérimenté avec un historique vierge de sinistres bénéficiera généralement de tarifs plus avantageux qu’un jeune conducteur ou une personne ayant été impliquée dans plusieurs accidents. Les assureurs considèrent ces informations comme des indicateurs fiables du risque futur et ajustent leurs devis en conséquence.
Options et services inclus dans le contrat
Les options et services inclus dans le contrat LLD peuvent significativement influencer le devis d’assurance. Des éléments tels que l’assistance routière, la mise à disposition d’un véhicule de remplacement ou la couverture des accessoires ajoutés au véhicule doivent être pris en compte dans le calcul de la prime.
Ces services supplémentaires peuvent augmenter le coût de l’assurance, mais ils offrent également une protection plus complète au locataire. Un devis fiable doit clairement détailler ces options et leur impact sur le tarif final, permettant ainsi au client de faire un choix éclairé en fonction de ses besoins et de son budget.
Méthodologies de calcul des assureurs pour les devis LLD
Algorithmes de tarification dynamique
Les assureurs modernes utilisent des algorithmes de tarification dynamique pour générer des devis LLD précis et compétitifs. Ces systèmes complexes intègrent en temps réel une multitude de variables pour ajuster les tarifs. Ils prennent en compte non seulement les caractéristiques du véhicule et du conducteur, mais aussi des facteurs externes tels que les conditions de circulation locales ou les tendances du marché de l’assurance.
L’utilisation de big data et d’intelligence artificielle permet aux assureurs d’affiner constamment leurs modèles de tarification. Par exemple, certains algorithmes peuvent analyser les habitudes de conduite grâce à des dispositifs télématiques, offrant ainsi des devis plus personnalisés et potentiellement plus avantageux pour les conducteurs prudents.
Analyse actuarielle des risques spécifiques à la LLD
L’analyse actuarielle joue un rôle central dans l’élaboration de devis fiables pour l’assurance LLD. Les actuaires développent des modèles statistiques sophistiqués qui évaluent les risques spécifiques associés à ce type de contrat. Ces modèles prennent en compte des facteurs tels que la fréquence et la gravité des sinistres pour les véhicules en LLD, ainsi que les particularités contractuelles qui peuvent influencer le comportement des locataires.
Par exemple, les actuaires peuvent étudier si les conducteurs en LLD ont tendance à être plus ou moins prudents que les propriétaires de véhicules. Ils analysent également l’impact de la durée du contrat sur le risque d’accident ou de dommage. Ces analyses permettent d’ajuster les primes avec précision, reflétant ainsi le risque réel associé à chaque contrat LLD.
Intégration des données du marché de l’occasion
Les assureurs intègrent de plus en plus les données du marché de l’occasion dans leurs calculs de devis LLD. La valeur résiduelle du véhicule à la fin du contrat est un élément crucial pour déterminer le montant potentiel d’indemnisation en cas de perte totale. Les fluctuations du marché de l’occasion peuvent donc avoir un impact significatif sur les primes d’assurance.
Les assureurs utilisent des outils de prévision sophistiqués pour anticiper l’évolution de la valeur des véhicules sur le marché de l’occasion. Ces prévisions tiennent compte de facteurs tels que la popularité des modèles, les évolutions technologiques ou les changements réglementaires qui pourraient affecter la valeur future des véhicules. L’intégration de ces données permet d’obtenir des devis plus précis et mieux adaptés à la réalité économique du marché automobile.
Comparaison des devis LLD entre assureurs majeurs
Critères d’évaluation de la fiabilité des devis ALD automotive
ALD Automotive, l’un des leaders du marché de la LLD, propose des devis d’assurance qui se distinguent par leur approche globale. Pour évaluer la fiabilité de ces devis, il est essentiel de considérer plusieurs critères clés. Tout d’abord, la transparence des informations fournies : un devis fiable doit clairement détailler les garanties incluses, les franchises applicables et les exclusions éventuelles.
Ensuite, la cohérence des tarifs proposés par rapport au profil du conducteur et aux caractéristiques du véhicule est un indicateur important de fiabilité. ALD Automotive utilise des algorithmes avancés qui prennent en compte une multitude de facteurs pour ajuster ses tarifs, ce qui se traduit généralement par des devis bien calibrés.
Particularités des offres arval et LeasePlan
Arval et LeasePlan, deux autres acteurs majeurs du secteur, présentent des particularités dans leurs offres d’assurance LLD qui méritent attention. Arval, par exemple, met l’accent sur des solutions d’assurance personnalisables, permettant aux clients de choisir précisément les garanties dont ils ont besoin. Cette approche modulaire peut conduire à des devis plus précis, reflétant mieux les besoins spécifiques de chaque client.
LeasePlan, quant à lui, se distingue par son approche axée sur la gestion des risques. Leurs devis intègrent souvent des services de prévention et de formation à la conduite, ce qui peut influencer positivement le calcul des primes. La fiabilité de ces devis repose en partie sur la capacité de LeasePlan à évaluer l’impact de ces services sur la réduction des risques.
Transparence des calculs chez alphabet et athlon car lease
La transparence dans le calcul des devis est un facteur crucial de fiabilité, et à cet égard, Alphabet et Athlon Car Lease se démarquent. Alphabet, filiale de BMW Group, propose des devis détaillés qui expliquent clairement comment chaque élément du contrat LLD influence le coût de l’assurance. Cette approche permet aux clients de comprendre précisément ce pour quoi ils paient.
Athlon Car Lease va encore plus loin en offrant des outils de simulation en ligne qui permettent aux clients de voir en temps réel comment les modifications de certains paramètres (durée du contrat, kilométrage, options) affectent le devis d’assurance. Cette interactivité renforce la confiance dans la fiabilité des calculs proposés.
La transparence et la personnalisation sont devenues des éléments clés dans l’élaboration de devis d’assurance LLD fiables. Les assureurs qui parviennent à combiner ces aspects avec des modèles de tarification sophistiqués sont ceux qui proposent les devis les plus précis et adaptés.
Outils en ligne pour obtenir des devis LLD précis
Simulateurs des constructeurs automobiles (renault, peugeot, BMW)
Les constructeurs automobiles proposent de plus en plus leurs propres simulateurs en ligne pour obtenir des devis LLD, y compris pour l’assurance. Ces outils, développés par des marques comme Renault, Peugeot ou BMW, offrent l’avantage d’être directement intégrés à leurs offres de véhicules, permettant ainsi une estimation plus précise des coûts totaux de la LLD.
Par exemple, le simulateur de Renault permet de configurer le véhicule souhaité, de choisir la durée du contrat et le kilométrage, puis d’ajouter les options d’assurance. L’outil calcule instantanément un devis qui prend en compte les spécificités du modèle choisi et les statistiques de sinistralité propres à la marque. Cette approche intégrée peut conduire à des devis plus fiables, car elle s’appuie sur des données précises concernant les véhicules proposés.
Plateformes de comparaison spécialisées en LLD
Les plateformes de comparaison spécialisées en LLD sont devenues des outils incontournables pour obtenir des devis précis et comparer les offres de différents assureurs. Ces sites agrègent les propositions de multiples compagnies d’assurance et de loueurs, permettant aux utilisateurs de comparer facilement les tarifs et les garanties.
L’avantage de ces plateformes réside dans leur capacité à standardiser les informations, facilitant ainsi la comparaison entre les différentes offres. Elles utilisent souvent des algorithmes sophistiqués qui prennent en compte une multitude de facteurs pour générer des devis personnalisés. Certaines plateformes vont même jusqu’à intégrer des avis d’utilisateurs et des notes de satisfaction , ajoutant une dimension qualitative à la comparaison purement chiffrée.
Applications mobiles d’estimation LLD en temps réel
L’essor des applications mobiles a également touché le secteur de l’assurance LLD, avec l’apparition d’outils d’estimation en temps réel. Ces applications permettent aux utilisateurs d’obtenir des devis rapides et précis directement depuis leur smartphone, en scannant par exemple le code-barres d’un véhicule ou en utilisant la géolocalisation pour ajuster les tarifs en fonction de la zone de circulation.
L’un des avantages majeurs de ces applications est leur capacité à intégrer des données en temps réel, comme les conditions de circulation ou les statistiques de sinistralité locales. Certaines applications utilisent même la technologie de réalité augmentée pour permettre aux utilisateurs de visualiser virtuellement le véhicule et ses options, améliorant ainsi la précision du devis en fonction des équipements choisis.
L’évolution rapide des technologies digitales offre de nouvelles opportunités pour obtenir des devis d’assurance LLD toujours plus précis et personnalisés. La combinaison de données en temps réel, d’intelligence artificielle et d’interfaces utilisateur intuitives permet aux consommateurs d’accéder à des estim
ations précises directement depuis leur smartphone ou leur tablette.
Législation et normes encadrant les devis d’assurance LLD
Directive européenne sur la distribution d’assurances (DDA)
La Directive sur la Distribution d’Assurances (DDA), entrée en vigueur en 2018, a eu un impact significatif sur la façon dont les devis d’assurance LLD sont élaborés et présentés. Cette directive vise à renforcer la protection des consommateurs et à harmoniser les pratiques de distribution d’assurance au sein de l’Union européenne.
Pour les devis d’assurance LLD, la DDA impose une plus grande transparence sur les produits proposés. Les assureurs doivent désormais fournir un document d’information standardisé sur le produit d’assurance (IPID) qui résume clairement les garanties, exclusions et obligations du contrat. Cette exigence contribue à rendre les devis plus fiables et comparables entre différents assureurs.
Obligations de transparence imposées par l’ACPR
L’Autorité de Contrôle Prudentiel et de Résolution (ACPR) en France joue un rôle crucial dans la régulation des pratiques des assureurs, y compris pour les devis d’assurance LLD. L’ACPR impose des obligations strictes en matière de transparence et de clarté des informations fournies aux clients.
Par exemple, les assureurs doivent détailler clairement dans leurs devis les frais et commissions inclus dans le prix proposé. Ils doivent également expliquer de manière compréhensible les critères utilisés pour calculer la prime d’assurance. Ces exigences de l’ACPR contribuent à renforcer la fiabilité des devis en garantissant que toutes les informations pertinentes sont communiquées au client de manière transparente.
Normes WLTP et impact sur les devis LLD
L’introduction des normes WLTP (Worldwide Harmonized Light Vehicles Test Procedure) a eu un impact non négligeable sur les devis d’assurance LLD. Ces nouvelles normes, qui visent à mesurer de manière plus réaliste les émissions de CO2 et la consommation de carburant des véhicules, ont entraîné des changements dans la classification fiscale de nombreux modèles.
Pour les assureurs, cela signifie une nécessité d’ajuster leurs modèles de tarification pour prendre en compte ces nouvelles données. Les devis d’assurance LLD doivent désormais refléter avec précision l’impact des normes WLTP sur le coût total de possession du véhicule, y compris les potentielles variations de taxes et de primes d’assurance liées aux nouvelles mesures d’émissions.
L’évolution constante de la réglementation et des normes techniques dans le secteur automobile souligne l’importance pour les assureurs de maintenir des systèmes de tarification dynamiques et adaptables. Seule une mise à jour régulière de ces systèmes peut garantir la production de devis d’assurance LLD fiables et conformes aux dernières exigences légales et techniques.
# .gitignore# Ignore Gradle project-specific cache directory.gradle# Ignore Gradle build output directorybuild# Ignore IntelliJ files.idea# Ignore Git files.git.gitignore# Ignore Git Hooks.husky.env.env*binEnd File# husky.sh#!/usr/bin/env shif [ -z « $husky_skip_init » ]; then debug () { if [ « $HUSKY_DEBUG » = « 1 » ]; then echo « husky (debug) – $1 » fi } readonly hook_name= »$(basename — « $0″) » debug « starting $hook_name… » if [ « $HUSKY » = « 0 » ]; then debug « HUSKY env variable is set to 0, skipping hook » exit 0 fi if [ -f ~/.huskyrc ]; then debug « sourcing ~/.huskyrc » . ~/.huskyrc fi readonly husky_skip_init=1 export husky_skip_init sh -e « $0 » « $@ » exitCode= »$? » if [ $exitCode != 0 ]; then echo « husky – $hook_name hook exited with code $exitCode (error) » fi if [ $exitCode = 127 ]; then echo « husky – command not found in PATH=$PATH » fi exit $exitCodefiEnd File# src/main/java/com/backend/api/utils/Tokens.javapackage com.backend.api.utils;import com.backend.api.entity.User;import com.backend.api.response.TokenPair;import io.jsonwebtoken.Claims;import io.jsonwebtoken.Jwts;import io.jsonwebtoken.SignatureAlgorithm;import io.jsonwebtoken.security.Keys;import javax.crypto.SecretKey;import java.nio.charset.StandardCharsets;import java.security.Key;import java.util.Date;public class Tokens { private static final String ACCESS_SECRET_KEY = System.getenv(« ACCESS_SECRET_KEY »); private static final String REFRESH_SECRET_KEY = System.getenv(« REFRESH_SECRET_KEY »); private static final long ACCESS_EXPIRATION_TIME = 15 * 60 * 1000; // 15 minutes private static final long REFRESH_EXPIRATION_TIME = 7 * 24 * 60 * 60 * 1000; // 7 days public static TokenPair generateTokenPair(User user) { String accessToken = generateAccessToken(user); String refreshToken = generateRefreshToken(user); return new TokenPair(accessToken, refreshToken); } private static String generateAccessToken(User user) { return Jwts.builder() .setSubject(user.getEmail()) .claim(« id », user.getId()) .claim(« roles », user.getRoles()) .setIssuedAt(new Date()) .setExpiration(new Date(System.currentTimeMillis() + ACCESS_EXPIRATION_TIME)) .signWith(getSigningKey(ACCESS_SECRET_KEY), SignatureAlgorithm.HS256) .compact(); } private static String generateRefreshToken(User user) { return Jwts.builder() .setSubject(user.getEmail()) .claim(« id », user.getId()) .setIssuedAt(new Date()) .setExpiration(new Date(System.currentTimeMillis() + REFRESH_EXPIRATION_TIME)) .signWith(getSigningKey(REFRESH_SECRET_KEY), SignatureAlgorithm.HS256) .compact(); } public static Claims validateAccessToken(String token) { return validateToken(token, ACCESS_SECRET_KEY); } public static Claims validateRefreshToken(String token) { return validateToken(token, REFRESH_SECRET_KEY); } private static Claims validateToken(String token, String secretKey) { return Jwts.parserBuilder() .setSigningKey(getSigningKey(secretKey)) .build() .parseClaimsJws(token) .getBody(); } private static Key getSigningKey(String secretKey) { byte[] keyBytes = secretKey.getBytes(StandardCharsets.UTF_8); return Keys.hmacShaKeyFor(keyBytes); } public static boolean isTokenExpired(String token) { try { Claims claims = validateAccessToken(token); return claims.getExpiration().before(new Date()); } catch (Exception e) { return true; } }}End Filepackage com.backend.api.entity;import com.backend.api.enums.Role;import jakarta.persistence.*;import lombok.Data;import java.util.Set;@Data@Entity@Table(name = « users »)public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String email; @Column(nullable = false) private String password; @ElementCollection(fetch = FetchType.EAGER) @CollectionTable(name = « user_roles », joinColumns = @JoinColumn(name = « user_id »)) @Column(name = « role ») @Enumerated(EnumType.STRING) private Set roles; private String resetPasswordToken;}End File# src/main/java/com/backend/api/services/UserService.javapackage com.backend.api.services;import com.backend.api.dto.RegisterRequest;import com.backend.api.entity.User;import com.backend.api.enums.Role;import com.backend.api.exception.AppException;import com.backend.api.repository.UserRepository;import lombok.RequiredArgsConstructor;import org.springframework.http.HttpStatus;import org.springframework.security.crypto.password.PasswordEncoder;import org.springframework.stereotype.Service;import java.util.Collections;import java.util.Optional;@Service@RequiredArgsConstructorpublic class UserService { private final UserRepository userRepository; private final PasswordEncoder passwordEncoder; public User registerUser(RegisterRequest request) { if (userRepository.findByEmail(request.getEmail()).isPresent()) { throw new AppException(« User already exists with this email », HttpStatus.BAD_REQUEST); } User user = new User(); user.setEmail(request.getEmail()); user.setPassword(passwordEncoder.encode(request.getPassword())); user.setRoles(Collections.singleton(Role.USER)); return userRepository.save(user); } public Optional findByEmail(String email) { return userRepository.findByEmail(email); } public Optional findByResetPasswordToken(String token) { return userRepository.findByResetPasswordToken(token); } public void updateResetPasswordToken(String token, String email) { User user = userRepository.findByEmail(email) .orElseThrow(() -> new AppException(« User not found », HttpStatus.NOT_FOUND)); user.setResetPasswordToken(token); userRepository.save(user); } public void updatePassword(User user, String newPassword) { user.setPassword(passwordEncoder.encode(newPassword)); user.setResetPasswordToken(null); userRepository.save(user); }}End Filepackage com.backend.api.controller;import com.backend.api.dto.LoginRequest;import com.backend.api.dto.RegisterRequest;import com.backend.api.dto.ResetPasswordRequest;import com.backend.api.entity.User;import com.backend.api.exception.AppException;import com.backend.api.response.AuthResponse;import com.backend.api.response.TokenPair;import com.backend.api.services.UserService;import com.backend.api.utils.Tokens;import io.jsonwebtoken.Claims;import jakarta.servlet.http.HttpServletRequest;import lombok.RequiredArgsConstructor;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.security.crypto.password.PasswordEncoder;import org.springframework.web.bind.annotation.*;import java.util.UUID;@RestController@RequestMapping(« /api/auth »)@RequiredArgsConstructorpublic class AuthController { private final UserService userService; private final AuthenticationManager authenticationManager; private final PasswordEncoder passwordEncoder; @PostMapping(« /register ») public ResponseEntity registerUser(@RequestBody RegisterRequest request) { User user = userService.registerUser(request); return ResponseEntity.ok(new AuthResponse(« User registered successfully »)); } @PostMapping(« /login ») public ResponseEntity authenticateUser(@RequestBody LoginRequest loginRequest) { Authentication authentication = authenticationManager.authenticate( new UsernamePasswordAuthenticationToken( loginRequest.getEmail(), loginRequest.getPassword() ) ); SecurityContextHolder.getContext().setAuthentication(authentication); User user = userService.findByEmail(loginRequest.getEmail()) .orElseThrow(() -> new AppException(« User not found », HttpStatus.NOT_FOUND)); TokenPair tokenPair = Tokens.generateTokenPair(user); return ResponseEntity.ok(tokenPair); } @PostMapping(« /refresh ») public ResponseEntity refreshToken(HttpServletRequest request) { String refreshToken = extractTokenFromRequest(request); if (refreshToken == null) { return ResponseEntity.badRequest().body(« Refresh token is required »); } try { Claims claims = Tokens.validateRefreshToken(refreshToken); String userEmail = claims.getSubject(); User user = userService.findByEmail(userEmail) .orElseThrow(() -> new AppException(« User not found », HttpStatus.NOT_FOUND)); TokenPair newTokenPair = Tokens.generateTokenPair(user); return ResponseEntity.ok(newTokenPair); } catch (Exception e) { return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(« Invalid refresh token »); } } private String extractTokenFromRequest(HttpServletRequest request) { String bearerToken = request.getHeader(« Authorization »); if (bearerToken != null && bearerToken.startsWith(« Bearer « )) { return bearerToken.substring(7); } return null; } @PostMapping(« /forgot-password ») public ResponseEntity forgotPassword(@RequestParam(« email ») String email) { User user = userService.findByEmail(email) .orElseThrow(() -> new AppException(« User not found », HttpStatus.NOT_FOUND)); String token = UUID.randomUUID().toString(); userService.updateResetPasswordToken(token, email); // Here you would typically send an email with the reset link // For this example, we’ll just return the token return ResponseEntity.ok(« Reset password token: » + token); } @PostMapping(« /reset-password ») public ResponseEntity resetPassword(@RequestBody ResetPasswordRequest request) { User user = userService.findByResetPasswordToken(request.getToken()) .orElseThrow(() -> new AppException(« Invalid token », HttpStatus.BAD_REQUEST)); userService.updatePassword(user, request.getNewPassword()); return ResponseEntity.ok(« Password has been reset successfully »); }}End Filepackage com.backend.api.security;import com.backend.api.security.AuthTokenFilter;import lombok.RequiredArgsConstructor;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.configuration.AuthenticationConfiguration;import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;import org.springframework.security.config.annotation.web.builders.HttpSecurity;import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;import org.springframework.security.config.http.SessionCreationPolicy;import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;