# orika-demo

**Repository Path**: yuyanCoder/orika-demo

## Basic Information

- **Project Name**: orika-demo
- **Description**: 使用orika可以很好的完成数据的拷贝 本项目中有测试用例可以很好的理解orika的基本使用
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 5
- **Forks**: 5
- **Created**: 2020-07-10
- **Last Updated**: 2022-09-06

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# orika用户指南

## 入门


orika是最近在GitHub上比较活跃的项目 它能解决数据之间复杂的关系映射，像我们常用的Do和DTO之间的映射，都可以很方便的使用它 它的运行效率是dozer的20倍。

###导入依赖

要在项目中使用orika,需要导入依赖，下面的demo都是在springboot环境中测试的，因此确保导入了springboot依赖和启动类。

```html
<dependency>
   <groupId>ma.glasnost.orika</groupId>
   <artifactId>orika-core</artifactId>
   <version>1.4.2</version><!-- 版本 -->
</dependency>
```

建一个orika配置类 ,获取mapperFactory工厂（核心类）

```java
@Configuration //打上注解为配置类
public class OrikaConfig{
    @bean //将mapper注册到bean容器中
    public MapperFactory mapperFacroty(){
        return new DefaultMapperFactory.Builder().build();
    }
}
```

现在我们来完成一个简单的hello world。

###相同属性之间的映射

先创建俩个类 Student,StudentDto

```java
//Student
public class Student{
    private String name;
    private int age;
    //get和set方法 构造方法
    ...
}

//StudentDto
public class StudentDto{
    private String name;
    private int age;
    //get和set方法 构造方法
    ...
}
```

####编写测试类（第一种方法）

导入依赖

```html
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     <scope>test</scope>
     <exclusions>
         <exclusion>
             <groupId>org.junit.vintage</groupId>
             <artifactId>junit-vintage-engine</artifactId>
         </exclusion>
     </exclusions>
</dependency>
```

代码编写

```java
@SpringBootTest
class Orika2DemoApplicationTests {
    @Autowired  //从bean容器中获取mapperFactory
    private MapperFactory mapperFactory;
    @Test
    public void test(){
        // 获取mapperFacade映射对象
        MapperFacade mapperFacade=mapperFactory.getMapperFacade();
        //创建student 并赋值
        Student student=new Student("lishi",25);
        //调用map() 开始映射
        StudentDto studentDto=mapperFacade.map(student,StudentDto.class);
        
        System.out.println(studentDto);
    }
}

打印结果： stuidentDto("lishi",25);
```

#### 第二种方法(提高性能)

```java
 @Test
    public void test2(){
       //使用BoundMapperFacade映射对象
        BoundMapperFacade<Student, StudentDto> mapperFacade = 		           		     mapperFactory.getMapperFacade(Student.class, StudentDto.class);
        
        Student student = new Student("lishi", 25);
        //开始映射
        StudentDto studentDto = mapperFacade.map(student);
        System.out.println(studentDto);

    }
```



### 不相同属性名之间的映射

改变俩个类的属性值

```java
//Student
public class Student{
    private String name;
    private int age;
    private String addr;
    //get和set方法 构造方法
    ...
}

//StudentDto
public class StudentDto{
    private String nameDto;
    private int ageDto;
    private String addr;
    //get和set方法 构造方法
    ...
}
```

####编写测试类

```java
@SpringBootTest
class Orika2DemoApplicationTests {
    @Autowired  
    private MapperFactory mapperFactory;
   @Test
    public void test(){
        //使用field将双方名字相对应,若有多个不同可连续使用field, 使用byDefault将其余相同名字的自动拷贝
        mapperFactory.classMap(Student.class, StudentDto.class)
                .field("name","nameDto")
                .field("age","ageDto")
                .byDefault()
                .register();
        //获取映射器
        MapperFacade mapperFacade = mapperFactory.getMapperFacade();
        Student student = new Student("lishi", 25,"beijing");
        //开始映射
        StudentDto studentDto = mapperFacade.map(student, StudentDto.class);
        System.out.println(studentDto);
    }
}
测试结果：
	StudentDto(nameDto=lishi, ageDto=25, addr=beijing)
```

