Refine search
public static void main(String[] args) { // init mapper MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build(); mapperFactory.classMap(Source.class, Destination.class). field("message", "text").register(); MapperFacade mapper = mapperFactory.getMapperFacade(); // convert Source source = new Source("Hello World!"); Destination destObject = mapper.map(source, Destination.class); destObject.print(); // print Hello World! } }
private void configureMapperFactory(MapperFactory factory) { factory.registerClassMap(factory.classMap(Policy.class, PolicyDTO.class).byDefault()); factory.registerClassMap(factory.classMap(CustomerElement.class, CustomerElementDTO.class).byDefault()); factory.registerClassMap(factory.classMap(ProductElement.class, ProductElementDTO.class).byDefault()); factory.registerClassMap(factory.classMap(OtherElement.class, OtherElementDTO.class).byDefault()); factory.registerClassMap(factory.classMap(OneOtherElement.class, OneOtherElementDTO.class).byDefault()); }
MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build(); ClassMapBuilder<Foo, Bar> map = mapperFactory.classMap(Foo.class, Bar.class); Type<Foo> fooType = map.getAType(); Type<Bar> barType = map.getBType() boolean exists = mapperFactory.existsRegisteredMapper(fooType, barType, false);
@Provides @Singleton MapperFacade provideMapperFacade( MapperFactory factory, Set<BeanMapperConfig> configs ) { ConverterFactory converterFactory = factory.getConverterFactory(); converterFactory.registerConverter( new DateTimeToDateConverter() ); for ( BeanMapperConfig next : configs ) { next.config( factory ); } return factory.getMapperFacade(); }
@Before public void setUp() { MapperFactory mapperFactory = createMapperFactory(); mapperFactory.registerClassMap(mapperFactory.classMap(Order.class, OrderData.class).byDefault().toClassMap()); mapperFactory.registerClassMap(mapperFactory.classMap(Position.class, PositionData.class).byDefault().toClassMap()); facade = mapperFactory.getMapperFacade(); }
@Test public void testConvertStringToString() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.getConverterFactory().registerConverter(new MyCustomConverter2()); factory.classMap(A.class, B.class).field("id", "string").register(); B source = new B(); source.setString("hello"); C destination = factory.getMapperFacade().map(source, C.class); Assert.assertEquals("string: hello", destination.string); }
class HomeMapperRegister extends ConfigurableMapper { @Override public void configure(MapperFactory mapperFactory) { mapperFactory.classMap(HomeContentDTO.class, SubscriberUpsertDTO.class) .fieldAToB("subscriberName", "name") .fieldAToB("subscriberEmail", "email") .fieldAToB("subscriberCompanyName", "companyName") .register(); } }
@Override public void configure(MapperFactory factory) { factory.registerClassMap(factory.classMap(MySourceObject.class, MyTargetObject.class)// .field("e", "sub.s") .toClassMap()); factory.getConverterFactory().registerConverter(new MyEnumConverter()); } };
@Test public void testMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); mapperFactory.registerClassMap( mapperFactory.classMap(Order.class, OrderData.class) .field("entityID", "orderId").byDefault().toClassMap()); mapperFactory.getConverterFactory().registerConverter(new OrderIDConverter()); MapperFacade facade = mapperFactory.getMapperFacade(); OrderData data = new OrderData(1234l); Order order = facade.map(data, Order.class); Assert.assertEquals(new OrderID(1234l), order.getEntityID()); } }
@SuppressWarnings("deprecation") @Test public void testMappingEmptyArray() { MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build(); mapperFactory.registerClassMap(ClassMapBuilder.map(Object.class,Object.class).byDefault().toClassMap()); List<Object> listA = new ArrayList<Object>(); List<Object> listB = mapperFactory.getMapperFacade().mapAsList(listA, Object.class); Assert.assertNotNull(listB); Assert.assertTrue(listB.isEmpty()); }
@Test public void resolveConcreteClass() { MapperFacade mapper = factory.getMapperFacade(); factory.registerClassMap(ClassMapBuilder.map(ChildEntity.class, ChildDTO.class).byDefault().toClassMap()); factory.build(); ChildEntity entity = new ChildEntity(); entity.setId(1L); entity.setName("Khettabi"); BaseDTO dto = mapper.map(entity, BaseDTO.class); Assert.assertTrue(dto instanceof ChildDTO); Assert.assertEquals(entity.getName(), ((ChildDTO) dto).getName()); }
@Test(expected=MappingException.class) public void testToString_withoutConverter() { MapperFactory factory = new DefaultMapperFactory.Builder().useBuiltinConverters(false).build(); MapperFacade mapper = factory.getMapperFacade(); Date now = new Date(); String string = mapper.map(now, String.class); Assert.assertFalse(now.toString().equals(string)); }
@Test public void testConvertLongString() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.getConverterFactory().registerConverter(new LongToStringConverter()); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).field("id", "string").toClassMap()); factory.build(); A source = new A(); source.setId(42L); B destination = factory.getMapperFacade().map(source, B.class); Assert.assertEquals("42", destination.getString()); }
@Test public void testMapping() { MapperFactory mapperFactory = MappingUtil.getMapperFactory(); mapperFactory.getConverterFactory().registerConverter(new OrderIdConverter()); ClassMapBuilder<Order, OrderData> builder = ClassMapBuilder.map(Order.class, OrderData.class); ClassMap<Order, OrderData> classMap = builder.field("id", "number").byDefault().toClassMap(); mapperFactory.registerClassMap(classMap); MapperFacade facade = mapperFactory.getMapperFacade(); OrderData data = new OrderData(1234l); Order order = facade.map(data, Order.class); Assert.assertEquals(Long.valueOf(1234l), order.getId()); }
@Test public void testLookupDestinationGetsMostSpecific() { MapperFactory factory = MappingUtil.getMapperFactory(); factory.registerClassMap(ClassMapBuilder.map(A.class, BSub.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(A.class, B.class).byDefault().toClassMap()); factory.registerClassMap(ClassMapBuilder.map(A.class, BSuper.class).byDefault().toClassMap()); factory.getMapperFacade(); Type bsuper = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(BSuper.class), null); Assert.assertEquals(BSuper.class, bsuper.getRawType()); Type b = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(B.class), null); Assert.assertEquals(B.class, b.getRawType()); Type bsub = factory.lookupConcreteDestinationType(TypeFactory.valueOf(A.class), TypeFactory.valueOf(BSub.class), null); Assert.assertEquals(BSub.class, bsub.getRawType()); }
/** * Registers a {@link Converter} into the {@link ConverterFactory}. * * @param converter */ public void addConverter(final Converter<?, ?> converter) { factory.getConverterFactory().registerConverter(converter); }
private static MapperFacade createMapperFacade() { DefaultMapperFactory.Builder builder = new DefaultMapperFactory.Builder(); builder.compilerStrategy(new EclipseJdtCompilerStrategy()); MapperFactory factory = builder.build(); factory.registerMapper(new MergingMapper()); factory.registerConcreteType(new TypeBuilder<Collection<Entity>>() {}.build(), new TypeBuilder<ArrayList<Entity>>() {}.build()); return factory.getMapperFacade(); }
&& !mapperFactory.existsRegisteredMapper(key.getAType(), key.getBType(), true) && mapperFactory.getClassMap(key) == null) { ClassMapBuilder<?,?> builder = builders.get(key); if (builder == null) { builder = mapperFactory.classMap(key.getAType(), key.getBType()); builders.put(key, builder);
protected void configure(MapperFactory mapperFactory) { mapperFactory.getConverterFactory().registerConverter(new CustomConverter<Address, String>() { public String convert(Address source, Type<? extends String> destinationType) { return source.getLine1() + " " + source.getLine2(); } }); ClassMapBuilder<Order, OrderDTO> classMapBuilder = ClassMapBuilder.map(Order.class, OrderDTO.class); classMapBuilder.fieldMap("customer.address", "shippingAddress").add(); mapperFactory.registerClassMap(classMapBuilder.byDefault().toClassMap()); }
private static MapperFacade createMapperFacade() { DefaultMapperFactory.Builder builder = new DefaultMapperFactory.Builder(); MapperFactory factory = builder.build(); factory.registerMapper(new MergingMapper()); return factory.getMapperFacade(); }