jpa02

springdata jpa

Spring Data JPA是Spring提供的一套对JPA操作的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。

quick start

pom.xml

<properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <hibernate.version>5.0.7.Final</hibernate.version>
        <slf4j.version>1.6.6</slf4j.version>
        <log4j.version>1.2.12</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <!-- junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.9</version>
            <scope>test</scope>
        </dependency>

        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- spring end -->

        <!-- hibernate beg -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>5.2.1.Final</version>
        </dependency>
        <!-- hibernate end -->

        <!-- c3p0 beg -->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- c3p0 end -->

        <!-- log end -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <!-- log end -->


        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!-- el beg 使用spring data jpa 必须引入 -->
        <dependency>
            <groupId>javax.el</groupId>
            <artifactId>javax.el-api</artifactId>
            <version>2.2.4</version>
        </dependency>

        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>javax.el</artifactId>
            <version>2.2.4</version>
        </dependency>
        <!-- el end -->
    </dependencies>

springdata jpa 整合 spring

applicationContext.xml

可以通过 @ContextConfiguration(locations = "classpath:applicationContext.xml ")指定容器的配置信息

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">


    <!--1.创建entityManagerFactory对象交给spring容器管理 -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>

        <property name="packagesToScan" value="com.jpa.domain"/>

        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
        </property>

        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="false"/>
                <property name="database" value="MYSQL"/>
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
                <property name="showSql" value="true"/>
            </bean>
        </property>


        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
        </property>

    </bean>

    <!--创建数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="root"/>
        <property name="password" value="root"/>
        <property name="jdbcUrl" value="jdbc:mysql:///jpa"/>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
     </bean>

    <!--整合spring dataJpa-->
    <jpa:repositories base-package="com.jpa.dao" transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>


    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"></property>
    </bean>

    <!--5.声明式事务 -->

    <!--6.配置包扫描-->
    <context:component-scan base-package="com.jpa"></context:component-scan>
</beans>

1.　创建实体类　

　{ 1.实体与表的映射关系，2.类中属性和表中字段的映射关系 }

2.dao层的接口规范

　　需要继承两个接口（JpaRepository,JpaSpecificationExecutor）

　　提供响应的泛型

extends JpaRepository<T,ID>,JpaSpecificationExecutor<T>

　　JpaRepository<操作的实体类类型,实体类中主键属性的类型>

　　JpaSpecificationExecutor<操作的实体类类型>

save 保存或更新，如果传递的对象是否有主键id,如果没有主键属性，保存

存在主键属性，根据id查询数据，更新数据

运行原理

1.通过jdkDynamicAopProxy的invoke方法创建一个动态代理对象

2.SimpleJpaRepository当中封装了jpa的操作

3.通过hibernate完成数据库操作

复杂查询

1.使用接口定义的方法进行查询

2.jpql 的查询方式

　　查询的是类和类中的属性

需要将jpql 语句配置到接口方法上，在新添加的方法上，使用注解形式配置jpql查询语句，注解@Query

根据客户名称查询客户

1     /**
2      * 使用jpql查询
3      *      from Customer where custName = ?
4      *      @Query注解
5      *          value: sql语句 | jpql语句
6      *          nativeQuery = true,使用sql ,false(默认)，使用jpql
7      */
8     @Query(value = " from Customer where custName = ?")
9     public Customer findJpql(String custName);



根据客户名称和客户id查询客户

 1 /**
 2      *      jpql: from Customer where custName = ? and custId = ?
 3      *                                                  参数与条件不存在关系
 4      *      对于多个占位符参数，赋值的时候默认的情况
 5      *      占位符的位置需要和方法参数保持一致
 6      *      如果不一致，可以指定占位符参数的位置
 7      *      ？ 索引的方式 ,指定此占位的取值来源
 8      *
 9      */
10     @Query(value = "from Customer where custName = ? and custId = ?")
11     public Customer findCustNameAndId(String name ,Long id);

更新客户

1    /**u/d
2      * sql: update cst_customer set cust_name = ? where cust_id = ?
3      * @Moditying
4      *          表示当前执行的是更新操作
5      * 需要手动添加事务，默认执行后会回滚 @Transaction
6      */
7     @Query(value = "update Customer set custName = ?2 where custId = ?1")
8     @Modifying
9     public void updateCustomer(long custId,String custName);

3.方法命名规则查询

按照SpringDataJpa 提供的方法名称规则定义方法，不需要配置jpql语句

findBy 查询

　　根据属性名称进行查询

　　对象中的属性名（首字母大写），查询的条件

 public Customer findByCustName(String custName);

