# quattro

**Repository Path**: markerccc/quattro

## Basic Information

- **Project Name**: quattro
- **Description**: 生态交互,原项目train
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2018-10-23
- **Last Updated**: 2024-11-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

**使用协议:**<br>
 The Apache Software License, Version 2.0 <br>
 http://www.apache.org/licenses/LICENSE-2.0.txt <br>
  **开发中,全代码不开源:**<br>



 **项目规划:** 
 ```
 native-api:api调用层
 native-crawler: 爬虫层
 native-jdbc: jdbc数据交互层
 native-swagger: 文档
 native-tx: 分布式事务
 native-shiro: 权限
 native-workflow: 工作流
 native-verify: 数据验证
```
 
 **使用方案:** 

 **1. 数据库表构建体系** 

```
<root>
   <entity>
     <sys_log>
       <id/> 
       <!--示例-->
       <name type="String" cfa="[0,9]" message="异常提示" groups="验证组(不含则不验证,默认全验证,手动指定)" defVal="默认值" ignore="update,delete(插入忽略或删除忽略)"/> 
       <age/> 
       <sex/> 
     </sys_log>
   </entity>
</root> 
```
 




 **验证规则:** 

|   |   |
|---|---|
|  type |  数据库该列数据类型(应映射为java类型,示例int->integer) |
|  cfa  |  传入参数的合法性验证,示例(1,9) = 1<param<9,(1,9] = 1<param<=9. 方括号为开区间不包含,正括号为闭区间包含,无穷采用∞替代或tele替代 |
|  message |   当cfa不满足时输出的信息,内部为抛出一个IllegalArgumentException(msg).自定义抓获|
|   groups|   验证组,自定义分组验证。例如insert时不验证cfa,并集用都好隔开示例(insert,update,delete)|
|   defVal|   默认值,仅当传入参数为null时,这个参数覆盖以值,默认不赋予,时间标记(timestamp)|
|   ignore|   更新条件.示例值 ("update"  ),更新时不更新此列。|


 **2.   辅助器：** 

      前后端分离采用。需要提供jwt的包和自定义规则
       <token state="true" />  

       session交互
       <session state="true" />

       启用缓存, ref缓存数据库默认redis,state=true默认开启,refClass=自定义缓存处理类,继承cn.lesper.cacheRule
       <cache ref="redis" state="true" refClass="" />

 **3.  默认CRUD,及手动构造** 

     查询(如果不写SQL语句,会自动根据前面配置好的数据映射构建SQL语句),支持关联查询：
     分页参数:page,limit

   
```
 <page return="Object">
         <sql>SELECT * FROM sys_log WHERE r_id = :rId</sql>
         <where>id=:id</where>
         
         <!-- 条件表达式待证参数可以为任意名,不一定来自数据库集合表-->
         <eq expression="id[1,5]">id=:id</eq>
         <eq expression="id != null">id=:id</eq>
         <eq expression="id == null">id=:id</eq>
         <eq expression="id == 123">id=:id</eq>
         
         <and>1=1</and>
         <and>1=1</and>
         
         <forward ref="跨xml跳转查询(test2.page,test2.info1),本地链接跳转查询(info不可带点),后台拼接结果集" />
 </page>

```

     链接跳转查询:

         使用referto指定下一节点,最终查询将合并结果(支持跨xml链接)
     
```
                    
 	<info referto="info1,info2">
		<major>SELECT * FROM sys_log</major>
		<majorParam>
			<where>id=:id</where>
			<eq value="1">id=:id</eq>
			<and>1=1</and>
			<and>1=1</and>
		</majorParam>
	</info>
	
	<info1>
		<minor>SELECT * FROM sys_log</minor>
		<minorParam>
			<where>id=:id</where>
			<eq value="1">id=:id</eq>
			<and>1=1</and>
			<and>1=1</and>
		</minorParam>
	</info1>
	
	<info2>
		<minor>SELECT * FROM sys_log</minor>
		<minorParam>
			<where>id=:id</where>
			<eq value="1">id=:id</eq>
			<and from="session">1=1</and>
			<and>1=1</and>
		</minorParam>
	</info2>
```


       

   增加： 



```
  <save>
     <sql>不配置将默认组装</sql>
     <referto>多表保存(支持跨xml指定)</referto>
  </save>
```




删除：

 
```
<del>
     <sql>不配置将默认组装</sql>
     <referto>多表删除(支持跨xml指定)</referto>
     <maior>
         <!--这里是主表的删除条件支持多条件-->
        <eq expression="id[1,9]">id=:id</eq>
        <where>id=:id</where>
    </major>
    <minor ref="子节点">
         <!--这里是子节点的删除条件支持多条件-->
        <eq expression="id[1,9]">id=:id</eq>
        <where>id=:id</where>
    </minor>
  </del>
```

