public @interface Entity {
    String name() default "";
}

public @interface Table {
    // 表的名字,可選,默認(rèn)實(shí)體類名為表的名稱(駝峰命名規(guī)則)
    String name() default "";
    // 此表的catlog,可選
    String catalog() default "";
    // 此表所在的schema,可選
    String schema() default "";
    // 唯一性約束，只有在創(chuàng)建表的時(shí)候有用，默認(rèn)不需要
    UniqueConstraint[] uniqueConstraints() default {};
    // 索引，只有創(chuàng)建表的時(shí)候有用，默認(rèn)不需要
    Index[] indexes() default {};
}

public @interface IdClass {
     // 聯(lián)合主鍵的類
    Class value();
}

@Data
public class UserArticleKey implements Serializable {
    private String title;
    private Long createUserId;
    public UserArticleKey() {
    }
    public UserArticleKey(String title, String content, Long createUserId) {
        this.title = title;
        this.createUserId = createUserId;
    }
}

@Entity
@IdClass(value = UserArticleKey.class)
@Data
public class UserArticle {
    private Integer id;
    @Id
    private String title;
    @Id
    private Long createUserId;
}

public interface ArticleRepository extends JpaRepository<UserArticle, UserArticleKey> {
}

@Test
public void testUnionKey(){
    Optional<UserArticle> userArticle = this.articleRepository.findById(new UserArticleKey("新聞",1L));
    if (userArticle.isPresent()){
        System.out.println(userArticle.get());
    }
}

public @interface GeneratedValue {
    // Id 的生成策略
    GenerationType strategy() default GenerationType.AUTO;
    // 通過 Sequence生成Id, 常見Oracle生成規(guī)則，需要配合@SequenceGenerator使用
    String generator() default "";
}

public enum GenerationType {
    // 通過表產(chǎn)生主鍵，框架由表模擬序列產(chǎn)生主鍵(有益于數(shù)據(jù)庫移植)
    TABLE,
    // 通過序列產(chǎn)生主鍵，通過@SequenceGenerator注解指定序列名，不支持MySQL
    SEQUENCE,
    // 采用數(shù)據(jù)ID自增長,一般用于MySQL
    IDENTITY,
    // JPA自動適配的策略，默認(rèn)選項(xiàng)
    AUTO;
    private GenerationType() {
    }
}

public @interface Basic {
    // 可選，默認(rèn)為立即加載(EAGER)，LZAY延遲加載(應(yīng)用在大字段上)
    FetchType fetch() default FetchType.EAGER;
    // 可選，設(shè)置這個(gè)字段是否可為null,默認(rèn) true
    boolean optional() default true;
}

public @interface Column {
    // 是語句庫中表的列名, 默認(rèn)字段名和屬性名一樣, 可選
    String name() default "";
    // 是否唯一，默認(rèn) false, 可選
    boolean unique() default false;
    // 是否允許空, 默認(rèn) true, 可選
    boolean nullable() default true;
    // 執(zhí)行insert操作的時(shí)候是否包含此字段，默認(rèn) true, 可選
    boolean insertable() default true;
    // 執(zhí)行update操作的時(shí)候是否包含此字段，默認(rèn) true, 可選
    boolean updatable() default true;
    // 該字段在數(shù)據(jù)庫中的實(shí)際類型
    String columnDefinition() default "";
    // 當(dāng)映射多個(gè)表時(shí),指在哪張表的字段，默認(rèn)為主表
    String table() default "";
    // 字段長度,字段類型為VARCHAR時(shí)有效
    int length() default 255;
    // 精度，當(dāng)字段類型為double時(shí)候, precision表示數(shù)值總長度
    int precision() default 0;
    // 精度, 當(dāng)字段類型為double時(shí)候, scale表示小數(shù)位數(shù)
    int scale() default 0;
}

public @interface Enumerated {
    // 映射枚舉的類型
    EnumType value() default EnumType.ORDINAL;
}
public enum EnumType {
    // 映射枚舉字段的下標(biāo)
    ORDINAL,
    // 映射枚舉的name
    STRING;
}

