# 领域模型数仓

**Repository Path**: weizuxiao911/domain-repository

## Basic Information

- **Project Name**: 领域模型数仓
- **Description**: 基于领域驱动设计架构思想下，结合Spring框架进行增强，实现Repository组件化，支持自动装配，注解声明式应用。
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 0
- **Created**: 2022-09-06
- **Last Updated**: 2023-12-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Framework

## README

# 特征
- 自动装配，按需加载
- 支持MySQL、MongoDB
- 支持MySQL事务管理
- 支持MySQL读写分离

# 应用

## 引入依赖

```xml
<!-- 引入spring jdbc，如果不使用MySQL作为存储，可删除 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
    <version>2.1.14.RELEASE</version>
</dependency>
<!-- 引入spring mongodb，如果不使用MongoDB作为存储，可删除 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
    <version>2.1.14.RELEASE</version>
</dependency>

<!-- 引入组件 -->
<dependency>
    <groupId>w.z.x.framework</groupId>
    <artifactId>repository</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</dependency>
```

## MYSQL应用

### 读写分离
```yaml
spring:
  datasource:
    # 写库
    master:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
      username: root
      password: P@ssw0rd
    # 读库
    slave:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=GMT%2b8&allowPublicKeyRetrieval=true
      username: root
      password: P@ssw0rd
```

### 数据结构

```java
/**
 * MYSQL 测试类
 *
 * @author 魏祖潇
 */
@Slf4j
@Data /* getter / setter */
@Mapper("t_user") /* reflect to table */
public class User extends MysqlFactory implements Serializable {

    /**
     * 自增ID
     */
    @GenKey
    private Long id;

    /**
     * 创建时间，新增时自动填充
     */
    private Date createTime;

    /**
     * 修改时间，新增或修改时自动填充
     */
    private Date modifyTime;

    /**
     * 逻辑删，新增时自动填充，查询时自动拼接到where条件
     */
    @LogicDelete
    private Boolean deleted;

    /**
     * 乐观锁，新增时自动填充，更新时自增且拼接到where条件
     */
    @Version
    private Long version;

    /**
     * 用户名
     */
    @ID
    private String username;

    /**
     * 性别
     */
    private Gender gender;

    /**
     * html
     */
    private String html;

    /**
     * 不持久化属性
     */
    @Transient
    private Integer ignore;

    /**
     * 其他行为方法
     */
}
```

### 单元测试

