Maven jar sem dependências

Programação Java
#1

Prezados tenho um projeto onde o jar fica em torno de 30 MB, o jar sem as dependências é bem pequeno melhor para enviar atualizações contudo ( lógico ) tenho que ter os jar´s das lib´s no cliente
Isto com certeza ira causar um problema pois tenho que ter as dependências sempre atualizadas ( caso inclua um novo jar o cliente precisa atualizar também)

como posso configurar meu jar para trabalhar desta forma como dizer onde estão os jar´s das lib´s?

No NetBeans quando gera o jar ele já cria uma pasta lib onde ficam todos os outros arquivos, já no Eclipse e Trabalhando com Maven como fazer isto?

Obrigado.

#2

Veja, você está trabalhando com dois conceitos distintos: é possível pegar os jars “na unha” e colocar num ponto específico utilizando o eclipse.
Da mesma maneira, é possível trabalhar com maven e NB.
Agora, vamos lá: não considero usual a troca de jars em um projeto. Se isso ocorre, alguma coisa não está correta: falha no planejamento, em geral. Faltou algo ou o projeto foi ampliado. Nas duas situações, é preciso criar um novo artefato e enviar ao cliente (ou fazer a compilação no cliente, evitando, assim, que você crie um artefato enorme).
Outro ponto é que, mesmo para projetos antigos, nunca vi trocar a versão de uma dependência para outra. Isso pode quebrar muito do teu código e causar um impacto ainda maior. Sem falar que eu não vejo vantagem em, dentro de um universo de 200 jars, atualizar 3 ou 4 e manter mais de 190 antigos. Qual a lógica nisso?

Agora, meu testemunho: quando eu comecei a desenvolver, não entendia maven. Não achava aquilo necessário e, como essa p0rr@ precisa de um XML pra configurar, eu odiava mais.
Sempre achei muito mais simples ir lá, caçar um jar aqui, 10 ali, 20 acolá e juntar tudo.
Os duplicados removia manualmente e boa.
Aí, um belo dia, caí num projeto que me forçou usar essa disgrama.
Hoje eu não crio projetos sem ser maven project (exceto no Android Studio, que tem o gradle).
O que fica de lição: não nade contra a corrente, é mais fácil.

#3

Opa Darlan tranquilo.

Obrigado pela interação, deixa esclarecer.

como comentei tenho um Projeto que tem a configuração do Maven para embutir as dependências, ao executar o processo de geração do jar ( clean, package ) vemos dois jar´s um com ( aproximadamente 30 Mb que é o que eu envio para o cliente) e outro pequeno que tem apenas o código de minha regra de negocio.
Envio para o cliente uma atualização e pode ocorrer de precisar enviar alguma alteração no mesmo dia, ou amanhã ou qdo ele solicitar algo novo, em vez de enviar Tudo poderia enviar apenas o jar menor ( mais rápido de enviar )
Não quis dizer Troca de jar mais deixa explicar digamos que eu não tenha o recurso de enviar e-mail , este (jar/dependência) é acrescida no pom e ao gerar um novo jar vai junto, caso tivesse utilizando de outra forma isto causa um incoveniente passível de dar erro no cliente pois se estivesse enviando o jar ( menor ) a dependência não estaria no cliente
Ou seja teria que ter um cuidado maior com o que teria que enviar para o cliente.

Acho valido ter apenas que enviar um jar menor , ja ocorreu de atualizar o cliente duas , cinco vezes no dia por solicitacoes , até erros e enviar um com 2 é bem melhor do que com 30Mb.

#4

Cara, isso tudo é, ao meu ver, um modo de querer “andar para trás”.
Você pode, simplesmente, upar isso no google drive ou outro local na nuvem e disponibilizar o link pro cliente.
Ou, ainda, criar uma aplicação java, mais leve, que simplesmente gere o .jar final, a partir do pom.xml deste.

Não se realiza testes? Não existe contrato definindo o que cada versão deve ter?

#5

Sim, sim faço isto, uso os Drives na nuvem para este fim, sobre projetos pego projeto que nem é do meu dominio apenas para uma prestação de serviço onde eu nem conheço todas as regras e o que me passam descrobre-se depois que falta algo que eu não conhecia.

Ou seja pego projeto com um escopo definido da mesma forma que pelo projeto que não.

Só comentei a respeito do assunto porque uso Maven, uso os drives em nuvem mais não sei como proceder para gerar um jar apenas com minhas regras de negocio e as dependências não estar embutidas e saber como configurar o jar para acha-las,

Citei o NetBeans porque projetos com o Ant ele gera e as dependências ficam em uma pasta lib, qdo preciso atualizar o cliente só envio o jar da aplicação (bem menor ) porque a pasta Lib ja ta no cliente, queria saber fazer isto com Eclipse/Maven desculpa ai pode ser que muitos saibam eu infelizmente não tenho esta bagagem toda, mais chego lá.

#6

Este é um risco. Quando você precisa alterar algo e tem domínio do todo, este risco é minimizado, porém, ainda existe. Quando não conhece, a probabilidade de problema é imensa. Ninguém sabe o quão acoplado o código está, onde vai quebrar se você mexer aqui e ali.

Até dá para fazer, mas não acredito que seja viável.

O eclipse também permite isso, basta você configurar.

Eu ainda insisto na manutenção do modelo atual, a questão é alinhar com o cliente de que maneira os testes serão realizados.

#7

Prezados boa tarde.

Eu estava procurando uma forma de gerar um jar de minha aplicação menor para facilitar o envio visto que o maior peso são os jar´s das dependências e estas dificilmente serão alteradas e eu não sabia como fazer isto em um projeto maven então a quem interessar segue abaixo o uso do plugin dependency , e lembre-se ao compilar o seu projeto ou seja qdo fizer o clean, package na pasta target haverá uma pasta chamada lib esta pasta com seu conteudo deverá ir para o cliente juntamente com o jar de sua aplicação, das próximas vezes que vc for enviar um novo jar devido a alguma alteração vc só precisara enviar o jar de sua aplicação uma vez que a pasta lib já se encontra no cliente.

Espero ter ajudado a quem não sabia como eu a fazer este processo com o maven

<groupId>seugroupId</groupId>
<artifactId>seuartifactId</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
    
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.3</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>

        <!--Plugin para configurar o manifest no seu arquivo jar-->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <finalName>${project.artifactId}</finalName>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>suaClasseMain</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>2.10</version>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        <overWriteReleases>true</overWriteReleases>
                        <overWriteSnapshots>true</overWriteSnapshots>
                        <excludeTransitive>false</excludeTransitive>

                        <!--Exclude not necessary libs-->
                        <excludeArtifactIds>
                        </excludeArtifactIds>
                    </configuration>
                </execution>
            </executions>
        </plugin>            
    </plugins>
</build>

<dependencies>
    <!-- Algumas dependencias como exemplo -->                
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.4</version>
    </dependency>
    
    <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.6.3</version>
    </dependency>

</dependencies>