目录

  • 四种状态
  • API示例  
    • persist
    • remove
    • merge
    • refresh
  • 参考链接

四种状态

首先以一张图,简单介绍写实体生命周期中四种状态之间的转换关系:

瞬时(New):瞬时对象,刚New出来的对象,无id,还未和持久化上下文(Persistence Context)建立关联。

托管(Managed):托管对象,有id,已和持久化上下文(Persistence Context)建立关联,对象属性的所有改动均会影响到数据库中对应记录。

  • 瞬时对象调用em.persist()方法之后,对象由瞬时状态转换为托管状态
  • 通过find、get、query等方法,查询出来的对象为托管状态
  • 游离状态的对象调用em.merge方法,对象由游离状态转换为托管状态

游离(Datached):游离对象,有id值,但没有和持久化上下文(Persistence Context)建立关联。

  • 托管状态对象提交事务之后,对象状态由托管状态转换为游离状态
  • 托管状态对象调用em.clear()方法之后,对象状态由托管状态转换为游离状态
  • New出来的对象,id赋值之后,也为游离状态

删除(Removed):执行删除方法(em.remove())但未提交事务的对象,有id值,没有和持久化上下文(Persistence Context)建立关联,即将从数据库中删除。

API示例

针对JPA规范的四个方法,写了一个简单的Demo,进行了一一的验证,以下进行验证过程说明,完整代码传送门:https://github.com/hdlxt/SpringDataJpaDemo.git

整体结构如下:

persist

不同状态下执行em.persist()方法产生结果:

  • 瞬时态:转化为托管态
  • 托管态:不发生改变,但执行instert语句
  • 删除态:转化为托管态
  • 游离态:抛异常

验证删除态和游离态持久化如下:

1.持久化删除态

  • 代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    /**
* 持久化删除态的对象
*@param id
* @return
*/
@RequestMapping("/persistRemove/{id}")
public String persistRemove(@PathVariable("id")Long id){
try {
User user = userDao.findById(id);
userDao.persistRemove(user);
}catch (Exception e){
logger.error("持久化一个删除态的对象!",e);
return REPONSE_ERR;
}
return REPONSE_SUCCESS;
}
--------------------------------------------------------
/**
* 持久化删除态的对象
*
* @param user
*/
@Override
public void persistRemove(User user) {
remove(user);
persist(user);
user.setName("persist remove success!");
}

