Spring-Data-Jpa使用总结@慕课网原创_慕课网

！[]（http://img3.sycdn.imooc.com/5dd38a95000100b816000900.jpg）

参考资源列表>> 1.官方文档：https : //docs.spring.io/spring-data/jpa/docs/2.1.5.RELEASE/reference/html/ > 2.“春数据JPA入门到精通”

前言

JPA是Java持久性API '的简称，是'春天'在'休眠'的基础上进行的二次封装框架，为了更好更方便的融入'春天'大家庭，同时也提供了一些休眠SpringData` 没有的特性，与其他ORM框架一起构成，统一封装了ORM层，使开发人员使用起来更加方便快捷。

备注：本文所有代码都是基于SpringBoot 2.1.5版本

JPA的使用

基本单表操作的使用

对于操作单表来说，JPA提供了非常方便使用的封装，我们只需要按规范编写库接口同时继承JpaRepository就可以接受JPA基本功能了代码如下：

用户实体：

java 包 com 。一竹。实体; 进口龙目岛。建造者; 进口龙目岛。数据; 进口龙目岛。ToString ; 导入 javax 。坚持不懈。* ; 导入 java 。io 。可序列化; 导入 java 。实用程序。清单; 导入 java 。实用程序。设置;

@Entity @Table（名称= “T_USER”）@Data @Builder公共类用户器具序列化{私人静态最终长的的的serialVersionUID = 1L ; @Id @GeneratedValue（策略= GenerationType.IDENTITY）私人龙ID;私有字符串名称;专有字符串密码;私有整体时代;私人的整数性别; } 储存库接口：。java的包COM一竹仓库;引入玉米一竹实体用户。;公共接口UserRepository扩展了JpaRepository <用户，龙> { } 下面看看JPA为我们提供了一些替代操作单表数据的方法。java的包有机弹簧框架。数据。jpa。仓库; @NoRepositoryBean公共接口JpaRepository

