Hibernate should mount query only with the required joins

I have list with createCriteria on it I have several ifs to query only the parameters queried on the form, however, the hibernete by default at the time of the query assembly joins all tables that have constraints:

select *from volume this_ 
  left outer join area area4_ on this_.area_id=area4_.id inner 
  join compania compania5_ on this_.compania_id=compania5_.id 
  left outer join volume contidoem_1_ on this_.contido_em_id=contidoem_1_.id 
  left outer join lote lote7_ on contidoem_1_.lote_id=lote7_.id 
  left outer join produto produto8_ on contidoem_1_.produto_id=produto8_.id 
  inner join codigogs1 sscc_alias2_ on contidoem_1_.sscc_id=sscc_alias2_.id 
  left outer join codigogs1 sscc10_ on this_.sscc_id=sscc10_.id 
    where ((sscc_alias2_.identificacao='001234560002790702'))

volume list function:

def list() {
    log.info '* Method: list'
    log.debug "* Params: ${params}"

    def volumeList = []
    def codigo = null

    if (params.codigo) {
        def map = codigoGS1Service.decodificaBarCode(params.codigo)

        if (map[["00"]]) {
            params.caixa = map[["00"]]
        }

        if (!params.caixa && map[["01"]]) {
            codigo = map[["01"]]
        }

        if (!params.caixa && map[["10"]]) {
            params.lote = map[["10"]]
        }

        if (!params.caixa && map[["21"]]) {
            params.serie = map[["21"]]
        }
    }

    if (params.serie || params.caixa || params.recebimento || params.contidoEm
        || params.lote || params.produto || params.area || codigo || params.etiquetaImpressaSim ||
        params.etiquetaImpressaNao) {

        def tenant_id = companiaService.getCurrent().id

        volumeList = Volume.createCriteria().list() {
            if (codigo) {
                produto {
                    gtin {
                        eq('identificacao', codigo) <-- repare no select acima ele montou o apenas na clasula where com esse parametro, então não havia a necessidade de fazer todos aqueles joins
                    }
                }
            }

            if (params.serie) {
                eq('serial', params.serie)
            }

            if (params.caixa) {
                sscc {
                    eq('identificacao', params.caixa)
                    isNotNull('id') //IMPORTANT: Query otimization!!!
                }
            }

            if (params.recebimento) {
                try {
                    event('hook_recebimento_busca', params.recebimento, [fork: false])

                } catch (Exception e) {
                    log.error (e.message, e)
                    flashMessage(e.message, params.recebimento)
                }
                recebimento {
                    eq('codigo', params.recebimento)
                    eq('tenantId', tenant_id as Integer)
                }
            }

            if (params.contidoEm) {
                contidoEm {
                    sscc {
                        eq('identificacao', params.contidoEm)
                    }
                }
            }

            if (params.lote) {
                log.debug "* Buscou lote: ${params.lote}"
                lote {
                    eq('codigo', params.lote)
                }
            }

            if (params.produto) {
                produto {
                    eq('codigo', params.produto)
                }
            }

            if (params.area) {
                area {
                    eq('nome', params.area)
                }
            }

            if (params.etiquetaImpressaSim) {
                eq('etiquetaImpressa', true)
            } else if (params.etiquetaImpressaNao) {
                eq('etiquetaImpressa', false)
            }

            if (params.ordem =='on') {
                order('id', 'desc')
            }
        }
    }
    [volumeList: volumeList, params: params]
}

domain.groovy:

class Volume {

    def historicoService
    def springSecurityService

    def codigoGS1Service
    def sequenciaService

    public static float CUBAGEM_VARIAVEL = -1f
    public static float CAPACIDADE_VARIAVEL = -2f

    Area area
    Volume contidoEm

    String tipoArmazenamento = "I"

    Float altura
    Float largura
    Float profundidade

    Float cubagemUtil
    Float capacidade
    Float ocupacao

    Date dataArmazenamento

    Produto produto
    Lote lote

    SSCC sscc
    String serial
    Compania compania

    Boolean etiquetaImpressa = false

    Recebimento recebimento
    Expedicao expedicao
    MotivoDescarte motivoDescarte

    static mapping = {
      area      fetch: 'join'
      produto   fetch: 'join'
      lote      fetch: 'join'
      sscc      fetch: 'join'
      compania  fetch: 'join'
      serial column: 'serial', index:'Idx_Serial'
    }

    def folhas
    def internos

    static transients = [ "folhas", "internos" ]

    static constraints = {
        tipoArmazenamento(blank: false, inList: ["I", "S"])
        altura(min: 0f)
        largura(min: 0f)
        profundidade(min: 0f)
        cubagemUtil(nullable: true)
        capacidade(nullable: true)
        ocupacao(nullable: true)
        contidoEm(nullable: true)
        area(nullable: true)
        dataArmazenamento(nullable: true)
        produto(nullable: true)
        lote(nullable: true,
            validator: { val, obj ->
                if (obj.lote) {
                    obj.produto == obj.lote.produto
                } else {
                    return true
                }
            }
        )
        sscc(nullable:true,
            validator: { val, obj ->
                obj.sscc != obj.serial
            }
        )
        serial(nullable:true,
            validator: { val, obj ->
                obj.sscc != obj.serial
            }
        )
        recebimento(nullable: true)
        expedicao(nullable: true)
        motivoDescarte(nullable: true)
        compania()
        etiquetaImpressa(nullable: false, display: false)
    }

    ...

}

Does anyone know how to create this query in a way only with the values passed in the parameters?