jpa+springdata

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:jpa="http://www.springframework.org/schema/data/jpa"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 8         http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
 9         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
10         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
11 
12     <!-- 配置自动扫描的包 -->
13     <context:component-scan base-package="com.atguigu.springdata"></context:component-scan>
14 
15     <!-- 1. 配置数据源 -->
16     <context:property-placeholder location="classpath:db.properties"/>
17 
18     <bean id="dataSource"
19         class="com.mchange.v2.c3p0.ComboPooledDataSource">
20         <property name="user" value="${jdbc.user}"></property>
21         <property name="password" value="${jdbc.password}"></property>    
22         <property name="driverClass" value="${jdbc.driverClass}"></property>
23         <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
24         
25         <!-- 配置其他属性 -->
26     </bean>
27 
28     <!-- 2. 配置 JPA 的 EntityManagerFactory -->
29     <bean id="entityManagerFactory" 
30         class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
31         <property name="dataSource" ref="dataSource"></property>
32         <property name="jpaVendorAdapter">
33             <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
34         </property>
35         <property name="packagesToScan" value="com.atguigu.springdata"></property>
36         <property name="jpaProperties">
37             <props>
38                 <!-- 二级缓存相关 -->
39                 <!--  
40                 <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
41                 <prop key="net.sf.ehcache.configurationResourceName">ehcache-hibernate.xml</prop>
42                 -->
43                 <!-- 生成的数据表的列的映射策略 -->
44                 <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
45                 <!-- hibernate 基本属性 -->
46                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
47                 <prop key="hibernate.show_sql">true</prop>
48                 <prop key="hibernate.format_sql">true</prop>
49                 <prop key="hibernate.hbm2ddl.auto">update</prop>
50             </props>
51         </property>
52     </bean>
53 
54     <!-- 3. 配置事务管理器 -->
55     <bean id="transactionManager"
56         class="org.springframework.orm.jpa.JpaTransactionManager">
57         <property name="entityManagerFactory" ref="entityManagerFactory"></property>    
58     </bean>
59 
60     <!-- 4. 配置支持注解的事务 -->
61     <tx:annotation-driven transaction-manager="transactionManager"/>
62 
63     <!-- 5. 配置 SpringData -->
64     <!-- 加入  jpa 的命名空间 -->
65     <!-- base-package: 扫描 Repository Bean 所在的 package -->
66     <jpa:repositories base-package="com.atguigu.springdata"
67         entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
68 
69 </beans>

