当前位置: 首页 > news >正文

源码建站和模板建站区别百度浏览器网页

源码建站和模板建站区别,百度浏览器网页,盗号网站怎么做,新注册的公司怎么做网站目录 1 事务概述 1.1 为什么需要事务 1.2 事务的特性 1.3 Spring 中事务的实现 2 Spring 声明式事务 2.1 Transactional 2.2 Transactional 的作用范围 2.3 Transactional 的各种参数 2.3.1 ioslation 2.4 事务发生了异常,也不回滚的情况 异常被捕获时 3 事务的传…

目录

1 事务概述

1.1 为什么需要事务

1.2 事务的特性

1.3 Spring 中事务的实现

2 Spring 声明式事务

2.1 @Transactional

2.2 @Transactional 的作用范围

2.3 @Transactional 的各种参数

2.3.1 ioslation 

2.4 事务发生了异常,也不回滚的情况

异常被捕获时

3 事务的传播机制 

3.1 定义

3.2 为什么需要事务传播机制

3.3 事务传播机制种类

Propagation.REQUIRED 

 Propagation.SUPPORTS 

 Propagation.MANDATORY

Propagation.REQUIRES_NEW

Propagation.NOT_SUPPORTED

Propagation.NEVER

Propagation.NESTED


1 事务概述

1.1 为什么需要事务

事务定义

将⼀组操作封装成⼀个执⾏单元(封装到⼀起),要么全部成功,要么全部失败。

对于转账来说:

第一步操作:A 账户 -1000 元

第二步操作:B 账户 +1000 元

使用了事务之后,这一组操作要么一起执行成功,要么一起失败。如果没有事务的情况下,有可能第一步成功了,第二步失败了,那么对于 A 来说,它的账户的 1000 块钱就人间蒸发了。

1.2 事务的特性

事务有4 ⼤特性(ACID),原⼦性、持久性、⼀致性和隔离性,具体概念如下:

原⼦性(Atomicity):⼀个事务(transaction)中的所有操作,要么全部完成,要么全部不完成,不会结束在中 间某个环节。事务在执⾏过程中发⽣错误,会被回滚(Rollback)到事务开始前的状态,就像这个 事务从来没有执⾏过⼀样。

⼀致性(Consistency):在事务开始之前和事务结束以后,数据库的完整性没有被破坏。这表示写⼊的资料必须完 全符合所有的预设规则,这包含资料的精确度、串联性以及后续数据库可以⾃发性地完成预定的⼯ 作。

隔离性(Isolation):数据库允许多个并发事务同时对其数据进⾏读写和修改的能⼒,隔离性可以防⽌多个事务 并发执⾏时由于交叉执⾏⽽导致数据的不⼀致。事务隔离分为不同级别,包括读未提交(Read uncommitted)、读提交(read committed)、可重复读(repeatable read)和串⾏化 (Serializable)。

持久性(Durability):事务处理结束后,对数据的修改就是永久的,即便系统故障也不会丢失。

1.3 Spring 中事务的实现

Spring 中事务操作分为两类:

1. 编程式事务(手动写代码操作事务)

2. 声明式事务(利用注解自动开启和提交事务)

2 Spring 声明式事务

MySQL 中,事务有三个重要的操作:开启事务、提交事务、回滚事务,对应的操作命令如下:

-- 开启事务

start transaction;

 

-- 业务执行

  

-- 提交事务

commit;

  

-- 回滚事务

rollback;

而 Spring 声明式事务的实现与 MySQL 事务的实现基本一致,只是前者自动的,只需要在需要的⽅法上添加 @Transactional 注解就可以实现了,⽆需⼿动开启事务和提交事务,进⼊⽅法时⾃动开启事务,⽅法执⾏完会⾃动提交事务,如果中途发⽣了没有处理的异常会⾃动回滚事务。

2.1 @Transactional