@Entity(name = "t_user")
@Data
@Table
public class SystemUser implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @Basic
    private String uname;
    private String email;
    private String address;
    @Enumerated(EnumType.STRING)
    @Column(name = "user_gender")
    private Gender sex;
    public enum Gender{
        MALE("男性"),
        FEMALE("女性")
        ;
        private String value;
        Gender(String value) {
            this.value = value;
        }
    }
}

@NamedNativeQueries({
        @NamedNativeQuery(
                name = "getUsers",
                query = "select id,title,create_user_id,create_date from user_article order by create_date desc",
                resultSetMapping = "userArticleMap"
        )
})
@SqlResultSetMappings({
        @SqlResultSetMapping(
                name = "userArticleMap",
                entities = {},
                columns = {
                        @ColumnResult(name = "id"),
                        @ColumnResult(name = "title"),
                        @ColumnResult(name = "createUserId"),
                        @ColumnResult(name = "createDate"),
                }
        )
})
@Entity
@IdClass(value = UserArticleKey.class)
@Data
public class UserArticle {
    @Column
    private Integer id;
    @Id
    private String title;
    @Id
    private Long createUserId;
    private Date createDate;
}

public @interface JoinColumn {
    // 目標(biāo)表的字段名，必填
    String name() default "";
    // 本實(shí)體類的字段名, 非必填, 默認(rèn)本表ID
    String referencedColumnName() default "";
    // 外鍵字段是否唯一, 可選
    boolean unique() default false;
    // 外鍵字段是否允許為空, 可選
    boolean nullable() default true;
    // 是否跟隨一起新增, 可選
    boolean insertable() default true;
    // 是否跟隨一起更新, 可選
    boolean updatable() default true;
    // 生成DDL的時(shí)候使用的SQL片段 可選
    String columnDefinition() default "";
    // 包含列的表的名稱 , 可選
    String table() default "";
    // 外鍵約束類別, 默認(rèn)為 默認(rèn)約束行為， 可選
    ForeignKey foreignKey() default @ForeignKey(ConstraintMode.PROVIDER_DEFAULT);
}

public @interface OneToOne {
    // 關(guān)系目標(biāo)實(shí)體, 默認(rèn)為void.class, 可選
    Class targetEntity() default void.class;
    // 級聯(lián)操作策略， PERSIST(級聯(lián)新增)、REMOVE(級聯(lián)刪除)、REFRESH(級聯(lián)刷新)、MERGE(級聯(lián)更新)、ALL(全選)
    // 默認(rèn)表不會產(chǎn)生任何影響
    CascadeType[] cascade() default {};
    // 數(shù)據(jù)獲取方式，EAGER(立即加載)、LAZY(延遲加載)
    FetchType fetch() default EAGER;
    // 是否允許空
    boolean optional() default true;
    // 關(guān)聯(lián)關(guān)系被誰維護(hù)，非必填，一遍不需要特別指定
    // mappedBy不能與@JoinColumn或者@JoinTable同時(shí)使用
    // mappedBy的值是指另一方的實(shí)體里面屬性的字段，而不是數(shù)據(jù)庫字段，也不是實(shí)體的對象的名字，即另一方配置了@JoinColumn或者@JoinTable注解的屬性的字段名稱
    String mappedBy() default "";
    
    // 是否級聯(lián)刪除，和CascadeType.REMOVE 效果一樣，任意配置一種即可生效
    boolean orphanRemoval() default false;
}

@OneToOne
// name 為當(dāng)前實(shí)體對應(yīng)數(shù)據(jù)庫表中的字段名
// referencedColumnName 為 SystemUser 實(shí)體中@Id標(biāo)記的字段對應(yīng)的數(shù)據(jù)庫字段名
@JoinColumn(name = "create_user_id",referencedColumnName = "id")
private SystemUser createUser = new SystemUser();

@OneToOne(mappedBy = "createUser")
private UserArticle article = new UserArticle();

@OneToOne
@JoinColumn(name = "user_article_id",referencedColumnName = "id")
private UserArticle article = new UserArticle();

