Spring4新特性——泛型限定式依赖注入

Spring 4.0已经发布RELEASE版本，不仅支持Java8，而且向下兼容到JavaSE6/JavaEE6，并移出了相关废弃类，新添加如Java8的支 持、Groovy式Bean定义DSL、对核心容器进行增强、对Web框架的增强、Websocket模块的实现、测试的增强等。其中两个我一直想要的增 强就是：支持泛型依赖注入、对cglib类代理不再要求必须有空参构造器了。具体更新请参考：

http://docs.spring.io/spring/docs/4.0.0.RELEASE/spring-framework-reference/htmlsingle/#new-in-4.0

 

1、相关代码：

1.1、实体

public class User implements Serializable {
    private Long id;
    private String name;
}

public class Organization implements Serializable {
    private Long id;
    private String name;
}

 1.2、Repository

public abstract class BaseRepository<M extends Serializable> {
    public void save(M m) {
        System.out.println("=====repository save:" + m);
    }
}

@Repository
public class UserRepository extends BaseRepository<User> {
}

@Repository
public class OrganizationRepository extends BaseRepository<Organization> {
}

 对于Repository，我们一般是这样实现的：首先写一个模板父类，把通用的crud等代码放在BaseRepository；然后子类继承后，只需要添加额外的实现。

 

1.3、Service

1.3.1、以前Service写法

public abstract class BaseService<M extends Serializable> {
    private BaseRepository<M> repository;
    public void setRepository(BaseRepository<M> repository) {
        this.repository = repository;
    }
    public void save(M m) {
        repository.save(m);
    }
}
@Service
public class UserService extends BaseService<User> {
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        setRepository(userRepository);
    }
}

@Service
public class OrganizationService extends BaseService<Organization> {
    @Autowired
    public void setOrganizationRepository(OrganizationRepository organizationRepository) {
        setRepository(organizationRepository);
    }
}

 

可以看到，以前必须再写一个setter方法，然后指定注入的具体类型，然后进行注入；

 

1.3.2、泛型Service的写法

public abstract class BaseService<M extends Serializable> {
    @Autowired
    protected BaseRepository<M> repository;

    public void save(M m) {
        repository.save(m);
    }
}

@Service
public class UserService extends BaseService<User> {
}

@Service
public class OrganizationService extends BaseService<Organization> {
}

 

 大家可以看到，现在的写法非常简洁。支持泛型式依赖注入。

 

这个也是我之前非常想要的一个功能，这样对于那些基本的CRUD式代码，可以简化更多的代码。

 

 

如果大家用过Spring data jpa的话，以后注入的话也可以使用泛型限定式依赖注入 ：

@Autowired
private Repository<User> userRepository;

 

 对于泛型依赖注入，最好使用setter注入，这样万一子类想变，比较容易切换。比如https://github.com/zhangkaitao/es，如果有多个实现时，子类可以使用@Qualifier指定使用哪一个。

 

评论

33 楼 lancijk 2014-08-20   引用

大牛,得顶一顶.. 膜拜学习中...

32 楼 jinnianshilongnian 2014-08-18   引用

awake0474 写道

我用的spring3.2.1 。 好像也支持泛型限定式依赖注入

你是怎么用的？

31 楼 awake0474 2014-08-18   引用

我用的spring3.2.1 。 好像也支持泛型限定式依赖注入

30 楼 userapplewings 2014-03-12   引用

jinnianshilongnian 写道

userapplewings 写道

学习了，我想请问这种反省依赖注入能够写成spring的xml形式呢？在xml中如何实现呢？是将BaseRepository，注入到BaseService中的BaseRepository么？

可以在xml中配置的；但是必须使用注解注入依赖

果然是必须用注解注入，我想问的就是注入部分是不是还能写成xml，昨天想了半天，感觉xml貌似做不了了

29 楼 jinnianshilongnian 2014-03-12   引用

userapplewings 写道

学习了，我想请问这种反省依赖注入能够写成spring的xml形式呢？在xml中如何实现呢？是将BaseRepository，注入到BaseService中的BaseRepository么？

可以在xml中配置的；但是必须使用注解注入依赖

28 楼 userapplewings 2014-03-12   引用

学习了，我想请问这种反省依赖注入能够写成spring的xml形式呢？在xml中如何实现呢？是将BaseRepository，注入到BaseService中的BaseRepository么？

