Spring Boot JpaRepository知识学习（Spring Data JPA）

[color=red][size=large][b]1.Spring Data所解决的问题 [/b][/size][/color]
Spring Data：提供了一整套数据访问层(DAO)的解决方案，致力于减少数据访问层(DAO)的开发量。它使用一个叫作Repository的接口类为基础，它被定义为访问底层数据模型的超级接口。而对于某种具体的数据访问操作，则在其子接口中定义。

public interface Repository<T, ID extends Serializable> { 
} 

所有继承这个接口的interface都被spring所管理，此接口作为标识接口，功能就是用来控制domain模型的。
Spring Data可以让我们只定义接口，只要遵循spring data的规范，就无需写实现类。

[color=red][b]配置文件：[/b][/color]

spring:
  application:
    name: service-client
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: oracle.jdbc.driver.OracleDriver
    url: jdbc:oracle:thin:@ip:port:xx
    username: xxx
    password: xxxxx
  jpa:
    database: oracle

import com.springcloud.eurekaclient.jpa.dao.DemoUserRepository;
import com.springcloud.eurekaclient.jpa.entity.DemoUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@EnableEurekaClient
@RestController
@EnableJpaRepositories(basePackages = "com.springcloud.eurekaclient.jpa")
@ComponentScan(basePackages = {"com.springcloud.eurekaclient"})
@EntityScan(basePackages="com.springcloud.eurekaclient.jpa")
public class EurekaclientApplication {

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

注意事项：
要使用JpaRepository实现增删查改需要进行如下操作：

[color=red]1.在pom.xml中添加JPA依赖包（jdbc数据库相关）[/color]
[b]2.User.java类需要添加@Entity注解，在类的属性上面需要添加@Id或者@Column注解[/b]
3.UserRepository.java接口需要实现JpaRepository接口，默认有增删查方法，修改方法可以自己定义
[color=red][b]4.启动类需要添加两个注解，分别是：@EnableJpaRepositories(basePackages="com.etc.*")和@EntityScan(basePackages="com.etc.*") [/b][/color]

[color=red][b]实体类（注意ID生成策略）：[/b][/color]

@Entity
@Table(name="DEMO_USER")
@JsonIgnoreProperties(value = { "hibernateLazyInitializer", "handler" })
public class DemoUser{

    @Id
    @GeneratedValue(generator="system_uuid")
    @GenericGenerator(name="system_uuid",strategy="uuid")
    private String id;

    @Column(name = "USER_NAME")
    private String userName ;

    private String sex;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "DemoUser{" +
                "id='" + id + '\'' +
                ", userName='" + userName + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }
}

[color=red][size=large][b]2.什么是Repository [/b][/size][/color]

[b]2.1 Repository（资源库）：[/b]通过用来访问领域对象的一个类似集合的接口，在领域与数据映射层之间进行协调。这个叫法就类似于我们通常所说的DAO，在这里，我们就按照这一习惯把数据访问层叫Repository。
Spring Data给我们提供几个Repository，基础的Repository提供了最基本的数据访问功能，其几个子接口则扩展了一些功能。它们的继承关系如下：
a.Repository： 仅仅是一个标识，表明任何继承它的均为仓库接口类，方便Spring自动扫描识别
b.CrudRepository： 继承Repository，实现了一组CRUD相关的方法
c.PagingAndSortingRepository： 继承CrudRepository，实现了一组分页排序相关的方法
[size=medium][color=blue][b]d.JpaRepository： 继承PagingAndSortingRepository，实现一组JPA规范相关的方法 [/b][/color][/size]
e.JpaSpecificationExecutor： 比较特殊，不属于Repository体系，实现一组JPA Criteria查询相关的方法

[color=red][b]我们自己定义的XxxxRepository需要继承JpaRepository，这样我们的XxxxRepository接口就具备了通用的数据访问控制层的能力。 [/b]
[/color]
[color=blue][size=medium][b]2.2 JpaRepository 所提供的基本功能 [/b][/size][/color]
[b]2.2.1 CrudRepository<T, ID extends Serializable>： [/b]
这个接口提供了最基本的对实体类的添删改查操作