2.持久化游离态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    /**
    * 持久化游离态的对象
    *@param id
    * @return
    */
    @RequestMapping("/persisDetached/{id}")
    public String persisDetached(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.clear();
    userDao.persist(user);
    }catch (Exception e){
    logger.error("持久化一个游离态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
  • 步骤

  • 结果:抛异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    2019-01-26 00:00:34.090 ERROR 5228 --- [io-8080-exec-10] c.e.demo.controller.UserController       : 持久化一个游离态的对象!
    org.springframework.dao.InvalidDataAccessApiUsageException: detached entity passed to persist: com.example.demo.entity.User; nested exception is org.hibernate.PersistentObjectException: detached entity passed to persist: com.example.demo.entity.User
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.convertHibernateAccessException(HibernateJpaDialect.java:317) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:253) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.DataAccessUtils.translateIfNecessary(DataAccessUtils.java:242) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

    ....

remove

不同状态下执行em.remove()方法产生结果:

  • 瞬时态:对状态无影响,后台打印日志
  • 托管态:转化为托管态
  • 删除态:无影响,什么都不发生
  • 游离态:抛异常Removing a detached instance com.example.demo.entity.User...

验证过程如下:

1.瞬时态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
    * 删除new出来的对象
    *@param id
    * @return
    */
    @RequestMapping("/removeNew")
    public String removeNew(){
    try {
    User user = new User().setName("lxt").setNumber("007");
    userDao.remove(user);
    }catch (Exception e){
    logger.error("删除(remove)一个new的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
  • 步骤

  • 结果:返回SUCCESS!后台输出日志

    1
    2019-01-26 00:17:32.811  INFO 10136 --- [nio-8080-exec-5] o.h.e.i.DefaultDeleteEventListener       : HHH000114: Handling transient entity in delete processing

2.删除态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
        /**
    * 删除 删除态对象
    *@param id
    * @return
    */
    @RequestMapping("/removeRemove/{id}")
    public String removeRemove(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.removeRemove(user);
    }catch (Exception e){
    logger.error("删除(remove)一个删除态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    -----------------------------------------------------
    /**
    * 删除 删除态的对象
    *
    * @param user
    */
    @Override
    public void removeRemove(User user) {
    remove(user);
    remove(user);
    }

3.游离态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
        /**
    * 删除游离态对象
    *@param id
    * @return
    */
    @RequestMapping("/removeDetached/{id}")
    public String removeDetached(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.removeDetached(user);
    }catch (Exception e){
    logger.error("删除(remove)一个游离态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    -------------------------------------------------------------
    /**
    * 删除游离态的对象
    *
    * @param user
    */
    @Override
    public void removeDetached(User user) {
    clear();
    remove(user);
    }
  • 步骤

  • 结果:返回ERROR!抛异常

    1
    2
    3
    4
    5
    6
    7
    8
    2019-01-26 00:14:11.071 ERROR 5228 --- [io-8080-exec-10] c.e.demo.controller.UserController       : 删除(remove)一个游离态的对象!

    org.springframework.dao.InvalidDataAccessApiUsageException: Removing a detached instance com.example.demo.entity.User#5; nested exception is java.lang.IllegalArgumentException: Removing a detached instance com.example.demo.entity.User#5
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:373) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.DataAccessUtils.translateIfNecessary(DataAccessUtils.java:242) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

merge

不同状态下执行em.merge()方法产生结果:

  • 瞬时态:提交到数据库,返回一个新的托管态的对象
  • 托管态:根据原对象返回一个新的托管态的对象
  • 删除态:抛异常org.springframework.dao.InvalidDataAccessApiUsageException: org.hibernate.ObjectDeletedException: deleted instance passed to merge: [com.example.demo.entity.User#<null>]...
  • 游离态:提交到数据库,进行更新或插入,返回一个新的托管态的对象

合并(merge)删除态和游离态验证过程如下:

1.删除态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
        /**
    * 持久化删除态的对象
    *@param id
    * @return
    */
    @RequestMapping("/mergeRemove/{id}")
    public String mergeRemove(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.mergeRemove(user);
    }catch (Exception e){
    logger.error("合并(merge)一个删除态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    --------------------------------------------------------------------
    /**
    * 合并删除态的对象
    *
    * @param user
    */
    @Override
    public void mergeRemove(User user) {
    remove(user);
    merge(user);
    }
  • 步骤

  • 结果:返回ERROR抛异常!

    1
    2
    3
    4
    5
    6
    7
    8
    9
    2019-01-26 00:23:01.187  INFO 10136 --- [nio-8080-exec-3] o.h.h.i.QueryTranslatorFactoryInitiator  : HHH000397: Using ASTQueryTranslatorFactory
    Hibernate: select user0_.id as id1_0_, user0_.name as name2_0_, user0_.number as number3_0_ from t_user user0_ where user0_.id=?
    2019-01-26 00:23:01.322 ERROR 10136 --- [nio-8080-exec-3] c.e.demo.controller.UserController : 合并(merge)一个删除态的对象!

    org.springframework.dao.InvalidDataAccessApiUsageException: org.hibernate.ObjectDeletedException: deleted instance passed to merge: [com.example.demo.entity.User#<null>]; nested exception is java.lang.IllegalArgumentException: org.hibernate.ObjectDeletedException: deleted instance passed to merge: [com.example.demo.entity.User#<null>]
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:373) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

2.游离态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
        /**
    * 持久化游离态的对象
    *@param id
    * @return
    */
    @RequestMapping("/mergeDetached/{id}")
    public String mergeDetached(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.mergeDetached(user);
    }catch (Exception e){
    logger.error("合并(merge)一个游离态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    ---------------------------------------------------------------
    /**
    * 合并游离态的对象
    *
    * @param user
    */
    @Override
    public void mergeDetached(User user) {
    clear();
    User newUser = merge(user);
    newUser.setName("newUser merge detached success!");
    user.setName("user merge detached success!");
    }
  • 步骤

  • 结果:对应实体的name值变为newUser merge detached success!,证明返回新的对象为托管态对象

2.游离态

refresh

方法可以保证当前的实例与数据库中的实例的内容一致,注意:是反向同步,将数据库中的数据同步到实体中

不同状态下执行em.refresh()方法产生结果:

  • 瞬时态:抛异常org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed;
  • 托管态: 将数据库中的数据同步到实体中,返回一个托管态的对象。
  • 删除态:抛异常org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed;
  • 游离态:抛异常org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed;

总结:只有被托管的对象才可以被refresh。

1.瞬时态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
    * 刷新new出来的对象
    *@param id
    * @return
    */
    @RequestMapping("/refreshNew")
    public String refreshNew(){
    try {
    User user = new User().setName("lxt").setNumber("007");
    userDao.refresh(user);
    }catch (Exception e){
    logger.error("刷新(refresh)一个new的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
  • 步骤

  • 结果:返回ERROR!抛异常

    1
    2
    3
    4
    5
    6
    7
    2019-01-26 00:38:18.037 ERROR 10136 --- [nio-8080-exec-3] c.e.demo.controller.UserController       : 刷新(refresh)一个new的对象!

    org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed; nested exception is java.lang.IllegalArgumentException: Entity not managed
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:373) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

2.托管态:

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
       /**
    * 刷新托管态对象
    *@param id
    * @return
    */
    @RequestMapping("/refreshManaged/{id}")
    public String refreshManaged(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.refreshManaged(user);
    }catch (Exception e){
    logger.error("刷新(refresh)一个托管态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    ------------------------------------------------------------------
    /**
    * 刷新托管态的对象
    *
    * @param user
    */
    @Override
    public void refreshManaged(User user) {
    user.setName("refresh before!");
    refresh(user);
    logger.info("user:"+user);
    }
  • 步骤

  • 结果:数据库中数据并无变化,日志打印为数据库中查询出的值,并未打印refresh before!

3.删除态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
        /**
    * 刷新删除态对象
    *@param id
    * @return
    */
    @RequestMapping("/refreshRemove/{id}")
    public String refreshRemove(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.refreshRemove(user);
    }catch (Exception e){
    logger.error("刷新(refresh)一个删除态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    ----------------------------------------------------------------------
    /**
    * 刷新删除态的对象
    *
    * @param user
    */
    @Override
    public void refreshRemove(User user) {
    remove(user);
    user.setName("refresh remove before!");
    refresh(user);
    user.setName("refresh remove after!");
    }
  • 步骤

  • 结果:返回ERROR!抛异常

    1
    2
    3
    4
    5
    6
    7
    2019-01-26 00:40:57.713 ERROR 10136 --- [nio-8080-exec-3] c.e.demo.controller.UserController       : 刷新(refresh)一个删除态的对象!

    org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed; nested exception is java.lang.IllegalArgumentException: Entity not managed
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:373) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

4.游离态

  • 代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
        /**
    * 刷新游离态对象
    *@param id
    * @return
    */
    @RequestMapping("/refreshDetached/{id}")
    public String refreshDetached(@PathVariable("id")Long id){
    try {
    User user = userDao.findById(id);
    userDao.refreshDetached(user);
    }catch (Exception e){
    logger.error("刷新(refresh)一个游离态的对象!",e);
    return REPONSE_ERR;
    }
    return REPONSE_SUCCESS;
    }
    ----------------------------------------------------------------------
    /**
    * 刷新游离态的对象
    *
    * @param user
    */
    @Override
    public void refreshDetached(User user) {
    clear();
    refresh(user);
    }
  • 步骤

  • 结果:返回ERROR!抛异常!

    1
    2
    3
    4
    5
    6
    7
    2019-01-26 00:42:09.598 ERROR 10136 --- [nio-8080-exec-7] c.e.demo.controller.UserController       : 刷新(refresh)一个游离态的对象!

    org.springframework.dao.InvalidDataAccessApiUsageException: Entity not managed; nested exception is java.lang.IllegalArgumentException: Entity not managed
    at org.springframework.orm.jpa.EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(EntityManagerFactoryUtils.java:373) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.vendor.HibernateJpaDialect.translateExceptionIfPossible(HibernateJpaDialect.java:255) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.translateExceptionIfPossible(AbstractEntityManagerFactoryBean.java:527) ~[spring-orm-5.1.4.RELEASE.jar:5.1.4.RELEASE]
    at org.springframework.dao.support.ChainedPersistenceExceptionTranslator.translateExceptionIfPossible(ChainedPersistenceExceptionTranslator.java:61) ~[spring-tx-5.1.4.RELEASE.jar:5.1.4.RELEASE]

参考链接

Spring Data JPA实体的生命周期总结的更多相关文章

  1. Spring Data JPA实体详解

    1. Spring Data JPA实体概述 JPA提供了一种简单高效的方式来管理Java对象(POJO)到关系数据库的映射,此类Java对象称为JPA实体或简称实体.实体通常与底层数据库中的单个关系 ...

  2. idea 从数据库快速生成Spring Data JPA实体类

    第一步,调出 Persistence 窗口. File—>Project Structure—>model—> + —>JPA 第二步:打开 Persistence窗口 配置 ...

  3. spring data jpa实体类映射配置

    @Entity:用来标志实体类,知名这是一个和数据库表映射的实体类 @Id注解指明这个属性映射为数据库的主键 @GeneratedValue注解默认使用主键生成方式为自增,hibernate会自动生成 ...

  4. 在Spring Data JPA 中使用Update Query更新实体类

    对于 Spring Data JPA 使用的时间不长,只有两年时间.但是踩过坑的却不少. 使用下列代码 @Modifying @Query("update User u set u.firs ...

  5. Spring Data JPA 多个实体类表联合视图查询

    Spring Data JPA 查询数据库时,如果两个表有关联,那么就设个外键,在查询的时候用Specification创建Join 查询便可.但是只支持左连接,不支持右连接,虽说左右连接反过来就能实 ...

  6. Spring Data Jpa系列教程--------实体解析和关联关系

    Spring Data Jpa是基于HIbernate开发的,所以建立实体建的实体和映射关系需要好好好的去了解一下,本文有以下内容,实体管理器介绍,实体与数据库表的映射介绍,关联关系(一对多,多对多) ...

  7. spring data JPA entityManager查询 并将查询到的值转为实体对象

    spring data JPA entityManager查询 并将查询到的值转为实体对象 . https://blog.csdn.net/qq_34791233/article/details/81 ...

  8. Spring Data JPA 查询结果返回至自定义实体

    本人在实际工作中使用Spring Data Jpa框架时,一般查询结果只返回对应的Entity实体.但有时根据实际业务,需要进行一些较复杂的查询,比较棘手.虽然在框架上我们可以使用@Query注解执行 ...

  9. Spring Data JPA系列5:让IDEA自动帮你写JPA实体定义代码

    大家好,又见面了. 这是本系列的最后一篇文档啦,先来回顾下前面4篇: 在第1篇<Spring Data JPA系列1:JDBC.ORM.JPA.Spring Data JPA,傻傻分不清楚?给你 ...

随机推荐

  1. 简单快速安装Apache+PHP+MySql服务环境(四)—— 将php版本升级到7.2

    书接上文,简单快速安装Apache+PHP+MySql服务环境(二)-- centos使用yum安装指定版本的php. 随着各种PHP框架的升级,对PHP的版本也有了更高的要求,所以笔者也尝试着更新升 ...

  2. 【Javaweb】Cookie和Session

    会话技术 什么是会话 从浏览器访问服务器开始,到访问服务器结束,浏览器关闭为止的这段时间内容产生的多次请求和响应,合起来叫做浏览器和服务器之间的一次会话 会话管理作用 共享数据用的,并且是在不同请求间 ...

  3. selenium定位,操作元素

    1.定位方式 1.id driver.find_element_by_id('username').send_keys('byhy') 2.name driver.find_element_by_na ...

  4. Android系统编程入门系列之界面Activity响应多元的属性动画

    在响应丝滑动画一篇文章中,分别介绍了作用于普通视图.绘制视图的绘制对象.和界面这三种对象的动画效果,但是都有一些使用的局限性.比如这些动画都只是以屏幕上绘制更新的方式绘制动画,并没有真实改变作用对象的 ...

  5. HashMap的转化时机

    HashMap的转化时机 /** * 使用红黑树(而不是链表)来存放元素.当向至少具有这么多节点的链表再添加元素时,链表就将转换为红黑树. * 该值必须大于2,并且应该至少为8,以便于删除红黑树时转回 ...

  6. DC-4靶机

    仅供个人娱乐 靶机信息 下载地址:http://www.five86.com/downloads/DC-4.zip 一.主机扫描 arp-scan -l nmap -p 1-65535 -A -sV ...

  7. 过渡——transition

    ① 设置参与过渡的属性 transition-property:  ;      all / transform / 参与过渡的属性 ② 设置过渡的时长 transition-duration:  s ...

  8. NODEJS对象

    1.全局对象 Node.js: global 交互模式下var声明的变量都属于全局下的变量,可以使用global访问,例如global.a 脚本模式下var声明的变量不属于全局下的变量.不能使用glo ...

  9. 通过比较rgb破解滑动验证码

    目标url:信用中国(广东中山)行政处罚 /** * base64转BufferedImage * * @param base64 * @return */ public static Buffere ...

  10. 判断状态栏是否显示以及获取状态栏高度的方法,及工具类列子【续:及OnGlobalLayoutListener的利用】

    http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2014/0731/1640.html 本篇博客是http://www.cnblogs.co ...