[学习交流] 【广州校区】+SpringDataJpa学习

- 使用了SpringDataJpa，我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法
- 引入依赖

```
<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.18</mysql.version>
</properties>

<dependencies>

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.9</version>
      <scope>test</scope>
</dependency>


<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>




<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>



<dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>${c3p0.version}</version>
</dependency>



<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>


<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>4.2.4.RELEASE</version>
</dependency>


<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>

</dependencies>
```

- Spring配置文件

```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">


<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="com.mysql.jdbc.Driver"/>
      <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
      <property name="user" value="root"/>
      <property name="password" value="root"/>
</bean>


<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
      <property name="dataSource" ref="dataSource"/>
      <property name="packagesToScan" value="com.itheima.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="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
      <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

<jpa:repositories base-package="com.itheima.dao"
                  transaction-manager-ref="transactionManager"
                  entity-manager-factory-ref="entityManagerFactory"/>


<tx:advice id="txAdvice" transaction-manager="transactionManager">
      <tx:attributes>
         <tx:method name="save*" propagation="REQUIRED"/>
         <tx:method name="insert*" propagation="REQUIRED"/>
         <tx:method name="update*" propagation="REQUIRED"/>
         <tx:method name="delete*" propagation="REQUIRED"/>
         <tx:method name="get*" read-only="true"/>
         <tx:method name="find*" read-only="true"/>
         <tx:method name="*" propagation="REQUIRED"/>
      </tx:attributes>
</tx:advice>


<aop:config>
      <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.*.*(..))"/>
      <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
</aop:config>
<context:component-scan base-package="com.itheima"/>

</beans>
```

- 映射实体类

```
@Entity // 声明实体类是JPA的ORM类
@Table(name = "cst_customer") // 指定该类与哪个表映射
public class Customer implements Serializable {
@Id // 指定主键
@Column(name = "cust_id") // 指定映射的列
@GeneratedValue(strategy = GenerationType.IDENTITY) // 配置主键的生成策略
private Long custId;
@Column(name = "cust_name")
private String custName;
@Column(name = "cust_source")
private String custSource;
@Column(name = "cust_industry")
private String custIndustry;
@Column(name = "cust_level")
private String custLevel;
@Column(name = "cust_address")
private String custAddress;
@Column(name = "cust_phone")
private String custPhone;

public Customer() {
}
"setter and getter methods"
}
```

##### 使用Spring Data JPA完成CURD

###### 编写符合Spring Data JPA规范的Dao层接口

- Spring Data JPA是spring提供的一款对于数据访问层（Dao层）的框架
- 使用Spring Data JPA，只需要按照框架的规范提供dao接口，不需要实现类就可以完成数据库的增删改查、分页查询等方法的定义
- 极大的简化了我们的开发过程

###### 规范1

- 创建一个Dao层接口，并实现JpaRepository和JpaSpecificationExecutor
- 提供相应的泛型

```
import com.itheima.domain.Customer;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

/**
* JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
* JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
*/
public interface CustomerDao extends JpaRepository<Customer, Long>,
      JpaSpecificationExecutor<Customer> {

}
```

###### 执行CURD

```
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
@Test
public void testSave() {
      Customer c = new Customer();
      c.setCustName("余大麻");
      customerDao.save(c);
}
@Test
public void testUpdate() {
      Customer customer = customerDao.findOne(1l);
      customer.setCustAddress("广州天河9巷");
      customerDao.save(customer);
}
@Test
public void testDelete() {
      customerDao.delete(1l);
}
@Test
public void testFindById() {
      Customer customer = customerDao.findOne(2l);
      System.out.println(customer);
}
}
```

###### 原理

- 在使用Spring Data JPA时，一般实现JpaRepository和JpaSpecificationExecutor接口，这样就可以使用这些接口中定义的方法
- 本质上是通过JdkDynamicAopProxy生成的一个代理对象

###### 使用JPQL的方式查询

- 使用Spring Data JPA提供的查询方法已经可以解决大部分的应用场景，但是对于某些业务来说，我们还需要灵活的构造查询条件
- 这时就可以使用@Query注解，结合JPQL的语句方式完成查询
- ==@Query 注解的使用非常简单，只需在方法上面标注该注解，同时提供一个JPQL查询语句即可==

```
public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {
"@Query 使用jpql的方式查询。"
@Query(value="from Customer")
public List<Customer> findAllCustomer();
"@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引"
@Query(value="from Customer where custName = ?1")
public Customer findCustomer(String custName);
}
```

- 此外，也可以通过使用 @Query 来执行一个更新操作
- 为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询
- 这样框架最终会生成一个更新的操作，而非查询

```
@Query(value="update Customer set custName = ?1 where custId = ?2")
@Modifying
public void updateCustomer(String custName,Long custId);
```

- Spring Data JPA同样也支持sql语句的查询

```
/**
* nativeQuery : 使用本地sql的方式查询
*/
@Query(value="select * from cst_customer",nativeQuery=true)
public void findSql();
```

###### 方法命名规则查询

- 顾名思义，方法命名规则查询就是根据方法的名字，就能创建查询
- 只需要按照Spring Data JPA提供的方法命名规则定义方法的名称，就可以完成查询工作
- Spring Data JPA在程序执行的时候会根据方法名称进行解析，并自动生成查询语句进行查询

1. 按照Spring Data JPA 定义的规则，查询方法以findBy开头
2. 涉及条件查询时，条件的属性用条件关键字连接
- 要注意的是：条件属性首字母需大写

//方法命名方式查询（根据客户名称查询客户）
public Customer findByCustName(String custName);

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【广州校区】+SpringDataJpa学习

0 个回复