findBy 属性名称（根据属性名称进行匹配的查询）

findBy 属性名称查询方式（like | isnull ）

 public Customer findByCustNameLike(String custName);

多条件查询

findBy 属性名- 查询方式- 多条件的连接符（or | and)-属性名-查询方式

 public Customer findByCustNameAndCustIndustry(String custName,String custIndustry);

动态查询

Specifications

1 public interface Specification<T> {
2     Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3);
3 }

自定义我们自己的Specification实现类

实现方法中参数
　　root：查询的根对象（查询的任何属性都可以从根对象中获取）
　　CriteriaQuery：顶层查询对象，自定义查询方式（一般不用）
　　CriteriaBuilder：查询的构造器，封装了很多的查询条件
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件

 1 /**
 2      * 自定义查询条件
 3      *  1.实现Specification 接口（提供泛型，查询对象类型）
 4      *  2.实现toPredicate方法（构造查询条件）
 5      *  3.需要借助方法参数中的两个参数
 6      *      root 需要查询的对象属性
 7      *      CriteriaBuilder 构造查询条件，内部封住了查询条件（模糊匹配，精确匹配）
 8      */
 9     @Test
10     public void testSpec(){
11 
12         Specification<Customer> spec = new Specification<Customer>() {
13             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder cb) {
14 
15                 Path<Object> custName = root.get("custName");
16                 Predicate predicate = cb.equal(custName, "zhangsan");//equal 进行精准匹配 (属性，取值)
17                 return predicate;
18             }
19         };
20 
21         Customer customer = customerDao.findOne(spec);
22         System.out.println(customer);
23     }

多条件拼接

 1     /**
 2      * 多条件查询
 3      * 根据客户名和行业查询
 4          * root用来获取属性
 5          * cb构造查询
 6      *      1.构造客户名的精准匹配查询
 7      *      2.构造所属行业的精准匹配查询
 8      *      3.将连个查询联合起来
 9      */
10     @Test
11     public void testSpec1(){
12         Specification<Customer> spec = new Specification<Customer>() {
13             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
14                 Path<Object> custName = root.get("custName");
15                 Path<Object> custIndustry = root.get("custIndustry");
16 
17                 //构造查询
18                 Predicate p1 = cb.equal(custName, "zhangsan");
19                 Predicate p2 = cb.equal(custIndustry, "it");
20                 //将查询条件组合起来
21                 Predicate and = cb.and(p1, p2);
22                 return and;
23             }
24         };
25 
26         Customer customer = customerDao.findOne(spec);
27         System.out.println(customer);
28     }

模糊匹配及排序

 1  /**
 2      * 模糊匹配
 3      * equal 直接得到path对象
 4      * gt,lt,le ,like 得到path对象,根据path指定的参数类型，进行比较
 5      * 指定参数类型 ： path.as(类型的字节码对象)
 6      */
 7     @Test
 8     public void testSpec2(){
 9         Specification<Customer> spec = new Specification<Customer>() {
10             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
11                 //查询属性客户名
12                 Path<Object> custName = root.get("custName");
13                 //查询方式模糊匹配
14                 Predicate like = cb.like(custName.as(String.class), "华%");
15 
16                 return like;
17             }
18         };
19 
20 //        List<Customer> list = customerDao.findAll(spec);
21 //        for (Customer customer : list){
22 //            System.out.println(customer);
23 //        }
24 
25     //添加排序
26     //创建排序对象，需要调用构造方法实例化sort对象
27     //第一个参数：排序的顺序
28         //Sort.Direction.Desc：倒序
29         //Sort.Direction.ASC:升序
30     //第二个参数：排序的属性名称
31         Sort sort  = new Sort(Sort.Direction.DESC,"custId");
32         List<Customer> list = customerDao.findAll(spec,sort);
33         for (Customer customer : list) {
34             System.out.println(customer);
35         }
36 
37 
38     }

分页

 1     /**
 2      * 分页查询
 3      *  findAll(Specification,Pageable)
 4      *  Specficaation 查询条件
 5      *  Pageable 分页参数
 6      *
 7      */
 8     @Test
 9     public void testSpec4(){
10 
11         Specification spec = null;
12         Pageable pageable = new PageRequest(0, 2); //当前查询页数，每页查询条数
13         Page<Customer> page = customerDao.findAll(null, pageable);
14         System.out.println(page.getTotalPages());
15         System.out.println(page.getTotalElements());
16 
17     }

多表操作

多表关系

一对多：
一的一方：主表
多的一方：从表
外键：需要再从表上新建一列作为外键，他的取值来源于主表的主键

多对多：
中间表：中间表中最少应该由两个字段组成，这两个字段做为外键指向两张表的主键，又组成了联合主键