< T ， ID > 扩展了PagingAndSortingRepository < T ， ID > ， QueryByExampleExecutor < T > { List < T > findAll （）; //查询全表数据列表< T > findAll

（对var1排序）; //查询全表数据，支持排序 List < T > findAllById （ Iterable < ID > var1 ）; //根据id细分查询所有匹配数据< S 扩展T >列表< S > saveAll （ Iterable < S > var1 ）; //批量保存或更新数据void flush （）; //刷新本地缓存到数据库< S 扩展T > S saveAndFlush

 （ S var1 ）;  //保存或更新单挑数据及刷新本地缓存到数据库空隙deleteInBatch （可迭代< Ť > VAR1 ）; //批量删除数据无效deleteAllInBatch （）; //批量删除全表数据     T getOne （ ID var1 ）; //根据id查询一条匹配数据< S 扩展T > List < S > findAll （示例< S > ar1 ）；//示例方式的查询指定实体<

  

  



   

S 扩展 T > List < S >  findAll （示例< S > var1 ， Sort var2 ）; 	//示例方式的查询指定实体并排序} ```

java 包 org 。弹簧框架。数据。仓库; @NoRepositoryBean 公共接口PagingAndSortingRepository < T ， ID > 扩展CrudRepository < T ， ID > { Iterable < T > findAll （ Sort var1 ）; //根据排序查询全表，返回类型是任意集合 Page < T > findAll （ Pageable var1 ）; //根据分页参数分页查询

} `“ java包org。弹簧框架。数据。仓库；@NoRepositoryBean公共接口CrudRepository < T，ID >扩展存储库< T，ID > { < S扩展T > S save（S var1）；//保存或更新单条数据<S扩展T>可重复 saveAll（可迭代< S > var1）； //批量保存或更新可选 findById（ID var1）； //根据id查询数据，，返回类型是可选的boolean existById（ID var1）； //根据id判断数据是否存在Iterable findAll（）；//查询全表数据，返回类型为集合Iterable findAllById（Iterable var1）；//根据id集合查询数据long count（）；//统计全表数据量void deleteById（ID var1）；//根据ID删除数据无效删除（ŤVAR1）；//删除单条数据void deleteAll（可迭代<？扩展T>

    		//删除指定集合数据无效的deleteAll（）；//删除全表数据} ```的java包有机弹簧框架数据仓库查询。。;公共接口QueryByExampleExecutor < Ť > { <小号扩展Ť >可选<小号> findOne（示例<小号> VAR1）; //根据示例查询一条<S扩展T>可迭代<S> findAll（示例< S > var1）；//根据示例查询所有数据<S扩展T>可重复<S> findAll（示例<S> var1，对var2排序）； //根据示例查询所有数据，并排序<S扩展T>页面<S> findAll （示例<S> var1，可分页的var2）；//根据示例分页查询<S     扩展T > long   count（示例<

; ///根据示例统计<S扩展T>布尔值存在（示例 var1）； //根据示例判断数据是否存在} 另外，jpa提供了一套新的生成sql的机制，非常方便好用，JPA根据存储库接口的方法中的关键字，实体替换及出入参，自动生成SQL，这种方式启动容器的时候就可以检查语法是否正确，简单使用示例如下：的Java 包融为一体。一竹。仓库; 导入 com 。一竹。实体。用户; 导入组织。弹簧框架。数据。jpa 。仓库。实体图; 导入组织。弹簧框架。数据。jpa。仓库。JpaRepository

; 导入组织。弹簧框架。数据。jpa 。仓库。JpaSpecificationExecutor ; 导入组织。弹簧框架。数据。jpa 。仓库。查询; 导入组织。弹簧框架。数据。仓库。查询。参数; 导入 java 。

util.List;

public interface UserRepository extends JpaRepository<User, Long>{

/**
 * 根据年龄查询用户信息
 * @param age
 * @return
 */
List<User> findAllByAge(Integer age);

/**
 * 根据用户性别和所属组织名称查询用户信息
 * @param userSex
 * @param orgName
 * @return
 */
List<User> findBySexAndOrg(@Param("sex") Integer sex, @Param("name") String name);

/**
 *根据用户名模糊查询
 * @return 
 * / 
 列出<用户> findAllByNameLike（@Param（“名称”）字符串名称）；} ``除了`发现`，`由`，`和`之外，还有一些关键字，全部定义在`PartTree`，`部分'类，组装起来可以生成各种各样的SQL，下面截取部分代码，研究员的同学可以打开原始码去阅读```java package org 。弹簧框架。数据。仓库。查询。解析器; 公共类PartTree 实现Streamable < PartTree 。OrPart > { 私有静态最终字符串KEYWORD_TEMPLATE =







 
   “（％s）（？=（\\ p {Lu} | \\ P {InBASIC_LATIN}））” ；私有静态最终字符串QUERY_PATTERN = “查找|读取|获取|查询|流” ; 私有静态最终字符串COUNT_PATTERN = “ count” ; 私有静态最终字符串EXISTS_PATTERN = “ exists” ; 私有静态最终字符串DELETE_PATTERN = “ delete | remove” ; 私有静态最终模式PREFIX_TEMPLATE = Pattern 。编译（
   
   
   
   
  “ ^（查找|读取|获取|查询|流|计数|存在|删除|删除）（（（\\ p {Lu}。*？））??通过” ）；私有最终 PartTree 。学科学科; 私有最终 PartTree 。谓词谓词; 。。。私有静态 String [ ] split （ String text ， String关键字）{         模式模式=模式。编译（字符串。格式（“（％s）（？=（\\ p {Lu} | \\ P {InBASIC_LATIN}））” ，

关键字））; 返回模式。分割（文字）; } 私人静态类谓词工具可流< PartTree 。OrPart > { 私有静态最终模式ALL_IGNORE_CASE =模式。编译（“ AllIgnor（ing | e）Case” ）; 私有静态最终字符串ORDER_BY = “ OrderBy” ; 私人决赛

     列出< PartTree 。OrPart >节点; 私有最终 OrderBySource orderBySource ; 私有boolean alwaysIgnoreCase ; 公共谓词（字符串谓词，类< ？> domainClass ）{             字符串[ ] parts = PartTree 。分裂（此。detectAndSetAllIgnoreCase （谓词），“排序依据” ）

; 如果（部分。长度> 2）{抛出新的IllegalArgumentException（“在方法名称中不能多次使用OrderBy！”））；}其他{这个。例程=（列表）副本。流（PartTree。分割（份[0]，“或”））。。过滤器（StringUtils的：：

              hasText).map((part) -> {
                return new PartTree.OrPart(part, domainClass, this.alwaysIgnoreCase);
            }).collect(Collectors.toList());
            this.orderBySource =零件。length String > subject {                  匹配器GRP = LIMITED_QUERY_TEMPLATE。匹配（它）；返回可选< String > subject ， Pattern pattern ）{== 2 ? new OrderBySource(parts[1], Optional.of(domainClass)) : OrderBySource.EMPTY;
        }
    }
    ...
}

private static class Subject {
    private static final String DISTINCT = "Distinct";
    private static final Pattern COUNT_BY_TEMPLATE = Pattern.compile("^count(\\p{Lu}.*?)??By");
    private static final Pattern EXISTS_BY_TEMPLATE = Pattern.compile("^(exists)(\\p{Lu}.*?)??By");
    private static final Pattern DELETE_BY_TEMPLATE = Pattern.compile("^(delete|remove)(\\p{Lu}.*?)??By"); 私有静态最终字符串LIMITING_QUERY_PATTERN = “（First | Top）（\\ d *）？” ; 私有静态最终模式LIMITED_QUERY_TEMPLATE =模式。编译（“ ^（find | read | get | query | stream）（Distinct）？（First | Top）（\\ d *）？（\\ p {Lu}。*？）?? By” ）; 私人最终布尔不同; 私有最终布尔计数; 私有最终布尔存在; 私有最终布尔删除;
       
      
      
      
      
      
    private  final可选的< Integer > maxResults ; 公共主题（可选< ）{ this 。独特= （布尔）主题。映射（（它）- > { 返回它。包含（“鲜明” ）; } ）。orElse （假）; 这个。数=

      
           
            
        
         this.matches(subject, COUNT_BY_TEMPLATE);
        this.exists = this.matches（subject，EXISTS_BY_TEMPLATE）; 
        this.delete = this.matches（subject，DELETE_BY_TEMPLATE）; 
        这个。maxResults= this。returnMaxResultsIfFirstKSubjectOrNull（主题）；} private任选<Integer> returnMaxResultsIfFirstKSubjectOrNull（任选<String> subject）{返回主题。映射（（它）-> 
    
             ！grp.find（）？null：StringUtils.hasText（grp.group（4））吗？Integer.valueOf（grp.group（4））：1;             }）;         } 		...         private布尔匹配（返回）。映射（（它）-> {返回图案。匹配（它）。发现（）；}）。否则容易（假）; }}}```

java包org。弹簧框架。数据。仓库。查询。解析器; 公共类Part {专有静态最终模式IGNORE_CASE =模式。编译（“ Ignor（ing | e）情况”）；私有最终PropertyPath propertyPath; 私人最后部分。类型类型; 公共静态枚举类型{BETWEEN（2，新的字符串[] {“ IsBetween”，“之间”}），IS_NOT_NULL（0，新的字符串[] {“ IsNotNull”，”。NotNull”}）， IS_NULL（0，新的字符串[] {“ IsNull”，“ Null”}），LESS_THAN（新字符串[] {“ IsLessThan”，“一个不超过”）），LESS_THAN_EQUAL（新字符）串[] { “ IsLessThanEqual”，“ LessThanEqual”}），GREATER_THAN（新字符串[] {“ IsGreaterThan”，“大于”}），GREATER_THAN_EQUAL（新变量[] {“ IsGreaterThanEqual”，“ GreaterThanEqual”}），BEFORE（新字符）串[] {“ IsBefore”，“ Before”}），AFTER（新字符串[] {“ IsAfter”，“ After”}），LIKE（新字符串[] {“ IsLike”，“ Like”}）），， STARTING_WITH（新字符串[] {“ IsStartingWith”，“ StartingWith”，“ StartsWith”}），ENDING_WITH（新字符串[] {“ IsEndingWith”，“ EndingWith”，“ EndsWith”}），IS_NOT_EMPTY（0，新的弦[] {“ I sNotEmpty”，“ NotEmpty”}），

    IS_EMPTY（0，新的字符串[] {“ IsEmpty”，“ Empty”}）），
    NOT_CONTAINING（新字符串[] {“ IsNotContaining”，“ NotContaining”，“ NotContains”}}，包含
    （新的字符串[] {“ IsContaining”，“ Containing”，“包含”}），
    NOT_IN（新的字符串[] {“ IsNotIn”，“ NotIn”}），
    IN（新字符串[] {“ IsIn”，” In “}}），
    NEAR（新字符串[] {“ IsNear”，“ Near”}”），
    WITHIN（新字符串[] {“ IsWithin”，“ Inside”}），
    REGEX（新字符串[] { “ MatchesRegex”，“ Matches”，“ Regex”}），
    EXISTS（0，新字符串[] {“ Exists”}），
    TRUE（0，新字符串[] {“ IsTrue”，“ True”}），
    FALSE（0，新字符串[] {“ IsFalse”，“ False”}），
    NEGATING_SIMPLE_PROPERTY（新字符串[] {“ IsNot”，“ Not”}），SIMPLE_PROPERTY（新字符串[] {“是”，'等于'}）；私人静态最终列表<部分类型> ALL =副本.asList（ IS_NOT_NULL，IS_NULL，不到LESS_THAN，LESS_THAN_EQUAL，GREATER_THAN，GREATER_THAN_EQUAL 
      

      之前，之后，NOT_LIKE，LIKE，STARTING_MPITH，ENDING_EITH，TY_IST_T，NOT_IN，IN，NEAR ININ，TY_TY，TY，TY，PER，TY，PER，PER 
      长度> ALL_KEYWORDS ；私有最终列表<String>关键字; 私有final int numberOfArguments; 静态。List{String> allKeywords = new ArrayList（）;。。。。。继承器var1 = ALL。继承器（）; 而（VAR1。具有下一个（））{部分。型型=（部分。类型）VAR1。下一个（）；                                                                                                                                                                                        
     
      
	
     

            allKeywords。addAll（类型。关键字）；} ALL_KEYWORDS =集合。unmodifiableList（allKeywords）；}} }```

可以看到单表操作的大部分需求JPA都为我们提供了现成的实现，但也支持我们使用@Query注解自定义查询SQL，方便有SQL基础的同学使用，SQL可控性强。

java包com。一竹。仓库; 引入com。一竹。实体。用户; jpa。仓库。实体图；导入组织。弹簧框架。数据。jpa。仓库。JpaRepository；导入组织。弹簧框架。数据。导入组织。弹簧框架。数据

。jpa。仓库。JpaSpecificationExecutor；导入组织。弹簧框架。数据。jpa。仓库。查询；导入组织。弹簧框架。数据。仓库。查询。参数; 引入java。实用程序。清单; 公共接口UserRepository扩展了JpaRepository <User，

 Long>{

/**
 * 查询所有用户信息
 * @return
 */
@Query(value = "from User u")
List<User> findAll();

/**
 * 根据年龄查询用户信息
 * @param age
 * @return
 */
@Query(value = "select * from t_user u where u.user_age = ?1", nativeQuery = true)
List<User> findAllByAge(Integer age); / **      *根据用户性别和所属组织名称查询用户信息     * @param userSex      * @param orgName      * @return      * / @Query （ value = “从用户u中选择u从u左加入u.org o其中u.userSex =： userSex和o.orgName =：orgName“ ）     列表<用户> findUsersBySexAndOrg （@Param （” userSex“ ）整数userSex ，@Param （” orgName“ ）字符串orgName ）; } ```

多表关联

@OneToOne，@OneToMany，@ManyToOne，@ManyToMany


 
   




     



     
    
    
    

     
     
    

     
     


     
     
    

     
     
    

     
     
    长orgId; @ApiModelProperty（值=“用户信息”）@OneToOne @JoinColumn（名称=“ id”，可更新= false，可插入= false）私有UserInfo userInfo；@ApiModelProperty（值=“用户所属组织”）@ManyToOne @JoinColumn（名称=“ org_id”，可更新= false，可插入= false）    私人组织机构；@ApiModelProperty（值=“用户角色”）@OneToMany @JoinColumn（名称=“ USER_ID”，referencedColumnName =“ ID”，可插入=假，可更新=假）@NotFound（动作= NotFoundAction。IGNORE）私有集<角色>角色; @ApiModelProperty（值    =“用户工作”）@ManyToMany @JoinTable（名称=“ t_user_job”，joinColumns = @JoinColumn（名称=“ user_id”，referencedColumnName =“ id”），inverseJoinColumns = @JoinColumn（名称=“ job_id”）， referencedColumnName =“ id“））@ NotFound（动作= NotFoundAction。。）IGNORE）    私人集合<Job>工作；```

     
    
       
    

     
    
       


     
    
        
    
    


    
    
 
   
   
    
    



>`private Set <角色>角色；和和私订<工作>的工作；“不能用同时使用”列表代替，会报错`org.hibernate.loader.MultipleBagFetchException：不能同时获取多个袋：[com.yizhu.entity.User.jobs，com.yizhu.entity.User.roles] ` ###动态查询```java 包 com 。一竹。仓库; 导入 com 。一竹。dto 。UserQueryDto ; 导入 com 。一竹。实体。组织; 导入 com 。一竹。实体。用户; 导入组织。









弹簧框架。数据。jpa 。域。规格; 导入 javax 。坚持不懈。标准。加盟; 导入 javax 。坚持不懈。标准。JoinType ; 导入 javax 。坚持不懈。标准。谓词; 导入 java 。实用程序。ArrayList ; 导入 java 。实用程序。





清单; 导入 java 。实用程序。可选的; 公共类UserSpecs { 公共静态规范<用户> listQuerySpec （ UserQueryDto userQueryDto ）{ 返回（根，查询，构建器）- > {             列表<谓词>谓词= 新ArrayList < > （）;


   

      
           
  

            可选的。ofNullable （ userQueryDto 。的getId （））。ifPresent （我- >谓词。添加（助洗剂。等于（根。获得（“ID” ），我）））;             可选的。ofNullable （ userQueryDto 。的getName （））。ifPresent （ ñ -
>谓词。添加（建设者。等于（根。获得（“名称” ）， ñ ）））; 
            可选的。ofNullable （ userQueryDto 。getAge （））。ifPresent （一- >谓词。加（建设者。等于（根。获得（“时代” ）， a）））; 
            可选的。ofNullable （ userQueryDto 。getOrgId （））。ifPresent （ OI - >谓词。添加（助洗剂。等于（根。获得（“ORGID” ）， OI ）））;             可选的。ofNullable （ userQueryDto 。getOrgName （））。
ifPresent(on -> {
                Join<User, Organization> userJoin = root.join(root.getModel().getSingularAttribute("org", Organization.class), JoinType.LEFT);
                predicates.add(builder.equal(userJoin.get("orgName"), on));
            });

            return builder.and(predicates.toArray(new Predicate[predicates.size()]));
        };
    }
}

package com.yizhu.service;

import com.yizhu.dto.UserQueryDto;
import com.yizhu.entity.User;
import com.yizhu.repository.UserRepository;
import com.yizhu.repository.UserSpecs;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> findUsersDynamic(UserQueryDto userQueryDto){
        return userRepository.findAll(UserSpecs.listQuerySpec(userQueryDto));
    }
}

审计功能使用

在启动类添加@EnableJpaAuditing注解表示开启jpa审计功能

package com.yizhu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@EnableJpaAuditing
@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}
}