27 楼 jinnianshilongnian 2014-01-02   引用

hantsy 写道

我所期待的是 Spring 能够 produces 和 Inject Generic type bean。。。

这个已经在 Seam 2 及 CDI 中提供了很长时间，Spring4 依然不支持。 Spring 落伍太多了。

现在这种 Generic Type Injection 只是代替 Qualifer 的一种表示方式。

http://my.oschina.net/hantsy/blog/186939

看了下javaee7的CDI规范，确实很强大；

26 楼 jinnianshilongnian 2013-12-31   引用

jinnianshilongnian 写道

jinnianshilongnian 写道

hantsy 写道

我所期待的是 Spring 能够 produces 和 Inject Generic type bean。。。

这个已经在 Seam 2 及 CDI 中提供了很长时间，Spring4 依然不支持。 Spring 落伍太多了。

现在这种 Generic Type Injection 只是代替 Qualifer 的一种表示方式。

http://my.oschina.net/hantsy/blog/186939

因为spring对集合等作了特殊处理 可以参考 http://jinnianshilongnian.iteye.com/blog/1989379；

另外我简单的改造了下spring即可支持你说的功能，可以提交下spring看看接受不
https://github.com/zhangkaitao/spring4-showcase/tree/master/spring4-others/src/test/java/com/sishuok/spring4/genericinject

改造的bean工厂如下
https://github.com/zhangkaitao/spring4-showcase/blob/master/spring4-others/src/test/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java

目前对xml List定义 也支持的

注：XML方式的话，注入时必须必须指定名字（因为xml中配置的集合没有泛型信息，除非只有一个集合 Bean）   除非bean definition使用ResolvableType 而不是class存储；

25 楼 jinnianshilongnian 2013-12-31   引用

jinnianshilongnian 写道

hantsy 写道

我所期待的是 Spring 能够 produces 和 Inject Generic type bean。。。

这个已经在 Seam 2 及 CDI 中提供了很长时间，Spring4 依然不支持。 Spring 落伍太多了。

现在这种 Generic Type Injection 只是代替 Qualifer 的一种表示方式。

http://my.oschina.net/hantsy/blog/186939

因为spring对集合等作了特殊处理 可以参考 http://jinnianshilongnian.iteye.com/blog/1989379；

另外我简单的改造了下spring即可支持你说的功能，可以提交下spring看看接受不
https://github.com/zhangkaitao/spring4-showcase/tree/master/spring4-others/src/test/java/com/sishuok/spring4/genericinject

改造的bean工厂如下
https://github.com/zhangkaitao/spring4-showcase/blob/master/spring4-others/src/test/java/org/springframework/beans/factory/support/DefaultListableBeanFactory.java

目前对xml List定义 也支持的

24 楼 jinnianshilongnian 2013-12-31   引用

hantsy 写道

我所期待的是 Spring 能够 produces 和 Inject Generic type bean。。。

这个已经在 Seam 2 及 CDI 中提供了很长时间，Spring4 依然不支持。 Spring 落伍太多了。

现在这种 Generic Type Injection 只是代替 Qualifer 的一种表示方式。

http://my.oschina.net/hantsy/blog/186939

因为spring对集合等作了特殊处理 可以参考 http://jinnianshilongnian.iteye.com/blog/1989379；

另外我简单的改造了下spring即可支持你说的功能，可以提交下spring看看接受不
https://github.com/zhangkaitao/spring4-showcase/tree/master/spring4-others/src/test/java/com/sishuok/spring4/genericinject

23 楼 hantsy 2013-12-30   引用

我所期待的是 Spring 能够 produces 和 Inject Generic type bean。。。

这个已经在 Seam 2 及 CDI 中提供了很长时间，Spring4 依然不支持。 Spring 落伍太多了。

现在这种 Generic Type Injection 只是代替 Qualifer 的一种表示方式。

http://my.oschina.net/hantsy/blog/186939

22 楼 jinnianshilongnian 2013-12-19   引用

manong_java 写道

我貌似找到原因了有两个同类型的Dao:UserDao和UserDao1
且所有Service 继承BaseService<T> ，去掉BaseService的继承则可以正常运行。
这样一来就说明BaseService中的BaseDao<T>不会根据具体的service类型来注入。

