JPA实现产品之二 Eclipselink

最近闲来无事,整理了一下JPA的几个实现产品之间的差异问题.包括
(1): hibernate 5.2.10.Final
(2): eclipselink 2.7.0
(3): openjpa 2.2.2
(4): openjpa 2.4.2

环境:
JDK 1.8.0_102
Maven 3.5.0
spring-data-jpa 1.11.6.RELEASE

JPA实现产品(2) Ecliselink
源码参见 https://github.com/kshell/jpa.git 之eclipselink分支
或者参见 https://gitee.com/kshell/jpa.git 之eclipselink分支

早些时候就看烦了Hibernate那些破配置,想尝试一下其他的就怕实现.但是使用toplink的时候没有成功.
最近翻看了一下eclipselink的官方文档,真的是又长又臭.然后就配置成功了.

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>org.kshell</groupId>
    <artifactId>jpa</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <name>jpa</name>

    <dependencies>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.11.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.27</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>6.11</version>
        </dependency>

        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>org.eclipse.persistence.jpa</artifactId>
            <version>2.7.0</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

 

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>

<persistence xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://java.sun.com/xml/ns/persistence"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">

        <persistence-unit name="eclipselink" transaction-type="RESOURCE_LOCAL">
            <!--
            配置使用什么 ORM 产品来作为 JPA 的实现
            1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
            2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点.
            -->
            <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
            <properties>
                <property name="eclipselink.ddl-generation" value="create-or-extend-tables"/>
                <property name="eclipselink.ddl-generation.output-mode" value="database"/>
                <!-- eclipselink.weaving设为ture运行不成功, false,和static成功, 这是一个关键点 -->
                <property name="eclipselink.weaving" value="static" />
                <!-- 修改为FINE后,控制台会打印出执行的sql语句,方便调试, 可选值SERVER -->
                <property name="eclipselink.logging.level" value="FINE"/>
                <property name="eclipselink.jdbc.allow-native-sql-queries" value="true" />
                <!-- 定义主键 UUID -->
                <!--<property name="eclipselink.session.customizer" value="com.tgb.itoo.base.util.uuid.UUIDSequence" />-->
            </properties>
        </persistence-unit>
</persistence>

 

db.properties

use=eclipselink

eclipselink.jdbc.driver=com.mysql.jdbc.Driver
eclipselink.jdbc.url=jdbc:mysql://localhost:3306/jpa_eclipselink
eclipselink.jdbc.username=root
eclipselink.jdbc.password=123456

 

spring-bean.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.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.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">

    <!-- 自动扫描component -->
    <context:component-scan base-package="org.kshell.jpa.service" />
    <!--自动扫描repository-->
    <jpa:repositories base-package="org.kshell.jpa.repository" />
    <!--加载配置文件-->
    <context:property-placeholder location="classpath*:db.properties" />
    <!--定义数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" >
        <property name="driverClassName" value="${${use}.jdbc.driver}" />
        <property name="url" value="${${use}.jdbc.url}" />
        <property name="username" value="${${use}.jdbc.username}" />
        <property name="password" value="${${use}.jdbc.password}" />
        <property name="initialSize" value="5" />
    </bean>

    <!--事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager" />

    <!--定义entityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="org.kshell.jpa.entity" />
        <property name="jpaProperties">
            <props>
                <prop key="showSql">true</prop>
                <prop key="generateDdl">true</prop>
            </props>
        </property>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter" />
        </property>
        <property name="persistenceUnitName" value="eclipselink" />
    </bean>
</beans>

 

Person.java

mysql数据库中,只有使用GenerationType.IDENTITY注解才能正常使用数据库的自动增长特性

package org.kshell.jpa.entity;

import lombok.Data;

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

@Data
@Entity
public class Person {
    /**
     * mysql数据库中,只有使用GenerationType.IDENTITY注解
     * 才能正常使用数据库的自动增长特性
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String lastName;
    private String email;
    private Date birth;
}

 

PersonRepository.java

List<Person> findByLastNameIn(List<String> lastNames);不被eclipselink支持,原因是不能根据list的size产生多个变量占位符
package org.kshell.jpa.repository;

import org.kshell.jpa.entity.Person;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.query.Param;

import java.util.List;


/**
 * @author kshell
 * @version 1.0
 * create by 2017-11-10
 * describe:
 */
@org.springframework.stereotype.Repository
public interface PersonRepository extends JpaRepository<Person, Integer>, JpaSpecificationExecutor<Person> {
    /**
     * 该方法不被eclipselink支持
     * @param lastNames
     * @return
     */
    List<Person> findByLastNameIn(List<String> lastNames);
}

 

PersonService.java

package org.kshell.jpa.service;

import org.kshell.jpa.entity.Person;
import org.kshell.jpa.repository.PersonRepository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author kshell
 * @version 1.0
 * create by 2017-11-10
 * describe:
 */
@Service
public class PersonService {
    @Resource
    private PersonRepository personRepository;

