Le modèle M.V.C. de Spring 1/2

package mybootapp.web;

import java.io.IOException;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

@Service("/hello")
public class HelloController implements Controller {

    protected final Log logger = LogFactory.getLog(getClass());

    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException, IOException {
        logger.info("Returning hello view");
        return new ModelAndView("hello");
    }

}

...
    String now = (new Date()).toString();
    return new ModelAndView("hello", "now", now);
...

package mybootapp.web;

import java.util.Date;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

@Controller()
@RequestMapping("/tests")
public class HelloAnnoController {

    protected final Log logger = LogFactory.getLog(getClass());

    @GetMapping("/welcome")
    public ModelAndView sayHello() {
        String now = (new Date()).toString();
        logger.info("Running " + this);
        return new ModelAndView("hello", "now", now);
    }

}

@GetMapping("/plus10")
public ModelAndView plus10(
        @RequestParam(value = "num", defaultValue = "100") Integer value) {
    logger.info("Running plus10 controler with param = " + value);
    return new ModelAndView("hello", "now", value + 10);
}

@GetMapping("/voir/{param}")
public ModelAndView voir(@PathVariable("param") Integer param) {
    logger.info("Running param controler with param=" + param);
    return new ModelAndView("hello", "now", param);
}

@Override
// Pour activer les variables matrix
public void configurePathMatch(PathMatchConfigurer configurer) {
    var urlPathHelper = new UrlPathHelper();
    // Nous gardons le contenu après le point virgule
    urlPathHelper.setRemoveSemicolonContent(false);
    configurer.setUrlPathHelper(urlPathHelper);
}

@GetMapping("/matrix/{param}")
@ResponseBody
public String testMatrix(//
        @PathVariable("param") String param, //
        @MatrixVariable(name = "a", defaultValue = "A") String a, //
        @MatrixVariable(name = "b", defaultValue = "1") Integer b//
) {
    return String.format("param=%s, a=%s, b=%d", param, a, b);
}

package mybootapp.model;

import jakarta.persistence.Basic;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

import lombok.Data;

@Entity
@Data
public class Product {

    @Id
    @GeneratedValue
    private Long number;

    @Basic
    private String name;

    @Basic
    private Double price;

    @Basic
    private String description;

    @Basic
    private String type;

}

package mybootapp.repo;

import org.springframework.data.jpa.repository.JpaRepository;

import mybootapp.model.Product;

public interface ProductRepository extends JpaRepository<Product, Long> {

}

package mybootapp.web;

import java.util.Collection;

import jakarta.annotation.PostConstruct;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import mybootapp.model.Product;
import mybootapp.repo.ProductRepository;

@Controller
@RequestMapping("/product")
public class ProductController {

    @Autowired
    ProductRepository repo;

    protected final Log logger = LogFactory.getLog(getClass());

    @PostConstruct
    public void init() {
        Product p1 = new Product();
        p1.setName("Car");
        p1.setPrice(2000.0);
        p1.setDescription("Small car");
        p1.setType("x");
        Product p2 = new Product();
        p2.setName("Gift");
        p2.setPrice(100.0);
        p2.setDescription("Big gift");
        p2.setType("x");
        repo.save(p1);
        repo.save(p2);
    }

    @GetMapping("/list")
    public ModelAndView listProducts() {
        logger.info("List of products");
        Collection<Product> products = repo.findAll();
        return new ModelAndView("productsList", "products", products);
    }

}

@ModelAttribute("products")
Collection<Product> products() {
    logger.info("Making list of products");
    return repo.findAll();
}

@GetMapping("/list")
public String listProducts() {
    logger.info("List of products");
    return "productsList";
}

@GetMapping("/edit")
public String editProduct(@ModelAttribute Product p) {
    return "productForm";
}

@ModelAttribute
public Product newProduct(
    @RequestParam(value = "id", required = false) Long productNumber)
{
    if (productNumber != null) {
        logger.info("find product " + productNumber);
        var p = repo.findById(productNumber);
        return p.get();
    }
    Product p = new Product();
    p.setNumber(null);
    p.setName("");
    p.setPrice(0.0);
    p.setDescription("");
    logger.info("new product = " + p);
    return p;
}

@PostMapping("/edit")
public String saveProduct(@ModelAttribute Product p, BindingResult result) {
    if (result.hasErrors()) {
        return "productForm";
    }
    repo.save(p);
    return "productsList";
}

@ModelAttribute("productTypes")
public Map<String, String> productTypes() {
    Map<String, String> types = new LinkedHashMap<>();
    types.put("type1", "Type 1");
    types.put("type2", "Type 2");
    types.put("type3", "Type 3");
    types.put("type4", "Type 4");
    types.put("type5", "Type 5");
    return types;
}

package mybootapp.web;

import org.springframework.stereotype.Service;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

import mybootapp.model.Product;

@Service
public class ProductValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return Product.class.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        Product product = (Product) target;

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name",
                "product.name", "Field name is required.");

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description",
                "product.description", "Field description is required.");

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "type",
                "product.type", "Field type is required.");

        if (!(product.getPrice() > 0.0)) {
            errors.rejectValue("price", "product.price.too.low",
                    "Price too low");
        }
    }

}

