整合 Spring Data Jpa

Java 持久层框架访问数据库的方式大致分为两种。一种以 SQL 核心,封 装一定程度的 JDBC 操作,比如: MyBatis。另一种是以 Java 实体类为核心,将实体类 的和数据库表之间建立映射关系,也就是我们说的 ORM 框架,如:Hibernate、Spring Data JPA
Spring Data JPA 是建立的 JPA 的基础之上的。
JPA 全称为 Java Persistence API(Java 持久层 API),它是 Sun 公司在 JavaEE 5 中提出的 Java 持久化规范。它为 Java 开发人员提供了一种对象/关联映射工具,来管理 Java 应用 中的关系数据,JPA 吸取了目前 Java 持久化技术的优点,旨在规范、简化 Java 对象的持久 化工作。很多 ORM 框架都是实现了 JPA 的规范,如:Hibernate、EclipseLink。也就是 JPA 统一了 Java 应用程序访问 ORM 框架的规范,而 Hibernate 是一个 ORM 框架,Hibernate 是 JPA 的一种实现,是一个框架。
Spring Data 是 Spring 社区的一个子项目,主要用于简化数据访问,其主要目标是使得 数据库的访问变得方便快捷。它不仅支持关系型数据库,也支持非关系型数据库。
Spring Data JPA 是在实现了 JPA 规范的基础上封装的一套 JPA 应用框架,虽然 ORM 框架都实现了 JPA 规范,但是在不同的 ORM 框架之间切换仍然需要编写不同的代码,而使 用 Spring Data JPA 能够方便大家在不同的 ORM 框架之间进行切换而不需要更改代码。 Spring Data JPA 旨在通过将统一 ORM 框架的访问持久层的操作,来提高开发人的效率。 Spring Data JPA 给我们提供的主要的类和接口

整合 Spring Data Jpa

 

 

总的来说 JPA 是 ORM 规范,Hibernate、TopLink 等是 JPA 规范的具体实现,这样的好 处是开发者可以面向 JPA 规范进行持久层的开发,而底层的实现则是可以切换的。Spring Data Jpa 则是在 JPA 之上添加另一层抽象(Repository 层的实现),极大地简化持久层开发 及 ORM 框架切换的成本

整合 Spring Data Jpa

 

 

Cors 跨域配置

在实际开发过程中我们经常会遇到跨域问题(如一个项目区访问另一个项目的接口),跨域其实是浏览器对于 ajax 请求的一种安全限制。目前比较常用的跨域解决方案有 3 种:
Jsonp:最早的解决方案,利用 script 标签可以跨域的原理实现。 
nginx 反向代理:利用 nginx 反向代理把跨域转为不跨域,支持各种请求方式。
CORS:规范化的跨域请求解决方案,安全可靠。
       CORS:全称"跨域资源共享"(Cross-origin resource sharing)。CORS 需要浏览器和服 务器同时支持,才可以实现跨域请求,目前几乎所有浏览器都支持 CORS,IE 则不能低于 IE10。CORS 的整个过程都由浏览器自动完成,前端无需做任何设置,跟平时发送 ajax 请求 并无差异。实现 CORS 的关键在于服务器(后台),只要服务器实现 CORS 接口,就可以 实现跨域通信。
CORS 实现跨域也是非常简单的,事实上,SpringMVC 已经帮我们写好了 CORS 的跨 域过滤器:CorsFilter ,内部已经实现了判定逻辑,我们直接用就好了。

项目下新建 GlobalCorsConfig 类用于跨域的全局配置,代码如下:
@Configuration 
public class GlobalCorsConfig { 
    @Bean public CorsFilter corsFilter() { 
              //1.添加 CORS 配置信息 CorsConfiguration config = new 
              CorsConfiguration(); 
              //1) 允许接收的域,不要写*,否则 cookie 就无法使用了
             config.addAllowedOrigin("http://localhost:8081"); 
             //2) 是否发送 Cookie 信息 
             config.setAllowCredentials(true); //3) 允许的请求方式 
             config.addAllowedMethod("OPTIONS");
             config.addAllowedMethod("HEAD"); 
             config.addAllowedMethod("GET"); 
             config.addAllowedMethod("PUT");
             config.addAllowedMethod("POST"); 
             config.addAllowedMethod("DELETE"); config.addAllowedMethod("PATCH"); 
             // 4)允许的头信息 
             config.addAllowedHeader("*"); 
            //2.添加映射路径,我们拦截一切请求 
            UrlBasedCorsConfigurationSource configSource = new 
UrlBasedCorsConfigurationSource(); 
            configSource.registerCorsConfiguration("/**", config); 
            //3.返回新的 CorsFilter. 
            return new CorsFilter(configSource); 
      } 
}
配置项目一:
<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.jdbctemplate</groupId>
    <artifactId>jdbctemplate</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <!-- 声明项目配置依赖编码格式为 utf-8 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <fastjson.version>1.2.24</fastjson.version>
    </properties>

    <dependencies>
        <!--Spring Data Jpa依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>8.0.13</version><!--$NO-MVN-MAN-VER$ -->
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

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

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

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
server.port =8089
server.servlet.context-path=/

spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?serverTimezone=UTC&autoReconnect=true
spring.datasource.username=root
spring.datasource.password=admin
##spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.database=MySQL
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql=true