1 jdbc.user=root
2 jdbc.password=1111
3 jdbc.driverClass=com.mysql.jdbc.Driver
4 jdbc.jdbcUrl=jdbc:mysql://localhost:3306/springdata

  1 package com.atguigu.springdata.test;
  2 
  3 import java.io.FileNotFoundException;
  4 import java.io.IOException;
  5 import java.sql.SQLException;
  6 import java.util.ArrayList;
  7 import java.util.Arrays;
  8 import java.util.Date;
  9 import java.util.List;
 10 
 11 import javax.persistence.criteria.CriteriaBuilder;
 12 import javax.persistence.criteria.CriteriaQuery;
 13 import javax.persistence.criteria.Path;
 14 import javax.persistence.criteria.Predicate;
 15 import javax.persistence.criteria.Root;
 16 import javax.sql.DataSource;
 17 
 18 import org.junit.Test;
 19 import org.springframework.context.ApplicationContext;
 20 import org.springframework.context.support.ClassPathXmlApplicationContext;
 21 import org.springframework.data.domain.Page;
 22 import org.springframework.data.domain.PageRequest;
 23 import org.springframework.data.domain.Sort;
 24 import org.springframework.data.domain.Sort.Direction;
 25 import org.springframework.data.domain.Sort.Order;
 26 import org.springframework.data.jpa.domain.Specification;
 27 
 28 import com.atguigu.springdata.Person;
 29 import com.atguigu.springdata.PersonRepsotory;
 30 import com.atguigu.springdata.PersonService;
 31 import com.atguigu.springdata.commonrepositorymethod.AddressRepository;
 32 
 33 public class SpringDataTest {
 34 
 35     private ApplicationContext ctx = null;
 36     private PersonRepsotory personRepsotory = null;
 37     private PersonService personService;
 38     
 39     {
 40         ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 41         personRepsotory = ctx.getBean(PersonRepsotory.class);
 42         personService = ctx.getBean(PersonService.class);
 43     }
 44     
 45 
 46     //使用自定义的方法，需要声明接口，并继承，同时完成实现类，此方法比较少用
 47     @Test
 48     public void testCustomRepositoryMethod(){
 49         personRepsotory.test();
 50     }
 51         
 52     /**
 53      * 目标: 实现带查询条件的分页. id > 5 的条件
 54      * 
 55      * 调用 JpaSpecificationExecutor 的 Page<T> findAll(Specification<T> spec, Pageable pageable);
 56      * Specification: 封装了 JPA Criteria 查询的查询条件
 57      * Pageable: 封装了请求分页的信息: 例如 pageNo, pageSize, Sort
 58      */
 59     //使用继承JpaSpecificationExecutor的方法实现条件查询+分页
 60     @Test
 61     public void testJpaSpecificationExecutor(){
 62         int pageNo = 3 - 1;
 63         int pageSize = 5;
 64         PageRequest pageable = new PageRequest(pageNo, pageSize);
 65         
 66         //通常使用 Specification 的匿名内部类
 67         Specification<Person> specification = new Specification<Person>() {
 68             /**
 69              * @param *root: 代表查询的实体类. 
 70              * @param query: 可以从中可到 Root 对象, 即告知 JPA Criteria 查询要查询哪一个实体类. 还可以
 71              * 来添加查询条件, 还可以结合 EntityManager 对象得到最终查询的 TypedQuery 对象. 
 72              * @param *cb: CriteriaBuilder 对象. 用于创建 Criteria 相关对象的工厂. 当然可以从中获取到 Predicate 对象
 73              * @return: *Predicate 类型, 代表一个查询条件. 
 74              */
 75             @Override
 76             public Predicate toPredicate(Root<Person> root,
 77                     CriteriaQuery<?> query, CriteriaBuilder cb) {
 78                 Path path = root.get("id");
 79                 Predicate predicate = cb.gt(path, 5);
 80                 return predicate;
 81             }
 82         };
 83         
 84         Page<Person> page = personRepsotory.findAll(specification, pageable);
 85         
 86         System.out.println("总记录数: " + page.getTotalElements());
 87         System.out.println("当前第几页: " + (page.getNumber() + 1));
 88         System.out.println("总页数: " + page.getTotalPages());
 89         System.out.println("当前页面的 List: " + page.getContent());
 90         System.out.println("当前页面的记录数: " + page.getNumberOfElements());
 91     }
 92     
 93     //使用继承JpaRepository的方法
 94     @Test
 95     public void testJpaRepository(){
 96         Person person = new Person();
 97         person.setBirth(new Date());
 98         person.setEmail("xy@atguigu.com");
 99         person.setLastName("xyz");
100         person.setId(28);
101         
102         Person person2 = personRepsotory.saveAndFlush(person);
103         
104         System.out.println(person == person2);
105     }
106     
107     //使用继承PagingAndSortingRespository的方法，实现分页
108     @Test
109     public void testPagingAndSortingRespository(){
110         //pageNo 从 0 开始. 
111         int pageNo = 6 - 1;
112         int pageSize = 5;
113         //Pageable 接口通常使用的其 PageRequest 实现类. 其中封装了需要分页的信息
114         //排序相关的. Sort 封装了排序的信息
115         //Order 是具体针对于某一个属性进行升序还是降序. 
116         Order order1 = new Order(Direction.DESC, "id");
117         Order order2 = new Order(Direction.ASC, "email");
118         Sort sort = new Sort(order1, order2);
119         
120         PageRequest pageable = new PageRequest(pageNo, pageSize, sort);
121         Page<Person> page = personRepsotory.findAll(pageable);
122         
123         System.out.println("总记录数: " + page.getTotalElements());
124         System.out.println("当前第几页: " + (page.getNumber() + 1));
125         System.out.println("总页数: " + page.getTotalPages());
126         System.out.println("当前页面的 List: " + page.getContent());
127         System.out.println("当前页面的记录数: " + page.getNumberOfElements());
128     }
129     
130     //使用继承CrudReposiory的方法
131     @Test
132     public void testCrudReposiory(){
133         List<Person> persons = new ArrayList<>();
134         
135         for(int i = ‘a‘; i <= ‘z‘; i++){
136             Person person = new Person();
137             person.setAddressId(i + 1);
138             person.setBirth(new Date());
139             person.setEmail((char)i + "" + (char)i + "@atguigu.com");
140             person.setLastName((char)i + "" + (char)i);
141             
142             persons.add(person);
143         }
144         
145         personService.savePersons(persons);
146     }
147     
148     @Test
149     public void testModifying(){
150 //        personRepsotory.updatePersonEmail(1, "mmmm@atguigu.com");
151         personService.updatePersonEmail("mmmm@atguigu.com", 1);
152     }
153     
154     //设置 nativeQuery=true 即可以使用原生的 SQL 查询
155     @Test
156     public void testNativeQuery(){
157         long count = personRepsotory.getTotalCount();
158         System.out.println(count);
159     }
160     
161     
162     //使用 @Query 几种传递参数的方式
163     @Test
164     public void testQueryAnnotationLikeParam(){
165 //        List<Person> persons = personRepsotory.testQueryAnnotationLikeParam("%A%", "%bb%");
166 //        System.out.println(persons.size());
167         
168 //        List<Person> persons = personRepsotory.testQueryAnnotationLikeParam("A", "bb");
169 //        System.out.println(persons.size());
170         
171         List<Person> persons = personRepsotory.testQueryAnnotationLikeParam2("bb", "A");
172         System.out.println(persons.size());
173     }
174     
175     @Test
176     public void testQueryAnnotationParams2(){
177         List<Person> persons = personRepsotory.testQueryAnnotationParams2("aa@atguigu.com", "AA");
178         System.out.println(persons);
179     }
180     
181     @Test
182     public void testQueryAnnotationParams1(){
183         List<Person> persons = personRepsotory.testQueryAnnotationParams1("AA", "aa@atguigu.com");
184         System.out.println(persons);
185     }
186     
187     //使用 @Query 注解可以自定义 JPQL 语句以实现更灵活的查询
188     @Test
189     public void testQueryAnnotation(){
190         Person person = personRepsotory.getMaxIdPerson();
191         System.out.println(person);
192     }
193     
194     //根据外键条件查询，注意下划线的使用，若无下滑线，将优先获取person的属性,下滑线则表示为外键
195     @Test
196     public void testKeyWords2(){
197         List<Person> persons = personRepsotory.getByAddress_IdGreaterThan(1);
198         System.out.println(persons);
199     }
200     
201     //几种条件查询的例子
202     @Test
203     public void testKeyWords(){
204         List<Person> persons = personRepsotory.getByLastNameStartingWithAndIdLessThan("X", 10);
205         System.out.println(persons);
206         
207         persons = personRepsotory.getByLastNameEndingWithAndIdLessThan("X", 10);
208         System.out.println(persons);
209         
210         persons = personRepsotory.getByEmailInAndBirthLessThan(Arrays.asList("AA@atguigu.com", "FF@atguigu.com", 
211                 "SS@atguigu.com"), new Date());
212         System.out.println(persons.size());
213     }
214     
215     //获取lastname为AA的person
216     @Test
217     public void testHelloWorldSpringData() throws FileNotFoundException, IOException, InstantiationException, IllegalAccessException{
218         System.out.println(personRepsotory.getClass().getName());
219         Person person = personRepsotory.getByLastName("AA");
220         System.out.println(person);
221     }
222     
223     //验证数据库连接是否成功
224     @Test
225     public void testDataSource() throws SQLException {
226         DataSource dataSource = ctx.getBean(DataSource.class);
227         System.out.println(dataSource.getConnection());
228     }
229 
230 }

 1 package com.atguigu.springdata;
 2 
 3 import java.util.Date;
 4 import java.util.List;
 5 
 6 import org.springframework.data.jpa.repository.JpaRepository;
 7 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
 8 import org.springframework.data.jpa.repository.Modifying;
 9 import org.springframework.data.jpa.repository.Query;