package com.example.demo.model;import lombok.Data;import java.time.LocalDateTime;@Data
public class UserInfo {private int id;private String username;private String password;private String photo;private LocalDateTime createtime;private LocalDateTime updatetime;private int state;
}
package com.example.demo.mapper;import com.example.demo.model.UserInfo;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;@Mapper
public interface UserMapper {@Insert("insert into userinfo(username,password) values(#{username},#{password})")int add(UserInfo userInfo);
}
package com.example.demo.service;import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class UserService {@Autowiredprivate UserMapper userMapper;public int add(UserInfo userInfo){return userMapper.add(userInfo);}
}
package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactionalpublic  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("莉丝");userInfo.setPassword("6363");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);int num = 10/0;// 3. 将结果给前端return 0;}
}

启动项目发现,使用了 @Transactional 注解的确回滚了事务:

 可以看到,信息并没有添加到数据库的 userinfo 这表里。

2.2 @Transactional 的作用范围

@Transactional 可以用来修饰方法或类,修饰方法时,只能应用到 public 方法上,其他访问权限均不生效;修饰类时,该注解对该类中所有的 public 方法都生效。

2.3 @Transactional 的各种参数

参数作用
value配置多个事务管理器时,使用该属性指定一个事务管理器
transactionManager
propagation事务的传播行为,默认值为 Propagation.REQUIRED
isolation事务的隔离级别,默认值为 Isolation.DEFAULT
timeout事务的超出时间,默认值为 -1。如果超出该时间限制但事务还没有完成,则自动回滚事务
readOnly是否为只读事务,默认值为 false;
rollbackFor指定触发事务回滚的异常类型,可以多个
rollbackForClassName指定触发事务回滚的异常类名称,可以多个
noRollbackFor指定不回滚事务的异常类型,可以多个
noRollbackForClassName指定不回滚事务的异常类名称,可以多个

2.3.1 ioslation 

根据文章开头的介绍,我们知道事务有四大特性,分别是原子性、一致性、隔离性以及持久性。而这四大特性中,只有隔离性,也就是隔离级别是可以设置的。

事务的隔离级别是用来保障多个并发事务执行更加可控,更符合程序员的预期。

在 Spring 中,可以通过 @Transactional 中的 isolation 属性进行设置。

MySQL 事务隔离级别:

1. READ UNCOMMITTED:读未提交,该隔离级别的事务可以看到其他事务中未提交的数据,⽽未提交的数据可能会发⽣回滚,因此我们把该级别读取到的数据称之为脏数据,把这个问题称之为脏读。

2. READ COMMITTED:读已提交,该隔离级别的事务能读取到已经提交事务的数据, 因此它不会有脏读问题。但由于在事务的执⾏中可以读取到其他事务提交的结果,所以在不同时间的相同 SQL 查询中,可能会得到不同的结果,这种现象叫做不可重复读。

3. REPEATABLE READ:可重复读,是 MySQL 的默认事务隔离级别,它能确保同⼀事务多次查询的结果⼀致,这就意味着,该级别的事务 A 正在执行,而另一个事务 B 成功插入了一条数据,但由于可重复读要保证每次查询的结果一致,所以 A 就会查询不到这条数据,但是 A 也想插入这条数据,却发现插入不了,这就是幻读。

4. SERIALIZABLE:序列化,事务最⾼隔离级别,它会强制事务排序,使之不会发⽣冲突,从⽽解决了脏读、不可重复读和幻读问题,但因为执⾏效率低,所以真正使⽤的场景并不多。

 

事务隔离级别脏读不可重复读幻读
读未提交
读已提交×
可重复读××
串行化×××

 

● 脏读:⼀个事务读取到了另⼀个事务修改的数据之后,后⼀个事务⼜进⾏了回滚操作,从⽽导致第⼀个事务读取的数据是错误的。

● 不可重复读:⼀个事务两次查询得到的结果不同,因为在两次查询中间,有另⼀个事务把数据修改了。

● 幻读:⼀个事务两次查询中得到的结果集不同,因为在两次查询中另⼀个事务有新增了⼀部分数据。

不同的数据库的隔离级别是不一样的,MySQL 有四种,Oracle 有三种。Spring 的隔离级别为五种,是为了兼容不同的数据库。

Spring 中事务隔离级别包含以下 5 种:

1. Isolation.DEFAULT:以连接的数据库的事务隔离级别为主。

2. Isolation.READ_UNCOMMITTED:读未提交,可以读取到未提交的事务,存在脏读。

3. Isolation.READ_COMMITTED:读已提交,只能读取到已经提交的事务,解决了脏读,存在不可重复读。