spring.initialSize=5 
spring.minIdle=5 
spring.maxActive=20
spring.maxWait: 60000 
spring.timeBetweenEvictionRunsMillis=60000
spring.minEvictableIdleTimeMillis=300000
spring.validationQuery=SELECT 1 FROM DUAL
spring.testWhileIdle=true
spring.testOnBorrow=false
spring.testOnReturn=false
spring.poolPreparedStatements=true

spring.filter.stat.enabled=true 
spring.filter.stat.log-slow-sql=true 

spring.filter.wall.enabled=true
package com.tszr.jpa.entity;

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

@Entity
@Table(name = "t_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "username", unique = true, nullable = false, length = 64)
    private String username;

    @Column(name = "password", nullable = false, length = 64)
    private String password;

    @Column(name = "email", length = 64)
    private String email;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

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

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}
package com.tszr.jpa.dao;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import com.tszr.jpa.entity.User;

public interface UserRepository extends JpaRepository<User, Integer> {
    /* 相当于select * from t_user where username = ? and password = ? */
    public User findByUsernameAndPassword(String username, String password);

    @Query("select u from User u where u.username like %?1%")
    public List<User> getUserByUsername(@Param("username") String username);
}
package com.tszr.jpa.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
public class Config {
    /* 把配置文件中 spring.datasource.initialSize 等属性和 DruidDataSource 中属 性 进行绑定 */
    @ConfigurationProperties(prefix = "spring.datasource")
    @Bean
    public DruidDataSource druidDataSource() {
        return new DruidDataSource();
    }
}
package com.tszr.jpa.config;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;

@Configuration
public class DuridConfig {
    /**
     * 配置 Druid 的监控 1、配置一个管理后台的 Servlet,拦截登陆
     * 
     * @return
     */
    @Bean
    public ServletRegistrationBean<StatViewServlet> statViewServlet() {
        ServletRegistrationBean<StatViewServlet> servletRegistrationBean = new ServletRegistrationBean<StatViewServlet>(
                new StatViewServlet(), "/druid/*");
        Map<String, String> initParams = new HashMap<>();
        initParams.put("loginUsername", "admin");
        initParams.put("loginPassword", "123456");
        initParams.put("allow", ""); // 允许所有访问
        servletRegistrationBean.setInitParameters(initParams);
        return servletRegistrationBean;
    }

    // 配置一个 web 监控的 filter,哪些请求会被监控,哪些排除。
    @Bean
    public FilterRegistrationBean<WebStatFilter> webStatFilter() {
        FilterRegistrationBean<WebStatFilter> bean = new FilterRegistrationBean<WebStatFilter>(new WebStatFilter());
        Map<String, String> initParams = new HashMap<>();
        initParams.put("exclusions", "*.js,*.css,/druid/*");
        bean.setInitParameters(initParams);
        bean.setUrlPatterns(Arrays.asList("/*"));
        return bean;
    }
}
package com.tszr.jpa.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

@Configuration
public class GlobalCorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        // 1.添加CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
        // 1) 允许的域,不要写*,否则cookie就无法使用了
        config.addAllowedOrigin("http://localhost:8081");
        // 2) 是否发送Cookie信息
        config.setAllowCredentials(true);
        // 3) 允许的请求方式
        config.addAllowedMethod("OPTIONS");
        config.addAllowedMethod("HEAD");
        config.addAllowedMethod("GET");
        config.addAllowedMethod("PUT");
        config.addAllowedMethod("POST");
        config.addAllowedMethod("DELETE");
        config.addAllowedMethod("PATCH");
        // 4)允许的头信息
        config.addAllowedHeader("*");

        // 2.添加映射路径,我们拦截一切请求
        UrlBasedCorsConfigurationSource configSource = new UrlBasedCorsConfigurationSource();
        configSource.registerCorsConfiguration("/**", config);

        // 3.返回新的CorsFilter.
        return new CorsFilter(configSource);
    }
}
package com.tszr.jpa;

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

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
启动第一个项目。

创建第二个项目。
<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.cors</groupId>
    <artifactId>SpringCors</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <!-- 声明项目配置依赖编码格式为 utf-8 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <fastjson.version>1.2.24</fastjson.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
server.port=8081
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="jquery-1.8.3.js"></script>
</head>
<body>
    <input type="button" value="添加数据" onclick="addUser()">
    <br>
    <input type="button" value="删除数据" onclick="deleteUser()">
    <script>
        function addUser() {
            $.ajax({
                type : 'post',
                /*访问15.3.2小节项目中的添加接口*/
                url : 'http://localhost:8080/users',
                data : JSON.stringify({
                    "username" : "admin",
                    "password" : "123456",
                    "email" : "635498720"
                }),
                dataType : "json",
                contentType : "application/json;charset=UTF-8",
                success : function(msg) {}
            })
        }
        function deleteUser() {
            $.ajax({
                type : 'delete',
                /*访问15.3.2小节项目中的删除接口*/
                url : 'http://localhost:8080/users/5',
                success : function(msg) {}
            })
        }
    </script>
</body>
</html>
package com.tszr.springcors;

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

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

整合 Spring Data Jpa

 

 整合 Spring Data Jpa

 

 整合 Spring Data Jpa

 

 整合 Spring Data Jpa

 

上一篇:JPA学习笔记二:实践篇之实现正向工程


下一篇:spring整合jpa 测试查询,查询不到中文字段?