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.xsd10         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=root2 jdbc.password=11113 jdbc.driverClass=com.mysql.jdbc.Driver4 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     @Test109     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     @Test132     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     @Test149     public void testModifying(){150 //        personRepsotory.updatePersonEmail(1, "mmmm@atguigu.com");151         personService.updatePersonEmail("mmmm@atguigu.com", 1);152     }153     154     //设置 nativeQuery=true 即可以使用原生的 SQL 查询155     @Test156     public void testNativeQuery(){157         long count = personRepsotory.getTotalCount();158         System.out.println(count);159     }160     161     162     //使用 @Query 几种传递参数的方式163     @Test164     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     @Test176     public void testQueryAnnotationParams2(){177         List<Person> persons = personRepsotory.testQueryAnnotationParams2("aa@atguigu.com", "AA");178         System.out.println(persons);179     }180     181     @Test182     public void testQueryAnnotationParams1(){183         List<Person> persons = personRepsotory.testQueryAnnotationParams1("AA", "aa@atguigu.com");184         System.out.println(persons);185     }186     187     //使用 @Query 注解可以自定义 JPQL 语句以实现更灵活的查询188     @Test189     public void testQueryAnnotation(){190         Person person = personRepsotory.getMaxIdPerson();191         System.out.println(person);192     }193     194     //根据外键条件查询，注意下划线的使用，若无下滑线，将优先获取person的属性,下滑线则表示为外键195     @Test196     public void testKeyWords2(){197         List<Person> persons = personRepsotory.getByAddress_IdGreaterThan(1);198         System.out.println(persons);199     }200     201     //几种条件查询的例子202     @Test203     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的person216     @Test217     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     @Test225     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 来获取对应的 Person34     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 值最大的那个 Person49     //使用 @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="http://www.mamicode.com/SELECT count(id) FROM jpa_persons", nativeQuery=true)71     long getTotalCount();72     73     //可以通过自定义的 JPQL 完成 UPDATE 和 DELETE 操作. 注意: JPQL 不支持使用 INSERT74     //在 @Query 注解中编写 JPQL 语句, 但必须使用 @Modifying 进行修饰. 以通知 SpringData, 这是一个 UPDATE 或 DELETE 操作75     //UPDATE 或 DELETE 操作需要使用事务, 此时需要定义 Service 层. 在 Service 层的方法上添加事务操作. 76     //默认情况下, SpringData 的每个方法上有事务, 但都是一个只读事务. 他们不能完成修改操作!77     @Modifying78     @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     @Override12     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 @Service10 public class PersonService {11 12     @Autowired13     private PersonRepsotory personRepsotory;14     15     @Transactional16     public void savePersons(List<Person> persons){17         personRepsotory.save(persons);18     }19     20     @Transactional21     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 @Entity15 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     @GeneratedValue28     @Id29     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     @ManyToOne72     public Address getAddress() {73         return address;74     }75 76     public void setAddress(Address address) {77         this.address = address;78     }79 80     @Override81     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 @Entity10 public class Address {11 12     private Integer id;13     private String province;14     private String city;15 16     @GeneratedValue17     @Id18     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 }