1、 @Entity(name=”EntityName”)

      表示该类是一个可持化的实体。当在容器中时，服务器将会首先加载所有标注了@Entity注释的实体类，其中@Entity中的“name”属性表示实体名称，若不作设置，默认为标注实体类的名称（注意大小写与系统的关系。）。 @Entity标注是必需的 ，name属性为可选。 

Java代码   收藏代码
  1. @Entity(name=“person_1”)  
  2. public class Person implements Serializable {  
  3.       
  4.       
  5.     public Person(){  
  6.         id=System.currentTimeMillis();  
  7.     }  
  8.   
  9.     public Person(Long id){  
  10.         this.id = id;  
  11.     }  
  12. }  
 

 @Entity标注的实体类至少需要有一个无参的构造方法。这是因为，在使用类反射机制 Class.newInstance()方法创建实例时，必需要有一个默认的无参数构造方法，否则会执出实例化异常（InstantiationException）。

   如果指定name属性后，在执行JPQL时应该使用name属性所指的名称。像上面的标注后，在执行JPQL时要像下面这样：

Sql代码   收藏代码
  1. SELECT p FROM person_1 AS p  

 name属性为默认值时就使用类名称：

Sql代码   收藏代码
  1. SELECT p FROM Person AS p;   

    有两点须要注意：

      （1）实体可继承，非实体类可以继承自实体类，实体类也要中以继承自非实类。

      （2）抽象类（abstract）也可以标注为实体类。

 

2、@Table

     在使用@Table标记时，需要注意以下几个问题。

     （1） 此标记需要标注在类名前，不能标注在方法或属性前。

     （2） name 属性表示实体所对应表的名称，默认表名为实体名称。

     （3） catalog 和schema 属性表示实体指定的目录名或数据库名，这个根据不同的数据类型有所不同。

     （4） uniqueConstraints 属性表示该实体所关联的唯一约束条件，一个实体可以有多个唯一的约束，默认没有约束条件。

     （5）若使用uniqueContraints 属性时，需要配合标记UniqueContraint标记来使用。

 

Java代码   收藏代码
  1. package model;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. import javax.persistence.Entity;  
  6. import javax.persistence.Table;  
  7. import javax.persistence.UniqueConstraint;  
  8.   
  9. @Entity  
  10. @Table(name = “tb_contact”, schema = “test”, uniqueConstraints = {   
  11.         @UniqueConstraint(columnNames = {“name”, “email” }),  
  12.         @UniqueConstraint(columnNames = {“col1”, “col2” })  
  13. })  
  14. public class ContactEO implements Serializable {  
  15.   
  16.     private Long id;  
  17.   
  18.     private String name;  
  19.   
  20.     private String email;  
  21.   
  22.     private String col1;  
  23.   
  24.     private String col2;  
  25.   
  26. }  

 以上的@Table注释表示指定数据库名“test”，表名为“tb_contact”，并创建了两组唯一索引。


3、@Column

        @Column标记表示持久化属性映射表中的字段。此标记可以标注在Getter方法或属性前。

如标注在属性前

Java代码   收藏代码
  1. public class ContactEO implements Serializable {  
  2.   
  3.     @Column(name = “name”)  
  4.     private String name;  
  5.   
  6.     public String getName() {  
  7.         return name;  
  8.     }  
  9.   
  10.     public void setName(String name) {  
  11.         this.name = name;  
  12.     }  
  13. }  

 或者标注在Getter方法前。

