springboot2.1.0、JPA简单使用

该篇章主要讲解jpa的一些简单使用

一）在pom.xml引入jpa对应的jar

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

    <groupId>com.oysept.springboot</groupId>
    <artifactId>oysept-springboot-jpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>oysept-springboot-jpa</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
		
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
		
        <!-- jpa start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- jpa end -->
        
        <!-- oracle start -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
        </dependency>
        <!-- oracle end -->
        
        <!-- json处理jar -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

 

二）在resources下application.properties中添加oracle支持

server.port=8080

spring.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@localhost:1521/oysept
spring.datasource.username=oysept
spring.datasource.password=oysept

spring.jpa.database=oracle
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.hibernate.ddl-auto=none

 

三）创建一个Entity类，对应的表创建就不贴出来了，直接在oracle创建一个简单的表即可

package com.oysept.springboot.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * 员工基本信息entity
 * 注意: table的name和column的name都小写,不然在解析对应表关系的时候会出错,比如Oysept_Employee会解析成oysept_employee
 * @author ouyangjun
 */
@Entity
@Table(name = "oysept_employee")
public class EmployeeEntity {
	
    @Id
    @Column(name = "emp_id")
    private String empID;

    @Column(name = "emp_no")
    private String empNO;
	
    @Column(name = "emp_name")
    private String empName;
	
    @Column(name = "status")
    private String status;

    @Column(name = "create_date")
    private String createDate;

    public String getEmpID() {return empID;}
    public void setEmpID(String empID) {this.empID = empID;}

    public String getEmpNO() {return empNO;}
    public void setEmpNO(String empNO) {this.empNO = empNO;}

    public String getEmpName() {return empName;}
    public void setEmpName(String empName) {this.empName = empName;}

    public String getStatus() {return status;}
    public void setStatus(String status) {this.status = status;}

    public String getCreateDate() {return createDate;}
    public void setCreateDate(String createDate) {this.createDate = createDate;}
}

 

四）创建一个Repository操作类

package com.oysept.springboot.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

import com.oysept.springboot.entity.EmployeeEntity;

@Repository
public interface EmployeeRepository extends JpaRepository<EmployeeEntity, String>, JpaSpecificationExecutor<EmployeeEntity>{
	
    // 根据empID查询员工信息,empID和entity的属性要一样
    public EmployeeEntity findByEmpID(String empID);
}

 

五）创建一个DTO，该DTO和Entity属性一致，主要是做数据转换，返回给前端使用

package com.oysept.springboot.dto;

import java.io.Serializable;

/**
 * 员工DTO,注意用于参数传递,数据转换,把entity隐藏不暴露,和entity查不多
 * @author ouyangjun
 */
public class EmployeeDTO implements Serializable {
    
	private static final long serialVersionUID = 1L;

    private String empID;
    private String empNO;
    private String empName;
    private String status;
    private String createDate;

    public String getEmpID() {return empID;}
    public void setEmpID(String empID) {this.empID = empID;}

    public String getEmpNO() {return empNO;}
    public void setEmpNO(String empNO) {this.empNO = empNO;}

    public String getEmpName() {return empName;}
    public void setEmpName(String empName) {this.empName = empName;}

    public String getStatus() {return status;}
    public void setStatus(String status) {this.status = status;}

    public String getCreateDate() {return createDate;}
    public void setCreateDate(String createDate) {this.createDate = createDate;}
}

 

六）创建一个数据转换工具类，主要是把数据转换成对应的DTO

package com.oysept.springboot.utils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import com.alibaba.fastjson.JSONObject;

public class ObjectConvertUtils {

    /**
     * List<Map<Object,Object>>转换List<T>
     * @param map
     * @param beanClass
     * @return
     * @throws Exception
     */
    public static <T> List<T> castMapToBean(List<Map<Object, Object>> list, Class<T> beanClass) {
        List<T> returnList = new ArrayList<T>();
        if (list == null || list.size()==0) {
            return returnList;
        }
        
        String json = "";
        for (Map<Object, Object> map : list) {
            json = JSONObject.toJSONString(map);
        	
            // 添加到集合中
            returnList.add(JSONObject.parseObject(json, beanClass));
        }
        // 返回
        return returnList;
    }
}

 

