spring data jpa 记录学习过程

　　学习spring data jpa记录配置过程以及配置文件，已备以后迅速上手。大概做了一个小demo。比较简陋，以后再继续完善这个小demo。

　　1.pom依赖引入，非常重要。

　　

 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>lpp</groupId>
 8     <artifactId>spring_data_jpa</artifactId>
 9     <version>1.0-SNAPSHOT</version>
10 
11     <!-- 全局属性配置  -->
12     <properties>
13         <project.source.encoding>utf-8</project.source.encoding>
14         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15         <!-- 防止控制输出台中文乱码 -->
16         <argLine>-Dfile.encoding=UTF-8</argLine>
17     </properties>
18 
19     <dependencies>
20         <!-- junit_jar包依赖 -->
21         <dependency>
22             <groupId>junit</groupId>
23             <artifactId>junit</artifactId>
24             <version>4.11</version>
25             <!--保留到测试 -->
26             <scope>test</scope>
27         </dependency>
28         <!-- spring-data-jpa相关依赖
29             (这个依赖自动把一堆spring的东西依赖进来了，所有可以不需要再引入spring的包)-->
30         <dependency>
31             <groupId>org.springframework.data</groupId>
32             <artifactId>spring-data-jpa</artifactId>
33             <version>1.11.7.RELEASE</version>
34         </dependency>
35         <!-- Hibernate -->
36         <dependency>
37             <groupId>org.hibernate</groupId>
38             <artifactId>hibernate-core</artifactId>
39             <version>5.0.11.Final</version>
40         </dependency>
41         <dependency>
42             <groupId>org.hibernate</groupId>
43             <artifactId>hibernate-entitymanager</artifactId>
44             <version>5.0.11.Final</version>
45         </dependency>
46         <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
47         <dependency>
48             <groupId>com.mchange</groupId>
49             <artifactId>c3p0</artifactId>
50             <version>0.9.5.2</version>
51         </dependency>
52         <!-- mysql驱动 -->
53         <dependency>
54             <groupId>mysql</groupId>
55             <artifactId>mysql-connector-java</artifactId>
56             <version>5.1.29</version>
57         </dependency>
58 
59         <dependency>
60             <groupId>log4j</groupId>
61             <artifactId>log4j</artifactId>
62             <version>1.2.17</version>
63         </dependency>
64 
65     </dependencies>
66 </project>

　　2.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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
    <!-- 配置自动扫描的包,扫描service层,service上面有注解就直接被spring容器实例化 -->
    <context:component-scan base-package="com.lpp.jpa.dao"/>
    <!--引入jdbc配置文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <!-- 1. 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driverClass}"/>
        <property name="jdbcUrl" value="${jdbcurl}"/>
        <property name="user" value="${user}"/>
        <property name="password" value=""/>
    </bean>
    <!-- 2. 配置 JPA 的 EntityManagerFactory -->
    <bean id="entityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
        </property>
        <!-- 配置包扫描，扫描实体 -->
        <property name="packagesToScan" value="com.lpp.jpa.entity"/>
        <property name="jpaProperties">
            <props>
                <!-- 生成的数据表的列的映射策略 -->
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <!-- hibernate 基本属性 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
    <!-- 3. 配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!-- 4. 配置支持注解的事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 5. 配置 SpringData,需要加入  jpa 的命名空间 -->
    <!-- base-package: 扫描 Repository Bean 所在的 package -->
    <jpa:repositories base-package="com.lpp.jpa.dao"
                      entity-manager-factory-ref="entityManagerFactory">
    </jpa:repositories>
</beans>

　　3.entity实体类，相关注解已经在之前的博文中说明了。这里就简单应用一下。

package com.lpp.jpa.entity;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Date;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: lpp
 * Date: 2018-05-02
 * Time: 15:11
 */
@Entity
@Table(name="jpa_persons")
public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Integer id;
    @Column
    private String name;
    @Column
    private String email;

    /** setter and getter method */
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
}

　　4.personDao  这里是dao层实现，之后会介绍一下这里面代码书写的一些规则。这里先就写一个简单的查询方法。作为测试。

package com.lpp.jpa.dao;

import com.lpp.jpa.entity.Person;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: lpp
 * Date: 2018-05-02
 * Time: 21:08
 */

public interface PersonDao extends JpaRepository<Person,Integer> {
    public Person findOneById(int id);
}

　　5.接下来是测试方法。

import com.lpp.jpa.dao.PersonDao;
import com.lpp.jpa.entity.Person;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.sql.SQLException;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: lpp
 * Date: 2018-05-02
 * Time: 15:04
 */
public class test {
    private static ApplicationContext ctx;
    static {
        ctx = new ClassPathXmlApplicationContext("classpath:Spring.xml");
    }

    @Test
    public void testDataSource () throws SQLException {
//        DataSource dataSource= (DataSource) ctx.getBean("dataSource");
        PersonDao personDao = ctx.getBean(PersonDao.class);
        Person p = new Person();
       /* p.setId(1);
        p.setName("lpp");
        p.setEmail("[email protected]");
        personDao.saveAndFlush(p);*/
       p = personDao.findOneById(1);
        System.out.println(p);
    }
}

　　运行测试方法，数据库会自动生成person表，先执行注释离得内容插入一条数据。在运行查询方法，就可以查询到数据库里的数据了。接下来会写一篇spring data jpadao层方法的书写规范。