T save(T entity);//保存单个实体 
        Iterable<T> save(Iterable<? extends T> entities);//保存集合 
        T findOne(ID id);//根据id查找实体 
        boolean exists(ID id);//根据id判断实体是否存在 
        Iterable<T> findAll();//查询所有实体,不用或慎用! 
        long count();//查询实体数量 
        void delete(ID id);//根据Id删除实体 
        void delete(T entity);//删除一个实体 
void delete(Iterable<? extends T> entities);//删除一个实体的集合 
        void deleteAll();//删除所有实体,不用或慎用! 

[b]2.2.2 PagingAndSortingRepository<T, ID extends Serializable> [/b]
这个接口提供了分页与排序功能

Iterable<T> findAll(Sort sort);//排序 
        Page<T> findAll(Pageable pageable);//分页查询（含排序功能） 

[b]2.2.3 JpaRepository<T, ID extends Serializable> [/b]
这个接口提供了JPA的相关功能

List<T> findAll();//查找所有实体 
        List<T> findAll(Sort sort);//排序 查找所有实体 
        List<T> save(Iterable<? extends T> entities);//保存集合 
        void flush();//执行缓存与数据库同步 
        T saveAndFlush(T entity);//强制执行持久化 
        void deleteInBatch(Iterable<T> entities);//删除一个实体集合

[color=red][size=large][b]3.Spring data 查询 [/b][/size][/color]

[b]3.1 简单条件查询：查询某一个实体类或者集合 [/b]
[color=red][b]按照Spring data 定义的规则，查询方法以find|read|get开头 [/b][/color]
涉及条件查询时，条件的属性用条件关键字连接，要注意的是：条件属性以首字母大写其余字母小写为规定。

[img]http://dl2.iteye.com/upload/attachment/0129/1346/da56df95-52fc-3213-8f5c-0d6f575060f3.png[/img]

例如：定义一个Entity实体类

class User｛ 
private String firstname; 
private String lastname; 
｝ 

[color=red][b]使用And条件连接时，应这样写： [/b][/color]
findByLastnameAndFirstname(String lastname,String firstname);
条件的属性名称与个数要与参数的位置与个数一一对应

[size=medium][b]3.2 使用JPA NamedQueries （标准规范实现） [/b][/size]
这种查询是标准的JPA规范所定义的，直接声明在Entity实体类上，调用时采用在接口中定义与命名查询对应的method，由Spring Data根据方法名自动完成命名查询的寻找。
（1）在Entity实体类上使用@NamedQuery注解直接声明命名查询。

@Entity 
@NamedQuery(name = "User.findByEmailAddress", 
  query = "select u from User u where u.emailAddress = ?1") 
public class User { 

} 

注：定义多个时使用下面的注解

@NamedQueries(value = { 
                @NamedQuery(name = User.QUERY_FIND_BY_LOGIN, 
                                        query = "select u from User u where u." + User.PROP_LOGIN 
                                                + " = :username"), 
        @NamedQuery(name = "getUsernamePasswordToken", 
                        query = "select new com.aceona.weibo.vo.TokenBO(u.username,u.password) from User u where u." + User.PROP_LOGIN 
                            + " = :username")}) 

[b]（2）在interface中定义与(1)对应的方法 [/b]

public interface UserRepository extends JpaRepository<User, Long> { 

  List<User> findByLastname(String lastname); 

  User findByEmailAddress(String emailAddress); 
} 

[size=medium][b]3.3 使用@Query自定义查询（Spring Data提供的）（?1形式或@Param）[/b][/size]
这种查询可以声明在Repository方法中，[b]摆脱像命名查询那样的约束[/b]，将查询直接在相应的接口方法中声明，结构更为清晰，这是Spring data的特有实现。
例如：

