Java: utilizar el valor de una property en una clase.

En .yml:

application.yml
sirec:
    kill-list-enabled: ${KILL_LIST_ENABLED:false}

O en .properties:

application.properties
sirec.kill-list-enabled: ${KILL_LIST_ENABLED:false}

Y en Java:

ApiTareasService.java
@Value("#{new Boolean('${sirec.kill-list-enabled:false}')}")
private Boolean killListEnabled;

if (killListEnabled) {
    ...
}

Java: sumar días o meses a una fecha en formato String

public static final String FECHA_FORMATO_ENTRADA = "yyyy-MM-dd HH:mm:ss.S";
public static final String FECHA_FORMATO_SALIDA = "dd/MM/yyyy";

SimpleDateFormat formatIn = new SimpleDateFormat(Constants.FECHA_FORMATO_ENTRADA);
SimpleDateFormat formatOut = new SimpleDateFormat(Constants.FECHA_FORMATO_SALIDA);

String tmpFecha = null;

try {
    Date dateSel = formatIn.parse(valoracionesBienInner.getFecha());
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(dateSel);
    calendar.add(Calendar.MONTH, Integer.valueOf(valoracionesBienInner.getPeriodoValidez()));
    Date salida = calendar.getTime();

    tmpFecha = formatOut.format(salida);

} catch (ParseException e) {
    throw new SirecApplicationException(0, "Error parseo fecha validez en valoraciones", e);
}

aElementoListaValoraciones.setFechaValidez(getNullHandlingValue(tmpFecha));

public static String getNullHandlingValue(String valor) {
    return valor == null ? "" : valor;
}

Java RestCall (TODO)

 // Requires:
//<!-- https://mvnrepository.com/artifact/net.minidev/json-smart -->
//<dependency>
//    <groupId>net.minidev</groupId>
//    <artifactId>json-smart</artifactId>
//    <version>2.4.7</version>
//</dependency>

package com.thymewizards.util;

import java.util.Map;
import net.minidev.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.HttpStatusCodeException;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;

public class RestCall {
    private static final Logger logger = LoggerFactory.getLogger(RestCall.class);
    private RestTemplate restTemplate = new RestTemplate();

    public ResponseEntity<Object> executePOST(String url, HttpHeaders header, Map<String, String> urlParams, MultiValueMap<String, String> queryParams, Object obj) throws Exception {
        ResponseEntity<Object> resp = null;
        UriComponents builder = null;
        try {
            if (obj != null) {
                logger.info(String.format("{Body} : %s", obj.toString()));
            }
            builder = UriComponentsBuilder.fromHttpUrl(url).buildAndExpand(urlParams);
            if (queryParams != null) {
                builder = UriComponentsBuilder.fromUriString(url).queryParams(queryParams).buildAndExpand(urlParams);
            }
            HttpEntity<Object> httpEntity = new HttpEntity(obj, header);
            logger.info(String.format("{Header} : %s", httpEntity.getHeaders()));
            logger.info(String.format("Accediendo a la URL %s via POST", builder.toUriString()));
            resp = this.restTemplate.postForEntity(builder.toUriString(), httpEntity, Object.class, new Object[1]);
            if (resp != null) {
                logger.info(String.format("{Response} : %s", resp));
            }
            logger.info("OK.!");
        } catch (HttpStatusCodeException var9) {
            logger.error("KO.! Error!!", var9);
            throw var9;
        } catch (Exception var10) {
            logger.error(String.format("Accediendo a la URL {%s} via POST KO.! Error!!", url), var10);
            throw new Exception(var10);
            return resp;
        }
    }

