精华内容
下载资源
问答
  • springboot整合jpa

    2019-04-26 09:56:01
    springboot2.0 , jdk 1.8 ,mysql ,jpa,搭建好的空项目,可以自动生成库表.
  • 运行项目之前先阅读readme!!! 这个项目利用SpringBoot2结合jpa实现了懒加载、二级查询等知识点!
  • SpringBoot整合JPA

    2018-07-23 14:50:33
    1什么是JPA? JPA顾名思义就是Java Persistence API的意思,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 2 JPA的优势 2.1标准化 JPA 是 JCP 组织发布的 Java EE 标准...

    1什么是JPA?

    JPA顾名思义就是Java Persistence API的意思,是JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。

    2 JPA的优势

    2.1标准化

    JPA JCP 组织发布的 Java EE 标准之一,因此任何声称符合 JPA 标准的框架都遵循同样的架构,提供相同的访问API,这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

    2.2容器级特性的支持

    JPA框架中支持大数据集、事务、并发等容器级事务,这使得 JPA 超越了简单持久化框架的局限,在企业应用发挥更大的作用。

    2.3简单方便

    JPA的主要目标之一就是提供更加简单的编程模型:在JPA框架下创建实体和创建Java 类一样简单,没有任何的约束和限制,只需要使用 javax.persistence.Entity进行注释,JPA的框架和接口也都非常简单,没有太多特别的规则和设计模式的要求,开发者可以很容易的掌握。JPA基于非侵入式原则设计,因此可以很容易的和其它框架或者容器集成。

    2.4查询能力

    JPA的查询语言是面向对象而非面向数据库的,它以面向对象的自然语法构造查询语句,可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQLJava Persistence Query Language),JPQLEJB QL的一种扩展,它是针对实体的一种查询语言,操作对象是实体,而不是关系数据库的表,而且能够支持批量更新和修改、JOINGROUP BYHAVING 等通常只有 SQL 才能够提供的高级查询特性,甚至还能够支持子查询。

    2.4高级特性

    JPA 中能够支持面向对象的高级特性,如类之间的继承、多态和类之间的复杂关系,这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用,而不需要自行处理这些特性在关系数据库的持久化。

    3 JPA的实现

    目前JPA主要实现由hibernateopenJPA

    4 什么是SpringData?

    Spring Data是一个用于简化数据库访问,并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷,并支持map-reduce框架和云计算数据服务。此外,它还支持基于关系型数据库的数据服务,如Oracle RAC等。对于拥有海量数据的项目,可以用Spring Data来简化项目的开发,就如Spring Framework对JDBC、ORM的支持一样,Spring Data会让数据的访问变得更加方便。

    5 什么是Spring DATA JPA?

    可以极大的简化JPA的写法,可以在几乎不用写实现的情况下,实现对数据的访问和操作。除了CRUD外,还包括如分页、排序等一些常用的功能。

    首先我们需要清楚的是Spring Data是一个开源框架,在这个框架中Spring Data JPA只是这个框架中的一个模块,所以名称才叫Spring Data JPA。如果单独使用JPA开发,你会发现这个代码量和使用JDBC开发一样有点烦人,所以Spring Data JPA的出现就是为了简化JPA的写法,让你只需要编写一个接口继承一个类就能实现CRUD操作了。

    6 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.5.2.RELEASE</version>
        </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>
    
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>spring_boot_jpa</artifactId>
        <dependencies>
    
    
            <!--集成JPA-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
    
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.36</version>
                <scope>runtime</scope>
            </dependency>
    
            <!--阿里巴巴数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.5</version>
            </dependency>
    
    
            <!--支持web开发-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
        </dependencies>
    
    </project>

    定义一个javabean:通过JPA注解来绑定和表的关系

    package com.springboot.jpa.bean;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    import javax.persistence.*;
    import java.math.BigDecimal;
    
    /**
    * @Author 18011618
    * @Date 9:49 2018/7/9
    * @Function 使用JPA注解
    */
    @Table(name = "user")
    @Entity
    @Getter
    @Setter
    @ToString
    public class User {
    
      public User(Long id, String username) {
        super();
        this.id = id;
        this.username = username;
      }
    
      public User() {
        super();
      }
    
      @Id
      @GeneratedValue(strategy = GenerationType.AUTO)
      private Long id;
    
      @Column(name = "username")
      private String username;
    
    
    }
    

    这里定义了相关的JPA注

    @Table(name = "user"):name是用来绑定实体类和对应的数据表,如果数据表和实体类是一致的话,可以不要写name
    @Column(name = "username"):绑定属性的列和数据表的字段,一致可以省略不写
    
    @Id
    
    @GeneratedValue(strategy = GenerationType.AUTO):标识数据表的主键且自增

    定义数据访问层接口:

    package com.springboot.jpa.resposity;
    
    import com.springboot.jpa.bean.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.repository.CrudRepository;
    import org.springframework.stereotype.Repository;
    
    /**
    * @Author 18011618
    * @Date 9:50 2018/7/9
    * @Function 定义数据访问接口
    */
    @Repository
    public interface UserRepository extends JpaRepository<User, Long> {
    
    }
    

    只定义空接口,为了能通过ioc让spring来管理,没有实现,接口的实现都是通过反射自己生成sql语句的.

    这里需要扩展讲解一下相关的Repository:

    Repository 接口是 Spring Data 的一个核心接口,它不提供任何方法,开发者需要在自己定义的接口中声明需要的方法 :

    public interface Repository<T, ID extends Serializable> { }

    有这么几点需要强调下:

    1. Repository是一个空接口,即是一个标记接口;

    2. 若我们定义的接口继承了Repository,则该接口会被IOC容器识别为一个Repository Bean纳入到IOC容器中,进而可以在该接口中定义满足一定规范的方法。

    3. 实际上也可以通过@RepositoryDefinition,注解来替代继承Repository接口。

    4. 查询方法以find | read | get开头;

    5. 涉及查询条件时,条件的属性用条件关键字连接,要注意的是条件属性以首字母大写。

    6.使用@Query注解可以自定义JPQL语句实现更灵活的查询

    CrudRepository接口

    --T save(T entity);//保存单个实体   

    --Iterable<T> save(Iterable<? extends T> entities);//保存集合         

    --T findOne(ID id);//根据id查找实体          

      --boolean exists(ID id);//根据id判断实体是否存在          

      --Iterable<T> findAll();//查询所有实体,不用或慎用!          

      --long count();//查询实体数量          

      --void delete(ID id);//根据Id删除实体          

      --void delete(T entity);//删除一个实体   

      --void delete(Iterable<? extends T> entities);//删除一个实体的集合          

      --void deleteAll();//删除所有实体,不用或慎用!   

    PagingAndSortingRepository接口

    --Iterable<T> findAll(Sort sort); //排序   

    --Page<T> findAll(Pageable pageable); //分页查询(含排序功能)

    JpaRepository 接口:

    查找所有实体,排序、查找所有实体,执行缓存与数据库同步

    JpaSpecificationExecutor 接口:

    不属于Repository体系,实现一组 JPA Criteria 查询相关的方法,封装  JPA Criteria 查询条件。通常使用匿名内部类的方式来创建该接口的对象。

    在这里为了方便演示就不写service,实际开发中必须要写service层,直接写一个测试的controller,调用数据访问层接口

    看controller对应的内容:

    package com.springboot.jpa.controller;
    
    import com.springboot.jpa.bean.User;
    import com.springboot.jpa.future.UserFuture;
    import com.springboot.jpa.resposity.UserRepository;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.ModelAndView;
    
    import java.util.Map;
    import java.util.concurrent.CompletableFuture;
    
    /**
     * @Author 18011618
     * @Description 用户提供服务的controller
     * @Date 9:51 2018/7/9
     * @Modify By
     */
    @Controller
    public class UserController {
    
        @Autowired
        private UserRepository userRepository; //数据访问层接口
    
    
        @RequestMapping("/findUser/{id}")
        @ResponseBody
        public User findUserById(@PathVariable long id){
    
            return this.userRepository.findOne(id);
        }
    
      
    
    }
    
    

    看一下对应的配置文件:applicaiton.yaml

    spring:
       datasource:
              driver-class-name: com.mysql.jdbc.Driver #加载数据库的驱动
              filters: stat,wall,log4j #过滤类型
              initialSize: 5 #资源池初始化大小
              maxActive: 20 #资源池最大激活数
              maxOpenPreparedStatements: 20
              maxWait: 60000 #最大等待时间
              minEvictableIdleTimeMillis: 300000
              minIdle: 1 #最小空闲数量
              password: 123123
              poolPreparedStatements: true
              testOnBorrow: false
              testOnReturn: false
              testWhileIdle: true
              timeBetweenEvictionRunsMillis: 60000
              type: com.alibaba.druid.pool.DruidDataSource
              url: jdbc:mysql://localhost:3306/emp
              username: root
              validationQuery: select 'x'
              logSlowSql: true
       jpa:
         hibernate:
           ddl-auto: update
         show-sql: false
    #   thymeleaf:
    #     cache: 'false  '
    #     encoding: UTF-8
    #     prefix: classpath:/templates/
    #     suffix: .html
    
    server:
      port: 8888
    
    

    最后写一个启动应用类

    package com.springboot.jpa;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    /**
     * @Author 18011618
     * @Description
     * @Date 18:58 2018/7/16
     * @Modify By
     */
    @SpringBootApplication
    public class JPAApplication {
        public static void main(String[] args) {
            SpringApplication.run(JPAApplication.class,args);
        }
    }
    

    最后把对应的sql语句也给一下,方便测试:

    SET FOREIGN_KEY_CHECKS=0;
    
    -- ----------------------------
    -- Table structure for `user`
    -- ----------------------------
    DROP TABLE IF EXISTS `user`;
    CREATE TABLE `user` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `username` varchar(255) DEFAULT NULL,
      UNIQUE KEY `id_x` (`id`) USING BTREE
    ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of user
    -- ----------------------------
    INSERT INTO `user` VALUES ('1', 'jiahp');
    INSERT INTO `user` VALUES ('2', 'wangli');
    INSERT INTO `user` VALUES ('3', 'guoyanbin');
    INSERT INTO `user` VALUES ('4', 'yaodong');
    

    最后启动应用类,在浏览器端输入 http://localhost:8888/findUser/1 可以看到如下结果

    到此为止就实现了和JPA的整合,当然代码很简单,配置也很简单,如果需要对JPA的配置进行扩展或者自定义,可以按照下面这样定义一个configuration:

    package com.springboot.jpa.config;
    
    import org.springframework.boot.autoconfigure.domain.EntityScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
    import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    /**
     * @Author 18011618
     * @Description JPA的配置类
     * @Date 9:35 2018/7/20
     * @Modify By
     */
    @Configuration
    @EnableTransactionManagement(proxyTargetClass = true)
    @EnableJpaRepositories(basePackages = "com.springboot.jpa.resposity")
    @EntityScan(basePackages = "com.springboot.jpa.bean")
    public class JpaConfiguration {
        PersistenceExceptionTranslationPostProcessor oersistenceExceptionTranslationPostProcessor(){
            return new PersistenceExceptionTranslationPostProcessor();
        }
    }
    

    主要指定以下内容:

    1 启动JAP事务管理

    2 启动数据访问层接口包的扫描地址

    3 指定JPA实体扫描的地址

    尽管上面的代码没有写这个配置类,也是可以成功运行,那是因为spring内部对JPA有默认的配置实现.

    展开全文
  • 编译器Intellij IDEA 关系型数据库MySql 5.7 对象关系映射框架JPA 首先新建springboot工程,取名为springbootjpa,设置好java版本后点击next

    编译器Intellij IDEA

    关系型数据库MySql 5.7

    对象关系映射框架JPA

    jpa可以通过实体类生成数据库的表,同时自带很多增删改查方法,大部分sql语句不需要我们自己写,配置完成后直接调用方法即可,很方便。

    1,首先新建springboot工程,取名为springbootjpa,设置好java版本后点击next

    2,选中三个依赖,lombok,spring Web和Spring Boot DevTools。然后点击finish。

    Lombok:实体类中通过注解可省略getter,setter,有参构造,无参构造等。

    Sprong Boot DevTools:应用提供一些开发时特性,包括默认值设置,自动重启,livereload 等。

    Spring Web:springboot起步依赖,默认的服务器是tomcat。

    下方Spring Boot 版本号一般是默认,不用管

     3,在pom.xml文件中添加SpringData jpa和数据库MySql的依赖。

            <!-- 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>
            </dependency>

    代码位置如下图:

     随后右键pom.xml,找到Maven项,点击右边的Reload project。导入上一步加入的jpa和mysql依赖。

     4,在application.properties文件中添加数据库连接配置:在这里我的数据库名是springbootjpa,用户名和密码大家改为自己的。

    #自动生成数据库表(关键)
    spring.jpa.hibernate.ddl-auto=update
    #mysql数据库连接配置(非常重要)
    spring.datasource.url = jdbc:mysql://localhost:3306/springbootjpa?serverTimezone=Asia/Shanghai
    #数据库用户名
    spring.datasource.username = root
    #数据库密码
    spring.datasource.password = lidong
    #mysql数据库驱动程序(重要)
    spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver
    #jpa配置:在控制台显示Hibernate的sql(可选)
    spring.jpa.show-sql = true
    #其他配置:关闭Thymeleaf 的缓存
    spring.thymeleaf.cache = false

    这是整体效果图

     5,在springbootjpa文件夹下创建entity文件夹,entity文件夹中创建实体类User,用于映射数据库表。

    实体类User中用到的注解

     同时在MySql中新建数据库,命名为springbootjpa,不用建表,运行项目后会自动生成表。

    启动项目:运行启动类SpringbootjpaApplication

     这时在我们创建的数据库springbootjpa中会自动生成表user。表的字段是我们在实体类User中的属性。

    6,在springbootjpa文件夹下新建文件夹,命名为repository,在repository文件夹下新建接口类:命名为UserRepository,该接口要 extends JpaRepository<User,Long>接口,其中User表示实体模型,Long代表主键类型。

    类上面添加注解@Repository,表示包含增删改查等功能的接口

     到这里,关于jpa的依赖导入和配置基本完成。这里自带很多内置的增删改查方法,不用我们自己写sql语句,直接调用即可。

     7,在springbootjpa文件夹下新建文件夹controller,在controller文件夹中新建类UserController。用来进行jpa的测试。

     在这里我写了三个方法,分别是查找,添加和删除。 在类上添加注解@RestController,表示输出格式为json格式。

    我们在数据库的表中手动添加几条测试数据

     8,再次运行项目,打开浏览器测试,输入http://localhost:8080/findall

    即可得到数据库中添加的两条数据,说明jpa整合成功。

    接下来在浏览器地址栏输入

    http://localhost:8080/add?id=3&username=three&password=three&regdate=2021-08-03 16:33:15

    我们发现数据库多了一条数据,插入方法成功

     在浏览器输入http://localhost:8080/deleteById?id=2

    此时发现数据库里少了一条id为2的数据,说明删除方法测试成功。

    至此,springboot整合jpa的操作全部完成,欢迎大家评论或私信交流,共同学习深究。

     

    展开全文
  • springboot-jpa springboot JPA
  • Springboot整合四之Springboot整合JPA

    万次阅读 多人点赞 2018-06-04 00:08:43
    JPA是什么首先,我们说说JPA是什么?JPA(java persistence api),它并不是一个框架,而是一组规范。我觉得对于任何一个开发人员来说,理解“规范”这个词应该不在话下。其中,Hibernate就实现了这个规范,而且呢是...

    JPA是什么

    首先,我们说说JPA是什么?

    JPA(java persistence api),它并不是一个框架,而是一组规范。我觉得对于任何一个开发人员来说,理解“规范”这个词应该不在话下。其中,Hibernate就实现了这个规范,而且呢是相当成功的(其实TopLink和OpenJPA也都实现了JPA规范,不过它们被Hinernate的光环笼罩了委屈委屈委屈)。所以呢,当我们说到JPA的时候,好多人首先想到的就是Hibernate。

    今天呢,我们就来说说Springboot整合JPA

    1、创建工程并添加依赖


    2、在yml文件中进行配置

    spring:
      devtools:
        restart:
          enabled: false
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test
        hikari: # springboot 2.0 整合了hikari ,据说这是目前性能最好的java数据库连接池
          username: root
          password: 123
      jpa:
        hibernate:
          ddl-auto: update  # 第一次建表create  后面用update,要不然每次重启都会新建表
        show-sql: true

    3、创建一个entity

    package com.space.jpa.bean;
    
    import lombok.Data;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    
    /**
     * @author zhuzhe
     * @date 2018/6/3 23:27
     * @email 1529949535@qq.com
     */
    @Data
    @Entity  // 该注解声明一个实体类,与数据库中的表对应
    public class User {
    
        @Id   // 表明id
        @GeneratedValue   //  自动生成
        private Long id ;
    
        private String name ;
    }
    

    4、创建DAO

    package com.space.jpa.dao;
    
    import com.space.jpa.bean.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    /**
     * @author zhuzhe
     * @date 2018/6/3 23:32
     * @email 1529949535@qq.com
     */
    @Component
    public interface UserDAO extends JpaRepository<User,Long> {
        /*
        * 我们在这里直接继承 JpaRepository
        * 这里面已经有很多现场的方法了
        * 这也是JPA的一大优点
        *
        * */
    }

    在这里我直接截图,我们可以看看JpaRepository中的一些方法


    我们可以直接使用这些方法,包括其父类的好多方法。是不是很方便啊。大笑

    5、Service

    package com.space.jpa.service;
    
    import com.space.jpa.bean.User;
    
    import java.util.List;
    /**
     * @author zhuzhe
     * @date 2018/6/3 23:38
     * @email 1529949535@qq.com
     */
    public interface UserService {
        List<User> findAll();
    }
    package com.space.jpa.service.impl;
    
    import com.space.jpa.bean.User;
    import com.space.jpa.dao.UserDAO;
    import com.space.jpa.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.List;
    
    /**
     * @author zhuzhe
     * @date 2018/6/3 23:38
     * @email 1529949535@qq.com
     */
    @Service
    public class UserServiceImpl implements UserService {
    
        @Autowired
        private UserDAO userDAO;
    
        @Override
        public List<User> findAll() {
            // 这里我们就可以直接使用 findAll 方法
            return userDAO.findAll();
        }
    }

    6、Controller

    package com.space.jpa.controller;
    
    import com.space.jpa.bean.User;
    import com.space.jpa.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    /**
     * @author zhuzhe
     * @date 2018/6/3 23:43
     * @email 1529949535@qq.com
     */
    @RestController
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        @GetMapping("/list")
        public List<User> findAll() {
            return userService.findAll();
        }
    }
    

    7、进行测试

    我们启动项目,可以看到日志打印


    数据表会自动创建,此时我们查看数据库


    确实已经自动创建了数据表。

    我们给表里添加两条数据,然后通过浏览器访问findAll接口:


    得到结果如下:


    这样,我们就整合完成了。是不是 So Easy!!!

    源码:https://github.com/zhuzhegithub/springboot-jpa


    转载请务必保留此出处(原作者):https://blog.csdn.net/zhuzhezhuzhe1


    版权声明:本文为原创文章,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。

    https://blog.csdn.net/zhuzhezhuzhe1


    展开全文
  • springboot整合JPA

    2021-03-27 08:50:38
    springboot整合JPA 本文只是简单地springboot整合的入门案例,无实质内容货。 1. 引入pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-...

    springboot整合JPA

    本文只是简单地springboot整合的入门案例,无实质内容货。

    1. 引入pom依赖

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

    2. 创建实体类

    @Entity(name = "t_comment")
    @Data
    @SuppressWarnings("all")//忽略所有异常
    public class Discuss {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
        private String content;
        private String author;
        @Column(name = "a_id")
        private Integer aId;
    }
    

    3. 编写接口

    public interface DiscussRepository extends JpaRepository<Discuss,Integer> {
        public List<Discuss> findByAuthorNotNull();
    
        @Query("SELECT c FROM t_comment c WHERE  c.aId = ?1")
        public List<Discuss> getDiscussPaged(Integer aid, Pageable pageable);
    
        @Query(value = "SELECT * FROM t_comment  WHERE  a_Id = ?1",nativeQuery = true)
        public List<Discuss> getDiscussPaged2(Integer aid,Pageable pageable);
    
        @Transactional
        @Modifying
        @Query("UPDATE t_comment c SET c.author = ?1 WHERE  c.id = ?2")
        public int updateDiscuss(String author,Integer id);
    
        @Transactional
        @Modifying
        @Query("DELETE t_comment c WHERE  c.id = ?1")
        public int deleteDiscuss(Integer id);
    
    }
    
    1. @Transactional:开启声名式事务,在抛出RuntimeException或者Error时会触发事务的回滚
    2. ?X :索引参数,需要和方法中所传递的参数顺序一致。X是从1开始,从1开始。
    3. 命名参数:可以定义好参数名,赋值时使用@Param(“参数名”),不用管顺序。
    4. @Modifying注解:在@Query注解中编写JPQL实现DELETE和UPDATE操作的时候必须加上@modifying注解,以通知Spring Data 这是一个DELETE或UPDATE操作。UPDATE或者DELETE操作需要使用事务,此时需要 定义Service层,在Service层的方法上添加事务操作。注意JPQL不支持INSERT操作。
    5. JPQL

    4. 测试

    在测试包中新建测试类,粘贴如下代码到类中。

    @Autowired
        private DiscussRepository repository;
        //使用Jpa内部方法
        @Test
        public void slelectComment(){
            Optional<Discuss> optional=repository.findById(1);
            if (optional.isPresent()){
                System.out.println(optional.get());
            }
        }
        //使用方法名关键字进行操作
        @Test
        public void selectCommentByKeys() {
            List<Discuss> list = repository.findByAuthorNotNull();
            System.out.println(list);
        }
        //使用@Query注解
        @Test
        public void selectCommentPaged(){
            PageRequest pa = PageRequest.of(0, 3);
            List<Discuss> discussPaged = repository.getDiscussPaged(1, pa);
            System.out.println(discussPaged);
        }
        //使用Example封装
        @Test
        public void selectCommentByExample(){
            Discuss discuss = new Discuss();
            discuss.setAuthor("张三");
            Example<Discuss> of = Example.of(discuss);
            List<Discuss> all = repository.findAll(of);
            System.out.println(all);
        }
        @Test
        public void selectCommentByExampleMatcher(){
            Discuss discuss = new Discuss();
            discuss.setAuthor("张");
            ExampleMatcher author = ExampleMatcher.matching().withMatcher("author", startsWith());
            Example<Discuss> of = Example.of(discuss, author);
            List<Discuss> all = repository.findAll(of);
            System.out.println(all);
        }
    
    
    展开全文
  • Springboot整合jpa实现mysql&oraclepomapplicationentityJpaRepository测试多表关联查询interfaceJpaRepository测试 pom <dependency> <groupId>mysql</groupId> <artifactId>mysql-...
  • 主要介绍了springboot整合JPA过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • springboot集成jpa

    2017-11-07 16:46:59
    springboot集成jpa 采用maven配置项目 springboot集成jpa 采用maven配置项目 springboot集成jpa 采用maven配置项目
  • springBoot整合Jpa的框架

    2017-10-16 11:25:00
    自己编写的springboot整合jpa的框架,使用本地的tomcat,
  • 本篇文章主要介绍了SpringBoot整合JPA的实例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • SpringBoot整合JPA案例

    2019-03-14 17:21:28
    一、编写一个实体类(bean)和数据表进行映射,并且配置好...@Entity//告诉JPA这是一个实体类(和数据表映射的类) @Table(name="tbl_user")//指定和哪个数据表对应;如果不填默认表名是类名小写user publ...
  • SpringBoot 整合JPA

    2019-05-31 10:36:19
    一、SpringBoot 整合JPA Spring Boot 底层使用 Spring Data 来访问数据库,Spring Data JPA 等于在ORM之上又进行了一次封装,但具体的对数据库的访问依然要依赖于底层的ORM框架,Spring Data JPA 默认是通过 ...
  • 1. 什么是JPA JPA (Java Persistence API) 是 Sun 官方提出的 ...JPA的出现主要是为了简化现有的持久化开发工作和整合 ORM 技术 具有易于使用,伸缩性强等优点 Spring Boot JPA Sprng Boot Jpa 是 Spring 基于 ORM ...
  • Springboot整合JPA

    2019-12-16 11:21:32
    前面文章记录了Springboot整合Mybatis以及Spingboot整合JDBCTemlate的过程,这篇文章记录Springboot整合JPA操作过程。jpa实际也是用来操作数据库的持久层框架,如何使用jpa操作数据库,和Springboot整合Mybatis以及...
  • 项目说明:本项目虽然比较简陋,但是可以教会了你怎么搭建一个简单的Springboot项目 ...Springboot整合JPA项目实例 开发前言: 一.本项目用到的技术: 1.前端:Html、Css、bootstrap、jQuery 2.后端:Spring...
  • 这个demo同时整合springboot+JPA+mybatis这个两个orm框架。
  • 在控制台打印SQL spring.jpa.show-sql=true # 数据库平台 spring.jpa.database-platform=mysql # 每次启动项目时,数据库初始化策略 spring.jpa.hibernate.ddl-auto=update # 指定默认的存储引擎为InnoDB spring.jpa...
  • springBoot整合jpa

    2021-02-23 20:13:42
    plugin> plugins> build> 2,application.yml logging: level: com.atguigu.dao: debug # 配置日志 spring: datasource: username: root password: root url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=...
  • SpringBoot整合JPA基本步骤

    千次阅读 2018-10-18 23:31:21
    用了一段时间的JPA,相比MyBatis来说使用JPA代码真的是简洁了不少。 以下为创建一个SpringBoot+JAP的入门项目的步骤。 我们先创建一个数据库备用,数据库的名字叫:db_jpa     创建一个SpringBoot项目 ...
  • 主要介绍了SpringBoot整合JPA数据源方法及配置解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • springboot+jpa+oracle

    2018-01-17 19:53:20
    springboot+jpa+oracle实现增删改查,对入门学习十分有帮助
  • SpringBoot整合JPA(多表关联查询)

    千次阅读 2019-10-29 10:40:56
    SpringBoot整合JPA(多表关联查询) 本文链接:https://blog.csdn.net/qq_40693828/article/details/95357975 Spring Boot Jpa 是 Spring 基于 ORM 框架、Jpa 规范的基础上封装的一套 Jpa 应用框架,可使开发者用...
  • 一对多示例: 多对多示例:
  • 文章目录导入jpa及相关模块的依赖编写配置文件编写映射实体类实现JpaRepository接口访问测试部分效果展示 导入jpa及相关模块的依赖 使用Spring Intializr,选中JPA,web,jdbc模块完成项目的创建 并按找自己需要导入...
  • SpringBoot整合Jpa实现数据的增删改查

    千次阅读 2018-12-24 16:47:20
    SpringBoot是什么? SpringBoot框架 Spring Boot是由Pivotal团队提供的全新框架,属于spring旗下的一个项目,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,它...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,609
精华内容 5,843
关键字:

springboot整合jpa

spring 订阅