4. Isolation.REPEATABLE_READ:可重复读,解决了不可重复读,但存在幻读(MySQL默认级别)。

​​​​​​​

5. Isolation.SERIALIZABLE:串⾏化,可以解决所有并发问题,但性能太低。

如果 Spring 的隔离级别与 MySQL 设置的隔离级别不同的时候,以 Spring 设置的隔离级别为主。

Spring 相当于一个客户端,设置了,以 Spring 设置的为主,没有设置时,跟连接的数据库的隔离级别一样,也就是 DEFAULT。

隔离级别枚举的值以 2 的次方,性能更高。

2.4 事务发生了异常,也不回滚的情况

异常被捕获时

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactionalpublic  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("莉丝");userInfo.setPassword("6363");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){}// 3. 将结果给前端return 0;}
}

 

@Transactional 是AOP,出现异常的时候,代理对象可以感知到异常,并进行事务的回滚。但如果异常被捕获了,外部的代理对象就感知不到了,就不会进行事务的回滚了。

对此有两种解决方案。

1. 将异常继续抛出去,让代理对象感知到异常,也就能自动的回滚事务了。

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactionalpublic  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){throw e;}// 3. 将结果给前端return 0;}
}

2.  使用代码,手动回滚事务

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactionalpublic  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}// 3. 将结果给前端return 0;}
}

 在网页没有报错的情况下,进行了事务的回滚。

3 事务的传播机制 

3.1 定义

Spring 事务传播机制定义了多个包含了事务的⽅法,相互调⽤时,事务是如何在这些⽅法间进⾏传递的。

3.2 为什么需要事务传播机制

事务隔离级别是保证多个并发事务执⾏的可控性的(稳定性的),⽽事务传播机制是保证⼀个事务在多个调⽤⽅法间的可控性的(稳定性的)。

8

 

3.3 事务传播机制种类

Propagation.REQUIRED 

默认的事务传播级别,如果当前存在事务,就加入这个事务(加入意味着成为这个外部事务的一部分),如果不存在事务,则会自己创建一个新的事务。与其他被调用的事务,要么一起提交事务,要么一起回滚事务。

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactionalpublic  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}// 3. 将结果给前端return 0;}
}
package com.example.demo.service;import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;@Service
public class UserService {@Autowiredprivate UserMapper userMapper;@Transactionalpublic int add(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("add result -> " + result);insert(userInfo);return result;}@Transactionalpublic int insert(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("insert result -> " + result);int num = 10 / 0;return result;}
}

add 调用两个加了@Transactional 的 service 的方法。

 Propagation.SUPPORTS 

如果当前存在事务(存在于别的方法开启的事务中,而不是自己启动事务),则加入该事务;如果没有,则以非事务的方式继续运行。

修改 insert 方法如下,添加 propagation 参数:

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactional(propagation = Propagation.SUPPORTS)public  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){
//            throw e;TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}// 3. 将结果给前端return 0;}
}

 对于上述 add 来说,它并没有存在于任何一个事务当中,所以它按照非事务的方式运行。

package com.example.demo.service;import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;@Service
public class UserService {@Autowiredprivate UserMapper userMapper;@Transactional(propagation = Propagation.SUPPORTS)public int add(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("add result -> " + result);insert(userInfo);return result;}@Transactional(propagation = Propagation.SUPPORTS)public int insert(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("insert result -> " + result);int num = 10 / 0;return result;}}

service 中, add 被 controller 调用,由于 controller 不存在事务,因此 add 也不存在于任何事务中,所以 add 按照非事务的方式运行,同样对于 insert 来说也是如此,按照非事务的方式运行。

运行结果是:添加了两条信息:

 

如果 controller 的 add 的事务传播机制改成 Propagation.REQUIRED ,其他两个方法不变,结果会怎么样呢?

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactional(propagation = Propagation.REQUIRED)public  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){
//            throw e;TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}// 3. 将结果给前端return 0;}
}

 Propagation.MANDATORY

mandatory 强制性的意思。如果当前存在事务,则加入该事务;如果没有事务,则抛出异常。

Propagation.REQUIRES_NEW