七）创建一个Controller类，该类主要测试使用

package com.oysept.springboot.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.hibernate.query.internal.NativeQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.ExampleMatcher;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.oysept.springboot.dto.EmployeeDTO;
import com.oysept.springboot.entity.EmployeeEntity;
import com.oysept.springboot.repository.EmployeeRepository;
import com.oysept.springboot.utils.ObjectConvertUtils;

/**
 * 员工controller
 * @author ouyangjun
 */
@RestController
@RequestMapping(value="/employee")
public class EmployeeController {
	
    @Autowired
    private EmployeeRepository employeeRepository;
	
    // 自定义原生sql工具类
    @PersistenceContext
    EntityManager entityManager;
	
    /**
     * 获取所有员工信息
     * 访问地址: http://localhost:8080/employee/list
     * @return
     */
    @RequestMapping(value="/list")
    public List<EmployeeDTO> list(){
        // 查询
        List<EmployeeEntity> entityList = employeeRepository.findAll();
		
        // 数据转换
        List<EmployeeDTO> dtoList = new ArrayList<EmployeeDTO>();
        if (!CollectionUtils.isEmpty(entityList)) {
            entityList.forEach(entity -> {
                EmployeeDTO dto = new EmployeeDTO();
                BeanUtils.copyProperties(entity, dto);
        		
                // 添加到集合中返回
                dtoList.add(dto);
            });
        }
        return dtoList;
    }
	
    /**
     * 获取所有员工信息并分页
     * 访问地址: http://localhost:8080/employee/list/page?page=0&size=10
     * @return
     */
    @RequestMapping(value="/list/page")
    public List<EmployeeDTO> listPage(@RequestParam(value = "page") int page,@RequestParam(value = "size") int size){
		
        // 排序,字段在entity要存在
        Sort sort = new Sort(Sort.Direction.DESC, "empID", "createDate");
        // 拼接条件
        Specification<EmployeeEntity> specification = getEmployeeWhereClause(new EmployeeDTO());
        List<EmployeeEntity> entityList = null;
        
        // 如果分页参数不为空,需要分页展示数据
        if (!StringUtils.isEmpty(page) && !StringUtils.isEmpty(size)) {
            // 分页
            Page<EmployeeEntity> pageAll = employeeRepository.findAll(specification, new PageRequest(page, size, sort));
        	
            // 获取集合数据
            entityList = pageAll.getContent();
        } else {
            entityList = employeeRepository.findAll(specification, sort);
        }
        
        // 数据转换
        List<EmployeeDTO> dtoList = new ArrayList<EmployeeDTO>();
        if (!CollectionUtils.isEmpty(entityList)) {
            entityList.forEach(entity -> {
                EmployeeDTO dto = new EmployeeDTO();
                BeanUtils.copyProperties(entity, dto);
        		
                // 添加到集合中返回
                dtoList.add(dto);
            });
        }
        return dtoList;
    }
	
    // 拼接条件, 该方法只是展示条件的多样性
    public static Specification<EmployeeEntity> getEmployeeWhereClause(EmployeeDTO employeeDTO){
        return new Specification<EmployeeEntity>() {
            @Override
            public Predicate toPredicate(Root<EmployeeEntity> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> predicate = new ArrayList<>();
                // 有效员工
                predicate.add(cb.equal(root.get("status"), "0"));
                
                // 方式一: 转换成数组,查询多个,用分号分隔
                Object[] empIDs = employeeDTO.getEmpID().split(";");
                predicate.add(root.get("empID").in(empIDs));
                
                // 员工姓名
                String empName = employeeDTO.getEmpName();
                if (!StringUtils.isEmpty(empName)) {
                    List<Predicate> pred = new ArrayList<>();
                    // 循环
                    for (String name : empName.split(";")) {
                        pred.add(cb.or(
                            cb.like(root.get("empName"), "%"+name+"%")
                        ));
                    }
                    Predicate[] ppp = new Predicate[pred.size()];
                    predicate.add(cb.or(pred.toArray(ppp)));
                }
                Predicate[] pre = new Predicate[predicate.size()];
                return query.where(predicate.toArray(pre)).getRestriction();
            }
        };
    }
	