Java代码   收藏代码
  1. public class ContactEO implements Serializable {  
  2.   
  3.       
  4.     private String name;  
  5.   
  6.     @Column(name = “name”)  
  7.     public String getName() {  
  8.         return name;  
  9.     }  
  10.   
  11.     public void setName(String name) {  
  12.         this.name = name;  
  13.     }  
  14. }  

  （1） unique 属性表示该字段是否为唯一标识，默认为false。如果表中有一个字段需要唯一标识，则既可以使用@Column标记也可以使用@Table标记中的@UniqueConstraint。

  （2）nullable 属性表示该字段是否可以为null值，默认为true（允许为null值）。

  （3）insertable 属性表示在使用“INSERT” SQL语脚本插入数据时，是否需要插入该字段的值。

  （4）updatable 属性表示在使用“UPDATE”脚本插入数据时，是否需要更新该字段的值。insertable和updatable属性一般多用于只读属性，例如主键和外键等。这些字段值通常是自动生成的。

  （5）columnDefinition 属性表示创建表时，该字段创建的SQL语句，一般用于通过Entity生成表定义时使用。

  （6）table 属性表示当映射多个表时，指定表中的字段。默认值为主表的表名。

  （7）length 属性表示该字段的长度，当字段的类型为varchar时，该属性才有效，默认为255个字符。

  （8）precision 属性和scale 属性表示精度，当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数。

示例一、

Java代码   收藏代码
  1. private String name;  
  2.   
  3. @Column(name = “name”,nullable=false,length=512)  
  4. public String getName() {  
  5.     return name;  
  6. }  

 生成的SQL脚本为

Java代码   收藏代码
  1. CREATE TABLE contact(  
  2.       id integer not null,  
  3.       name varchar(512) not null,  
  4.       primary key(id)  
  5. );  

  示例二、为double型指定精度为12位，小数点位数为2位。

Java代码   收藏代码
  1. private BigDecimal monthlyIncome;  
  2.   
  3. @Column(name=“monthly_income”,precision=12,scale=2)  
  4. public BigDecimal getMonthlyIncome() {  
  5.     return monthlyIncome;  
  6. }  
  7.   
  8. public void setMonthlyIncome(BigDecimal monthlyIncome) {  
  9.     this.monthlyIncome = monthlyIncome;  
  10. }  

 生成的SQL脚本为

Java代码   收藏代码
  1. CREATE TABLE contact(  
  2.       id integer not null,  
  3.       monthly_income double(12,2),  
  4.       primary key(id)  
  5. );  

 示例三、自定义生成CLOB类型字段的SQL语句

Java代码   收藏代码
  1. @Column(name = “contact_name”,columnDefinition=“ clob not null” )  
  2. private String name;  
  3.   
  4. public String getName() {  
  5.     return name;  
  6. }  
  7.   
  8. public void setName(String name) {  
  9.     this.name = name;  
  10. }  

  生成的SQL脚本为

Sql代码   收藏代码
  1. CREATE TABLE contact(  
  2.       id integer not null,  
  3.       contact_name <strong>clob(200) not null,</strong>  
  4.   
  5.   
  6.   
  7.   
  8.   
  9.   
  10.   
  11.   
  12.   
  13.   
  14.   
  15.   
  16.       primary key(id)  
  17. );  

  其中加粗的部份为columnDefinition属性设置的值。若不指定该属笥，通常使用默认的类型建表，若此时需要自定义建表的类型时，可以在该属性设置。

 

可持久化的数据类型

分类类型
Java的基本数据类型byte、int、short、long、boolean、char、float、double
Java的基本数据类型对应的封装类Byte、Int、Short、Long、Boolean、Character、Float、Double
字节和字符型数组byte[]、Byte[]、char[]、Character[]
大数值类型

Java.math.BigInteger

java.math.BigDecimal
字符串类型java.lang.String
日期时间类型

java.util.Date

java.util.Calendar

java.sql.Date

java.sql.Time

java.sql.Timestamp
枚举型用户自定义的枚举型
Entity类型标注为@Entity的类
包含Entity类型的集合Collection类

java.util.Collection

java.util.Set

java.util.List

java.util.Map
嵌入式（embeddable）类 

 Java数据类型与数据库中的类型转换是由JPA实现框架自动转换的，所以不同的JPA实现框架转换的规则也不太一样。

     例如MySQL中，varchar和char类型都转化为String类型。Blob和Clob类型可以转化成Byte[]型。由于类型转化是JPA底层来实现的，这就遇到一个问题，很有可能在将表中的数据转换成Java的数据类型时出现异常。

       我们知道对于可以持久化的Java类型中，即可以映射基本的数据类型，如byte、int、short、long、boolean、char、float、double等，也可以映射成 Byte、Int、Short、Long、Boolean、Character、Float、 Double类型。那么选择哪种类型比较合适呢？