10 import org.springframework.data.repository.query.Param;
11 
12 /**
13  * 1. Repository 是一个空接口. 即是一个标记接口
14  * 2. 若我们定义的接口继承了 Repository, 则该接口会被 IOC 容器识别为一个 Repository Bean.
15  * 纳入到 IOC 容器中. 进而可以在该接口中定义满足一定规范的方法. 
16  * 
17  * 3. 实际上, 也可以通过 @RepositoryDefinition 注解来替代继承 Repository 接口
18  */
19 /**
20  * 在 Repository 子接口中声明方法
21  * 1. 不是随便声明的. 而需要符合一定的规范
22  * 2. 查询方法以 find | read | get 开头
23  * 3. 涉及条件查询时，条件的属性用条件关键字连接
24  * 4. 要注意的是：条件属性以首字母大写。
25  * 5. 支持属性的级联查询. 若当前类有符合条件的属性, 则优先使用, 而不使用级联属性. 
26  * 若需要使用级联属性, 则属性之间使用 _ 进行连接. 
27  */
28 //@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)
29 public interface PersonRepsotory extends 
30     JpaRepository<Person, Integer>,
31     JpaSpecificationExecutor<Person>, PersonDao{
32 
33     //根据 lastName 来获取对应的 Person
34     Person getByLastName(String lastName);
35     
36     //WHERE lastName LIKE ?% AND id < ?
37     List<Person> getByLastNameStartingWithAndIdLessThan(String lastName, Integer id);
38     
39     //WHERE lastName LIKE %? AND id < ?
40     List<Person> getByLastNameEndingWithAndIdLessThan(String lastName, Integer id);
41     
42     //WHERE email IN (?, ?, ?) OR birth < ?
43     List<Person> getByEmailInAndBirthLessThan(List<String> emails, Date birth);
44     
45     //WHERE a.id > ?
46     List<Person> getByAddress_IdGreaterThan(Integer id);
47     
48     //查询 id 值最大的那个 Person
49     //使用 @Query 注解可以自定义 JPQL 语句以实现更灵活的查询
50     @Query("SELECT p FROM Person p WHERE p.id = (SELECT max(p2.id) FROM Person p2)")
51     Person getMaxIdPerson();
52     
53     //为 @Query 注解传递参数的方式1: 使用占位符. 
54     @Query("SELECT p FROM Person p WHERE p.lastName = ?1 AND p.email = ?2")
55     List<Person> testQueryAnnotationParams1(String lastName, String email);
56     
57     //为 @Query 注解传递参数的方式1: 命名参数的方式. 
58     @Query("SELECT p FROM Person p WHERE p.lastName = :lastName AND p.email = :email")
59     List<Person> testQueryAnnotationParams2(@Param("email") String email, @Param("lastName") String lastName);
60     
61     //SpringData 允许在占位符上添加 %%. 
62     @Query("SELECT p FROM Person p WHERE p.lastName LIKE %?1% OR p.email LIKE %?2%")
63     List<Person> testQueryAnnotationLikeParam(String lastName, String email);
64     
65     //SpringData 允许在占位符上添加 %%. 
66     @Query("SELECT p FROM Person p WHERE p.lastName LIKE %:lastName% OR p.email LIKE %:email%")
67     List<Person> testQueryAnnotationLikeParam2(@Param("email") String email, @Param("lastName") String lastName);
68     
69     //设置 nativeQuery=true 即可以使用原生的 SQL 查询
70     @Query(value="SELECT count(id) FROM jpa_persons", nativeQuery=true)
71     long getTotalCount();
72     
73     //可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT
74     //在 @Query 注解中编写 JPQL 语句, 但必须使用 @Modifying 进行修饰. 以通知 SpringData, 这是一个 UPDATE 或 DELETE 操作
75     //UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作. 
76     //默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!
77     @Modifying
78     @Query("UPDATE Person p SET p.email = :email WHERE id = :id")
79     void updatePersonEmail(@Param("id") Integer id, @Param("email") String email);
80 }
81  