public interface UserRepository extends JpaRepository<User, Long> { 

  @Query("select u from User u where u.emailAddress = ?1") 
  User findByEmailAddress(String emailAddress); 
} 

[size=medium][b]3.4 @Query与 @Modifying 执行更新操作[/b][/size]
这两个annotation一起声明，可定义个性化更新操作，例如只涉及某些字段更新时最为常用，示例如下：

@Modifying 
@Query("update User u set u.firstname = ?1 where u.lastname = ?2") 
int setFixedFirstnameFor(String firstname, String lastname); 

[size=medium][b]3.5 索引参数与命名参数 [/b][/size]
[color=red][b]（1）索引参数如下所示，索引值从1开始，查询中 ”?X” 个数需要与方法定义的参数个数相一致，并且顺序也要一致 [/b][/color]

@Modifying 
@Query("update User u set u.firstname = ?1 where u.lastname = ?2") 
int setFixedFirstnameFor(String firstname, String lastname); 

[b]（2）命名参数（推荐使用这种方式） [/b]
可以定义好参数名，赋值时采用@Param("参数名")，而不用管顺序。如下所示：

public interface UserRepository extends JpaRepository<User, Long> { 

  @Query("select u from User u where u.firstname = :firstname or u.lastname = :lastname") 
  User findByLastnameOrFirstname(@Param("lastname") String lastname, 
                                 @Param("firstname") String firstname); 
} 

[size=large][b]4. Transactionality（事务） [/b][/size]

[size=medium][b]4.1 操作单个对象的事务 [/b][/size]
Spring Data提供了默认的事务处理方式，即所有的查询均声明为只读事务，对于持久化，更新与删除对象声明为有事务。
参见org.springframework.data.jpa.repository.support.SimpleJpaRepository<T, ID>

@org.springframework.stereotype.Repository 
@Transactional(readOnly = true) 
public class SimpleJpaRepository<T, ID extends Serializable> implements JpaRepository<T, ID>, 
                JpaSpecificationExecutor<T> { 
…… 
@Transactional 
        public void delete(ID id) { 

                delete(findOne(id)); 
        } 
…… 
} 

对于自定义的方法，如需改变spring data提供的事务默认方式，[size=medium][color=blue][b]可以在方法上注解@Transactional声明 [/b][/color][/size]

[size=medium][b]4.2 涉及多个Repository的事务处理 [/b][/size]
进行多个Repository操作时，也应该使它们在同一个事务中处理，按照分层架构的思想，这部分属于业务逻辑层，因此，[b]需要在Service层实现对多个Repository的调用，并在相应的方法上声明事务。 [/b]
例如：

@Service(“userManagement”) 
class UserManagementImpl implements UserManagement { 

  private final UserRepository userRepository; 
  private final RoleRepository roleRepository; 

  @Autowired 
  public UserManagementImpl(UserRepository userRepository, 
    RoleRepository roleRepository) { 
    this.userRepository = userRepository; 
    this.roleRepository = roleRepository; 
  } 

  @Transactional 
  public void addRoleToAllUsers(String roleName) { 

    Role role = roleRepository.findByName(roleName); 

    for (User user : userRepository.readAll()) { 
      user.addRole(role); 
      userRepository.save(user); 
    } 
} 

[size=large][b]5.关于DAO层的规范[/b][/size]
5.1.对于不需要写实现类的情况：定义XxxxRepository 接口并继承JpaRepository接口，如果Spring data所提供的默认接口方法不够用，[color=red][b]可以使用@Query在其中定义个性化的接口方法。[/b][/color]

5.2.对于需要写实现类的情况：定义XxxxDao 接口并继承com.aceona.xxx.persistent.data.GenericDao
书写XxxxDaoImpl实现类并继承com.aceona.xxxx.persistent.data.GenericJpaDao，同时实现XxxxDao接口中的方法

[color=red][b]在Service层调用XxxxRepository接口与XxxxDao接口完成相应的业务逻辑 [/b][/color]