举下面的例子进行说明。

Sql代码   收藏代码
  1. CREATE TABLE contact(  
  2.       id integer not null,  
  3.       monthly_income double(12,2),  
  4.       primary key(id)  
  5. );  

      对于表字段id，它的值不能为null，所以映射成int型和Integer型都是可以的。

      但对于表字段monthly_income来说，它的值可能为null。当为null时，若此时java的Enity类的对应属性的类型int，则将一个null值转化成int型必定产生转换异。但此时java的Entity类对应的属性为Integer，它是一个对象，对象可以为null，所以不会产生问题。

4、@Basic

    在默认情况下，Entity中属笥加载方式都是即时加载（EAGER）的，当Enity对象实例化时，就加截了实体中相应的属性值。

    但对于一些特殊属笥，比如大文本型text、字节流型blob型的数据，在加载Entity时，这些属性对应的数据量比较大，有时创建实体时如果也加载的话，可能造成资源严重占用。那么就可以为这些特殊的实体属性设置加载方式为惰性加载（LAZY）

   （1）fetch属性表示获取值的方式，它的值定义的枚举型，可选值为LAZY、EAGER。其中EAGER表示即时加载、LAZY表示惰性加载。默认为即时加载。

   （2）optional表示属性是否可以为null，不能用于java基本数据型（ byte、int、short、long、boolean、char、float、double ）。

如：

Java代码   收藏代码
  1. @Basic(fetch=FetchType.LAZY)  
  2. @Column(name = “contact_name”,columnDefinition=“ clob not null” )  
  3. private String name;  
  4.   
  5. public String getName() {  
  6.     return name;  
  7. }  
  8.   
  9. public void setName(String name) {  
  10.     this.name = name;  
  11. }  

 

5、@Id

       主键是实体的唯一标识，调用EntityManager的find方法，可以获得相应的实体对象。每一个实体类至少要有一个主键（Primary key）。

       一旦使用@Id 标记属性为主键，该实体属性的值可以指定，也可以根据一些特定的规则自动生成。这就涉及另一个标记@GeneratedValue 的使用。

       @GeneratedValue 标注有以两个属性：

       （1）strategy 属性表示生成主键的策略 ，有4种类型，分别定义在枚举型GenerationType中，其中有GenerationType.TABLE 、 GenerationType.SEQUENCE 、 GenerationType.IDENTITY 、 GenerationType.AUTO ,其中，默认为AUTO，表示自动生成。

       （2）generator 为不同策略类型所对应的生成规则名，它的值根据不同的策略有不同的设置。

       （3）能够标识为主键的属性类型，有如表5-2所列举的几种。

分类类型
Java的基本数据类型byte、int、short、long、char
Java的基本数据类型对应的封装类Byte、Integer、Short、Long、Character
大数值类型java.math.BigInteger
字符串类型java.lang.String
时间日期型java.util.Date
java.sql.Date

 

 

 

 

 

 

 

 

 

 

 

 

 

       double和float浮点类型和它们对应的封装类不能作为主键，这是因为判断是否唯一是通过equals方法来判断的，浮点型的精度太大，不能够准确地匹配。

       例一，自增主键 。在不同的数据库，自增主键的生成策略可能有所不同。例如MySQL的自增主键可以通过IDENTITY来实现，而Oracle可能需要创建Sequence来实现自增。JPA的实现将会根据不同的数据库类型来实现自增的策略。

Java代码   收藏代码
  1. @Id  
  2. @GeneratedValue(strategy = GenerationType.AUTO)  
  3. public Long getId() {  
  4.     return id;  
  5. }  
  6.   
  7. public void setId(Long id) {  
  8.     this.id = id;  
  9. }  

        例二，表生成器 。将当前主键的值单独保存到一个数据库的表中，主键的值每次都是从指定的表中查询来获得，这种生成主键的方式也是很常用的。这种方法生成主键的策略可以适用于任何的数据库，不必担心与同数据库不兼容造成问题。

         配置的Customer类

