spring data jpa 使用（一）

spring data jpa
Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。
致力于减少数据访问层 (DAO) 的开发量. 开发者唯一要做的，就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成。

第一个spring data jpa程序

1、创建项目，导入需要的jar包

2、引入spring配置文件(applicationContext.xml)以及数据库连接配置文件(db.properties)。
db.properties中：

jdbc.user=root
jdbc.password=123456
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///spring-data-jpa

applicationContext.xml中：

<!-- 1.配置c3p0数据源 -->
    <context:property-placeholder location="classpath:db.properties"/>
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="jdbcUrl" value="${jdbc.jdbcUrl}"/>
    </bean>

    <!-- 2.配置EntityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置JPA提供商的适配器 ,可以通过内部bean的方式来配置-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
        </property>
        <!-- 配置实体类所在的包 -->
        <property name="packagesToScan" value="com.itheima.entity"></property>
        <!-- 配置jpa的基本属性.例如JPA实现产品的属性 -->
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
    <!-- 3.配置jpa使用的事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!-- 4.配置支持基于注解事务方式 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!-- 配置spring data -->
    <!-- 加入jpa的命名空间 -->
    <!-- 
        base-package：用于扫描Repository Bean 所在的package
     -->
    <jpa:repositories base-package="com.itheima" entity-manager-factory-ref="entityManagerFactory"/>

添加实体类：User

@Entity
@Table(name = "t_user")
public class User {

    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;

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

    private String password;

    private String telephone;

    private String email;

    @Column(name="create_time")
    private Date createTime;
    @Column(name="modified_time")
    private Date modifiedTime = new Date();

    //映射必须定义个空构造器
    public User() {
    }

    public User(String userName, String password, String telephone, String email, Date createTime) {
        this.userName = userName;
        this.password = password;
        this.telephone = telephone;
        this.email = email;
        this.createTime = createTime;
    }
    get、set、toString方法
}

数据库表如下：

3、创建UserRepository接口继承Repository接口

public interface UserRepository extends Repository<User, Long>{ 
    User findById(long id);
    User findByUserName(String username);
}

Repository接口是一个标识，只要继承了该接口的接口都会被纳入spring容器管理。其中findById（findByUserName）该方法，顾名思义是根据id（用户名）查询用户。很奇妙的是，只要这样写确实就跟根据id（用户名）查出用户信息，而不需要我们做任何处理，这一切是因为spring data给我们命名做了规范。

4、测试

public class TestSpringDateJpa {

    ApplicationContext applicationContext ;
    @Before
    public void before(){
        applicationContext = 
                new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    /*
     * findById()
     */
    @Test
    public void test1(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        User user = userRepository.findById(1l);
        System.out.println(user);
    }
    /*
     * findByName()
     */
    @Test
    public void test2(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        User user = userRepository.findByUserName("aaa");
        System.out.println(user);
    }
}

结果：

Hibernate: 
    select
        user0_.id as id1_1_,
        user0_.create_time as create_t2_1_,
        user0_.email as email3_1_,
        user0_.modified_time as modified4_1_,
        user0_.password as password5_1_,
        user0_.telephone as telephon6_1_,
        user0_.user_name as user_nam7_1_ 
    from
        t_user user0_ 
    where
        user0_.id=?
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]

根据id查询用户信息的输出，可以看到发送的sql就是根据id查询用户信息。

再来看其它的查询命名规范：
（1）

    List<User> findByUserNameStartingWithAndIdLessThan(String username,long id);
    该方法相当于查询sql：WHERE userName LIKE ?% AND id<?

测试：

    /*
     * findByUserNameStartingWithAndIdLessThan();
     */
    @Test
    public void test3(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        List<User> users = userRepository.findByUserNameStartingWithAndIdLessThan("aa", 3);
        for (User user : users) {
            System.out.println(user);
        }
    }

结果：

Hibernate: 
    select
        user0_.id as id1_1_,
        user0_.create_time as create_t2_1_,
        user0_.email as email3_1_,
        user0_.modified_time as modified4_1_,
        user0_.password as password5_1_,
        user0_.telephone as telephon6_1_,
        user0_.user_name as user_nam7_1_ 
    from
        t_user user0_ 
    where
        (
            user0_.user_name like ?
        ) 
        and user0_.id<?
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]
User [id=2, userName=aaa, password=123456, telephone=15551182345, email=aaa@qq.com]

（2）

    List<User> getByTelephoneInOrIdGreaterThan(List<String> teles,long id);
    该方法相当域查询sql：WHERE telephone IN (?,?...?) OR id<?

测试：

/*
     * getByTelephoneInOrIdGreaterThan();
     */
    @Test
    public void test4(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        List<String> teles = new ArrayList<String>();
        teles.add("13344444445");
        teles.add("15551182345");
        long id = 5l;
        List<User> users = userRepository.getByTelephoneInOrIdGreaterThan(teles, id);
        for (User user : users) {
            System.out.println(user);
        }
    }

结果：

Hibernate: 
    select
        user0_.id as id1_1_,
        user0_.create_time as create_t2_1_,
        user0_.email as email3_1_,
        user0_.modified_time as modified4_1_,
        user0_.password as password5_1_,
        user0_.telephone as telephon6_1_,
        user0_.user_name as user_nam7_1_ 
    from
        t_user user0_ 
    where
        user0_.telephone in (
            ? , ?
        ) 
        or user0_.id>?
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]
User [id=2, userName=aaa, password=123456, telephone=15551182345, email=aaa@qq.com]
User [id=6, userName=ccc, password=123456, telephone=13346789876, email=ccc@qq.com]

（3）

    List<User> getByEmailStartingWithOrderByIdDesc(String email);
    该方法相当于查询sql：WHERE email like ?% ORDER BY id DESC

测试：