public abstract class BaseService<T extends Serializable> {

    @Autowired
    private BaseDao<T> baseDao;

    public void save(T t)
    {
        baseDao.save(t);
    }
}

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }
}

public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userservice=ctx.getBean(UserService.class);
    User user=new User();
    user.setName("张三");
    user.setId(1000);
    userservice.save(user);
}

jinnianshilongnian 写道

manong_java 写道

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？
可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

很明显   BaseDao<User>  有两个实现，不过你指定了@Qualifier("UserDao1") 不应该有问题的啊

public abstract class BaseService<T extends Serializable> { 
 
    @Autowired 
    private BaseDao<T> baseDao; 

在那篇文章中 对于这种情况推荐使用setter注入

21 楼 manong_java 2013-12-19   引用

我貌似找到原因了有两个同类型的Dao:UserDao和UserDao1
且所有Service 继承BaseService<T> ，去掉BaseService的继承则可以正常运行。
这样一来就说明BaseService中的BaseDao<T>不会根据具体的service类型来注入。

public abstract class BaseService<T extends Serializable> {

    @Autowired
    private BaseDao<T> baseDao;

    public void save(T t)
    {
        baseDao.save(t);
    }
}

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }
}

public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userservice=ctx.getBean(UserService.class);
    User user=new User();
    user.setName("张三");
    user.setId(1000);
    userservice.save(user);
}

jinnianshilongnian 写道

manong_java 写道

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？
可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

很明显   BaseDao<User>  有两个实现，不过你指定了@Qualifier("UserDao1") 不应该有问题的啊

20 楼 jinnianshilongnian 2013-12-19   引用

manong_java 写道

是的我故意写两个Repository<user>来测试根据类型自动注入，但事实就是出现这个异常
tao哥帮忙解决下呗

public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userservice=ctx.getBean(UserService.class);
    User user=new User();
    user.setName("张三");
    user.setId(1000);
    userservice.save(user);
}

jinnianshilongnian 写道

manong_java 写道

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

很明显   BaseDao<User>  有两个实现，不过你指定了@Qualifier("UserDao1") 不应该有问题的啊

你把代码站内信我 我看看

19 楼 manong_java 2013-12-19   引用

是的我故意写两个Repository<user>来测试根据类型自动注入，但事实就是出现这个异常
tao哥帮忙解决下呗

public static void main(String[] args) {
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserService userservice=ctx.getBean(UserService.class);
    User user=new User();
    user.setName("张三");
    user.setId(1000);
    userservice.save(user);
}

jinnianshilongnian 写道

manong_java 写道

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

很明显   BaseDao<User>  有两个实现，不过你指定了@Qualifier("UserDao1") 不应该有问题的啊

18 楼 jinnianshilongnian 2013-12-19   引用

manong_java 写道

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

很明显   BaseDao<User>  有两个实现，不过你指定了@Qualifier("UserDao1") 不应该有问题的啊

17 楼 manong_java 2013-12-19   引用

jinnianshilongnian 写道

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

可以的啊 比如 Repository<User> 即可注入

我定义了两个Dao:UserDao、UserDao1
我在service实现类中指定使用UserDao1 但没起作用，程序启动抛异常 这是什么原因呢？

Caused by: org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type [com.hulibo.spring.dao.impl.BaseDao] is defined: expected single matching bean but found 2: UserDao,UserDao1

@Service
public class UserService extends BaseService<User> {

    @Autowired
    @Qualifier("UserDao1")
    private BaseDao<User> dao;

    @Override
    public void save(User t) {
        System.out.println("重写save user方法:"+t.getName());
        dao.save(t);
    }

}

@Repository("UserDao")
public class UserDao extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao save :"+t.getName());
    }


}

@Repository("UserDao1")
public class UserDao1 extends BaseDao<User> {

    @Override
    public void save(User t) {
        System.out.println("userDao1 save>>>>:"+t.getName());
    }
}

16 楼 jinnianshilongnian 2013-12-19   引用

manong_java 写道

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

可以的啊 比如 Repository<User> 即可注入

15 楼 manong_java 2013-12-19   引用

他这个泛型支持 能根据user对象 自动注入UserRepository 对象吗？？？？？

14 楼 keeley 2013-12-14   引用

厉害！......