import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@PostConstruct
private void configure() {
    mapperFactory = new DefaultMapperFactory.Builder().build();
    mapperFactory.classMap(ApplicationUser.class, UserDTO.class)
            .exclude("createdDate")
            .mapNulls(false)
            .mapNullsInReverse(false)
            .byDefault()
            .register();
    mapperFactory.classMap(UserSetting.class, UserSettingDTO.class)
            .field("user.id", "userId")
            .mapNulls(false)
            .mapNullsInReverse(false)
            .byDefault()
            .register();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
/**
 * By using the ClassMapBuilder.byDefault(), we are relying on the automatic mapping of identically named fields (much as
 * you would get with BeanUtils.copyProperties()), as well as any nested classes. The service objects have core fields
 * that are the same as the DO object they represent as a base.
 * 
 * We then customize the class map to work with extended fields that don't fit the simple model. Because of this, mapper
 * classes are not needed for all of our objects. Some are fulfilled by the base mapping provided by orika. Orika handles
 * any two classes thrown at it, mapping what it can.
 */
private void buildFactory() {

	// Use for troubleshooting. This will make Orika write the generated mapping
	// file out to the filesystem.
	// System.setProperty(OrikaSystemProperties.WRITE_SOURCE_FILES,"true");
	// System.setProperty(OrikaSystemProperties.WRITE_CLASS_FILES,"true");

	factory = new DefaultMapperFactory.Builder().build();

	factory.classMap(ContactDO.class, Contact.class).byDefault().customize(new ContactDOandContactMapper()).register();
	factory.classMap(OrgDO.class, Org.class).byDefault().customize(new OrgDOandOrgMapper()).register();
	factory.classMap(ScopeDO.class, Scope.class).byDefault().customize(new ScopeDOandScopeMapper()).register();
	factory.classMap(UserDO.class, User.class).byDefault().customize(new UserDOandUserMapper()).register();
	factory.classMap(DeviceDO.class, Device.class).byDefault().customize(new DeviceDOandDeviceMapper()).register();
	factory.classMap(FileDO.class, File.class).byDefault().customize(new FileDOandFileMapper()).register();
	factory.classMap(UserRoleDO.class, UserRole.class).byDefault().customize(new UserRoleDOtoUserRoleMapper())
			.register();
	factory.classMap(UserOrgDO.class, UserOrg.class).byDefault().customize(new UserOrgDOToUserOrgMapper()).register();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Programmatic
@PostConstruct
public void init() {
    mapperFactory = new DefaultMapperFactory.Builder().build();
    mapperFactory.registerClassMap(
            mapperFactory.classMap(QuickObject.class, QuickObjectDto.class)
                    .byDefault() // all fields are the compatible
                    .toClassMap());
    mapperFactory.registerClassMap(
            mapperFactory.classMap(Bookmark.class, OidDto.class)
                    .field("identifier", "objectIdentifier") // customized
                    .byDefault() // all other fields are compatible
                    .toClassMap());
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public ModelRatingResultsDiagMapper() {
    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
    
    mapperFactory.classMap(gov.va.vba.persistence.entity.ModelRatingResultsDiag.class, ModelRatingResultsDiag.class)
      .field("id.diagId", "diagId")
      .field("modelRatingResults.processId", "processId")
      .field("count", "count")
      .register();
    
    mapperFacade = mapperFactory.getMapperFacade();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public ClaimMapper() {
    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
    mapperFactory.classMap(gov.va.vba.persistence.entity.Veteran.class, Veteran.class)
            .field("veteranId", "veteranId")
            .register();
    mapperFactory.classMap(gov.va.vba.persistence.entity.Claim.class, Claim.class)
            .field("claimDate", "claimDate")
            .field("claimId", "claimId")
            .field("veteran.veteranId", "veteran.veteranId")
            .field("regionalOfficeOfClaim", "regionalOfficeOfClaim")
            .field("contentionId", "contentionId")
            .field("contentionClaimTextKeyForModel", "contentionClaimTextKeyForModel")
            .register();
    mapperFacade = mapperFactory.getMapperFacade();

}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public BlogMapperFactory() {
	mapperFactory = new DefaultMapperFactory.Builder()
			.compilerStrategy(new ExtendedJavaassistCompilerStrategy()).build();
	
	registerBaseMapper();
	registerBlogMapper();
	registerCategoryMapper();
	registerKeywordMapper();
	registerPaginationMapper();
	registerPaginationQueryMapper();
	registerPostMapper();
	registerUserMapper();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@PostConstruct
public void configure() {
    mapperFactory = new DefaultMapperFactory.Builder().build();
    mapperFactory.classMap(Car.class, CarDTO.class)
            .field("user.id", "userId")
            .exclude("createdDate")
            .mapNulls(false)
            .mapNullsInReverse(false)
            .byDefault()
            .register();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@PostConstruct
public void configure() {
    mapperFactory = new DefaultMapperFactory.Builder().build();
    mapperFactory.classMap(Transaction.class, TransactionDTO.class)
            .field("user.id", "userId")
            .field("car.id", "carId")
            .exclude("createdDate")
            .mapNulls(false)
            .mapNullsInReverse(false)
            .byDefault()
            .register();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Bean
public Mapper mapper() {
  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
  mapperFactory.registerFilter(new OrikaHibernateFilter());

  return new EditorMapper(mapperFactory.getMapperFacade());
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@BeforeMethod
public void setUp() {
	// CDI: @Autowired, @Inject, etc.
	objectUnderTest = new TestOrikaModelTransformer(
			new TestReflectionModelTransformerFactory(
					singleton(new TestOrikaModelTransformerProvider(
							new DefaultMapperFactory.Builder().build()))));
	objectUnderTest.buildReflectionModelTransformers(); // CDI: @PostConstruct
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Bean(name = "dockerJavaMapper")
    public MapperFactory configROMapper() {
        MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();

        initCustom(mapperFactory);

//        mapperFactory.getConverterFactory().registerConverter(new LocalDateConverter());
//        mapperFactory.getConverterFactory().registerConverter(new LocalDatetimeConverter());
        mapperFactory.getConverterFactory().registerConverter(new PassThroughConverter(LocalDate.class));
        mapperFactory.getConverterFactory().registerConverter(new PassThroughConverter(LocalDateTime.class));
        mapperFactory.getConverterFactory().registerConverter(new PassThroughConverter(BigDecimal.class));

        return mapperFactory;
    }
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
protected BaseMapper()
{
    mapperFactory = new DefaultMapperFactory.Builder().build();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public ConversioTipusHelper() {
	mapperFactory = new DefaultMapperFactory.Builder().build();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public ModelRatingResultsMapper() {
    MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
    
    mapperFactory.classMap(gov.va.vba.persistence.entity.Veteran.class, Veteran.class)
            .field("veteranId", "veteranId")
            .register();
    mapperFactory.classMap(gov.va.vba.persistence.entity.DDMModelPatternIndex.class, ModelPatternIndex.class)
    		.field("patternId", "patternId")
    		.register();
    mapperFactory.classMap(gov.va.vba.persistence.entity.ModelRatingResults.class, ModelRatingResults.class)
      .field("processId", "processId")
      .field("veteran.veteranId", "veteran.veteranId")
      .field("patternIndex.patternId", "patternIndex.patternId")
      .field("patternIndex.accuracy", "patternIndex.accuracy")
      .field("patternIndex.patternIndexNumber", "patternIndex.patternIndexNumber")
      .field("patternIndex.CDD", "patternIndex.CDD")
      .field("patternIndex.modelType", "patternIndex.modelType")
      .field("claimId", "claimId")
      .field("claimDate", "claimDate")
      .field("claimAge", "claimAge")
      .field("modelType", "modelType")
      .field("priorCDD", "priorCDD")
      .field("quantPriorCDD", "quantPriorCDD")
      .field("currentCDD", "currentCDD")
      .field("quantCDD", "quantCDD")
      .field("processDate", "processDate")
      .field("CDDAge", "CDDAge")
      .field("claimCount", "claimCount")
      .field("claim.contentionClaimTextKeyForModel", "claim.contentionClaimTextKeyForModel")
      .byDefault()
            .register();
    mapperFactory.classMap(gov.va.vba.persistence.entity.ModelRatingResultsStatus.class, ModelRatingResultsStatus.class)
      .field("id.processId", "processId")
      .field("id.processStatus", "processStatus")
      .field("crtdBy", "createdBy")
.register();
    mapperFactory.classMap(gov.va.vba.persistence.entity.DDMModelPatternIndex.class, ModelRatingPattern.class)
      .field("patternId", "patternIndex.patternId")
      .field("accuracy", "patternIndex.accuracy")
      .field("patternIndexNumber", "patternIndex.patternIndexNumber")
      .field("CDD", "patternIndex.CDD")
      .field("modelType", "patternIndex.modelType")
      .field("categoryId", "categoryId")
      .field("createdDate", "createdDate")
      .field("createdBy", "createdBy")
.register();
    
    mapperFacade = mapperFactory.getMapperFacade();
    
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
public MapperFacade getObject() throws Exception {

        MapperFactory mapperFactory = new DefaultMapperFactory.Builder()
                .classMapBuilderFactory(new AnnotationClassMapBuilder.Factory())
                .build();
        mapperFactory.getConverterFactory().registerConverter(new PassThroughConverter(org.joda.time.DateTime.class));

//        mapperFactory.registerClassMap(
//                mapperFactory.classMap(ComplexCriterion.class, gov.va.vba.persistence.entity.ComplexCriterion.class)
//                        .field("criteria", "simpleCriteria")
//                        .byDefault()
//                        .toClassMap()
//        );

        return mapperFactory.getMapperFacade();
    }
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Override
public void configureFactoryBuilder(DefaultMapperFactory.Builder builder) {
  builder.compilerStrategy(new EclipseJdtCompilerStrategy());
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Bean
MapperFacade beanMapper() {
  return new DefaultMapperFactory.Builder().build().getMapperFacade();
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
/**
 * Convert an object to a Map
 *
 * @param object object to convert
 * @return Map<String, Object> converted object
 */
protected Map<String, Object> convertObjectToMap(Object object) {
  Type objectType = TypeFactory.valueOf(object.getClass());
  Type mapType = new TypeBuilder<Map<String, Object>>() {
  }.build();

  MapperFactory mapperFactory = new DefaultMapperFactory.Builder().build();
  mapperFactory.classMap(objectType, mapType).byDefault().register();
  BoundMapperFacade boundMapper = mapperFactory.getMapperFacade(objectType, mapType);
  Map<String, Object> convertedObject = (Map<String, Object>) boundMapper.map(object);

  return convertedObject;
}
 

import ma.glasnost.orika.impl.DefaultMapperFactory; //导入依赖的package包/类
@Test
public void clonerConverter() throws DatatypeConfigurationException {

    ClonerConverter cc2 = new ClonerConverter(DeepCopyHolder.class);

    MapperFactory factory = new DefaultMapperFactory.Builder().build();
    factory.getConverterFactory().registerConverter(cc2);

    GregorianCalendar cal = new GregorianCalendar();
    cal.add(Calendar.YEAR, 10);
    XMLGregorianCalendar xmlCal = DatatypeFactory.newInstance().newXMLGregorianCalendar((GregorianCalendar) cal);
    cal.add(Calendar.MONTH, 3);

    DeepCopyHolder source = new DeepCopyHolder();
    source.value = new IdHolder();
    source.value.setId("A Sample Value to Copy");
    source.timestamp = new Timestamp(System.currentTimeMillis() + 10000000);
    source.calendar = cal;
    source.xmlCalendar = xmlCal;

    DeepCopyHolder dest = factory.getMapperFacade().map(source, DeepCopyHolder.class);

    Assert.assertEquals(source.value, dest.value);
    Assert.assertNotSame(source.value, dest.value);
    Assert.assertEquals(source.timestamp, dest.timestamp);
    Assert.assertNotSame(source.timestamp, dest.timestamp);
    Assert.assertEquals(source.calendar, dest.calendar);
    Assert.assertNotSame(source.calendar, dest.calendar);
    Assert.assertEquals(source.xmlCalendar, dest.xmlCalendar);
    Assert.assertNotSame(source.xmlCalendar, dest.xmlCalendar);
}