JPA实现产品之三 Openjpa 2.2.2

最近闲来无事,整理了一下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实现产品(3) Openjpa2.2.2
源码参见 https://github.com/kshell/jpa.git 之openjpa2.2.2分支
或者参见 https://gitee.com/kshell/jpa.git  之openjpa2.2.2分支

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.apache.openjpa</groupId>
            <artifactId>openjpa-all</artifactId>
            <version>2.2.2</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="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             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="openjpa_2_2_2" transaction-type="RESOURCE_LOCAL">
        <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
        <properties>
            <!--自动建表-->
            <property name="openjpa.jdbc.SynchronizeMappings" 
　　　　　　　　　　　 　 value="buildSchema(ForeignKeys=true,PrimaryKeys=true,Indexes=true,schemaAction=refresh)"/>
            <!--不使用openjpa增强-->
            <property name="openjpa.ClassLoadEnhancement" value="false"/>
            <property name="openjpa.DynamicEnhancementAgent" value="false"/>
            <property name="openjpa.RuntimeUnenhancedClasses" value="supported"/>
        </properties>
    </persistence-unit>
</persistence>

 

db.properties

use=openjpa_2.2.2

openjpa_2.2.2.jdbc.driver=com.mysql.jdbc.Driver
openjpa_2.2.2.jdbc.url=jdbc:mysql://localhost:3306/jpa_openjpa_2_2_2
openjpa_2.2.2.jdbc.username=root
openjpa_2.2.2.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.OpenJpaVendorAdapter"/>
        </property>
        <property name="persistenceUnitName" value="openjpa_2_2_2"/>
    </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

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 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> {
    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 java.util.Arrays;
import java.util.List;

import javax.persistence.criteria.*;

/**
 * @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"));

        log.info(list.toString());
    }

    /**
     * 测试环境是否正确
     *
     * @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.使用openjpa2.2.2做为jpa实现产品时,需要提供persistence.xml配置
 并在entityManagerFactory中使用persistenceUnitName方式指定
 <property name="persistenceUnitName" value="openjpa_2_2_2" />
 persistence.xml范例:
    <persistence-unit name="openjpa_2_2_2" transaction-type="RESOURCE_LOCAL">
        <provider>org.apache.openjpa.persistence.PersistenceProviderImpl</provider>
        <properties>
            <!--自动建表-->
            <property name="openjpa.jdbc.SynchronizeMappings" 
                      value="buildSchema(ForeignKeys=true,PrimaryKeys=true,Indexes=true,schemaAction=refresh)"/>
            <!--不使用openjpa增强-->
            <property name="openjpa.ClassLoadEnhancement" value="false"/>
            <property name="openjpa.DynamicEnhancementAgent" value="false"/>
            <property name="openjpa.RuntimeUnenhancedClasses" value="supported"/>
        </properties>
    </persistence-unit>
 ----------------------------------
 2.实体主键注解差异(mysql,ID为int或Integer)
 @GeneratedValue
 @GeneratedValue(strategy = GenerationType.AUTO)
 以上两种注解将会生成一张名为openjpa_sequence_table的表用于记录主键,并且主键是全局共享.
 每次主键取50个值以供使用,未用完的直接废弃
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 使用这种方式将使用数据库的自动增长AUTO_INCREMENT

-------------------- JPA实现产品(3) Openjpa2.2.2 END --------------------