在需要使用审计功能的实体类添加@EntityListeners(AuditingEntityListener.class)注释解

package com.yizhu.entity;

import lombok.Builder;
import lombok.Data;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "t_role")
@Data
@Builder
@EntityListeners(AuditingEntityListener.class)
public class Role implements Serializable {
    private static final long serialVersionUID=1L;

    @ApiModelProperty(hidden = true)
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String roleName;

    @CreatedDate
    private Date createTime;
    
	@CreatedBy
    private Long createId;
    
    @LastModifiedDate
    private Date updateTime;
    
	@LastModifiedBy
    private Long updateId;
}

实现AuditorAware接口，告诉容器当前登录人id

package com.yizhu.configuration;

import org.springframework.data.domain.AuditorAware;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.Optional;

public class UserAuditorAwareImpl implements AuditorAware<Long> {
    @Override
    public Optional<Long> getCurrentAuditor() {
        // 从session中获取登录人id
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        Long userId = (Long)servletRequestAttributes.getRequest().getSession().getAttribute("userId");
        return Optional.of(userId);
    }
}

ok，然后jpa将会根据ID和Version判断当前操作是更新还是添加数据，添加时会注入当前登录人id到标有@CreateBy注解的转移上，当前时间注入到标有@CreateTime注解分段上；更新时则注入到@LastModifiedBy和对应@LastModifiedDate的基线上。想详细了解的可查看org.springframework.data.jpa.domain.support.AuditingEntityListener原始代码。