分析步骤

1.明确表关系
2.确定表关系（描述外键|中间表）
3.编写实体类，再实体类中描述表关系（包含关系）
4.配置映射关系

一对多

客户：联系人 1：*

联系人：公司 1：1

客户与联系人（一对多）

Customer

 1     /**
 2      * 客户与联系人，一对多
 3      * 使用注解的形式配置多表关系
 4      * 1.声明关系 @OnetwoMany targetEntity: 对方对象的字节码对象
 5      * 2.配置外键（中间表） name 外键字段名称
 6      *                  referencedColumnName 参照主表的主键字段名称
 7      *
 8      *  ! 在客户实体类添加了外键设置，对客户而言，具备了维护主键的作用
 9      */
10     @OneToMany(targetEntity = LinkMan.class)
11     @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
12     private Set<LinkMan> linkMans = new HashSet();

LinkMan

 1     /**
 2      * 配置联系人到客户的多对一关系
 3      *      使用注解的方式配置多对一关系
 4      *      1.配置表关系  @ManytoOne targetTarget 对方实体类的字节码
 5      *      2.配置外键（中间表）
 6      *
 7      *  配置外键的过程，配置到了多了一方，就会在多的一方维护外键
 8      */
 9     @ManyToOne(targetEntity = Customer.class)
10     @JoinColumn(name ="lkm_cust_id",referencedColumnName = "cust_id")
11     private Customer customer;

applicationContext.xml

entityManagerFactory 配置 property

 1         <!--注入jpa的配置信息
 2             加载jpa的基本配置信息和jpa实现方式（hibernate）的配置信息
 3             hibernate.hbm2ddl.auto : 自动创建数据库表
 4                 create ： 每次都会重新创建数据库表
 5                 update：有表不会重新创建，没有表会重新创建表
 6         -->
 7         <property name="jpaProperties" >
 8             <props>
 9                 <prop key="hibernate.hbm2ddl.auto">update</prop>
10             </props>
11         </property>

进行保存

 1     @Test
 2     @Transactional
 3     @Rollback(false)
 4     public void  add(){
 5         Customer customer = new Customer();
 6         customer.setCustName("zhangsan");
 7         LinkMan linkMan = new LinkMan();
 8         linkMan.setLkmName("lisi");
 9 
10         customer.getLinkMans().add(linkMan);
11 
12         customerDao.save(customer);
13         linkManDao.save(linkMan);
14     }

放弃外键维护（一的一方）

Customer

 1  /**
 2      * 放弃外键维护权
 3      *      mappedBy：对方配置关系的属性名称
 4      * cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
 5      *      CascadeType.all         : 所有
 6      *                  MERGE       ：更新
 7      *                  PERSIST     ：保存
 8      *                  REMOVE      ：删除
 9      *
10      * fetch : 配置关联对象的加载方式
11      *          EAGER   ：立即加载
12      *          LAZY    ：延迟加载
13 
14      */
15     @OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
16     private Set<LinkMan> linkMans = new HashSet<>();

一对多级联添加

 1     /**
 2      * 级联添加：保存一个客户的同时，保存客户的所有联系人
 3      *      需要在操作主体的实体类上，配置casacde属性
 4      */
 5     @Test
 6     @Transactional //配置事务
 7     @Rollback(false) //不自动回滚
 8     public void testCascadeAdd() {
 9         Customer customer = new Customer();
10         customer.setCustName("百度1");
11 
12         LinkMan linkMan = new LinkMan();
13         linkMan.setLkmName("小李1");
14 
15         linkMan.setCustomer(customer);
16         customer.getLinkMans().add(linkMan);
17 
18         customerDao.save(customer);
19     }

级联删除

<prop key = "hibernate.hbm2ddl.auto">update<prop>

 1     /**
 2      * 级联删除：
 3      *      删除1号客户的同时，删除1号客户的所有联系人
 4      */
 5     @Test
 6     @Transactional //配置事务
 7     @Rollback(false) //不自动回滚
 8     public void testCascadeRemove() {
 9         //1.查询1号客户
10         Customer customer = customerDao.findOne(1l);
11         //2.删除1号客户
12         customerDao.delete(customer);
13     }

多对多操作

案例：用户和角色（多对多关系）

分析步骤
1.明确表关系
多对多关系
2.确定表关系（描述外键|中间表）
中间间表
3.编写实体类，再实体类中描述表关系（包含关系）
用户：包含角色的集合
角色：包含用户的集合
4.配置映射关系