    public ResponseEntity<Object> executePUT(String url, HttpHeaders header, Map<String, String> urlParams, MultiValueMap<String, String> queryParams, Object obj) throws Exception {
        ResponseEntity<Object> resp = null;
        UriComponents builder = null;
        try {
            if (obj != null) {
                logger.info(String.format("{Body} : %s", obj.toString()));
            }
            builder = UriComponentsBuilder.fromHttpUrl(url).buildAndExpand(urlParams);
            if (queryParams != null) {
                builder = UriComponentsBuilder.fromUriString(url).queryParams(queryParams).buildAndExpand(urlParams);
            }
            HttpEntity<Object> httpEntity = new HttpEntity(obj, header);
            logger.info(String.format("{Header} : %s", httpEntity.getHeaders()));
            logger.info(String.format("Accediendo a la URL %s via PUT", builder.toUriString()));
            resp = this.restTemplate.exchange(builder.toUriString(), HttpMethod.PUT, httpEntity, Object.class, new Object[0]);
            if (resp != null) {
                logger.info(String.format("{Response} : %s", resp));
            }
            logger.info("OK.!");
        } catch (HttpStatusCodeException var9) {
            logger.error("KO.! Error!!", var9);
            throw var9;
        } catch (Exception var10) {
            logger.error(String.format("Accediendo a la URL {%s} via PUT KO.! Error!!", builder), var10);
            throw new Exception(var10);
            return resp;
        }
    }

    public ResponseEntity<Object> executeDELETE(String url, HttpHeaders header, Map<String, String> urlParams, MultiValueMap<String, String> queryParams) throws Exception {
        ResponseEntity<Object> resp = null;
        UriComponents builder = null;
        try {
            builder = UriComponentsBuilder.fromHttpUrl(url).buildAndExpand(urlParams);
            if (queryParams != null) {
                builder = UriComponentsBuilder.fromUriString(url).queryParams(queryParams).buildAndExpand(urlParams);
            }
            HttpEntity<Object> httpEntity = new HttpEntity(header);
            logger.info(String.format("{Header} : %s", httpEntity.getHeaders()));
            logger.info(String.format("Accediendo a la URL %s via DELETE", builder.toUriString()));
            resp = this.restTemplate.exchange(builder.toUriString(), HttpMethod.DELETE, httpEntity, Object.class, new Object[0]);
            logger.info(String.format("{Response} : %s", resp));
            logger.info("OK.!");
        } catch (HttpStatusCodeException var8) {
            logger.error("KO.! Error!!", var8);
            throw var8;
        } catch (Exception var9) {
            logger.error(String.format("Accediendo a la URL {%s} via DELETE KO.! Error!!", url), var9);
            throw new Exception(var9);
            return resp;
        }
    }

    public ResponseEntity<Object> executeGET(String url, HttpHeaders header, Map<String, String> urlParams, MultiValueMap<String, String> queryParams, Object obj) throws Exception {
        ResponseEntity<Object> resp = null;
        UriComponents builder = null;
        try {
            if (obj != null) {
                logger.info(String.format("{Body} : %s", obj.toString()));
            }
            builder = UriComponentsBuilder.fromHttpUrl(url).buildAndExpand(urlParams);
            if (queryParams != null) {
                builder = UriComponentsBuilder.fromUriString(url).queryParams(queryParams).buildAndExpand(urlParams);
            }
            HttpEntity<Object> httpEntity = new HttpEntity(obj, header);
            logger.info(String.format("{Header} : %s", header));
            logger.info(String.format("Accediendo a la URL %s via GET", builder.toUriString()));
            resp = this.restTemplate.exchange(builder.toUriString(), HttpMethod.GET, httpEntity, Object.class, new Object[0]);
            if (resp != null) {
                logger.info(String.format("{Response} : %s", resp));
            }
            logger.info("OK.!");
        } catch (HttpStatusCodeException var9) {
            logger.error("KO.! Error!!", var9);
            throw var9;
        } catch (Exception var10) {
            logger.error(String.format("Accediendo a la URL {%s} via GET KO.! Error!!", url), var10);
            throw new Exception(var10);
            return resp;
        }
    }

    public Object rest2Object(ResponseEntity<Object> resp, Object obj) throws Exception {
        if (obj == null) {
            throw new Exception(String.format("Error el objecto <%s> es nulo", obj));
        } else {
            try {
                if (!resp.getStatusCode().equals(HttpStatus.OK) && !resp.getStatusCode().equals(HttpStatus.CREATED)) {
                } else {
                    JSONObject jsonBody = new JSONObject((Map) resp.getBody());
                    return ObjectMapperFactory.defaultOne().readValue(jsonBody.toJSONString(), obj.getClass());
                }
            } catch (Exception var4) {
                logger.error(String.format("Error al convertir <%s>", resp, obj.getClass().getSimpleName()), var4);
                throw new Exception(var4);
                return obj;
            }
        }
    }
} 