常见的坑

N + 1问题，当使用@ManyToMany，@ManyToOne，@OneToMany，@OneToOne关联关系的时候，FetchType怎么配置LAZY或者EAGER.SQL执行真正的时候的英文由一条主表查询和Ñ条子表查询组成的。这种查询效率一般比较低下，某些子对象有N个就会执行N + 1条SQL。使用JPA 2.1启动的@ EntityGraph，@ NamedEntityGraph可以解决该问题。如下。



 
   




     

       serialVersionUID = 1L ; @ApiModelProperty （隐藏= 真）@Id @GeneratedValue （策略= GenerationType 。 IDENTITY ）私人龙ID ; //省略其他属性} ```

     
    
    
    
    
    



```java
package com.yizhu.repository;

import com.yizhu.entity.User;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */
    @EntityGraph(value = "User.findUsers", type = EntityGraph.EntityGraphType.FETCH)
    User findAllById(Long id);

    /**
     * 根据name查询用户信息
     * @param name
     * @return
     */
    @EntityGraph(value = "User.findUsers", type = EntityGraph.EntityGraphType.FETCH)
    @Query(value = "select * from t_user where user_name = :name", nativeQuery = true)
    List<User> findAllByUserName(@Param("name") String name);
}

所有的注解要么全配置在字段上，要么全配置在获得方法上，不能混用，混用就会启动不起来，但是语法配置没有问题。- 所有的关联都是支持单向关联和双向关联的，- 在所有的关联查询中，表一般是不需要建立外键索引的。。在特定情况下，视听特定业务场景而定。JSON序列化的时间使用双向注解会产生死循环，需要人为手动转换一次，或者使用@JsonIgnore 。 @mappedBy的使用需要注意。- 级联删除比较危险，建议考虑清楚，或者完全掌握。- 不同的关联关系的配置，@ JoinClumn里面的名字，referencedColumnName代表的意思是不一样的，很容易弄混，可以根据打印出来的SQL做调整。- 当配置这些关联关系的时候建议大家直接在表上面，把外键建好，然后通过后面我们介绍的开发工具直接生成，这样可以减少自己调试的时间。

JPA常用注解

摘自《 Spring Data JPA从入门到精通》

！[1554619508054]（http://img3.sycdn.imooc.com/5dd38a980001e64909160828.jpg）

！[1554619555135]（http://img1.sycdn.imooc.com/5dd38a9e00017a5808980852.jpg）

！[1554619583326]（http://img1.sycdn.imooc.com/5dd38aa00001f81808390276.jpg）

！[1554619600777]（http://img3.sycdn.imooc.com/5dd38aa40001f30a08990565.jpg）

！[1554619615592]（http://img2.sycdn.imooc.com/5dd38aa700010ead09290574.jpg ）

！[1554619631450]（http://img1.sycdn.imooc.com/5dd38aab0001a22709330901.jpg ）

！[1554620031094]（http://img1.sycdn.imooc.com/5dd38aaf0001548009410705.jpg ）

！[1554620213902]（http://img3.sycdn.imooc.com/5dd38ab400019c5309081128.jpg ）

！[1554620262086]（http://img4.sycdn.imooc.com/5dd38ab80001d6fa09060403.jpg ）

更多信息可以关注我的个人博客：[逸竹小站]