/*
     * getByEmailStartingWithOrderByIdDesc();
     */
    @Test
    public void test5(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        List<User> users = userRepository.getByEmailStartingWithOrderByIdDesc("aa");
        for (User user : users) {
            System.out.println(user);
        }
    }

结果：

Hibernate: 
    select
        user0_.id as id1_1_,
        user0_.create_time as create_t2_1_,
        user0_.email as email3_1_,
        user0_.modified_time as modified4_1_,
        user0_.password as password5_1_,
        user0_.telephone as telephon6_1_,
        user0_.user_name as user_nam7_1_ 
    from
        t_user user0_ 
    where
        user0_.email like ? 
    order by
        user0_.id desc
User [id=2, userName=aaa, password=123456, telephone=15551182345, email=aaa@qq.com]
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]

还支持其它的关键字：

如果不想去记这些，当然这些也不一定满足我们的查询需求的时候，我们可以自己写查询条件而不去理会这些关键字，关键字是为了方便，其实完全可以不使用，这时候使用spring data提供的注解@Query。

@Query

@Query允许我们手写sql，根据传入的形参，将查询结果封装到声明的返回的实体类型中。

比如查询id最大的用户信息

@Query(value="SELECT u FROM User u WHERE u.id=(SELECT max(t.id) FROM User t)")
    User findUserWithMaxId();

测试：

    @Test
    public void test1(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        User user = userRepository.findUserWithMaxId();
        System.out.println(user);
    }

结果：

Hibernate: 
    select
        user0_.id as id1_1_,
        user0_.create_time as create_t2_1_,
        user0_.email as email3_1_,
        user0_.modified_time as modified4_1_,
        user0_.password as password5_1_,
        user0_.telephone as telephon6_1_,
        user0_.user_name as user_nam7_1_ 
    from
        t_user user0_ 
    where
        user0_.id=(
            select
                max(user1_.id) 
            from
                t_user user1_
        )
User [id=6, userName=ccc, password=123456, telephone=13346789876, email=ccc@qq.com]

注：这里的查询语句是面向对象查询是jpa独有的jpql查询，jpa是支持原生sql查询的，在这里当然也是支持的，在不熟悉jpql查询或者较复杂查询的时候建议就使用原生sql查询。需要设置属性：nativeQuery=true

使用原生sql查询
比如：查询密码，要求不重复

@Query(value="SELECT DISTINCT(password) FROM t_user",nativeQuery=true)
    String findPassword();

测试：略

参数传递
1、使用占位符（推荐）

@Query(value="SELECT * FROM t_user u WHERE u.email LIKE ?1% AND id <?2",nativeQuery=true)
    List<User> findUserByemail(String email,long id);

测试：

    @Test
    public void test3(){
        UserRepository userRepository = applicationContext.getBean(UserRepository.class);
        List<User> list = userRepository.findUserByemail("aa", 2);
        for (User user : list) {
            System.out.println(user);
        }
    }

结果：

Hibernate: 
    SELECT
        * 
    FROM
        t_user u 
    WHERE
        u.email LIKE ? 
        AND id <?
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]

2、使用参数命名方式

    @Query(value="SELECT * FROM t_user u WHERE u.email LIKE :userEmail% AND id <:userId",nativeQuery=true)
    List<User> findUserByemail2(@Param("userId")long id,@Param("userEmail")String email);

测试：

Hibernate: 
    SELECT
        * 
    FROM
        t_user u 
    WHERE
        u.email LIKE ? 
        AND id <?
User [id=1, userName=aa, password=123456, telephone=13344444445, email=aa@qq.com]

使用参数命名方式虽然不需要管多个形参顺序，但是较麻烦，推荐使用占位符。

使用注解进行DML操作
前面使用的@Query注解来进行的都是查询操作，如果要进行数据更新，那么需要结合注解@Modifying来一起使用，注：不支持插入操作。

    @Modifying
    @Query(value="UPDATE t_user SET user_name = ?1 WHERE id=?2",nativeQuery=true)
    void updateUserNameById(String username,long id);

写到这里是不能进行测试的否则会抛出事务异常，Spring Data 提供了默认的事务处理方式，即所有的查询均声明为只读事务。所以进行增删改操作是行不通的。而通常事务都是加在了三层架构中的Service层，所以我们可以添加个Service，在该层调用Repository层方法，并添加注解（事务可读写而不仅仅是只读事务，对于自定义的方法，如需改变 Spring Data 提供的事务默认方式，可以在方法上注解 @Transactional 声明）测试的时候通过调用Service来进行修改操作。

Service实现类：

@Service(value=UserServiceImpl.SERVICE_NAME)
public class UserServiceImpl implements UserService{

    public static final String SERVICE_NAME="com.itheima.service.UserServiceImpl";
    @Autowired
    public UserRepository userRepository;
    @Transactional
    public void updateUser(String username, long id) {
        userRepository.updateUserNameById(username, id);
    }
}

测试：

    @Test
    public void test5(){//必须有@Transactional注解
        UserService userService = applicationContext.getBean(UserService.class);
        userService.updateUser("Lucene", 1l);
    }

结果：

Hibernate: 
    UPDATE
        t_user 
    SET
        user_name = ? 
    WHERE
        id=?

查看数据库t_user表id为1的用户选择的用户名

注：在项目中用的话很有可能是spring boot项目，这个时候就不用写那一堆配置文件了。只需要导包（创建项目的时候勾选即可而不需要自己手动导入，用eclipse需要装STS插件），然后在spring boot的配置文件（application.properties）中配置一下即可，如下：

spring.datasource.url=jdbc:mysql://localhost:3306/logistic
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql= true
spring.jpa.properties.hibernate.format_sql=true

然后启动项目配置就生效了，接下来便可以与数据库进行交互。