jpa问题

最新推荐文章于 2022-03-22 20:22:24 发布
最新推荐文章于 2022-03-22 20:22:24 发布
阅读量261 收藏
点赞数
分类专栏： 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/an341221/article/details/106296379
版权

集合操作实现题目
 
Order，OrderItem，是1对多的双向关联关系。
a)         这2个类用于网络传输
b)        复写equals,Hashcode,Comparaor,toString方法
c)         在order中写一个方法新增一条Orderitem，考虑双向关联，考虑null
d)        在OrderItem中写一个方法，setOrder，考虑双向关联，考虑null
e)         采用Springboot+JPA的方式实现根据用户传入的Orderid，返回Order（但不返回OrderItem的集合）
f)          采用工具自动根据表自动生成类，在类中ManyToOne等注解被自动生成。

 

项目结构如下：

 

 

配置文件

 


server.port=8081


spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/db_crm?serverTimezone=GMT%2B8&autoReconnect=true&useUnicode=yes&characterEncoding=UTF-8&useSSL=false

spring.datasource.username=root

spring.datasource.password=an341221

spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect

 

BbbApplication
package com.example.bbb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
public class BbbApplication {

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

}

 

 

Order类

package com.example.bbb;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;
@Data
@Entity
@Table(name="t_order")
public class Order implements Comparator,Serializable {

    private static final long serialVersionUID = -7849861349440231763L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="order_id", length = 100)
    private Long id;

    @Column(name="order_name")
    private String name;


    @JsonIgnoreProperties
    @OneToMany(mappedBy="order",fetch=FetchType.EAGER,cascade={CascadeType.ALL})
    private Set<OrderItem> set = new HashSet<OrderItem>(0);

    public void setSet(Set<OrderItem> set) {
            this.set = set;


    }

    public Set<OrderItem> getSet() {
        return set;
    }

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

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

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void addOrderItem(OrderItem item) {
        if(null!=item&&!set.contains(item)) {
            item.setOrder(this);
            this.set.add(item);
        }
    }

    @Override
    public int compare(Object o1, Object o2) {
        if(o1 == null || o2 == null)
            return 0;
        Order o = (Order)o1;
        Order p = (Order)o2;
        return o.getName().toUpperCase().compareTo(p.getName().toUpperCase());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Order)) return false;

        Order order = (Order) o;

        if (id != null ? !id.equals(order.id) : order.id != null) return false;
        return name != null ? name.equals(order.name) : order.name == null;
    }

    @Override
    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }



}

Orderitem类

package com.example.bbb;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import javax.persistence.*;
import java.io.Serializable;
import java.util.Comparator;

@Entity
@Table(name="t_order_item")
public class OrderItem implements Comparator,Serializable {

    private static final long serialVersionUID = -188903609403774903L;
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="order_item_id", length = 100)
    private Long id;

    @Column(name="order_item_name")
    private String name;

    @Column(name="order_id1")
    private Long orderId;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof OrderItem)) return false;

        OrderItem item = (OrderItem) o;

        if (id != null ? !id.equals(item.id) : item.id != null) return false;
        if (name != null ? !name.equals(item.name) : item.name != null) return false;
        return orderId != null ? orderId.equals(item.orderId) : item.orderId == null;
    }

    @Override
    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (orderId != null ? orderId.hashCode() : 0);
        return result;
    }

    @ManyToOne(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinColumn(
            name = "order_id1",
            referencedColumnName = "order_id",insertable =false,updatable = false
    )
    @JsonIgnoreProperties
    private Order order;

    public void setOrder(Order order) {
        if(null!=order){
            this.order = order;
        }

    }
    public Order getOrder() {
        return order;
    }

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

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

    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }


    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Long getOrderId() {
        return orderId;
    }




    @Override
    public String toString() {
        return "OrderItem{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", orderId=" + orderId +
                '}';
    }

    @Override
    public int compare(Object o1, Object o2) {
        if(o1 == null || o2 == null)
            return 0;
        OrderItem o = (OrderItem)o1;
        OrderItem p = (OrderItem)o2;
        return o.getName().toUpperCase().compareTo(p.getName().toUpperCase());
    }

}

OrderDao类

package com.example.bbb;

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

public interface OrderDao extends JpaRepository<Order,Long> {