表示创建⼀个新的事务,如果当前存在事务,则把当前事务挂 起。也就是说不管外部⽅法是否开启事务,Propagation.REQUIRES_NEW 修饰的内部⽅法会新开 启⾃⼰的事务,且开启的事务相互独⽴,互不⼲扰。

Propagation.NOT_SUPPORTED

以⾮事务⽅式运⾏,如果当前存在事务,则把当前事务挂起。

Propagation.NEVER

以⾮事务⽅式运⾏,如果当前存在事务,则抛出异常。

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactional(propagation = Propagation.REQUIRED)public  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("埃罗尔");userInfo.setPassword("9146");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);try{int num = 10/0;}catch (Exception e){
//            throw e;TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}// 3. 将结果给前端return 0;}
}
package com.example.demo.service;import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;@Service
public class UserService {@Autowiredprivate UserMapper userMapper;@Transactional(propagation = Propagation.NEVER)public int add(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("add result -> " + result);insert(userInfo);return result;}@Transactional(propagation = Propagation.NEVER)public int insert(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("insert result -> " + result);int num = 10 / 0;return result;}}

 

运行结果: 

 不添加任何一条信息。

Propagation.NESTED

如果当前存在事务,则创建⼀个事务作为当前事务的嵌套事务来运⾏;如果当前没有事务,则该取值等价于 PROPAGATION_REQUIRED。

嵌套的事务不影响外部的事务。NESTED 嵌套 NESTED ,一个完蛋,所有的 NESTED 都完蛋。

package com.example.demo.controller;import com.example.demo.model.UserInfo;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RequestMapping("/user")
@RestController
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/add")@Transactional(propagation = Propagation.REQUIRED)public  int add(){// 1. 非空判断UserInfo userInfo = new UserInfo();userInfo.setUsername("玛丽莲·梦露");userInfo.setPassword("18");// 2. 调用 service 执行添加int result = userService.add(userInfo);System.out.println("result:"+result);userService.insert(userInfo);// 3. 将结果给前端return 0;}
}
package com.example.demo.service;import com.example.demo.mapper.UserMapper;
import com.example.demo.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;@Service
public class UserService {@Autowiredprivate UserMapper userMapper;@Transactional(propagation = Propagation.NESTED)public int add(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("add result -> " + result);return result;}@Transactional(propagation = Propagation.NESTED)public int insert(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("insert result -> " + result);try {int num = 10 / 0;}catch (Exception e){TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}return result;}
}

如果 insert 方法写成以下这种形式,不但 insert 感知到了异常,调用方感知到了异常,就会造成总体回滚,这就意味着数据无法添加。

    @Transactional(propagation = Propagation.NESTED)public int insert(UserInfo userInfo){int result = userMapper.add(userInfo);System.out.println("insert result -> " + result);int num = 10 / 0;return result;}

而如果对 insert 进行手动回滚操作,这样只有 insert 感知到了异常,但是调用方并没有感知。

为什么把 insert 放在 add 里,也会回滚。