public @interface OneToMany {
    Class targetEntity() default void.class;
    // 級聯(lián)操作策略
    CascadeType[] cascade() default {};
    // 數(shù)據(jù)獲取方式
    FetchType fetch() default LAZY;
    // 關(guān)系被誰維護(hù)，單項(xiàng)的
    String mappedBy() default "";
    // 是否級聯(lián)刪除
    boolean orphanRemoval() default false;
}
public @interface ManyToOne {
    Class targetEntity() default void.class;
    // 級聯(lián)操作策略
    CascadeType[] cascade() default {};
    // 數(shù)據(jù)獲取方式
    FetchType fetch() default LAZY;　　　　 // 關(guān)聯(lián)是否可選。如果設(shè)置,若要為false，則必須始終存在非null關(guān)系。
    boolean optional() default true;
}

@Entity
@Data
public class UserArticle {
    @Column
    private Integer id;
    @Id
    private String title;
    @ManyToOne(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinColumn(name = "create_user_id",referencedColumnName = "id")
    private SystemUser systemUser = new SystemUser();
    private Date createDate;
}

@Entity(name = "t_user")
@Data
@Table
public class SystemUser implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    @Basic
    private String uname;
    private String email;
    private String address;
    @Enumerated(EnumType.STRING)
    private Gender sex;
@OneToMany
// name 當(dāng)前表id
// create_user_id 目標(biāo)表的關(guān)聯(lián)字段
@JoinColumn(name = "id",referencedColumnName = "create_user_id")
private List<UserArticle> articleList = new ArrayList<>();
    public enum Gender{
        MALE("男性"),
        FEMALE("女性")
        ;
        private String value;
        Gender(String value) {
            this.value = value;
        }
    }
}

public @interface OrderBy {
    /**
     * 要排序的字段格式如下:
     *    orderby_list::= orderby_item [,orderby_item]*
     *    orderby_item::= [property_or_field_name] [ASC | DESC]
     * 字段可以是實(shí)體屬性，也可以是數(shù)據(jù)字段，默認(rèn)ASC
     */
    String value() default "";
}

@OneToMany
@JoinColumn(name = "id",referencedColumnName = "create_user_id")
@OrderBy("createDate DESC") // createDate 是 UserArticle 的實(shí)體屬性
private List<UserArticle> articleList = new ArrayList<>();
 

public @interface JoinTable {
    // 中間關(guān)聯(lián)關(guān)系表名
    String name() default "";
    // 表的 catalog
    String catalog() default "";
    // 表的 schema
    String schema() default "";
    // 主連接表的字段
    JoinColumn[] joinColumns() default {};
    // 被連接表的字段
    JoinColumn[] inverseJoinColumns() default {};
    // 主連接外鍵約束類別
    ForeignKey foreignKey() default @ForeignKey(PROVIDER_DEFAULT);
    // 被連接外鍵約束類別
    ForeignKey inverseForeignKey() default @ForeignKey(PROVIDER_DEFAULT);
    // 唯一約束
    UniqueConstraint[] uniqueConstraints() default {};
    // 表的索引
    Index[] indexes() default {};
}

@Entity
// 主連接表 blog
public class Blog {
    @ManyToMany
    @JoinTable(
            name = "blog_tag_relation", // 關(guān)系表名稱
            joinColumns = @JoinColumn(name = "blog_id",referencedColumnName = "id"), // 主連接表配置
            inverseJoinColumns = @JoinColumn(name = "tag_id",referencedColumnName = "id") // 被連接表配置
    )
    // tag 是被連接表
    private List<Tag> tags = new ArrayList<>();
}

@NamedEntityGraph(
        name = "Blog.tags", attributeNodes = {
        @NamedAttributeNode("tags")
}
)
@Entity
// 主連接表 blog
public class Blog {
    @ManyToMany
    @JoinTable(
            name = "blog_tag_relation", // 關(guān)系表名稱
            joinColumns = @JoinColumn(name = "blog_id", referencedColumnName = "id"), // 主連接表配置
            inverseJoinColumns = @JoinColumn(name = "tag_id", referencedColumnName = "id") // 被連接表配置
    )
    // tag 是被連接表
    private List<Tag> tags = new ArrayList<>();
}

public interface BlogRepository extends JpaRepository<Blog,Long> {
    @Override
    @EntityGraph(value = "Blog.tags")
    List<Blog> findAll();
}