    @Query(value = "select order_id,order_name from t_order  where order_id=?1",nativeQuery = true)
    Order findByOrderId(Long  id);


}

OrderItemDao类

package com.example.bbb;

import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderItemDao  extends JpaRepository<OrderItem,Long> {
}

TestServiceImpl类
package com.example.bbb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TestServiceImpl implements TestService{



    @Autowired
    private OrderDao orderDao;

    @Autowired
    private OrderItemDao orderItemDao;

    @Transactional
    @Override
    public void add() {

        Order order = new Order();
        order.setName("o3");

        OrderItem item = new OrderItem();
        item.setName("i31");

        OrderItem item1 = new OrderItem();
        item1.setName("i32");

        order.getSet().add(item);
        order.getSet().add(item1);

        item.setOrder(order);
        item1.setOrder(order);

        Order o = orderDao.save(order);
        item.setOrderId(o.getId());
        item1.setOrderId(o.getId());
        orderItemDao.save(item);
        orderItemDao.save(item1);

    }

    @Override
    public Order findByOrderId(Long id) {
        return orderDao.findByOrderId(id);
    }
}

TestController类

 

package com.example.bbb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private TestService testService;

    @RequestMapping("/add")
    public void test(){
        testService.add();
    }

    @RequestMapping("/query")
    public void findByOrderId(){

        System.out.println(testService.findByOrderId(1L));

    }

}

 

 

项目启动的建表语句

Hibernate: 
    
    create table t_order (
       order_id bigint not null auto_increment,
        order_name varchar(255),
        primary key (order_id)
    ) engine=MyISAM
Hibernate: 
    
    create table t_order_item (
       order_item_id bigint not null auto_increment,
        order_item_name varchar(255),
        order_id1 bigint,
        primary key (order_item_id)
    ) engine=MyISAM
Hibernate: 
    
    alter table t_order_item 
       add constraint FK4421rqle7r4qiecv2uj5ec9kx 
       foreign key (order_id1) 
       references t_order (order_id)

 

插入数据库的字段

orderitem

order

 

 

没有OrderItem集合的查询结果如下

 

 

工具生成实体类，会产生中间类，需要手动复制下

建表语句