Java代码   收藏代码
  1. package model;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. import javax.persistence.Basic;  
  6. import javax.persistence.Column;  
  7. import javax.persistence.Entity;  
  8. import javax.persistence.GeneratedValue;  
  9. import javax.persistence.GenerationType;  
  10. import javax.persistence.Id;  
  11. import javax.persistence.Table;  
  12. import javax.persistence.TableGenerator;  
  13.   
  14. @Entity  
  15. @Table(schema = “open_jpa”, name = “customer”)  
  16. public class Customer implements Serializable  
  17. {  
  18.     private static final long serialVersionUID = -8480590552153589674L;  
  19.   
  20.     private Integer           id;  
  21.   
  22.     private String            name;  
  23.   
  24.     @Id  
  25.     @GeneratedValue(strategy = GenerationType.TABLE, generator = “customer_gen”)  
  26.     @TableGenerator(schema = “open_jpa”,   
  27.             name = ”customer_gen”,   
  28.             table = ”tbl_generator”,   
  29.             pkColumnName = ”gen_name”,   
  30.             pkColumnValue = ”CUSTOMER_PK”,   
  31.             valueColumnName = ”gen_value”,   
  32.             allocationSize = 1,   
  33.             initialValue = 0)  
  34.     public Integer getId()  
  35.     {  
  36.         return id;  
  37.     }  
  38.   
  39.     public void setId(Integer id)  
  40.     {  
  41.         this.id = id;  
  42.     }  
  43.   
  44.     @Basic  
  45.     @Column(name = “name”)  
  46.     public String getName()  
  47.     {  
  48.         return name;  
  49.     }  
  50.   
  51.     public void setName(String name)  
  52.     {  
  53.         this.name = name;  
  54.     }  
  55. }  

 （1）在Entity标记的主键的位置，指定主键生成策略为“GenerationType.TABLE ”。

 （2）指定生成主键策略的名称，例如这里命名为“generator = “customer_gen” ”。

 （3）使用@TableGenerator标定义表生成策略的具体设置：

Java代码   收藏代码
  1. @TableGenerator(schema = “open_jpa”,   
  2.            name = ”customer_gen”,   
  3.            table = ”tbl_generator”,   
  4.            pkColumnName = ”gen_name”,   
  5.            pkColumnValue = ”CUSTOMER_PK”,   
  6.            valueColumnName = ”gen_value”,   
  7.            allocationSize = 1,   
  8.            initialValue = 0)  

 可以看到数据生成tbl_generator 的结构及添加的数据：

Sql代码   收藏代码
  1. CREATE TABLE `tbl_generator` (  
  2.   `GEN_NAME` varchar(255) NOT NULL,  
  3.   `GEN_VALUE` bigint(20) default NULL,  
  4.   PRIMARY KEY  (`GEN_NAME`)  
  5. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  
  6. INSERT INTO tbl_generator VALUES (‘CUSTOMER_PK’, 1);  

 

使用Oracle的sequence方式生成ID值。  

 

Java代码   收藏代码
  1. @Id    
  2. @GeneratedValue(strategy = GenerationType.SEQUENCE,generator=“payablemoney_seq”)    
  3. @SequenceGenerator(name=“payablemoney_seq”, sequenceName=“seq_payment”)    

 

@SequenceGenerator定义

Java代码   收藏代码
  1. @Target({TYPE, METHOD, FIELD})     
  2. @Retention(RUNTIME)    
  3. public @interface SequenceGenerator {    
  4.  String name();    
  5.  String sequenceName() default “”;    
  6.  int initialValue() default 0;    
  7.  int allocationSize() default 50;    
  8. }   

 name属性表示该表主键生成策略的名称，它被引用在@GeneratedValue中设置的“generator”值中。 
sequenceName属性表示生成策略用到的数据库序列名称。 
initialValue表示主键初识值，默认为0。 
allocationSize表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。

# java
Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生