1. Introducción
Google Guice y Spring son dos marcos robustos que se utilizan para la inyección de dependencias. Ambos marcos cubren todas las nociones de inyección de dependencia, pero cada uno tiene su propia forma de implementarlas.
En este tutorial, discutiremos cómo los frameworks Guice y Spring difieren en configuración e implementación.
2. Dependencias de Maven
Comencemos agregando las dependencias de Guice y Spring Maven en nuestro archivo pom.xml :
org.springframework spring-context 5.1.4.RELEASE com.google.inject guice 4.2.2 Siempre podemos acceder a las últimas dependencias de contexto de primavera o guice desde Maven Central.
3. Configuración de inyección de dependencia
La inyección de dependencias es una técnica de programación que usamos para hacer nuestras clases independientes de sus dependencias.
En esta sección, nos referiremos a varias características centrales que difieren entre Spring y Guice en sus formas de configurar la inyección de dependencias.
3.1. Cableado de resorte
Spring declara las configuraciones de inyección de dependencia en una clase de configuración especial. Esta clase debe estar anotada por la anotación @Configuration . El contenedor Spring usa esta clase como fuente de definiciones de frijoles.
Las clases administradas por Spring se llaman Spring beans.
Spring usa la anotación @Autowired para conectar las dependencias automáticamente . @Autowired es parte de las anotaciones centrales integradas de Spring. Podemos usar @Autowired en variables miembro, métodos setter y constructores.
Spring también es compatible con @Inject. @Inject es parte de Java CDI (Contexts and Dependency Injection) que define un estándar para la inyección de dependencias.
Digamos que queremos conectar automáticamente una dependencia a una variable miembro. Simplemente podemos anotarlo con @Autowired :
@Component public class UserService { @Autowired private AccountService accountService; }@Component public class AccountServiceImpl implements AccountService { }En segundo lugar, creemos una clase de configuración para usar como fuente de beans mientras cargamos el contexto de nuestra aplicación:
@Configuration @ComponentScan("com.baeldung.di.spring") public class SpringMainConfig { }Tenga en cuenta que también hemos anotado UserService y AccountServiceImpl con @Component a registrarlos como los frijoles. Es la anotación @ComponentScan la que le indicará a Spring dónde buscar componentes anotados.
Aunque hemos anotado AccountServiceImpl , Spring puede asignarlo al AccountService ya que implementa AccountService .
Luego, necesitamos definir un contexto de aplicación para acceder a los beans. Observemos que nos referiremos a este contexto en todas nuestras pruebas unitarias de Spring:
ApplicationContext context = new AnnotationConfigApplicationContext(SpringMainConfig.class);Ahora, en tiempo de ejecución, podemos recuperar la instancia A ccountService de nuestro bean UserService :
UserService userService = context.getBean(UserService.class); assertNotNull(userService.getAccountService());3.2. Encuadernación Guice
Guice administra sus dependencias en una clase especial llamada módulo. Un módulo Guice tiene que extender la clase AbstractModule y anular su método configure () .
Guice usa la unión como equivalente al cableado en Spring. En pocas palabras, los enlaces nos permiten definir cómo se inyectarán las dependencias en una clase . Los enlaces de Guice se declaran en el método configure () de nuestro módulo .
En lugar de @Autowired , Guice usa la anotación @Inject para inyectar las dependencias.
Creemos un ejemplo de Guice equivalente:
public class GuiceUserService { @Inject private AccountService accountService; }En segundo lugar, crearemos la clase de módulo que es una fuente de nuestras definiciones vinculantes:
public class GuiceModule extends AbstractModule { @Override protected void configure() { bind(AccountService.class).to(AccountServiceImpl.class); } }Normalmente, esperamos que Guice cree una instancia de cada objeto de dependencia de sus constructores predeterminados si no hay ningún enlace definido explícitamente en el método configure () . Pero dado que las interfaces no se pueden instanciar directamente, necesitamos definir enlaces para decirle a Guice qué interfaz se emparejará con qué implementación.
Luego, necesitamos definir un inyector usando GuiceModule para obtener instancias de nuestras clases. Observemos que todas nuestras pruebas de Guice utilizarán este inyector :
Injector injector = Guice.createInjector(new GuiceModule());Por último, en tiempo de ejecución recuperamos un GuiceUserService ejemplo con un no nulo AccountService dependencia:
GuiceUserService guiceUserService = injector.getInstance(GuiceUserService.class); assertNotNull(guiceUserService.getAccountService());3.3. Anotación @Bean de Spring
Spring también proporciona una anotación de nivel de método @Bean para registrar beans como una alternativa a sus anotaciones de nivel de clase como @Component . El valor de retorno de un método anotado @Bean se registra como un bean en el contenedor.
Digamos que tenemos una instancia de BookServiceImpl que queremos que esté disponible para inyección. Podríamos usar @Bean para registrar nuestra instancia:
@Bean public BookService bookServiceGenerator() { return new BookServiceImpl(); }Y ahora podemos obtener un bean BookService :
BookService bookService = context.getBean(BookService.class); assertNotNull(bookService);3.4. Anotación @Provides de Guice
As an equivalent of Spring's @Bean annotation, Guice has a built-in annotation @Provides to do the same job. Like @Bean, @Provides is only applied to the methods.
Now let's implement the previous Spring bean example with Guice. All we need to do is to add the following code into our module class:
@Provides public BookService bookServiceGenerator() { return new BookServiceImpl(); }And now, we can retrieve an instance of BookService:
BookService bookService = injector.getInstance(BookService.class); assertNotNull(bookService);3.5. Classpath Component Scanning in Spring
Spring provides a @ComponentScan annotation detects and instantiates annotated components automatically by scanning pre-defined packages.
The @ComponentScan annotation tells Spring which packages will be scanned for annotated components. It is used with @Configuration annotation.
3.6. Classpath Component Scanning in Guice
Unlike Spring, Guice doesn't have such a component scanning feature. But it's not difficult to simulate it. There are some plugins like Governator that can bring this feature into Guice.
3.7. Object Recognition in Spring
Spring recognizes objects by their names. Spring holds the objects in a structure which is roughly like a Map. This means that we cannot have two objects with the same name.
Bean collision due to having multiple beans of the same name is one common problem Spring developers hit. For example, let's consider the following bean declarations:
@Configuration @Import({SpringBeansConfig.class}) @ComponentScan("com.baeldung.di.spring") public class SpringMainConfig { @Bean public BookService bookServiceGenerator() { return new BookServiceImpl(); } }@Configuration public class SpringBeansConfig { @Bean public AudioBookService bookServiceGenerator() { return new AudioBookServiceImpl(); } }As we remember, we already had a bean definition for BookService in SpringMainConfig class.
To create a bean collision here, we need to declare the bean methods with the same name. But we are not allowed to have two different methods with the same name in one class. For that reason, we declared the AudioBookService bean in another configuration class.
Now, let's refer these beans in a unit test:
BookService bookService = context.getBean(BookService.class); assertNotNull(bookService); AudioBookService audioBookService = context.getBean(AudioBookService.class); assertNotNull(audioBookService);The unit test will fail with:
org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'AudioBookService' availableFirst, Spring registered the AudioBookService bean with “bookServiceGenerator” name in its bean map. Then, it had to override it by the bean definition for BookService due to the “no duplicate names allowed” nature of the HashMap data structure.
Lastly, we can overcome this issue by making bean method names unique or setting the name attribute to a unique name for each @Bean.
3.8. Object Recognition in Guice
Unlike Spring, Guice basically has a Map
Guice provides binding annotations to enable defining multiple bindings for the same type. Let's see what happens if we have two different bindings for the same type in Guice.
public class Person { }Now, let's declare two different binding for the Person class:
bind(Person.class).toConstructor(Person.class.getConstructor()); bind(Person.class).toProvider(new Provider() { public Person get() { Person p = new Person(); return p; } });And here is how we can get an instance of Person class:
Person person = injector.getInstance(Person.class); assertNotNull(person);This will fail with:
com.google.inject.CreationException: A binding to Person was already configured at GuiceModule.configure()We can overcome this issue by just simply discarding one of the bindings for the Person class.
3.9. Optional Dependencies in Spring
Optional dependencies are dependencies which are not required when autowiring or injecting beans.
For a field that has been annotated with @Autowired, if a bean with matching data type is not found in the context, Spring will throw NoSuchBeanDefinitionException.
However, sometimes we may want to skip autowiring for some dependencies and leave them as nullwithout throwing an exception:
Now let's take a look at the following example:
@Component public class BookServiceImpl implements BookService { @Autowired private AuthorService authorService; }public class AuthorServiceImpl implements AuthorService { }As we can see from the code above, AuthorServiceImpl class hasn't been annotated as a component. And we'll assume that there isn't a bean declaration method for it in our configuration files.
Now, let's run the following test to see what happens:
BookService bookService = context.getBean(BookService.class); assertNotNull(bookService);Not surprisingly, it will fail with:
org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'AuthorService' availableWe can make authorService dependency optional by using Java 8's Optional type to avoid this exception.
public class BookServiceImpl implements BookService { @Autowired private Optional authorService; }Now, our authorService dependency is more like a container that may or may not contain a bean of AuthorService type. Even though there isn't a bean for AuthorService in our application context, our authorService field will still be non-null empty container. Hence, Spring won't have any reason to throw NoSuchBeanDefinitionException.
As an alternative to Optional, we can use @Autowired‘s required attribute, which is set to true by default, to make a dependency optional. We can set the required attribute to false to make a dependency optional for autowiring.
Hence, Spring will skip injecting the dependency if a bean for its data type is not available in the context. The dependency will remain set to null:
@Component public class BookServiceImpl implements BookService { @Autowired(required = false) private AuthorService authorService; }Sometimes marking dependencies optional can be useful since not all the dependencies are always required.
With this in mind, we should remember that we'll need to use extra caution and null-checks during development to avoid any NullPointerException due to the null dependencies.
3.10. Optional Dependencies in Guice
Just like Spring, Guice can also use Java 8's Optional type to make a dependency optional.
Let's say that we want to create a class and with a Foo dependency:
public class FooProcessor { @Inject private Foo foo; }Now, let's define a binding for the Foo class:
bind(Foo.class).toProvider(new Provider() { public Foo get() { return null; } });Now let's try to get an instance of FooProcessor in a unit test:
FooProcessor fooProcessor = injector.getInstance(FooProcessor.class); assertNotNull(fooProcessor);Our unit test will fail with:
com.google.inject.ProvisionException: null returned by binding at GuiceModule.configure(..) but the 1st parameter of FooProcessor.[...] is not @NullableIn order to skip this exception, we can make the foo dependency optional with a simple update:
public class FooProcessor { @Inject private Optional foo; }@Inject doesn't have a required attribute to mark the dependency optional. An alternative approach to make a dependency optional in Guice is to use the @Nullable annotation.
Guice tolerates injecting null values in case of using @Nullable as expressed in the exception message above. Let's apply the @Nullable annotation:
public class FooProcessor { @Inject @Nullable private Foo foo; }4. Implementations of Dependency Injection Types
In this section, we'll take a look at the dependency injection types and compare the implementations provided by Spring and Guice by going through several examples.
4.1. Constructor Injection in Spring
In constructor-based dependency injection, we pass the required dependencies into a class at the time of instantiation.
Let's say that we want to have a Spring component and we want to add dependencies through its constructor. We can annotate that constructor with @Autowired:
@Component public class SpringPersonService { private PersonDao personDao; @Autowired public SpringPersonService(PersonDao personDao) { this.personDao = personDao; } }Starting with Spring 4, the @Autowired dependency is not required for this type of injection if the class has only one constructor.
Let's retrieve a SpringPersonService bean in a test:
SpringPersonService personService = context.getBean(SpringPersonService.class); assertNotNull(personService);4.2. Constructor Injection in Guice
We can rearrange the previous example to implement constructor injection in Guice. Note that Guice uses @Inject instead of @Autowired.
public class GuicePersonService { private PersonDao personDao; @Inject public GuicePersonService(PersonDao personDao) { this.personDao = personDao; } }Here is how we can get an instance of GuicePersonService class from the injector in a test:
GuicePersonService personService = injector.getInstance(GuicePersonService.class); assertNotNull(personService);4.3. Setter or Method Injection in Spring
In setter-based dependency injection, the container will call setter methods of the class, after invoking the constructor to instantiate the component.
Let's say that we want Spring to autowire a dependency using a setter method. We can annotate that setter method with @Autowired:
@Component public class SpringPersonService { private PersonDao personDao; @Autowired public void setPersonDao(PersonDao personDao) { this.personDao = personDao; } }Whenever we need an instance of SpringPersonService class, Spring will autowire the personDao field by invoking the setPersonDao() method.
We can get a SpringPersonService bean and access its personDao field in a test as below:
SpringPersonService personService = context.getBean(SpringPersonService.class); assertNotNull(personService); assertNotNull(personService.getPersonDao());4.4. Setter or Method Injection in Guice
We'll simply change our example a bit to achieve setter injection in Guice.
public class GuicePersonService { private PersonDao personDao; @Inject public void setPersonDao(PersonDao personDao) { this.personDao = personDao; } }Every time we get an instance of GuicePersonService class from the injector, we'll have the personDao field passed to the setter method above.
Here is how we can create an instance of GuicePersonService class and access its personDao fieldin a test:
GuicePersonService personService = injector.getInstance(GuicePersonService.class); assertNotNull(personService); assertNotNull(personService.getPersonDao());4.5. Field Injection in Spring
Ya vimos cómo aplicar la inyección de campo tanto para Spring como para Guice en todos nuestros ejemplos. Entonces, no es un concepto nuevo para nosotros. Pero enumerémoslo nuevamente para que esté completo.
En el caso de la inyección de dependencias basada en campos, inyectamos las dependencias marcándolas con @Autowired o @Inject .
4.6. Inyección de campo en Guice
Como mencionamos en la sección anterior, ya cubrimos la inyección de campo para Guice usando @Inject .
5. Conclusión
En este tutorial, exploramos las diversas diferencias centrales entre los frameworks Guice y Spring en sus formas de implementar la inyección de dependencias. Como siempre, las muestras de código de Guice y Spring terminaron en GitHub.