    @Transactional
    public void init() {
        List<Person> personList = new ArrayList<Person>();

        for (int i = 'a'; i <= 'z'; i++) {
            Person person = new Person();
            String name = (char) i + "" + (char) i + (char) i;
            String emal = name + "@kshell.org";

            person.setLastName(name.toUpperCase());
            person.setEmail(emal.toLowerCase());
            person.setBirth(new Date());
            personList.add(person);
        }
        personRepository.save(personList);
    }
}

 

SpringDataTest.java

package org.kshell.jpa.entity;


import lombok.extern.slf4j.Slf4j;
import org.kshell.jpa.repository.PersonRepository;
import org.kshell.jpa.service.PersonService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.testng.annotations.Test;

import javax.persistence.criteria.*;
import java.util.Arrays;
import java.util.List;

/**
 * @author kshell
 * @version 1.0
 * create by 2017-11-10
 * describe:
 */
@Slf4j
public class SpringDataTest {
    private ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-bean.xml");
    private PersonRepository personRepository = (PersonRepository) context.getBean("personRepository");
    private PersonService personService = context.getBean(PersonService.class);

    @Test
    public void testQueryIn() throws Exception {
        List<Person> list = this.personRepository.findByLastNameIn(Arrays.asList("AAA", "BBB"));
    }
    /**
     * 测试环境是否正确
     *
     * @throws Exception
     */
    @Test
    public void testJpa() throws Exception {

    }

    /**
     * 批量保存
     *
     * @throws Exception
     */
    @Test
    public void testSave() throws Exception {
        this.personService.init();
    }

    /**
     * 排序
     *
     * @throws Exception
     */
    @Test
    public void testSort() throws Exception {
        Sort.Order order = new Sort.Order(Sort.Direction.ASC, "lastName");
        Sort sort = new Sort(order);
        List<Person> personList = this.personRepository.findAll(sort);
        for (Person person : personList) {
            log.info(person.toString());
        }
    }

    /**
     * 分页
     *
     * @throws Exception
     */
    @Test
    public void testPage() throws Exception {
        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "lastName");
        Sort sort = new Sort(order);
        int pageNumber = 1;
        int pageSize = 5;
        Pageable pageable = new PageRequest(pageNumber, pageSize, sort);
        Page<Person> page1 = this.personRepository.findAll(pageable);
        log.info("总条数:" + page1.getTotalElements());
        log.info("总页数:" + page1.getTotalPages());
        log.info("当前页:" + (page1.getNumber() + 1));
        log.info("每页条数:" + page1.getSize());
        List<Person> personList = page1.getContent();
        for (Person person : personList) {
            log.info("记录:" + person);
        }
    }

    /**
     * 带查询条件的分页
     *
     * @throws Exception
     */
    @Test
    public void testSpecificationPage() throws Exception {
        int pageNumber = 0;
        int pageSize = 5;
        Pageable pageable = new PageRequest(pageNumber, pageSize);
        Specification<Person> specification = new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path path = root.get("id");
                Predicate predicate = cb.gt(path, 16);
                return predicate;
            }
        };

        Page<Person> page1 = this.personRepository.findAll(pageable);
        log.info("总条数:" + page1.getTotalElements());
        log.info("总页数:" + page1.getTotalPages());
        log.info("当前页:" + (page1.getNumber() + 1));
        log.info("每页条数:" + page1.getSize());
        List<Person> personList = page1.getContent();
        for (Person person : personList) {
            log.info("记录:" + person);
        }
    }


}

 

readme.txt

1.使用eclipselink做为jpa实现产品时,需要提供persistence.xml配置
并在entityManagerFactory中使用persistenceUnitName方式指定
<property name="persistenceUnitName" value="eclipselink" />
persistence.xml范例:
    <properties>
        <property name="eclipselink.ddl-generation" value="create-or-extend-tables"/>
        <property name="eclipselink.ddl-generation.output-mode" value="database"/>
        <!-- eclipselink.weaving设为ture运行不成功, false,和static成功, 这是一个关键点 -->
        <property name="eclipselink.weaving" value="static" />
        <!-- 修改为FINE后,控制台会打印出执行的sql语句,方便调试, 可选值SERVER -->
        <property name="eclipselink.logging.level" value="FINE"/>
        <property name="eclipselink.jdbc.allow-native-sql-queries" value="true" />
        <!-- 定义主键 UUID -->
        <!--<property name="eclipselink.session.customizer" value="com.tgb.itoo.base.util.uuid.UUIDSequence" />-->
    </properties>
----------------------------------
2.实体主键注解差异(mysql,ID为int或Integer)
@GeneratedValue
@GeneratedValue(strategy = GenerationType.AUTO)
以上两种注解将会生成一张名为sequence的表用于记录主键,并且主键是全局共享.
每次主键取50个值以供使用,未用完的直接废弃
@GeneratedValue(strategy = GenerationType.IDENTITY)
使用这种方式将使用数据库的自动增长AUTO_INCREMENT
----------------------------------
3.注意:PersonRepository中的如下自定义借口方法不被eclipselink支持
List<Person> findByLastNameIn(List<String> lastNames);

-------------------- JPA实现产品(2) Eclipselink END --------------------

posted on 2017-11-19 11:24  Kshell  阅读(2130)  评论(1)    收藏  举报

导航