User

 1   /**
 2      * 配置用户到角色的多对多关系
 3      *      配置多对多的映射关系
 4      *          1.声明表关系的配置
 5      *              @ManyToMany(targetEntity = Role.class)  //多对多
 6      *                  targetEntity：代表对方的实体类字节码
 7      *          2.配置中间表（包含两个外键）
 8      *                @JoinTable
 9      *                  name : 中间表的名称
10      *                  joinColumns：配置当前对象在中间表的外键
11      *                      @JoinColumn的数组
12      *                          name：外键名
13      *                          referencedColumnName：参照的主表的主键名
14      *                  inverseJoinColumns：配置对方对象在中间表的外键
15      */
16     @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)
17     @JoinTable(name = "sys_user_role",
18             //joinColumns,当前对象在中间表中的外键
19             joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
20             //inverseJoinColumns，对方对象在中间表的外键
21             inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
22     )
23     private Set<Role> roles = new HashSet<>();

Role

1     //配置多对多
2     @ManyToMany(mappedBy = "roles")  //配置多表关系
3     private Set<User> users = new HashSet<>();

Test

 1     /**
 2      * 保存一个用户，保存一个角色
 3      *
 4      *  多对多放弃维护权：被动的一方放弃
 5      */
 6     @Test
 7     @Transactional
 8     @Rollback(false)
 9     public void  testAdd() {
10         User user = new User();
11         user.setUserName("小李");
12 
13         Role role = new Role();
14         role.setRoleName("java程序员");
15 
16         //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
17         user.getRoles().add(role);
18 
19         //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
20         role.getUsers().add(user);
21 
22         userDao.save(user);
23         roleDao.save(role);
24     }

级联添加

确定主体用户，在user实体类上添加cascade属性

    @ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL)

    //测试级联添加（保存一个用户的同时保存用户的关联角色）
    @Test
    @Transactional
    @Rollback(false)
    public void  testCasCadeAdd() {
        User user = new User();
        user.setUserName("zhangsan");

        Role role = new Role();
        role.setRoleName("lisi");

        //配置用户到角色关系，可以对中间表中的数据进行维护     1-1
        user.getRoles().add(role);

        //配置角色到用户的关系，可以对中间表的数据进行维护     1-1
        role.getUsers().add(user);
        userDao.save(user);
    }

级联删除

 1     /**
 2      * 案例：删除id为1的用户，同时删除他的关联对象
 3      */
 4     @Test
 5     @Transactional
 6     @Rollback(false)
 7     public void  testCasCadeRemove() {
 8         //查询1号用户
 9         User user = userDao.findOne(1l);
10         //删除1号用户
11         userDao.delete(user);
12 
13     }

对象导航查询

1.对象导航查询
　　查询一个对象的同时，通过此对象查询他的关联对象

案例：客户和联系人
从一方查询多方
默认：使用延迟加载（****）

从多方查询一方
默认：使用立即加载

Test

查询客户，查询到客户下多个联系人

 1         //测试对象导航查询（查询一个对象的时候，通过此对象查询所有的关联对象）
 2         @Test
 3         @Transactional // 解决在java代码中的no session问题
 4         public void  testQuery1() {
 5             //查询id为1的客户
 6             Customer customer = customerDao.getOne(9l);
 7             //对象导航查询，此客户下的所有联系人
 8             Set<LinkMan> linkMans = customer.getLinkMans();
 9 
10             for (LinkMan linkMan : linkMans) {
11                 System.out.println(linkMan);
12             }
13         }

 对象导航查询：
    默认使用的是延迟加载的形式查询的
          调用get方法并不会立即发送查询，而是在使用关联对象的时候才会差和讯
     延迟加载
修改配置，将延迟加载改为立即加载
      fetch，需要配置到多表映射关系的注解上

Customer

@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL,fetch = FetchType.EAGER)
private Set<LinkMan> linkMans = new HashSet<>();

从联系人对象导航查询他的所属客户

 1 /**
 2          *  默认 ： 立即加载
 3          *  延迟加载：
 4          *
 5          */
 6         @Test
 7         @Transactional // 解决在java代码中的no session问题
 8         public void  testQuery3() {
 9             LinkMan linkMan = linkManDao.findOne(2l);
10             //对象导航查询所属的客户
11             Customer customer = linkMan.getCustomer();
12             System.out.println(customer);
13         }

完

相关阅读:
附加作业
 个人总结
 wordcount
vs2013安装及测试
 结对作业电梯调度问题
 阅读下面程序，请回答如下问题：
补作业：随机生成二元四则运算
 软件工程的认识
 结对编程完结
 结对编程加团队编程
原文地址：https://www.cnblogs.com/quyangyang/p/11442404.html