@Slf4j
@RequiredArgsConstructor
public class ApiCuotasOnlineService extends ApiDelegateBaseHandler implements IApiCuotasOnlineService {
    private final ICuentaService cuentaService;
    private final HttpServletRequest request;

    @Value("${sirec.restcall.host:http://www.xyzxyz.es/}")
    private String host;

    @Override
    @SuppressWarnings("checkstyle:ParameterNumber")
    public CuotasContrato obtenerCuotasProducto(final String agrupacionAdn,
            final String numeroContrato, final String situacion, final String fechaDesde, final String fechaHasta,
            final String date, final String number, final String currency, final String balancePosition) {
        CuotasContrato cuotasContrato = new CuotasContrato();
        Tabla2Respuesta respuesta = new Tabla2Respuesta();

        List<TablaRespuestaColumnas> columnas = obtenerColumnasCuotasOnline();
        respuesta.setColumnas(columnas);

        if (columnas != null && !columnas.isEmpty()) {
            MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();
            queryParams.add("agrupacionAdn", agrupacionAdn);
            queryParams.add("numeroContrato", numeroContrato);
            queryParams.add("situacion", situacion);
            queryParams.add("fechaDesde", fechaDesde);
            queryParams.add("fechaHasta", fechaHasta);
            queryParams.add("date", date);
            queryParams.add("number", number);
            queryParams.add("currency", currency);
            queryParams.add("balancePosition", balancePosition);
            List<Map<String, String>> datos = obtenerDatosCuotasProducto(queryParams, columnas);
            respuesta.setDatos(datos);
        }

        cuotasContrato.setRespuesta(respuesta);
        return cuotasContrato;
    }

    private List<Map<String, String>> obtenerDatosCuotasProducto(final MultiValueMap<String, String> queryParams,
            final List<TablaRespuestaColumnas> columnas) {

        RestCall restCall = new RestCall();
        List<Map<String, String>> datos = new ArrayList<>();
        ListaConsultaOnline detalle = new ListaConsultaOnline();
        List<Map<String, String>> datosFiltrados = new ArrayList<>();
        HttpHeaders headers = createDefaultHttpHeaders();
        ResponseEntity<Object> resp;
        try {
            resp = (ResponseEntity<Object>) restCall.executeGET(
                host + "api/core/v1/consultasOnline/cuotas", headers, new HashMap<String, String>(),
                queryParams, null);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new SirecApplicationException(0, e.getMessage(), e);
        }
        try {
            detalle = (ListaConsultaOnline) restCall.rest2Object(resp, (Object) detalle);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        datos = detalle.getRespuesta().getDatos();
        // Se filtran los datos que coinciden con las columnas
        for (Map<String, String> dato : datos) {
            Map<String, String> map = new HashMap();
            for (TablaRespuestaColumnas columna : columnas) {
                map.put(columna.getId(), dato.get(columna.getId()));
            }
            datosFiltrados.add(map);
        }

        return datosFiltrados;
    }

    private List<TablaRespuestaColumnas> obtenerColumnasCuotasOnline() {
        log.info("ApiCuotasOnlineService.obtenerColumnasCuotasOnline");
        CuentaCamposDTO cuentaCamposDTO = new CuentaCamposDTO();
        cuentaCamposDTO = cuentaService.obtenerCamposDetalleCuotasOnlinePrestamosImpagados();
        return obtenerColumnasPreparadasCuotasOnline(cuentaCamposDTO);
    }

    private List<TablaRespuestaColumnas> obtenerColumnasPreparadasCuotasOnline(final CuentaCamposDTO cuentaCamposDTO) {
        // Campos configurables
        List<TablaRespuestaColumnas> columnas = new ArrayList<TablaRespuestaColumnas>();
        // Columnas
        if (cuentaCamposDTO != null && cuentaCamposDTO.getCampos() != null) {
            List<CampoConfiguracionInner> listCamposMostrar = new ArrayList<>();
            for (CampoConfiguracionInner campo : cuentaCamposDTO.getCampos()) {
                if (campo.getOrden() != null && campo.getOrden() > 0) {
                    listCamposMostrar.add(campo);
                }
            }
            listCamposMostrar.sort(Comparator.comparing(CampoConfiguracionInner::getOrden));

            // Columnas dinamicas
            columnas = listCamposMostrar.stream().map(campos -> new TablaRespuestaColumnas()
                    .id(campos.getNombreTecnicoCampo()).label(campos.getCampo()).tipo(campos.getTipoDato()))
                    .collect(Collectors.toList());
        } else {
            columnas.add(new TablaRespuestaColumnas());
        }
        return columnas;
    }

    private HttpHeaders createDefaultHttpHeaders() {
        HttpHeaders headers = new HttpHeaders();
        Enumeration<?> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String name = (String) names.nextElement();
            Enumeration<?> values = request.getHeaders(name);
            while (values.hasMoreElements()) {
                headers.add(name, (String) values.nextElement());
            }
        }
        return headers;
    }

}

