1....创建步骤：练习使用
1... 创建 maven工程
2...添加依赖 mysql c3p0 hibernate springDataJpa spring相关的包
3...创建 配置文件 员（数据源）工（工程类对象）是（事物）爹(dao 扫描器)
4... 创建实体类
5... 创建dao 接口 继承 JapRespository
2....五种查询方式
（1） crud
添加/修改 数据 save 方法
删除数据 delete 方法
查询 ：findOne. getOne 方法
查询全部 findAll() 方法
findAll(Pageable pageaable) 返回Page对象 进行分页 排序
（2） 在springDataJpa框架使用Jpql 查询
a: 在dao 接口中定义一个方法 使用方法的参数设置jpql的参数 并且使用方法的返回值接受查询的结果
b: 在方法上添加一个注解Qquery
c 在注解中编写jpql
d 测试
（3）使用原生的Sql语句
1 dao中 定义一个方法
2 在方法中添加@Query注解
3 在注解中 添加 原生的sql 语句 添加一个属性 nativeQuery=true
4 测试
（4）方法命名规则查询
通过一定的规则 定义一个方法 框架本省就可以根据方法名生成一个SQL语句进行查询
规则：
1 使用findBy开头
2 查询某个字段 findBy后跟实体类的属性的名称
3 如果有多个条件 就在方法后加And+实体类的属性名
4 方法的参数 对应查询的定义
5 返回值根据返回的数据类型定义
如果需要分页查询 在方法中添加一个参数Pageable 即可
（5）使用Specification方式进行查询
最强大的查询方式 除了原生的SQL 语句以外 最复杂的查询方式
使用方式：
1 要在dao 继承JpaSeciFicationExection 接口
2 使用JpaSeciFicationExection 接口 中提供的方法进行查询
每个方法都需要使用Specification对象作为参数
具体实现：：：
1...pom.xml 配置
1 <?xml version="1.0" encoding="UTF-8"?> 2 <project xmlns="http://maven.apache.org/POM/4.0.0" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 5 <modelVersion>4.0.0</modelVersion> 6 7 <groupId>com.wsc</groupId> 8 <artifactId>springdatalpa01</artifactId> 9 <version>1.0-SNAPSHOT</version> 10 11 12 <properties> 13 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 14 <maven.compiler.source>1.8</maven.compiler.source> 15 <maven.compiler.target>1.8</maven.compiler.target> 16 <spring.version>4.2.4.RELEASE</spring.version> 17 <hibernate.version>5.0.7.Final</hibernate.version> 18 <slf4j.version>1.6.6</slf4j.version> 19 <log4j.version>1.2.12</log4j.version> 20 <c3p0.version>0.9.1.2</c3p0.version> 21 <mysql.version>5.1.6</mysql.version> 22 </properties> 23 <dependencies> 24 <dependency> 25 <groupId>junit</groupId> 26 <artifactId>junit</artifactId> 27 <version>4.12</version> 28 <scope>test</scope> 29 </dependency> 30 <!--spring start--> 31 <dependency> 32 <groupId>org.aspectj</groupId> 33 <artifactId>aspectjweaver</artifactId> 34 <version>1.6.8</version> 35 </dependency> 36 <dependency> 37 <groupId>org.springframework</groupId> 38 <artifactId>spring-aop</artifactId> 39 <version>${spring.version}</version> 40 </dependency> 41 <dependency> 42 <groupId>org.springframework</groupId> 43 <artifactId>spring-context</artifactId> 44 <version>${spring.version}</version> 45 </dependency> 46 <dependency> 47 <groupId>org.springframework</groupId> 48 <artifactId>spring-context-support</artifactId> 49 <version>${spring.version}</version> 50 </dependency> 51 <dependency> 52 <groupId>org.springframework</groupId> 53 <artifactId>spring-orm</artifactId> 54 <version>${spring.version}</version> 55 </dependency> 56 <dependency> 57 <groupId>org.springframework</groupId> 58 <artifactId>spring-beans</artifactId> 59 <version>${spring.version}</version> 60 </dependency> 61 <dependency> 62 <groupId>org.springframework</groupId> 63 <artifactId>spring-core</artifactId> 64 <version>${spring.version}</version> 65 </dependency> 66 <!--spring end--> 67 <!--hibernate start--> 68 <dependency> 69 <groupId>org.hibernate</groupId> 70 <artifactId>hibernate-core</artifactId> 71 <version>${hibernate.version}</version> 72 </dependency> 73 <dependency> 74 <groupId>org.hibernate</groupId> 75 <artifactId>hibernate-entitymanager</artifactId> 76 <version>${hibernate.version}</version> 77 </dependency> 78 <dependency> 79 <groupId>org.hibernate</groupId> 80 <artifactId>hibernate-validator</artifactId> 81 <version>5.2.1.Final</version> 82 </dependency> 83 <!--hibernate end--> 84 <dependency> 85 <groupId>c3p0</groupId> 86 <artifactId>c3p0</artifactId> 87 <version>${c3p0.version}</version> 88 </dependency> 89 <dependency> 90 <groupId>log4j</groupId> 91 <artifactId>log4j</artifactId> 92 <version>${log4j.version}</version> 93 </dependency> 94 <dependency> 95 <groupId>org.slf4j</groupId> 96 <artifactId>slf4j-api</artifactId> 97 <version>${slf4j.version}</version> 98 </dependency> 99 <dependency> 100 <groupId>org.slf4j</groupId> 101 <artifactId>slf4j-log4j12</artifactId> 102 <version>${slf4j.version}</version> 103 </dependency> 104 <dependency> 105 <groupId>mysql</groupId> 106 <artifactId>mysql-connector-java</artifactId> 107 <version>${mysql.version}</version> 108 </dependency> 109 <dependency> 110 <groupId>org.springframework.data</groupId> 111 <artifactId>spring-data-jpa</artifactId> 112 <version>1.9.0.RELEASE</version> 113 </dependency> 114 <dependency> 115 <groupId>org.springframework</groupId> 116 <artifactId>spring-test</artifactId> 117 <version>4.2.4.RELEASE</version> 118 </dependency> 119 <dependency> 120 <groupId>javax.el</groupId> 121 <artifactId>javax.el-api</artifactId> 122 <version>2.2.4</version> 123 </dependency> 124 <dependency> 125 <groupId>org.glassfish.web</groupId> 126 <artifactId>javax.el</artifactId> 127 <version>2.2.4</version> 128 </dependency> 129 </dependencies> 130 </project>
2...applicationContext.xml
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" xmlns:aop="http://www.springframework.org/schema/aop" 4 xmlns:context="http://www.springframework.org/schema/context" 5 xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx" 6 xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task" 7 xsi:schemaLocation=" 8 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd 9 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd 10 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd 11 http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd 12 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd 13 http://www.springframework.org/schema/data/jpa 14 http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"> 15 <!--1 dataSource--> 16 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 17 <property name="password" value="wsc"></property> 18 <property name="user" value="root"></property> 19 <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shop?characterEncoding=utf-8"></property> 20 <property name="driverClass" value="com.mysql.jdbc.Driver"></property> 21 </bean> 22 <!--2 工厂类对象--> 23 <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"> 24 <!--数据源--> 25 <property name="dataSource" ref="dataSource"></property> 26 <property name="packagesToScan" value="com.wsc.core.entity"></property> 27 <!--配置供应商适配器--> 28 <property name="jpaVendorAdapter"> 29 <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"> 30 <property name="showSql" value="true"></property> 31 <property name="generateDdl" value="true"></property> 32 <!--是否向控制台输出语句 update hibernate.hbm2ddl.auto--> 33 <property name="database" value="MYSQL"></property> 34 </bean> 35 </property> 36 </bean> 37 <!--配置事物--> 38 <bean id="jpaTransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"> 39 <property name="entityManagerFactory" ref="entityManagerFactory"></property> 40 </bean> 41 <tx:advice id="txAdvice" transaction-manager="jpaTransactionManager"> 42 <tx:attributes> 43 <tx:method name="save*" propagation="REQUIRED"/> 44 <tx:method name="insert*" propagation="REQUIRED"/> 45 <tx:method name="update*" propagation="REQUIRED"/> 46 <tx:method name="delete*" propagation="REQUIRED"/> 47 <tx:method name="get*" read-only="true"/> 48 <tx:method name="find*" read-only="true"/> 49 <tx:method name="*" propagation="REQUIRED"/> 50 </tx:attributes> 51 </tx:advice> 52 <aop:config> 53 <aop:pointcut id="pointcut" expression="execution(* com.wsc.core.service.*.*(..)) "/> 54 <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"></aop:advisor> 55 </aop:config> 56 <!--dao--> 57 <jpa:repositories base-package="com.wsc.core.dao" 58 transaction-manager-ref="jpaTransactionManager" 59 entity-manager-factory-ref="entityManagerFactory"> 60 </jpa:repositories> 61 </beans>
3.....实体类
1 package com.wsc.core.entity; 2 3 import javax.persistence.*; 4 5 /** 6 * @version 1.0 7 * @ClassName Account 8 * @Description TODO 9 * @Author WSC 10 * @Date 2019/8/16 11:31 11 **/ 12 @Entity 13 @Table(name="ac_account") 14 public class Account { 15 @GeneratedValue(strategy= GenerationType.IDENTITY) 16 @Id 17 @Column(name="ac_id") 18 private int acId; 19 @Column(name="ac_address") 20 private String acAddress; 21 @Column(name="ac_name") 22 private String acName; 23 @Column(name="ac_age") 24 private int acAge; 25 26 public int getAcId() { 27 return acId; 28 } 29 30 public void setAcId(int acId) { 31 this.acId = acId; 32 } 33 34 public String getAcAddress() { 35 return acAddress; 36 } 37 38 public void setAcAddress(String acAddress) { 39 this.acAddress = acAddress; 40 } 41 42 public String getAcName() { 43 return acName; 44 } 45 46 public void setAcName(String acName) { 47 this.acName = acName; 48 } 49 50 public int getAcAge() { 51 return acAge; 52 } 53 54 public void setAcAge(int acAge) { 55 this.acAge = acAge; 56 } 57 58 @Override 59 public String toString() { 60 return "Account{" + 61 "acId=" + acId + 62 ", acAddress='" + acAddress + '\'' + 63 ", acName='" + acName + '\'' + 64 ", acAge=" + acAge + 65 '}'; 66 } 67 }
4....dao
1 package com.wsc.core.dao; 2 3 import com.wsc.core.entity.Account; 4 import org.springframework.data.domain.Page; 5 import org.springframework.data.domain.Pageable; 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.transaction.annotation.Transactional; 11 12 import java.util.List; 13 14 //实现JpaRepository接口 15 public interface AccountDao extends JpaRepository<Account,Integer>, JpaSpecificationExecutor<Account> { 16 /** 17 * 查询全部 18 * @return 19 */ 20 @Query("from Account ") 21 public List<Account> getFindAll(); 22 /** 23 * 查询全部 分页 24 * @return 25 * @param pageable 26 */ 27 @Query("from Account ") 28 public List<Account> getFindAllByPage(Pageable pageable); 29 /** 30 * 根据id查询 31 */ 32 @Query("from Account where ac_id=?1") 33 public Account getFindById(Long ac_id); 34 35 /** 36 * 37 * 模糊查询 38 */ 39 @Query("from Account where acName like ?1 and acAddress like ?2") 40 public List<Account> findByName(String acName,String acAddress); 41 42 /** 43 * 修改数据 44 */ 45 @Modifying 46 @Transactional 47 @Query("update Account set acName=?1 where acId=?2") 48 public void change(String acName,Integer acId); 49 50 // 原生SQL 语句查询 51 /** 52 * 原生SQL 语句查询 53 */ 54 @Query(value = "select * from ac_account WHERE ac_name LIKE ?" ,nativeQuery = true) 55 public List<Account> getAccount(String name); 56 57 //方法命名规则查询 58 /** 59 * 根据id查询 60 */ 61 public Account findAccountByAcId(Integer id); 62 63 /** 64 * 模糊查询 65 * @param address 66 * @param name 67 * @return 68 */ 69 public List<Account> findByAcAddressLikeAndAcNameLike(String address,String name); 70 71 /** 72 * 分页查询 73 * @param name 74 * @param pageable 75 * @return 76 */ 77 public Page<Account> findByAcNameLike(String name,Pageable pageable); 78 79 80 }
5.....test
test 01
(delete
save
findOne
count
getOne
分页
排序
判断是否存在)
1 package com.wsc.core.test; 2 3 import com.wsc.core.dao.AccountDao; 4 import com.wsc.core.entity.Account; 5 import org.junit.Test; 6 import org.junit.runner.RunWith; 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.data.domain.Page; 9 import org.springframework.data.domain.PageRequest; 10 import org.springframework.data.domain.Sort; 11 import org.springframework.test.context.ContextConfiguration; 12 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; 13 import org.springframework.transaction.annotation.Transactional; 14 15 import java.util.List; 16 17 /** 18 * @version 1.0 19 * @ClassName TestJPA 20 * @Description TODO 21 * @Author WSC 22 * @Date 2019/8/16 13:12 23 **/ 24 @RunWith(SpringJUnit4ClassRunner.class) 25 @ContextConfiguration("classpath:applicationContext.xml") 26 public class TestJPA { 27 @Autowired 28 private AccountDao accountDao; 29 /** 30 * 添加数据 31 */ 32 @Test 33 public void test01(){ 34 // ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); 35 // AccountDao accountDao = applicationContext.getBean(AccountDao.class); 36 Account account = new Account(); 37 account.setAcAddress("提阿女号"); 38 account.setAcAge(133); 39 account.setAcName("zhang"); 40 this.accountDao.save(account); 41 } 42 /** 43 * 删除数据 44 */ 45 @Test 46 public void test02(){ 47 accountDao.delete(22); 48 } 49 /** 50 * 修改数据 51 */ 52 @Test 53 public void test03(){ 54 Account account = accountDao.findOne(23); 55 account.setAcName("阿凡提123"); 56 account.setAcAddress("美丽的郑州"); 57 accountDao.save(account); 58 } 59 /** 60 * 查询单个数据 findOne 方法 61 */ 62 @Test 63 public void test04(){ 64 Account one = accountDao.findOne(23); 65 System.out.println(one); 66 } 67 /** 68 * 查询数据的总个数 count 方法 69 */ 70 @Test 71 public void getCount(){ 72 long count = accountDao.count(); 73 System.out.println(count); 74 } 75 /** 76 * 获得数据单个 77 * 必须加注解 @Transactional 事务注解 78 * 不加报错：could not initialize proxy - no Session 79 */ 80 @Test 81 @Transactional 82 public void getFindOne(){ 83 Account one = accountDao.getOne(23); 84 System.out.println(one); 85 } 86 /** 87 * 分页功能 88 */ 89 @Test 90 public void testPage(){ 91 PageRequest pageRequest = new PageRequest(0, 5); 92 Page<Account> accountPage = accountDao.findAll(pageRequest); 93 //总的数据条数 94 long totalElements = accountPage.getTotalElements(); 95 System.out.println(totalElements); 96 //总的页数 97 int totalPages = accountPage.getTotalPages(); 98 System.out.println(totalPages); 99 //遍历数据 100 for(Account account:accountPage){ 101 System.out.println(account); 102 } 103 List<Account> accountList = accountPage.getContent(); 104 System.out.println(accountList); 105 } 106 /** 107 * 排序 Sort.Direction.DESC 降序 108 */ 109 @Test 110 public void testSort(){ 111 // 创建一个sort 对象 112 // 参数1 排序方式 113 // 参数2 排序的字段 应该是实体类的属性名 114 Sort sort = new Sort(Sort.Direction.DESC,"acId"); 115 List<Account> accountList = accountDao.findAll(sort); 116 for(Account account:accountList) 117 System.out.println(account); 118 } 119 /** 120 * 判断 是否 存在 exists 121 */ 122 @Test 123 public void testExists(){ 124 boolean exists = accountDao.exists(1); 125 System.out.println(exists); 126 } 127 }
test02
（ 全部信息
根据id查
分页
模糊查询 原生SQL
方 法命名规则查询
模糊查询 方 法命名规则查询
根据 名字 模糊查询 并 分页）
1 package com.wsc.core.test; 2 3 import com.wsc.core.dao.AccountDao; 4 import com.wsc.core.entity.Account; 5 import org.junit.Test; 6 import org.junit.runner.RunWith; 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.data.domain.Page; 9 import org.springframework.data.domain.PageRequest; 10 import org.springframework.test.context.ContextConfiguration; 11 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; 12 13 import java.util.List; 14 15 /** 16 * @version 1.0 17 * @ClassName Test02 18 * @Description TODO 19 * @Author WSC 20 * @Date 2019/8/19 14:32 21 **/ 22 @RunWith(SpringJUnit4ClassRunner.class) 23 @ContextConfiguration("classpath:applicationContext.xml") 24 public class Test02 { 25 @Autowired 26 private AccountDao accountDao; 27 28 /** 29 * 全部信息 30 */ 31 @Test 32 public void testFindAll() { 33 List<Account> findAll = accountDao.getFindAll(); 34 for (Account account : findAll) { 35 System.out.println(account); 36 } 37 } 38 39 /** 40 * id 信息 41 */ 42 @Test 43 public void getById() { 44 Account findById = accountDao.getFindById(3L); 45 System.out.println(findById); 46 } 47 48 /** 49 * 查询全部 分页 50 */ 51 @Test 52 public void getByPage() { 53 // 参数 1：页面开始 2： 页面数据条数 54 PageRequest pageRequest = new PageRequest(0, 5); 55 List<Account> findAllByPage = accountDao.getFindAllByPage(pageRequest); 56 for (Account account:findAllByPage) { 57 System.out.println(account); 58 } 59 } 60 61 /** 62 * 模糊查询 63 */ 64 @Test 65 public void get02(){ 66 List<Account> byName = accountDao.findByName("%2%", "%中%"); 67 for(Account account:byName){ 68 System.out.println(account); 69 } 70 } 71 @Test 72 public void change(){ 73 accountDao.change("滚",3); 74 } 75 76 /** 77 * 原生SQL 语句查询 78 */ 79 @Test 80 public void get01(){ 81 List<Account> account = accountDao.getAccount("%2%"); 82 for(Account acc: account){ 83 System.out.println(acc); 84 } 85 } 86 87 /** 88 * 方 法命名规则查询 89 */ 90 @Test 91 public void get03(){ 92 Account accountByAcId = accountDao.findAccountByAcId(3); 93 System.out.println(accountByAcId); 94 } 95 96 /** 97 * 模糊查询 方 法命名规则查询 98 */ 99 @Test 100 public void get04(){ 101 List<Account> byAcAddressAndAcName = accountDao.findByAcAddressLikeAndAcNameLike("%中%", "%2%"); 102 for(Account account:byAcAddressAndAcName){ 103 System.out.println(account); 104 } 105 } 106 107 /** 108 * 根据 名字 模糊查询 并 分页 109 */ 110 @Test 111 public void get05(){ 112 Page<Account> byAcNameLike = accountDao.findByAcNameLike("%2%", new PageRequest(0, 2)); 113 long totalElements = byAcNameLike.getTotalElements(); 114 System.out.println(totalElements+"总的条数"); 115 int totalPages = byAcNameLike.getTotalPages(); 116 System.out.println(totalPages+"总的页数"); 117 List<Account> content = byAcNameLike.getContent(); 118 for(Account account:content){ 119 System.out.println(account); 120 } 121 } 122 }
test03
(使用Specification方式进行查询)
1 package com.wsc.core.test; 2 3 import com.wsc.core.dao.AccountDao; 4 import com.wsc.core.entity.Account; 5 import org.junit.Test; 6 import org.junit.runner.RunWith; 7 import org.springframework.beans.factory.annotation.Autowired; 8 import org.springframework.data.domain.Page; 9 import org.springframework.data.domain.PageRequest; 10 import org.springframework.data.jpa.domain.Specification; 11 import org.springframework.test.context.ContextConfiguration; 12 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; 13 14 import javax.persistence.criteria.CriteriaBuilder; 15 import javax.persistence.criteria.CriteriaQuery; 16 import javax.persistence.criteria.Predicate; 17 import javax.persistence.criteria.Root; 18 import java.util.List; 19 20 /** 21 * @version 1.0 22 * @ClassName test03 23 * @Description TODO 24 * @Author WSC 25 * @Date 2019/8/19 16:55 26 **/ 27 28 // 测试 使用 Specification 方式进行查询 29 30 @RunWith(SpringJUnit4ClassRunner.class) 31 @ContextConfiguration("classpath:applicationContext.xml") 32 public class test03 { 33 @Autowired 34 private AccountDao accountDao; 35 36 /** 37 * 使用 Specification 方式 38 * 根据 id 查询 39 */ 40 @Test 41 public void test01(){ 42 Account account=accountDao.findOne(new Specification<Account>() { 43 @Override 44 public Predicate toPredicate(Root<Account> root, CriteriaQuery<?> query, CriteriaBuilder cb) { 45 // 参数1 字段名称 46 // 参数2 字段的值 47 Predicate acId = cb.equal(root.get("acId"), 3); 48 return acId; 49 } 50 }); 51 System.out.println(account); 52 } 53 54 /** 55 * 多字段 模糊查询 并 整合 56 */ 57 @Test 58 public void get02(){ 59 accountDao.findAll(new Specification<Account>() { 60 @Override 61 public Predicate toPredicate(Root<Account> root, CriteriaQuery<?> query, CriteriaBuilder cb) { 62 // 创建 根据模糊查询的条件 63 Predicate acName = cb.like(root.get("acName"), "%2%"); 64 Predicate acAddress = cb.like(root.get("acAddress"), "%中%"); 65 // 组合两个条件 66 Predicate predicate = cb.and(acName, acAddress); 67 return predicate; 68 } 69 }).forEach(c->System.out.println(c));//打印功能 70 } 71 72 /** 73 * 多字段 模糊查询 并 整合 并 分页 74 */ 75 @Test 76 public void get03(){ 77 Page<Account> byAcNameLike= accountDao.findAll(new Specification<Account>() { 78 @Override 79 public Predicate toPredicate(Root<Account> root, CriteriaQuery<?> query, CriteriaBuilder cb) { 80 // 创建 根据模糊查询的条件 81 Predicate acName = cb.like(root.get("acName"), "%2%"); 82 Predicate acAddress = cb.like(root.get("acAddress"), "%中%"); 83 // 组合两个条件 84 Predicate predicate = cb.and(acName, acAddress); 85 return predicate; 86 } 87 },new PageRequest(0,3)); 88 long totalElements = byAcNameLike.getTotalElements(); 89 System.out.println(totalElements+"总的条数"); 90 int totalPages = byAcNameLike.getTotalPages(); 91 System.out.println(totalPages+"总的页数"); 92 List<Account> content = byAcNameLike.getContent(); 93 for(Account account:content){ 94 System.out.println(account); 95 } 96 } 97 }
1165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
