所以，我有一些仿制药的春季3.2和我的理想架构会是这个样子。
class GenericDao<T>{}
class GenericService<T, T_DAO extends GenericDao<T>>
{
// FAILS
@Autowired
T_DAO;
}
@Component
class Foo{}
@Repository
class FooDao extends GenericDao<Foo>{}
@Service
FooService extends GenericService<Foo, FooDao>{}
不幸的是与仿制药的多种实现自动装配抛出关于多个匹配的bean定义错误。 我想这是因为@Autowired类型擦除之前处理。 我发现还是拿出长相难看给我或者只是莫名的每一个解决方案拒绝工作。 什么是解决这个问题的最好方法是什么？
如何添加一个构造函数的GenericService和移动时自动连接到扩展的类，如
class GenericService<T, T_DAO extends GenericDao<T>> {
private final T_DAO tDao;
GenericService(T_DAO tDao) {
this.tDao = tDao;
}
}
@Service
FooService extends GenericService<Foo, FooDao> {
@Autowired
FooService(FooDao fooDao) {
super(fooDao);
}
}
更新：
随着春天4.0 RC1 ，有可能基于通用型的，这意味着你可以写像普通的服务自动装配
class GenericService<T, T_DAO extends GenericDao<T>> {
@Autowired
private T_DAO tDao;
}
并创建它像多个不同的Spring bean：
@Service
class FooService extends GenericService<Foo, FooDao> {
}
您可以使用@PostConstruct和ServiceLocatorFactoryBean删除@autowire注释和延迟执行“自动装配”。
你GenericService将类似于此
public class GenericService<T, T_DAO extends GenericDao<T>>{
@Autowired
private DaoLocator daoLocatorFactoryBean;
//No need to autowried, autowireDao() will do this for you
T_DAO dao;
@SuppressWarnings("unchecked")
@PostConstruct
protected void autowireDao(){
//Read the actual class at run time
final Type type;
type = ((ParameterizedType) getClass().getGenericSuperclass())
.getActualTypeArguments()[1];
//figure out the class of the fully qualified class name
//this way you can know the bean name to look for
final String typeClass = type.toString();
String daoName = typeClass.substring(typeClass.lastIndexOf('.')+1
,typeClass.length());
daoName = Character.toLowerCase(daoName.charAt(0)) + daoName.substring(1);
this.dao = (T_DAO) daoLocatorFactoryBean.lookup(daoName);
}
daoLocatorFactoryBean做魔术给你。
为了使用它，你需要添加类似下面这样的界面：
public interface DaoLocator {
public GenericDao<?> lookup(String serviceName);
}
您需要将下面的代码片段添加到您的applicationContext.xml
<bean id="daoLocatorFactoryBean"
class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean">
<property name="serviceLocatorInterface"
value="org.haim.springframwork.stackoverflow.DaoLocator" />
</bean>
这是一个很好的把戏，它会为你节省一点的样板类。
BTW我没有看到这个样板代码作为一个大问题，对于使用matsev方法处理的项目我。
这里是一个最接近的解决方案。 专业的DAO在业务层注解。 作为从OP的问题，尽最大努力将其在EntityDAO通用模板本身的注解DAO。 类型擦除似乎不允许特殊类型的信息得到传递到弹簧厂[导致报告来自所有专门的DAO匹配豆]
public class EntityDAO<T>
{
@Autowired
SessionFactory factory;
public Session getCurrentSession()
{
return factory.getCurrentSession();
}
public void create(T record)
{
getCurrentSession().save(record);
}
public void update(T record)
{
getCurrentSession().update(record);
}
public void delete(T record)
{
getCurrentSession().delete(record);
}
public void persist(T record)
{
getCurrentSession().saveOrUpdate(record);
}
public T get(Class<T> clazz, Integer id)
{
return (T) getCurrentSession().get(clazz, id);
}
}
public abstract class EntityBusinessService<T>
implements Serializable
{
public abstract EntityDAO<T> getDAO();
//Rest of code.
}
@Transactional
@Repository
public class UserDAO
extends EntityDAO<User>
{
}
@Transactional
@Service
@Scope("prototype")
public class UserBusinessService
extends EntityBusinessService<User>
{
@Autowired
UserDAO dao;
@Override
public EntityDAO<User> getDAO()
{
return dao;
}
//Rest of code
}
你为什么要一个通用的服务？ 服务类是为了对涉及multple实体工作的具体单位。 你可以只注入一个仓库直接到控制器。
这里是一个构造函数参数的通用仓库的例子，你也可以让每种方法的通用替代，没有构造函数的参数。 但是每一个方法调用需要类作为参数：
public class DomainRepository<T> {
@Resource(name = "sessionFactory")
protected SessionFactory sessionFactory;
public DomainRepository(Class genericType) {
this.genericType = genericType;
}
@Transactional(readOnly = true)
public T get(final long id) {
return (T) sessionFactory.getCurrentSession().get(genericType, id);
}
bean定义为通用信息库的例子 - 你可以有不同的multple豆，使用不同的contstructor ARGS。
<bean id="tagRepository" class="com.yourcompnay.data.DomainRepository">
<constructor-arg value="com.yourcompnay.domain.Tag"/>
</bean>
豆Depdncy注射使用资源注解
@Resource(name = "tagRepository")
private DomainRepository<Tag> tagRepository;
这允许Domainreposiroty被子类特定实体/方法，竟被其自动装配达洛：
public class PersonRepository extends DomainRepository<Person> {
public PersonRepository(){
super(Person.class);
}
...
你应该在课堂上使用自动装配延伸这些仿制药
对于这个问题，人们需要了解有关自动装配是什么。 在常见的术语，我们可以说，通过自动装配，我们在创建Web应用程序的部署时间，对象实例/豆。 所以，现在就一问题，如果您在多个地方使用相同的名称声明自动装配。 然后这个错误出现。 自动装配可以通过多种方式，所以如果你正在使用多个类型的自动装配技术来完成，然后还一个可能出现此错误。
使用Spring 4完成通用的解决方案：
@Component
class Foo{
}
@Component
class Bar{
}
interface GenericDao<T>{
//list of methods
}
class GenericDaoImpl<T> implements GenericDao<T>{
@Autowired
SessionFactory factory;
private Class<T> domainClass; // Get Class Type of <T>
public Session getCurrentSession(){
return factory.getCurrentSession();
}
public DaoImpl() {
this.domainClass = (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), DaoImpl.class);
}
//implementation of methods
}
interface FooDao extends GenericDao<Foo>{
//Define extra methods if required
}
interface BarDao extends GenericDao<Bar>{
//Define extra methods if required
}
@Repository
class FooDao extends GenericDaoImpl<Foo> implements FooDao{
//implementation of extra methods
}
@Repository
class BarDao extends GenericDaoImpl<Bar> implements BarDao{
//implementation of extra methods
}
interface GenericService<T>{
//List of methods
}
class GenericServiceImpl<T> implements GenericService<T>{
@Autowire
protected GenericDao<T> dao; //used to access DAO layer
}
class FooService extends GenericService<Foo>{
//Add extra methods of required
}
class BarService extends GenericService<Bar>{
//Add extra methods of required
}
@Service
class FooServiceImpl extends GenericServiceImpl<Foo> implements GenericService<Foo>{
//implementation of extra methods
}
@Service
class BarServiceImpl extends GenericServiceImpl<Bar> implements GenericService<Bar>{
//implementation of extra methods
}