---

### 多个实体类之间的映射

实体类

```java
//Student
public class Student {
    private String name;
    private int age;
    private String addr;
}
//StudentDto
public class StudentDto {
    private String nameDto;
    private int ageDto;
    private String addr;
    private String clazzName; //映射CLazz 中的ClazzName
}
//Clazz
public class Clazz {
    private String num;
    private String ClazzName;
}
```

#### 编写测试类

```java
 @Test
    public void test4(){
        //使用field将双方名字相对应,若有多个不同可连续使用field, 使用byDefault将其余相同名字的自动拷贝
        mapperFactory.classMap(Student.class, StudentDto.class)
                .field("name","nameDto")
                .field("age","ageDto")
                .byDefault()
                .register();
        //获取映射器
        MapperFacade mapperFacade = mapperFactory.getMapperFacade();
        Student student = new Student("lishi", 25,"beijing");
        Clazz clazz = new Clazz("0236", "android");
        StudentDto studentDto = new StudentDto();
        //复制student
        mapperFacade.map(student, studentDto);
        //复制clazz
        mapperFacade.map(clazz,studentDto);

        System.out.println(studentDto);

    }
测试结果
StudentDto(nameDto=lishi, ageDto=25, addr=beijing, clazzName=android)
```

###list集合与list集合之间的映射

#### 相同属性

编写实体类

```java
public class Student {
    private String name;
    private int age;
    private String addr;
}
public class StudentDto {
    private String name;
    private int age;
    private String addr;
}
```

编写测试类

```java
/***
     * List<Student> 和List<StudentDto>之间的映射
     */
@Test
public void test2(){
    //
    MapperFacade mapperFacade = mapperFactory.getMapperFacade();
    Student student = new Student("lishi", 25,"beijing");
    Student student2 = new Student("wangwu", 25,"jiangxi");
    List<Student> students = Arrays.asList(student, student2);
    //
    List<StudentDto> studentDtos = mapperFacade.mapAsList(students, StudentDto.class);
    System.out.println(studentDtos);

}
测试结果：
[StudentDto(name=lishi, age=25, addr=beijing), StudentDto(name=wangwu, age=25, addr=jiangxi)]
```

#### 不同属性

编写实体类

```java
//Student
public class Student {
    private String name;
    private int age;
    private String addr;
}
//StudentDto
public class StudentDto {
    private String nameDto;
    private int ageDto;
    private String addr;
}
```

编写测试类

```java
 @Test
public void test3(){
    // 使用field将双方名字相对应
    mapperFactory.classMap(Student.class,StudentDto.class)
        .field("name","nameDto")
        .field("age","ageDto")
        .byDefault()
        .register();
    MapperFacade mapperFacade = mapperFactory.getMapperFacade();
    Student student = new Student("lishi", 25,"beijing");
    Student student2 = new Student("wangwu", 25,"jiangxi");
    List<Student> students = Arrays.asList(student, student2);
    //
    List<StudentDto> studentDtos = mapperFacade.mapAsList(students, StudentDto.class);
    System.out.println(studentDtos);

}
测试结果：
[StudentDto(name=lishi, age=25, addr=beijing), StudentDto(name=wangwu, age=25, addr=jiangxi)]
```

### 类中属性到实体的映射 

编写实体类  将Student中的name数据复制到StudentDto 中

```java
public class Name{
    private String name;
    private int age;
}
public class Student {
   private Name name;
}
public class StudentDto {
    private String name;
    private int age;
}
```

编写测试类

```java
@Test
public void test6(){
    //可以直接通过.符号来映射名字
    mapperFactory.classMap(Student.class,StudentDto.class)
        .field("names.name","name")
        .field("names.age","age")
        .register();
    MapperFacade mapperFacade = mapperFactory.getMapperFacade();
    Student student = new Student();
    student.setNames(new Name("lishi",25));
    StudentDto map = mapperFacade.map(student, StudentDto.class);
    System.out.println(map);
}
测试结果
StudentDto(name=lishi, age=25)
```