[Spring] Chiarimenti

[|gonzo|]

Ciao, mi è stato chiesto (anzi, imposto) di usare spring+hibernate per un nuovo progetto, uno di quei progetti dove mille parti in azienda mettono becco e si finisce per dover sentire le solite panzane dell'agile development, deliverare in fretta, test driven e solite panzane insomma.

Dunque mando giù il rospo ed inizio a leggere un libro su spring e hibernate. Partiamo da spring, su hibernate ho letto ancora molto poco. Nel libro non si fa che tessere lodi a questo framework solo che, nel concreto, non riesco a vedere dove siano i vantaggi, ad esempio la dependency injection.

Partiamo dal codice classico:

Codice: Seleziona tutto

public class EmployeeService() {
    private EmployeeDAO edao;

    public EmployeeService() {
        edao = new EmployeeDao();
    }
}

E questo è male, c'è una dipendenza stretta tra EmployeeService e EmployeeDao. La brillante soluzione di spring è:

Codice: Seleziona tutto

public class EmployeeService() {
    private EmployeeDAO edao;

    public EmployeeService(EmployeeDAO edao) {
        this.edao = edao;
    }
}

Magia, la dipendenza è scomparsa. Gaudio, gioia e tripudio. In mia opinione no perché un'eventuale estensione di EmployeeService richiederebbe comunque una revisione di EmployeeDAO, come nel caso sopra. Magari l'esempio del libro non è proprio brillante e non rende l'idea di independency.
Se qualcuno riesce a spiegarmela gliene sarei grato perché se è così diffuso non può essere una presa in giro, ma è pur sempre vero che miliardi di mosche apprezzano le feci dei cani ma non per questo le feci sono buone.

Per Hibernate poi ho ancora più perplessità rispetto al semplice JDBC.

[ienaplinsky]

Per quello che ne so io di solito si utilizzano le interfacce, quando hai una classe dipendente è dipendente da un interfaccia, la vera potenza è che se hai bisogno di cambiare la dipendenza con un altta classe ti basta cambiare una riga nell xml o un annotation senza bisogno di ricompilare il codice
se ti può essere utile stavo leggendo pro spring 3

[|gonzo|]

Sarò contorto io evidentemente, ma non vedo alcun vantaggio ad avere files xml sparsi ovunque con definizioni dei bean, configurazioni e via dicendo, mi sembra di sparpagliare tutto in giro e rendere tutto più illeggibile.

Nel frattempo proseguo a studiare...

[ienaplinsky]

se ti può essere utile ti posto un esempio che stà sul libro, c'è praticamente l'interfaccia per fare il render di un messaggio

MessageRender.java

Codice: Seleziona tutto

public interface MessageRenderer {
	
	public void render();
	public void setMessageProvider(MessageProvider provider);
	public MessageProvider getMessageProvider();
	
}

l'interfaccia per il provider che provvederà a fornire il messaggio
MessageProvider.java

Codice: Seleziona tutto

public interface MessageProvider {
	
	public String getMessage();
	
}

le classi che implementano le interfacce, StandardOutMessageRender che è dipendente di HelloWorldMessageProvider

Codice: Seleziona tutto

public class StandardOutMessageRenderer implements MessageRenderer {

	private MessageProvider messageProvider;

	public void render() {
		if (messageProvider == null) {
			throw new RuntimeException(
					"You must set the property messageProvider of class:"
							+ StandardOutMessageRenderer.class.getName());
		}
		System.out.println(messageProvider.getMessage());
	}

	public void setMessageProvider(MessageProvider provider) {
		this.messageProvider = provider;
	}

	public MessageProvider getMessageProvider() {
		return messageProvider;
	}

}

public class HelloWorldMessageProvider implements MessageProvider {

	public String getMessage() {
		return "HelloWorld";
	}

}

e infine la classe con il main che fa il render del messaggio

Codice: Seleziona tutto

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloWorldSpringDI {
	
	public static void main(String args[]) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext
				("META-INF/spring/app-context.xml");
		MessageRenderer mr = ctx.getBean("renderer", MessageRenderer.class);
		mr.render();
	}
	
}

se in questa classe hai bisogno per esempio d cambiare il MessageRender ti basta cambiare solo l'xml senza dover toccare il codice, stesso discorso se nel MessageRender hai bisogno di cambiare il provider ti basta cambiare una riga nell'xml
ti lascio anche l'xml
app-context.xml

Codice: Seleziona tutto

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.0.xsd">
	
	<bean id="provider" class="com.apress.prospring3.ch2.HelloWorldMessageProvider" />
	
	<bean id="renderer" class="com.apress.prospring3.ch2.StandardOutMessageRenderer"
		p:messageProvider-ref="provider" />
</beans>

[|gonzo|]

grazie mille, domani con calma mi leggo tutto il codice.

edit: letto, ma continuo a rimanere perplesso, la dipendenza è solo spostata "fuori", grazie comunque del contributo.

[ienaplinsky]

Le dipendenze sono spostate nel xml o annotation, i vantaggi principali sono che non.cambi codice e non hai bisogno.di ricompilare ma spring assembla le dipendenze a runtime per te configurando l'applicazione