1 package com.atguigu.springdata;
2 
3 public interface PersonDao {
4     
5     void test();
6     
7 }

 1 package com.atguigu.springdata;
 2 
 3 import javax.persistence.EntityManager;
 4 import javax.persistence.PersistenceContext;
 5 
 6 public class PersonRepsotoryImpl implements PersonDao {
 7     
 8     @PersistenceContext
 9     private EntityManager entityManager;
10     
11     @Override
12     public void test() {
13         Person person = entityManager.find(Person.class, 11);
14         System.out.println("-->" + person);
15     }
16 
17 }

 1 package com.atguigu.springdata;
 2 
 3 import java.util.List;
 4 
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.stereotype.Service;
 7 import org.springframework.transaction.annotation.Transactional;
 8 
 9 @Service
10 public class PersonService {
11 
12     @Autowired
13     private PersonRepsotory personRepsotory;
14     
15     @Transactional
16     public void savePersons(List<Person> persons){
17         personRepsotory.save(persons);
18     }
19     
20     @Transactional
21     public void updatePersonEmail(String email, Integer id){
22         personRepsotory.updatePersonEmail(id, email);
23     }
24 }

 1 package com.atguigu.springdata;
 2 
 3 import java.util.Date;
 4 
 5 import javax.persistence.Column;
 6 import javax.persistence.Entity;
 7 import javax.persistence.GeneratedValue;
 8 import javax.persistence.Id;
 9 import javax.persistence.JoinColumn;
