springBoot整合JPA

首先是项目组成结构

然后是pom.xml

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.8.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>test</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>test</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>net.sf.json-lib</groupId>
			<artifactId>json-lib</artifactId>
			<version>2.4</version>
			<classifier>jdk15</classifier>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>1.7.7</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.6.1</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.6.1</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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

</project>

然后是yml配置

server:
  port: 9090
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/pbs191?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
    username: root
    password: 123456
  jpa:
      hibernate:
        ddl-auto: update
      properties:
        hibernate:
          dialect: org.hibernate.dialect.MySQL5Dialect
      show-sql: true
  profiles:
      active: '@package.environment@'

然后是controller

package com.example.test.controller;

import com.example.test.facade.UserFacade;
import com.example.test.pojo.User;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import net.sf.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;


/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-09-20 10:11
 * @Modified By:
 */
@Api
@RequestMapping("/user")
@Controller
public class UserController {

    @Autowired
    private UserFacade userFacade;

    private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @ApiOperation(value = "查询用户信息",notes = "根据用户工号查询用户基本信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "number", value = "用户工号", required = true, dataType = "String", paramType = "query")
    })
    @RequestMapping("/query")
    @ResponseBody
    public String query(@RequestParam("number") String number){
        logger.info("[查询用户信息] 接收的参数为："+number);
        User user=this.userFacade.query(number);
        String result= JSONObject.fromObject(user).toString();
        logger.info("[查询用户信息] 返回的结果为："+result);
        return result;
    }

    @ApiOperation(value = "查询用户集合信息",notes = "查询所有用户信息")
    @RequestMapping("/findAll")
    @ResponseBody
    public String findAll(){
        String result=this.userFacade.findAll();
        logger.info("[查询用户信息] 返回的结果为："+result);
        return result;
    }
    @ApiOperation(value = "添加用户信息",notes = "添加用户基本信息")
    @RequestMapping("/add")
    @ResponseBody
    public HashMap<String,String> add(){
        HashMap<String,String> result=this.userFacade.add();
        return result;
    }

    @ApiOperation(value = "修改用户信息",notes = "修改用户基本信息")
    @RequestMapping("/update")
    @ResponseBody
    public HashMap<String,String> update(User user){
        HashMap<String,String> result=this.userFacade.update(user);
        return result;
    }
    
}

然后是facade

package com.example.test.facade;

import com.example.test.pojo.User;

import java.util.HashMap;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-09-20 10:12
 * @Modified By:
 */
public interface UserFacade {

    User query(String number);

    String findAll();

    HashMap<String,String> add();

    HashMap<String,String> update(User user);


}

然后是service

package com.example.test.service;

import com.example.test.dao.UserDao;
import com.example.test.facade.UserFacade;
import com.example.test.pojo.User;
import net.sf.json.JSONArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-09-20 10:12
 * @Modified By:
 */
@Service("userService")
@Transactional
public class UserService implements UserFacade {

    @Autowired
    private UserDao userDao;

    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    /**
     * 查询用户基本信息
     * @param number
     * @return
     */
    @Override
    public User query(String number) {
        logger.info("[查询用户信息] 接收的参数为："+number);
        User user=new User();
        try {
            user=this.userDao.findUserByNumber(number);
            logger.info("[查询用户信息] 返回的查询结果为："+user.toString());
        }catch (Exception e){
            logger.info("[查询用户信息] 查询异常 异常信息为："+e);
            e.printStackTrace();
        }
        return user;
    }

    @Override
    public String findAll() {
        logger.info("[查询用户信息] 查询所有用户信息");
        List<User> list = this.userDao.findAll();
        String result= JSONArray.fromObject(list).toString();
        logger.info("[查询用户信息] 查询所有用户信息返回的结果为："+result);
        return result;
    }

    @Override
    public HashMap<String, String> add() {
        HashMap<String,String> resultMap=new HashMap<String,String>();
        User user=new User();
        user.setNumber("4001");
        user.setPassword("123456");
        user.setName("张三");
        user.setAge(28);
        user.setDepartment("软件开发部");
        user.setRemak("前端开发工程师，工作5年");
        try {
            this.userDao.save(user);
            resultMap.put("code","S");
            resultMap.put("msg","添加用户成功");
        }catch (Exception e){
            resultMap.put("code","E");
            resultMap.put("msg","添加用户失败");
            logger.info("[添加用户] 添加用户异常 异常信息为："+e);
            e.printStackTrace();
        }

        return resultMap;
    }

    /**
     * 修改用户基本信息
     * @param user
     * @return
     */
    @Override
    public HashMap<String, String> update(User user) {
        logger.info("[修改用户信息] 接收的参数为："+user.toString());
        HashMap<String,String> resultMap=new HashMap<String, String>();
        try {
            this.userDao.save(user);
            resultMap.put("code","S");
            resultMap.put("msg","修改用户信息成功 修改uuid为:"+user.getUuid());
        }catch (Exception e){
            resultMap.put("code","E");
            resultMap.put("msg","修改用户信息异常");
            logger.info("[修改用户信息] 修改用户信息异常 异常信息为："+e);
            e.printStackTrace();
        }
        return resultMap;
    }
}

然后是dao

package com.example.test.dao;

import com.example.test.pojo.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author: Administrator
 * @Description:
 * @Date: 2019-09-20 10:12
 * @Modified By:
 */
@Repository
public interface UserDao extends JpaRepository<User,String> {

    User findUserByNumber(String number);

    List<User> findAll();

    User save(User user);

}

由于使用了jpa所以对于单表就不需要再写SQL语句了
注意对于save方法的解释：如果执行此方法是对象中存在id属性，即为更新操作会先根据id查询，再更新 如果执行此方法中对象中不存在id属性，即为保存操作
然后是实体类（jpa会自动建立数据库表）

package com.example.test.pojo;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;

/**
 * @Author: Administrator
 * @Description:实体类映射数据库表
 * 使用spring data jpa开发的时候，会将实体类中的成员变量与表中的字段一一对应，
 * 当我们在实体类中加上一个不与数据库表一一对应的成员变量的时候，此时我们只要在
 * 这个成员变量上加上注解@Transient
 * @Date: 2019-09-20 10:12
 * @Modified By:
 */
@Entity
@Table(name = "test_user")
public class User {

    @Id
    @GeneratedValue(generator = "uuid")
    @GenericGenerator(name = "uuid", strategy = "uuid")
    @Column(name = "uuid",length = 36)
    private  String uuid;
    @Column(name = "number")
    private String number;
    @Column(name = "password")
    private String password;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private Integer age;
    @Column(name = "department")
    private String department;
    @Column(name = "remak")
    private String remak;

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public String getRemak() {
        return remak;
    }

    public void setRemak(String remak) {
        this.remak = remak;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
}

最后就是Swagger2的配置了

package com.example.test.conf;

import io.swagger.annotations.ApiOperation;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * http://localhost:8080/swagger-ui.html
 */
@Configuration
@EnableSwagger2
public class Swagger2 {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.example.test.controller"))
                //扫描所有有注解的api，用这种方式更灵活
                .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("测试用户相关接口")
                .description("简单优雅的restfun风格")
                .version("1.0")
                .build();
    }
}

package com.example.test.conf;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class WebMvcConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")//可以指定从某域过来的所有请求
                .allowedMethods("POST", "GET", "PUT", "OPTIONS", "DELETE")//请求方式
                .maxAge(3600)
                .allowCredentials(true);
    }
}

测试效果如下