CREATE TABLE `example1` (
  `stu_id` int(11) NOT NULL DEFAULT '0',
  `name` VARCHAR(11) NOT NULL DEFAULT '',
  `course_id` int(11) NOT NULL DEFAULT '0',
  `grade` float DEFAULT NULL,
  PRIMARY KEY (`stu_id`,`course_id`)
) engine=INNODB;
CREATE TABLE `example2` (
  `id` int(11) NOT NULL,
  `stu_id` int(11) DEFAULT NULL,
  `course_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `f_ck` (`stu_id`,`course_id`),
  CONSTRAINT `f_ck` FOREIGN KEY (`stu_id`, `course_id`) REFERENCES `example1` (`stu_id`, `course_id`)
) engine=INNODB;
insert into example1 (stu_id,name,course_id,grade)values(1,'baidu',1,97.5),(2,'google',2,89);
insert into example2 (id,stu_id,course_id)values(1,1,1),(2,2,2);

生成的实体类

package com.example.demoforjpa.pojo;

import java.util.Objects;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Table;

@Entity
@Table(name = "example1", schema ="mysql")
public class Example1Entity {

  private Integer stuId;
  private String name;
  private Integer courseId;
  private Double grade;

  @Id
  @Column(name = "stu_id")
  public Integer getStuId() {
    return stuId;
  }

  public void setStuId(Integer stuId) {
    this.stuId = stuId;
  }

  @Basic
  @Column(name = "name")
  public String getName() {
    return name;
  }

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

  @Id
  @Column(name = "course_id")
  public Integer getCourseId() {
    return courseId;
  }

  public void setCourseId(Integer courseId) {
    this.courseId = courseId;
  }

  @Basic
  @Column(name = "grade")
  public Double getGrade() {
    return grade;
  }

  public void setGrade(Double grade) {
    this.grade = grade;
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    Example1Entity that = (Example1Entity) o;
    return Objects.equals(stuId,that.stuId) &&
        Objects.equals(name,that.name) &&
        Objects.equals(courseId,that.courseId) &&
        Objects.equals(grade,that.grade);
  }

  @Override
  public int hashCode() {
    return Objects.hash(stuId, name,courseId, grade);
  }
}
package com.example.demoforjpa.pojo;

import java.util.Objects;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "example2", schema = "mysql")
public class Example2Entity {

  private Integer id;
  private Integer stuId;
  private Integer courseId;
  private Example1Entity example1;

  @Column(name = "stu_id")
  public Integer getStuId() {
    return stuId;
  }

  public void setStuId(Integer stuId) {
    this.stuId = stuId;
  }

  @Column(name = "course_id")
  public Integer getCourseId() {
    return courseId;
  }

  public void setCourseId(Integer courseId) {
    this.courseId = courseId;
  }



  @Id
  @Column(name = "id")
  public Integer getId() {
    return id;
  }

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

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (o == null || getClass() != o.getClass()) {
      return false;
    }
    Example2Entity that = (Example2Entity) o;
    return Objects.equals(id, that.id);
  }

  @Override
  public int hashCode() {
    return Objects.hash(id);
  }

  @ManyToOne
  @JoinColumns({
      @JoinColumn(name = "stu_id", referencedColumnName = "stu_id"),
      @JoinColumn(name = "course_id", referencedColumnName = "course_id")})
  public Example1Entity getExample1() {
    return example1;
  }

  public void setExample1(Example1Entity example1) {
    this.example1 = example1;
  }
}

 

欣赏月光
关注
专栏目录
使用Spring Data Jpa遇到问题汇总
codeJxwww's blog
06-06 3798
使用Spring Data Jpa遇到问题汇总 用于记录我在使用spring data jpa时遇到的各种问题及其解决方案 使用Spring Data Jpa遇到问题汇总 自定义查询语句(@Query 与 nativeQuery) 返回自定义查询对象(如”select new Map(xx,xx,xx)”) 字段映射相关问题(@Column) 字段命名解析 字段类型解析 ...
JPA：好与坏？常见问题解答
08-26 3532
问题：EJB专家团队是如何摆脱事务描述符的?　　回答：在会话bean和消息驱动bean中，可以通过描述符和注释来控制事务的行为。此外，我们将默认的事务属性更改为“REQUIRED”，这个默认值比以前的值“SUPPORTS”更常用。因此，完全不必为业务方法配置事务行为。　　JPA实体仅供本地使用，重点关注域模型。因此，无法在JPA实体上配置事务性(或远程边界或安全性)。而是必须使用会话bean fa
使用jpa需要注意的问题
zxc_user的博客
01-02 452
最近一直在做一个由航天发票系统切换到云砺发票系统的功能,说实话，我根本就不知道红票和蓝票是什么，不懂业务就无法编码，经过咨询同事和自己私下看了一个关于这方面的业务视频之后，终于明白是什么意思了视频地址：  http://www.iqiyi.com/w_19rs54vn7h.html个人觉得这个讲得很详细,虽然有点长,但是你听完一定就可以理解什么是开蓝票，什么是冲红(我一直卡在这里...)理解业务之
遇到JPA的一些问题记录
xsh的博客
06-19 409
1、count(*)在java中该用什么数据类型来接收 select a.uuid,a.title , (select count(*) from zc_attachment b WHERE b.notice_id=a.uuid ) as attachmentNum from zc_infomation a where a.tenant_id='4040e48b6956ca340169571c...
spring data jpa遇到的一些琐碎问题
u011844399的专栏
08-15 1234
jpa是几年前就已经接触过了，不过中间隔了好久没使用过，忘了不少细节上的问题。今天就来分享下在项目中遇到的一些坑吧，应该都比较基础，注意就好。 1.对象与表的映射。 全程采用注解形式，对象中的字段可以根据数据表的字段进行定义，但是在建数据表的时候要保证数据表字段都要是大写，否则在关联关系（如:一对多，多对一，多对多等）上一直会出错，说找不到对应的列。对于对象的get、set方法，可以直接采用简
解析JPA的视图查询问题
09-04
总之，通过自定义实体类和使用 `@NamedNativeQuery`，我们可以让JPA支持视图查询，从而解决在处理复杂查询或统计需求时的问题。这种方式使开发者能够在保持面向对象编程风格的同时，利用数据库视图的强大功能。在...
jpa
03-20
**JPA（Java Persistence API）**是Java平台上用于管理关系数据库的数据持久化标准API，它为应用程序提供了一种对象/关系映射工具，将关系数据库中的数据与Java类对象关联起来，使得开发者可以使用面向对象的方式来...
Spring Data JPA中文文档[1.4.3]_springdatajpa_erlang_waitxpf_
10-02
**Spring Data JPA** 是一个基于 **Java** 的开源框架，它是 **Spring Framework** 的一个模块，主要用于简化 **Java Persistence API (JPA)** 的使用。JPA 是 Java 平台上的一个标准，用于管理和持久化应用程序的...
springboot整合jpa
04-26
SpringBoot 整合 JPA（Java Persistence API）是现代Java应用中常见的数据访问技术栈，它简化了数据库操作，提供了ORM（对象关系映射）功能，使得开发者可以用面向对象的方式来处理数据库事务。以下是对这个主题的...
SpringBoot+JPA
04-03
**SpringBoot+JPA 整合指南** SpringBoot以其便捷的快速启动和自动配置特性，大大简化了Java Web应用的开发流程。而JPA（Java Persistence API）是Java平台上的ORM（Object-Relational Mapping）标准，它允许开发者...
Coverity中的bug们
Mr_JK的专栏
04-26 3863
1.DM_DEFAULT_ENCODING   1.1 Found reliance on default encoding in com.cmcc.aoi.httprequest.service.HttpRequest.sendGet(String, String): new java.io.InputStreamReader(InputStream) Found a call to a met...
[Java反序列化]Shiro反序列化学习(二)
feng的博客
08-30 472
前言 继续《Java安全漫谈》的学习。 预备知识 之前学习了Commons-BeanUtils1的反序列化链，之所以会学习这个链子，也提到了是因为shiro依赖了它。 写个pom.xml的dependency（不用commons-collections）： <dependencies> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shi
JPA 使用过程中问题汇总（持续更新...）
Willow的博客
03-22 2989
JPA save数据时，如果数据没有赋值，即使数据库层面设置了default值，但仍然会插入null 增加表中一个字段时的sql如下： ALTER TABLE account ADD status tinyint(1) DEFAULT b'1' COMMENT '是否加入黑名单'; 调用jpa的save方法时，并没有build实体类中status，即没有给该字段赋值，导致入库的值是空值，而不是预想中的1。 所以，修改为save时传true。sql保证的是原生sql insert时会设置默认值，使用JPA时
【错误解决】Spring JPA的错误及其解决方案
热门推荐
小鼠标的博客
09-12 2万+
昨天测试Spring jpa遇到一个错误，，遇到错误“三板斧”【1】 看控制台报错情况，一般情况下红色第一句很重要，细看（英文很水没关系，打开有道瞬间转换成中文，虽然有点变扭，能看） 比如，我这个错误， org.springframework.dao.InvalidDataAccessApiUsageException: Parameter value [1] did not matc
Comparator接口的使用
程序员那点事儿
07-08 1万+
    “                                                      一个人如果没有梦想，                                                  跟无忧无虑有什么区别呢？”            今天来给大家介绍下java.utils包下的Comparator接口。该接口代表一个比较器，java数组工具类和...
jpa避免n+1_JPA技巧：避免N + 1选择问题
最佳 Java 编程
07-04 1562
jpa避免n+1 介绍 像JPA这样的ORM框架通过帮助我们在对象<->关系数据映射期间避免了很多样板代码，从而简化了我们的开发过程。 但是，它们还给表带来了一些其他问题，N + 1是其中之一。 在本文中，我们将简要介绍该问题以及避免这些问题的一些方法。 问题 作为示例，我将使用在线图书订购应用程序的简化版本。 在这样的应用程序中，我可能会创建一个如下所示的实体来代表采购订单–...
java多线程问题以及spring jpa事物问题以及httpost传输问题总结
xiaolong2230的博客
11-01 1549
1、多线程事物控制问题：在新线程中执行dao中的方法的时候出现错误如下 java.lang.reflect.InvocationTargetException org.springframework.dao.InvalidDataAccessApiUsageException: Executing an update/delete query; nested exception is javax....
Glassfish 3.1.2.2 JPA问题与EclipseLink 2.4.2升级解决方案
本文档主要讨论了在 Glassfish 3.1.2.2 环境中使用 EclipseLink JPA 遇到的问题以及解决方法。问题集中在 TcUser 实体类中，当尝试注入多个字段（如 company 等）或者处理额外的 collection 关系时，JPA 注入过程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值