通用方法，通用类型unknow

Question

I have many bean i would like to convert to Dto

In every class, i do something like

private List<AddressDto> convertsToDto(List<Address> addresses) {

    List<AddressDto> addressesDto = new ArrayList<>();
    addresses.stream().map((address) -> convertToDto(address)).forEachOrdered((addressDto) -> {
        addressesDto.add(addressDto);
    });
    return addressesDto;

}

convertToDto would be in every class.... but for convertsToDto i will put in ta abstract class where every class will extends it and put a generic convertsToDto method with generic type

public abstract class BaseService {
    public List<T> convertsToDto(List<R> beans) {

        List<T> listDto = new ArrayList<>();
        beans.stream().map((bean) -> convertToDto(bean)).forEachOrdered((dto) -> {
            listDto.add(dto);
        });
        return listDto;
    }
}

I always get T and R is unknown... seem to miss something.

Answer 1

Start with adding T and R type parameters to your generic method. However, this will not do the trick, because convertToDto(bean) would remain undefined.

You have several options here:

• You could define bean interface to produce its DTO, or
• You could pass a bean-to-DTO function object.

Here is the first approach:

interface Bean<T> {
    T convertToDto();
}
public abstract class BaseService {
    public <T,R extends Bean<T>> List<T> convertsToDto(List<R> beans) {
        return beans.stream().map((b) -> b.convertToDto()).collect(Collectors.toList());
    }
    ... // Additional methods
}

Here is the second approach:

public abstract class BaseService {
    public <T,R> List<R> convertsToDto(List<T> beans, Function<T,R> convert) {
        return beans.stream().map((b) -> convert.apply(b)).collect(Collectors.toList());
    }
}

Answer 2

Your BaseService class does not define these generic types.

Try 
public abstract class BaseService<T, R> {
...
}

public class AddressService extends BaseService<AddressDto, Address> {
...
}

Answer 3

You can have a generic interface like Dto<T> for this to work.

And you will be able to have your generic convertion method to look like this:

public <T extends Dto<R>> List<T> convertsToDto(List<R> beans) {
}

Your Dto objects will be implementing the interface mapping them to the base object.