|   |   |
|---|---|
| 默认节点(page=分页,info=详细查询,save=增改,del=删除)  return="Object" 返回结果是一个对象,可手动指定entity。  |   |
| ：   |  	条件构造均采用具名参数 |
| from以下参数均可用  |  	参数数据来源,默认从httpRequest body中取出,亦可from="session"表示从session中取出。示例 <where from="session">id=:id</where> |
| sql   |  	sql语句,不填写默认根据实体组装 |
| eq  |   条件expression,条件满足才会组装sql条件|
| where | sql where条件  |
| and  |  sql and条件 |
| forward  |ref="跨xml跳转查询(test2.page,test2.info1),本地链接跳转查询(info不可带点),后台拼接结果集"   |
| info>referto="info1,info2"  |  子节点指定 |
| info>major  | 主节点语句  |
| info>majorParam  | 主节点条件 |
| info1>minor| 子节点语句 |
| info1>minorParam  | 子节点条件 |




 **4.   事务：** <br>
default:<br>
-  TransactionUtils.start(开启) 
-  TransactionUtils.commit(提交) 
-  TransactionUtils.rollback(回滚) 
        
        
**5.   分布式事务(sharding)：**  

   一.柔性事务<br>
		 **_1.最大努力送达型_** <br>
                ![输入图片说明](https://images.gitee.com/uploads/images/2018/0906/114546_2bb3e51a_1132713.png "QQ截图20180906114425.png")

 **适用场景:** <br>

- 根据主键删除数据。<br>
- 更新记录永久状态，如更新通知送达状态。<br>

 **使用规则：** <br>
- 使用最大努力送达型柔性事务的SQL需要满足幂等性。<br>
- INSERT语句要求必须包含主键，且不能是自增主键。<br>
- UPDATE语句要求幂等，不能是UPDATE xxx SET x=x+1<br>
- DELETE语句无要求。<br>


**_2.TCC型_** <br>
		
    ~待正

**_3.分库分表** <br>

```
CREATE TABLE IF NOT EXISTS t_order_x (
  order_id INT NOT NULL,
  user_id  INT NOT NULL,
  PRIMARY KEY (order_id)
);
CREATE TABLE IF NOT EXISTS t_order_item_x (
  item_id  INT NOT NULL,
  order_id INT NOT NULL,
  user_id  INT NOT NULL,
  PRIMARY KEY (item_id)
);
```
  _均匀分布:_ 

```
db0
  ├── t_order_0 
  └── t_order_1 
db1
  ├── t_order_0 
  └── t_order_1
```

 _规则构建:_ 
` TableRule orderTableRule = TableRule.builder("t_order").actualTables(Arrays.asList("t_order_0", "t_order_1")).dataSourceRule(dataSourceRule).build();`

 _自定义分布:_ 

```
db0
  ├── t_order_0 
  └── t_order_1 
db1
  ├── t_order_2
  ├── t_order_3
  └── t_order_4

```
 _规则构建:_ 
` TableRule orderTableRule = TableRule.builder("t_order").actualTables(Arrays.asList("db0.t_order_0", "db0.t_order_1", "db1.t_order_2", "db1.t_order_3", "db1.t_order_4")).dataSourceRule(dataSourceRule).build();`

 _案例：_ 

```
db0
  ├── t_order_0               user_id为偶数   order_id为偶数
  ├── t_order_1               user_id为偶数   order_id为奇数
  ├── t_order_item_0          user_id为偶数   order_id为偶数
  └── t_order_item_1          user_id为偶数   order_id为奇数
db1
  ├── t_order_0               user_id为奇数   order_id为偶数
  ├── t_order_1               user_id为奇数   order_id为奇数
  ├── t_order_item_0          user_id为奇数   order_id为偶数
  └── t_order_item_1          user_id为奇数   order_id为奇数
```

 _逻辑表与实际表:_ 


```
 select * from t_order where user_id = ? and order_id = ?;

 当user_id=0且order=0时，Sharding-JDBC将会将SQL语句转换为如下形式：

 select * from db0.t_order_0 where user_id = ? and order_id  = ?;

 其中原始SQL中的t_order就是 逻辑表，而转换后的db0.t_order_0就是 实际表
```


 更多详细配置参见:[sharding-jdbc](http://shardingsphere.io)

 **技术选型：** <br>
xml解析框架：dom4j <br>
数据交互：java jdbc <br>
数据交互优化方案:sharding-jdbc(可选。大型分布式采用)<br> 
web框架：Spring 4.3.8[用于测试可移除使用其他web框架,例如Struts] <br>     


 **正在优化中~**