Since Spring 3.0, Spring supports for the standard JSR 330: Dependency Injection for Java. In Spring 3 application, you can uses standard

  1. @Inject instead of Spring’s @Autowired to inject a bean.
  2. @Named instead of Spring’s @Component to declare a bean.

Those JSR-330 standard annotations are scanned and retrieved the same way as Spring annotations, the integration just happened automatically, as long as the following jar in your classpath.

pom.xml
	<dependency>
		<groupId>javax.inject</groupId>
		<artifactId>javax.inject</artifactId>
		<version>1</version>
	</dependency>

1. Spring Annotations

Let see a normal Spring’s annotation example – @Autowired and @Component

P.S @Component, @Repository and @Service are same, just declares a bean in Spring Ioc context.

CustomerDAO.java
package com.mkyong.customer.dao;
 
import org.springframework.stereotype.Repository;
 
@Repository
public class CustomerDAO 
{
	public void save() {
		System.out.println("CustomerDAO save method...");
	}	
}
CustomerService.java
package com.mkyong.customer.services;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mkyong.customer.dao.CustomerDAO;
 
@Service
public class CustomerService 
{
	@Autowired
	CustomerDAO customerDAO;
 
	public void save() {
 
		System.out.println("CustomerService save method...");
		customerDAO.save();
 
	}
 
}

2. JSR-330 Annotations

Basically, it works the same, just with different annotations – @Inject and @Named.

CustomerDAO.java
package com.mkyong.customer.dao;
 
import javax.inject.Named;
 
@Named
public class CustomerDAO 
{
 
	public void save() {
		System.out.println("CustomerDAO save method...");
	}	
}
CustomerService.java
package com.mkyong.customer.services;
 
import javax.inject.Inject;
import javax.inject.Named;
 
import com.mkyong.customer.dao.CustomerDAO;
 
@Named
public class CustomerService 
{
	@Inject
	CustomerDAO customerDAO;
 
	public void save() {
 
		System.out.println("CustomerService save method...");
		customerDAO.save();
 
	}
 
}

3. Run it

Both Spring and JSR330 annotations need component scan to works.

Spring-AutoScan.xml – Scan bean automatically
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">
 
    <context:component-scan base-package="com.mkyong.customer" />
 
</beans>
App.java – Run it
package com.mkyong;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.mkyong.customer.services.CustomerService;
 
public class App 
{
    public static void main( String[] args )
    {
    	ApplicationContext context = 
    		new ClassPathXmlApplicationContext(new String[] {"Spring-AutoScan.xml"});
 
    	CustomerService cust = (CustomerService)context.getBean("customerService");
    	cust.save();
 
    }
}

Above two examples are generated the same output

CustomerService save method...
CustomerDAO save method...

4. JSR-330 Limitations

There are some limitations on JSR-330 if compare to Spring :

  1. @Inject has no “required” attribute to make sure the bean is injected successful.
  2. In Spring container, JSR-330 has scope singleton by default, but you can use Spring’s @Scope to define others.
  3. No equivalent to Spring’s @Value, @Required or @Lazy.

Check out this Spring references.

5. Go for JSR-330

In fact, Spring’s annotations are more powerful, but only available on Spring framework. The JSR-330 is a standard spec, and it’s supported on all J2ee environment that follow the JSR-330 spec.

For new or migration project, it’s always recommended to use JSR-330 annotations, and remember, it works on Spring 3 as well.

Download Source Code

Download it – Spring-JSR330-Example.zip (27kb)

References

  1. Spring Reference : Using JSR 330 Standard Annotations
  2. JSR 330: Dependency Injection for Java
Tags :
Founder of Mkyong.com, love Java and open source stuffs. Follow him on Twitter, or befriend him on Facebook or Google Plus.
Here are some of my recommended Books

Related Posts

Popular Posts