10 import javax.persistence.ManyToOne;
11 import javax.persistence.Table;
12 
13 @Table(name="JPA_PERSONS")
14 @Entity
15 public class Person {
16 
17     private Integer id;
18     private String lastName;
19 
20     private String email;
21     private Date birth;
22     
23     private Address address;
24     
25     private Integer addressId;
26 
27     @GeneratedValue
28     @Id
29     public Integer getId() {
30         return id;
31     }
32 
33     public void setId(Integer id) {
34         this.id = id;
35     }
36 
37     public String getLastName() {
38         return lastName;
39     }
40 
41     public void setLastName(String lastName) {
42         this.lastName = lastName;
43     }
44 
45     public String getEmail() {
46         return email;
47     }
48 
49     public void setEmail(String email) {
50         this.email = email;
51     }
52 
53     public Date getBirth() {
54         return birth;
55     }
56 
57     public void setBirth(Date birth) {
58         this.birth = birth;
59     }
60     
61     @Column(name="ADD_ID")
62     public Integer getAddressId() {
63         return addressId;
64     }
65 
66     public void setAddressId(Integer addressId) {
67         this.addressId = addressId;
68     }
69 
70     @JoinColumn(name="ADDRESS_ID")
71     @ManyToOne
72     public Address getAddress() {
73         return address;
74     }
75 
76     public void setAddress(Address address) {
77         this.address = address;
78     }
79 
80     @Override
81     public String toString() {
82         return "Person [id=" + id + ", lastName=" + lastName + ", email="
83                 + email + ", brith=" + birth + "]";
84     }
85 }

 1 package com.atguigu.springdata;
 2 
 3 import javax.persistence.Entity;
 4 import javax.persistence.GeneratedValue;
 5 import javax.persistence.Id;
 6 import javax.persistence.Table;
 7 
 8 @Table(name="JPA_ADDRESSES")
 9 @Entity
10 public class Address {
11 
12     private Integer id;
13     private String province;
14     private String city;
15 
16     @GeneratedValue
17     @Id
18     public Integer getId() {
19         return id;
20     }
21 
22     public void setId(Integer id) {
23         this.id = id;
24     }
25 
26     public String getProvince() {
27         return province;
28     }
29 
30     public void setProvince(String province) {
31         this.province = province;
32     }
33 
34     public String getCity() {
35         return city;
36     }
37 
38     public void setCity(String city) {
39         this.city = city;
40     }
41 
42 }