@Slf4j
@RequiredArgsConstructor
public class ApiPaygoldService extends ApiDelegateBaseHandler implements IApiPaygoldService {

    private final HttpServletRequest request;

    @Value("${sirec.restcall.host:http://www.xyzxyz.es/}")
    private String host;

    @Override
    public DetalleConsultaOnline paygold(final PaygoldEntrada paygoldEntrada) {
        DetalleConsultaOnline detalleConsultaOnline = new DetalleConsultaOnline();
        DetalleConsultaOnlineRespuesta respuesta = new DetalleConsultaOnlineRespuesta();

        MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();

        Map<String, String> datos = obtenerDatosRespuestaPaygold(queryParams, paygoldEntrada);
        respuesta.setDatos(datos);

        detalleConsultaOnline.setRespuesta(respuesta);
        return detalleConsultaOnline;
    }

    private Map<String, String> obtenerDatosRespuestaPaygold(final MultiValueMap<String, String> queryParams,
            final PaygoldEntrada paygoldEntrada) {

        RestCall restCall = new RestCall();
        DetalleConsultaOnline detalle = new DetalleConsultaOnline();
        Map<String, String> datos = new HashMap<String, String>();
        HttpHeaders headers = createDefaultHttpHeaders();
        ResponseEntity<Object> resp;
        try {
            resp = (ResponseEntity<Object>) restCall.executePOST(
                    host + "api/core/v1/consultasOnline/paygold", headers, new HashMap<String, String>(),
                    queryParams, paygoldEntrada);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new SirecApplicationException(0, e.getMessage(), e);
        }
        try {
            detalle = (DetalleConsultaOnline) restCall.rest2Object(resp, (Object) detalle);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        datos = detalle.getRespuesta().getDatos();

        return datos;
    }

    private HttpHeaders createDefaultHttpHeaders() {
        HttpHeaders headers = new HttpHeaders();
        Enumeration<?> names = request.getHeaderNames();
        while (names.hasMoreElements()) {
            String name = (String) names.nextElement();
            Enumeration<?> values = request.getHeaders(name);
            while (values.hasMoreElements()) {
                headers.add(name, (String) values.nextElement());
            }
        }
        return headers;
    }

}

Convertir importes de String a Bigdecimal

     /**
     * Convierte un importe de String con . para miles y , para decimales a BigDecimal
     * @param valor   Valor a formatear
     * @return
     */
    public static BigDecimal stringToBigDecimal(final String valor) {
        BigDecimal valorDecimal = null;

        try {
            valorDecimal = new BigDecimal(valor);
        } catch (NumberFormatException e) {
            String valorReplace = valor.replace(".", "").replace(",", ".");
            try {
                valorDecimal = new BigDecimal(valorReplace);
            } catch (NumberFormatException e2) {
                log.error(e2.getMessage());
            }
        }

        return valorDecimal;
    }

Java Formatea una fecha String de yyyy-MM-dd a dd/MM/yyyy

     /**
     * Formatea una fecha String de yyyy-MM-dd a dd/MM/yyyy
     * @param fechaOrigen
     * @return
     */
    public static String formateoFechaString(final String fechaOrigen) {
        String fechaDestino = "";
        if (null != fechaOrigen && !fechaOrigen.isEmpty()) {
            DateTimeFormatter formatoOrigen = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            DateTimeFormatter formatoDestino = DateTimeFormatter.ofPattern("dd/MM/yyyy");
            fechaDestino = LocalDate.parse(fechaOrigen, formatoOrigen).format(formatoDestino);
        }
        return fechaDestino;
    }