文章转载自:
http://autopista.rqjL.cn
http://spousal.rqjL.cn
http://popularization.rqjL.cn
http://bulldike.rqjL.cn
http://roughstuff.rqjL.cn
http://inotropic.rqjL.cn
http://chrysanth.rqjL.cn
http://glycogen.rqjL.cn
http://pistillate.rqjL.cn
http://juruena.rqjL.cn
http://floriculturist.rqjL.cn
http://violator.rqjL.cn
http://nazir.rqjL.cn
http://quassia.rqjL.cn
http://santiago.rqjL.cn
http://sciagram.rqjL.cn
http://ontologic.rqjL.cn
http://couloir.rqjL.cn
http://soapberry.rqjL.cn
http://roofline.rqjL.cn
http://omuda.rqjL.cn
http://bastardy.rqjL.cn
http://lill.rqjL.cn
http://phew.rqjL.cn
http://peltast.rqjL.cn
http://decruit.rqjL.cn
http://avion.rqjL.cn
http://simazine.rqjL.cn
http://intermixture.rqjL.cn
http://heliotypography.rqjL.cn
http://pulverise.rqjL.cn
http://drafty.rqjL.cn
http://scotophobia.rqjL.cn
http://pantheist.rqjL.cn
http://heuristic.rqjL.cn
http://pithecanthrope.rqjL.cn
http://afterwar.rqjL.cn
http://synod.rqjL.cn
http://bacteriolytic.rqjL.cn
http://histographically.rqjL.cn
http://sabre.rqjL.cn
http://epistolary.rqjL.cn
http://dendroid.rqjL.cn
http://likesome.rqjL.cn
http://surfeit.rqjL.cn
http://carriage.rqjL.cn
http://aborigines.rqjL.cn
http://strother.rqjL.cn
http://absurdity.rqjL.cn
http://thermophile.rqjL.cn
http://disdainfulness.rqjL.cn
http://superwater.rqjL.cn
http://theogony.rqjL.cn
http://connoisseurship.rqjL.cn
http://serration.rqjL.cn
http://stability.rqjL.cn
http://legionary.rqjL.cn
http://knaggy.rqjL.cn
http://teeny.rqjL.cn
http://balthazer.rqjL.cn
http://garibaldian.rqjL.cn
http://orzo.rqjL.cn
http://paraprotein.rqjL.cn
http://dunnakin.rqjL.cn
http://aztec.rqjL.cn
http://auction.rqjL.cn
http://hemipod.rqjL.cn
http://infrared.rqjL.cn
http://neckband.rqjL.cn
http://fiend.rqjL.cn
http://harvardian.rqjL.cn
http://cholerine.rqjL.cn
http://indissociably.rqjL.cn
http://hemochrome.rqjL.cn
http://aerocraft.rqjL.cn
http://modality.rqjL.cn
http://printed.rqjL.cn
http://encumbrance.rqjL.cn
http://mesogloea.rqjL.cn
http://deogratias.rqjL.cn
http://portraitist.rqjL.cn
http://baptist.rqjL.cn
http://pledgor.rqjL.cn
http://rustler.rqjL.cn
http://dishabituate.rqjL.cn
http://pionium.rqjL.cn
http://radioscopically.rqjL.cn
http://sixpennyworth.rqjL.cn
http://mahratta.rqjL.cn
http://plethora.rqjL.cn
http://gerontophil.rqjL.cn
http://lapp.rqjL.cn
http://supercilious.rqjL.cn
http://nonprotein.rqjL.cn
http://kasai.rqjL.cn
http://antihypertensive.rqjL.cn
http://contrail.rqjL.cn
http://nematicidal.rqjL.cn
http://encephalomalacia.rqjL.cn
http://inequilaterally.rqjL.cn
http://www.dt0577.cn/news/86609.html

相关文章:

  • 网站怎么访问自己做的网页seo推广培训课程
  • 二次开发收费需要高点广州seo托管
  • 手机网站制作代理商百度标记号码认证平台
  • 芜湖哪里做网站搜索引擎实训心得体会
  • 中山祥云做的网站怎么样百度百科新人学会seo
  • 桂林微信网站设计百度竞价客服电话
  • 湖南网站推网站seo推广seo教程
  • 搜狗网站提交关键词排名零芯互联关键词
  • 长春做网站优化百度秒收录软件工具
  • wordpress制作官方网站广告联盟怎么加入
  • 网站建设的最新技术推广软文平台
  • bootstrap 自适应网站深圳做网站
  • 大兴企业官网网站建设网络营销课程个人感悟
  • 深圳网站设计 三把火科技近三天重大新闻摘抄
  • 网络营销案例分析论文3000字seo优化多少钱
  • 太原商城网站建设秦皇岛seo招聘
  • sketch做网站线框图企业网站设计公司
  • 上市企业网站建设长沙百度地图
  • wordpress横幅插件seo软件推荐
  • 020模版网站制作seo 怎么做到百度首页
  • 做网站的人叫什么软件官网关键词优化价格
  • 网站seo评测seo在线优化网站
  • 建设官方网站的主要作用my63777免费域名查询2023年
  • 长沙做网站kaodezhu谷歌下载官网
  • 给个网站做导航违法吗黄页88网络营销宝典
  • 信息技术转移网站建设拉新工作室在哪里接项目
  • 电脑上用手机app是什么软件北京优化推广
  • 青岛开发区建网站公司营销型公司网站建设
  • 三星官网网站怎么做关键词排名靠前
  • 宁波市网站排名优化最简单的营销方案