```java
/**
 * 单元测试
 *
 * @author 魏祖潇
 */
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Application.class)
@EnableTransactionManagement
public class MysqlTest {

    /**
     * save
     */
    @Test
    public void save() {
        User it = MysqlFactory.build(User.class)
                .of(User::getUsername, "1")
                .of(User::getGender, Gender.NONE)
                .of(User::getHtml,"");
        it.save();
    }

    /**
     * batch save
     */
    @Test
    public void save2() {
        List<User> list = Arrays.asList(
                MysqlFactory.build(User.class)
                        .of(User::getUsername, "1")
                        .of(User::getGender, Gender.NONE)
                        .of(User::getHtml,""),
                MysqlFactory.build(User.class)
                        .of(User::getUsername, "2")
                        .of(User::getGender, Gender.NONE)
                        .of(User::getHtml,""),
                MysqlFactory.build(User.class)
                        .of(User::getUsername, "3")
                        .of(User::getGender, Gender.NONE)
                        .of(User::getHtml,"")
        );
        MysqlFactory.save(list);
    }

    /**
     * update
     */
    @Test
    public void update() {
        User it = MysqlFactory.get(User.class, "1");
        if (Objects.nonNull(it)) {
            it.update();
        }
    }

    /**
     * batch update
     */
    @Test
    public void update2() {
        List<User> list = MysqlFactory.get(User.class, "1", "2");
        MysqlFactory.update(list);
    }

    /**
     * update with wrapper
     */
    @Test
    public void update3() {
        LambdaUpdateWrapper<User> wrapper = Wrapper.lambdaUpdateWrapper();
        wrapper.set(User::getGender, Gender.MALE.getCode())
                .eq(User::getUsername, "1");
        MysqlFactory.update(User.class, wrapper);
    }

    /**
     * update by sql
     */
    @Test
    public void update4() {
        String sql = "update t_user set version = version + 1 where username = ?";
        MysqlFactory.update(sql, "1");
    }

    /**
     * saveOrUpdate
     */
    @Test
    public void saveOrUpdate() {
        User it = MysqlFactory.build(User.class)
                .of(User::getUsername, "1");
        it.setHtml("<html></html>");
        it.saveOrUpdate();
    }

    /**
     * delete
     */
    @Test
    public void delete() {
        User it = MysqlFactory.get(User.class, "1");
        if (Objects.nonNull(it)) {
            it.delete();
        }
    }

    /**
     * delete with wrapper
     */
    @Test
    public void delete2() {
        LambdaDeleteWrapper wrapper = Wrapper.lambdaDeleteWrapper();
        wrapper.limit(1);
        MysqlFactory.delete(User.class, wrapper);
    }

    /**
     * get
     */
    @Test
    public void get() {
        log.info("{}", MysqlFactory.get(User.class, "2"));
    }

    /**
     * get in ids
     */
    @Test
    public void get2() {
        log.info("{}", MysqlFactory.get(User.class, "1", "11"));
    }

    /**
     * get with wrapper
     */
    @Test
    public void get3() {
        LambdaQueryWrapper<User> wrapper = Wrapper.lambdaQueryWrapper();
        wrapper.eq(User::getUsername, "1");
        log.info("{}", MysqlFactory.get(User.class, wrapper));
    }

    /**
     * find by sql
     */
    @Test
    public void find() {
        log.info("{}", MysqlFactory.find("select * from t_domain"));
    }

    /**
     * find and convert
     */
    @Test
    public void find2() {
        log.info("{}", MysqlFactory.find(User.class, "select * from t_domain"));
    }

    /**
     * find with wrapper
     */
    @Test
    public void find3() {
        LambdaQueryWrapper<User> wrapper = Wrapper.lambdaQueryWrapper();
        wrapper.limit(1);
        log.info("{}", MysqlFactory.find(User.class, wrapper));
    }

    /**
     * count by sql
     */
    @Test
    public void count() {
        log.info("{}", MysqlFactory.count("select count(1) from t_user"));
    }

    /**
     * count domain
     */
    @Test
    public void count2() {
        log.info("{}", MysqlFactory.count(User.class));
    }

    /**
     * count with wrapper
     */
    @Test
    public void count3() {
        LambdaQueryWrapper<User> wrapper = Wrapper.lambdaQueryWrapper();
        wrapper.like(User::getUsername, "1");
        log.info("{}", MysqlFactory.count(User.class, wrapper));
    }

    /**
     * page and convert
     */
    @Test
    public void page() {
        log.info("{}", MysqlFactory.page(User.class, 1, 10, "select * from t_user"));
    }

    /**
     * page with wrapper
     */
    @Test
    public void page2() {
        LambdaQueryWrapper<User> wrapper = Wrapper.lambdaQueryWrapper();
        wrapper.like(User::getUsername, "1");
        log.info("{}", MysqlFactory.page(User.class, wrapper, 1, 10));
    }

}
```

## MongoDB应用

### 数据结构

```java
/**
 * 测试类
 * @author 魏祖潇
 */
@Data
public class Role extends MongodbFactory {

    @Id
    private String id;

    private String userId;

    private String roleId;

    /**
     * 其他行为实现
     */
}
```

### 单元测试

```java
/**
 * 单元测试
 *
 * @author 魏祖潇
 */
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Application.class)
@EnableTransactionManagement
public class MongodbTest {

    @Test
    public void save() {
        Role role = new Role();
        role.setRoleId("3");
        role.setUserId("3");
        role.save();
        log.info("entity => {}", role);
    }

    @Test
    public void get() {
        Role role = MongodbFactory.get(Role.class, Query.query(Criteria.where("userId").is("3")));
        log.info("{}", role);
    }

    @Test
    public void update() {
        Role role = MongodbFactory.get(Role.class, Query.query(Criteria.where("userId").is("3")));
        if (Objects.nonNull(role)) {
            role.setRoleId("4");
            role.update();
        }
    }

    @Test
    public void count() {
        log.info("count => {}", MongodbFactory.count(Role.class));
    }

    @Test
    public void page() {
        log.info("page => {}", MongodbFactory.page(Role.class, new Query(), 2, 1));
    }

}

```