    /**
     * 根据状态查询员工信息
     * 访问地址: http://localhost:8080/employee/findByEmpDTO?status=0
     * @param status
     * @return
     */
    @RequestMapping(value="/findByEmpDTO", method = RequestMethod.POST)
    public List<EmployeeDTO> findByEmpDTO(@RequestBody EmployeeDTO empDTO){
        // 封装条件
        EmployeeEntity employeeEntity = new EmployeeEntity();
        employeeEntity.setStatus(empDTO.getStatus());
    	
        // 获取信息
        List<EmployeeEntity> entityList = employeeRepository.findAll(Example.of(employeeEntity, ExampleMatcher.matchingAll()));
    	
        // 数据转换
        List<EmployeeDTO> dtoList = new ArrayList<EmployeeDTO>();
        if (!CollectionUtils.isEmpty(entityList)) {
            entityList.forEach(entity -> {
                EmployeeDTO dto = new EmployeeDTO();
                BeanUtils.copyProperties(entity, dto);
        		
                // 添加到集合中返回
                dtoList.add(dto);
            });
        }
        return dtoList;
    }
	
    /**
     * 根据empID账号获取员工信息
     * 访问地址: http://localhost:8080/employee/findByEmpID/oysept
     * @param empID
     * @return
     */
    @RequestMapping(value="/findByEmpID/{empID}", method = RequestMethod.GET)
    public EmployeeDTO findByEmpID(@PathVariable("empID") String empID){
        // 获取信息
        EmployeeEntity entity = employeeRepository.findByEmpID(empID);
    	
        // 复制
        EmployeeDTO employeeDTO = new EmployeeDTO();
        BeanUtils.copyProperties(entity, employeeDTO);
        return employeeDTO;
    }
	
    /**
     * 自定义sql查询数据
     * 访问地址: http://localhost:8080/employee/findByNativeSql?empID=oysept
     * @param empID
     * @return
     */
    @RequestMapping(value="/findByNativeSql", method = RequestMethod.GET)
    public EmployeeDTO findByNativeSql(@RequestParam(value = "empID") String empID){
		
        // 获取服务主单查询sql
        StringBuffer buffer = new StringBuffer();
        buffer.append("select ");
        // 查询字段-----start-----
        buffer.append("emp_id       as empID, ");
        buffer.append("emp_no       as empNO, ");
        buffer.append("emp_name     as empName, ");
        buffer.append("status       as status, ");
        buffer.append("create_date  as createDate ");
        // 查询字段-----end-----
        buffer.append("from oysept_employee where 1=1 ");
        buffer.append("and emp_id = '" + empID + "' ");
				
        // 执行查询sql
        Query query = this.entityManager.createNativeQuery(buffer.toString());
        // 把查询的结果从List<Object[]>转换成List<Map<Object,Object>>
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List<Map<Object,Object>> objList = query.getResultList();
		
        try {
            List<EmployeeDTO> dtoList = ObjectConvertUtils.castMapToBean(objList, EmployeeDTO.class);
            System.out.println("==>findByNativeSql,dtoList.size(): " + dtoList.size());
            return dtoList.get(0);
        } catch (Exception e) {
            System.out.println("==> findByNativeSql数据转换异常:" + e);
        }
        return null;
    }
}

 

八）创建一个springboot启动类

package com.oysept.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * springboot启动类
 * @author ouyangjun
 */
@SpringBootApplication
public class JpaApplication {

    public static void main(String[] args) {
        SpringApplication.run(JpaApplication.class, args);
    }
}

 

九）项目结构图

最后启动JpaApplication，输入Controller中的地址测试，也可以下载Postman等测试工具测试。

 

识别二维码关注个人微信公众号

 本章完结，待续，欢迎转载！
 
本文说明：该文章属于原创，如需转载，请标明文章转载来源！