@Autowired
ProductValidator validator;

@PostMapping("/edit")
public String saveProduct(@ModelAttribute Product p, BindingResult result) {
    validator.validate(p, result);
    if (result.hasErrors()) {
        return "productForm";
    }
    repo.save(p);
    return "redirect:list";
}

@Bean("messageSource")
public MessageSource messageSource() {
    var r = new ReloadableResourceBundleMessageSource();
    r.setBasenames("classpath:product", "classpath:messages");
    return r;
}

package mybootapp.web;

import org.springframework.stereotype.Service;
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

import mybootapp.model.Product;

@Service
public class ProductValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
        return Product.class.isAssignableFrom(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
        Product product = (Product) target;

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name",
                "product.name");

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "description",
                "product.description");

        ValidationUtils.rejectIfEmptyOrWhitespace(errors, "type",
                "product.type");

        if (!(product.getPrice() > 0.0)) {
            errors.rejectValue("price", "product.price.too.low");
        }
    }

}

package mybootapp.model;

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Embeddable
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProductCode {

    @Column(name = "code_base")
    String base;

    @Column(name = "code_number")
    int number;

}

...

@Entity
@Data
public class Product {

    ...
    
    @Embedded
    private ProductCode code;

    ...

}

package mybootapp.web;

import java.beans.PropertyEditorSupport;

import mybootapp.model.ProductCode;

class ProductCodeEditor extends PropertyEditorSupport {

    @Override
    public String getAsText() {
        Object o = this.getValue();
        if (o instanceof ProductCode) {
            ProductCode c = (ProductCode) o;
            return c.getBase() + "" + c.getNumber();
        }
        return super.getAsText();
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        try {
            String base = text.substring(0, 1);
            int number = Integer.parseInt(text.substring(1));
            ProductCode c = new ProductCode(base, number);
            super.setValue(c);
        } catch (Exception e) {
            throw new IllegalArgumentException("Bad code format");
        }
    }

}

@InitBinder
public void initBinder(WebDataBinder b) {
    b.registerCustomEditor(ProductCode.class, new ProductCodeEditor());
}

package mybootapp.model;

import jakarta.persistence.Basic;
import jakarta.persistence.Embedded;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

import jakarta.validation.Valid;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

import lombok.Data;

@Entity
@Data
public class Product {

    @Id
    @GeneratedValue
    private Long number;

    @NotEmpty
    @Size(min = 1, message = "Le nom est obligatoire")
    @Basic
    private String name;

    @NotNull
    @Min(value = 1, message = "Le prix est trop bas")
    @Basic
    private Double price;

    @NotEmpty(message = "La description est obligatoire")
    @Size(min = 1, max = 100, message = "Entre 1 et 200 caractères")
    @Basic
    private String description;

    @NotEmpty
    @Size(min = 1, message = "Le type doit être renseigné")
    @Basic
    private String type;

    @Valid
    @Embedded
    private ProductCode code;

}

package mybootapp.model;

import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Pattern;
import jakarta.validation.constraints.Size;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Embeddable
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ProductCode {

    @NotNull
    @Size(min = 1, max = 1)
    @Pattern(regexp = "[A-Z]", message = "Le code doit débuter par une majuscule")
    @Column(name = "code_base")
    String base;

    @Min(value = 1000, message = "Le numéro doit être >= à 1000")
    @Max(value = 9999, message = "Le numéro doit être <= à 9999")
    @Column(name = "code_number")
    int number;

}

...

@PostMapping("/edit")
public String saveProduct(@ModelAttribute @Valid Product p, BindingResult result) {
    validator.validate(p, result);
    if (result.hasErrors()) {
        return "productForm";
    }
    repo.save(p);
    return "redirect:list";
}

...

@Override
public LocalValidatorFactoryBean getValidator() {
    var factory = new LocalValidatorFactoryBean();
    factory.setValidationMessageSource(messageSource());
    return factory;
}

...

public class Product {

    ...

    @NotEmpty
    @Size(min = 1, message="{product.name}")
    // avant @Size(min = 1, message = "Le nom est obligatoire")
    @Basic
    private String name;

    ...

}

package mybootapp.web;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import jakarta.validation.Constraint;
import jakarta.validation.Payload;

@Target({ ElementType.METHOD, ElementType.FIELD, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ByeConstraintValidator.class)
@Documented
public @interface Bye {

    String message() default "Il manque le 'bye'";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

package mybootapp.web;

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

public class ByeConstraintValidator implements ConstraintValidator<Bye, String> {

    @Override
    public void initialize(Bye arg0) {
    }

    @Override
    public boolean isValid(String arg0, ConstraintValidatorContext arg1) {
        if (arg0.contains("bye"))
            return true;
        return false;
    }

}

public class Product {

    ...

    @NotEmpty(message = "La description est obligatoire")
    @Size(min = 1, max = 100, message = "Entre 1 et 200 caractères")
    @Bye
    @Basic
    private String description;

    ...

}