參考：https://www.cnblogs.com/chenglc/p/11226693.html / https://blog.csdn.net/hbtj_1216/article/details/79773839 JPARepository接口說明
注：spring data jpa 2.0之后沒有 CrudRepositroy沒有findOne()等方法
體內容
一、 創建SpringDataJPA項目
1 導入依賴 2 配置數據源信息 3 編寫Dao 4 user 5 編寫測試代碼 二、 Spring Data JPA 的接口繼承結構 三、 Spring Data JPA 的運行原理 四、 Repository 接口 1 方法名稱命名規則查詢 2 基於@Query 注解的查詢 2.1通過 JPQL 語句查詢 2.2通過 SQL 語句查詢 3 通過@Query 注解完成數據更新 五、 CrudRepository 接口 六、 PagingAndSortingRepository 接口 1 分頁處理 2 排序的處理 七、 JpaRepository 接口 八、 JpaSpecificationExecutor 接口 1 單條件查詢 2 多條件查詢 2.1給定查詢條件方式一 2.2 給定查詢條件方式二 3 分頁 4 排序 5 分頁與排序 九、 用戶自定義Repository接口
十、關於spring.jpa.properties.hibernate.hbm2ddl.auto的配置
Spring Data JPA:
Spring Data JPA 是 spring data 項目下的一個模塊。提供了一套基於 JPA標准操作數據庫的簡化方案。底層默認的是依賴 Hibernate JPA 來實現的。Spring Data JPA 的技術特點:
我們只需要定義接口並集成 Spring Data JPA 中所提供的接口就可以了。不需要編寫接口實現類。一、 創建SpringDataJPA項目
1 導入依賴
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>2 配置數據源信息
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useSSL=false spring.datasource.username=root spring.datasource.password=tianya spring.jpa.hibernate.ddl-auto=none spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect server.port=8010 logging.level.org.springframework=error #spring.jpa.generate-ddl= spring.jpa.show-sql=true spring.jpa.properties.hibernate.format_sql=true spring.jpa.properties.hibernate.type=trace spring.jpa.properties.hibernate.use_sql_comments=true spring.jpa.properties.hibernate.jdbc.batch_size=50 logging.level.org.hibernate.type.descriptor.sql=trace3 編寫Dao
public interface UsersDao extends JpaRepository<Users, Integer> {}4 User
import java.io.Serializable; 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_users") public class Users implements Serializable{ @Id @GeneratedValue(strategy=GenerationType.IDENTITY)//strategy=GenerationType.IDENTITY 自增長 @Column(name="userid") private Integer userid; @Column(name="username") private String username; @Column(name="userage") private Integer userage; public Integer getUserid() { return userid; } public void setUserid(Integer userid) { this.userid = userid; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public Integer getUserage() { return userage; } public void setUserage(Integer userage) { this.userage = userage; } @Override public String toString() { return "Users [userid=" + userid + ", username=" + username + ", userage=" + userage + "]"; } }5 編寫測試代碼
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class UsersDaoImplTest { @Autowired private UsersDao usersDao; /** * 添加用戶 */ @Test @Transactional// 在測試類對於事務提交方式默認的是回滾。 @Rollback(false)//取消自動回滾 public void testInsertUsers(){ Users users = new Users(); users.setUserage(24); users.setUsername("張三"); this.usersDao.save(users); } }二、 Spring Data JPA 的接口繼承結構
三、 Spring Data JPA 的運行原理
@PersistenceContext(name="entityManagerFactory") private EntityManager em; @Test public void test1(){ //org.springframework.data.jpa.repository.support.SimpleJpaRepositor y@fba8bf //System.out.println(this.usersDao); //class com.sun.proxy.$Proxy29 代理對象 是基於 JDK 的動態代理方式創建的 //System.out.println(this.usersDao.getClass()); JpaRepositoryFactory factory = new JpaRepositoryFactory(em); //getRepository(UsersDao.class);可以幫助我們為接口生成實現類。而 這個實現類是 SimpleJpaRepository 的對象 //要求:該接口必須要是繼承 Repository 接口 UsersDao ud = factory.getRepository(UsersDao.class); System.out.println(ud); System.out.println(ud.getClass()); }四、 Repository 接口
Repository 接口是 Spring Data JPA 中為我我們提供的所有接口中的頂層接口 Repository 提供了兩種查詢方式的支持 1)基於方法名稱命名規則查詢 2)基於@Query 注解查詢1 方法名稱命名規則查詢
規則:
findBy(關鍵字)+屬性名稱(屬性名稱的首字母大寫)+查詢條件(首字母大寫)| 關鍵字 | 方法命名 | sql where 字句 |
|---|---|---|
| And | findByNameAndPwd | where name= ? and pwd =? |
| Or | findByNameOrSex | where name= ? or sex=? |
| Is,Equal | findById,findByIdEquals,findByIdIs | |
| Between | findByIdBetween | where id between ? and ? |
| LessThan | findByIdLessThan | where id < ? |
| LessThanEqual | findByIdLessThanEquals | where id <= ? |
| GreaterThan | findByIdGreaterThan | where id > ? |
| GreaterThanEqual | findByIdGreaterThanEquals | where id > = ? |
| After | findByIdAfter | where id > ? |
| Before | findByIdBefore | where id < ? |
| IsNull | findByNameIsNull | where name is null |
| isNotNull,Not Null | findByNameNotNull | where name is not |
| Like | findByNameLike | where name like ? |
| NotLike | findByNameNotLike | where name not like ? |
| StartingWith | findByNameStartingWith | where name like '?%' |
| EndingWith | findByNameEndingWith | where name like '%?' |
| Containing | findByNameContaining | where name like '%?%' |
| OrderBy | findByIdOrderByXDesc | where id=? order by x desc |
| Not | findByNameNot | where name <> ? |
| In | findByIdIn(Collection<?> c) | where id in (?) |
| NotIn | findByIdNotIn(Collection<?> c) | where id not in (?) |
| True | findByAaaTue | where aaa = true |
| False | findByAaaFalse | where aaa = false |
| IgnoreCase | findByNameIgnoreCase | where UPPER(name)=UPPER(?) |
創建接口
/** * Repository接口講解 * @author Administrator * */ public interface UsersDao extends Repository<Users, Integer> { //方法名稱命名規則 List<Users> findByUsernameIs(String string); List<Users> findByUsernameLike(String string); List<Users> findByUsernameAndUserageGreaterThanEqual(String name,Integer age); }測試類
/** * Repository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 需求：使用用戶名作為查詢條件 */ @Test public void test1(){ /** * 判斷相等的條件，有三種表示方式 * 1,什么都不寫，默認的就是做相等判斷 * 2,Is * 3,Equal */ List<Users> list = this.usersDao.findByUsernameIs("王五"); for (Users users : list) { System.out.println(users); } } /** * 需求：根據用戶姓名做Like處理 * Like:條件關鍵字 */ @Test public void test2(){ List<Users> list = this.usersDao.findByUsernameLike("王%"); for (Users users : list) { System.out.println(users); } } /** * 需求：查詢名稱為王五，並且他的年齡大於等於22歲 */ @Test public void test3(){ List<Users> list = this.usersDao.findByUsernameAndUserageGreaterThanEqual("王五", 22); for (Users users : list) { System.out.println(users); } } }2 基於@Query 注解的查詢
2.1通過 JPQL 語句查詢
JPQL: 通過 Hibernate 的 HQL 演變過來的。他和 HQL 語法及其相似。創建接口
/** * Repository接口講解 * @author Administrator * */ public interface UsersDao extends Repository<Users, Integer> { //使用@Query注解查詢 @Query(value="from Users where username = ?") List<Users> queryUserByNameUseJPQL(String name); @Query("from Users where username like ?") List<Users> queryUserByLikeNameUseJPQL(String name); @Query("from Users where username = ? and userage >= ?") List<Users> queryUserByNameAndAge(String name,Integer age); }測試類
/** * Repository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 測試@Query查詢 JPQL */ @Test public void test4(){ List<Users> list = this.usersDao.queryUserByNameUseJPQL("王五"); for (Users users : list) { System.out.println(users); } } /** * 測試@Query查詢 JPQL */ @Test public void test5(){ List<Users> list = this.usersDao.queryUserByLikeNameUseJPQL("王%"); for (Users users : list) { System.out.println(users); } } /** * 測試@Query查詢 JPQL */ @Test public void test6(){ List<Users> list = this.usersDao.queryUserByNameAndAge("王五", 22); for (Users users : list) { System.out.println(users); } } }2.2通過 SQL 語句查詢
接口
/** * Repository接口講解 * @author Administrator * */ public interface UsersDao extends Repository<Users, Integer> { //使用@Query注解查詢SQL //nativeQuery:默認的是false.表示不開啟sql查詢。是否對value中的語句做轉義。 @Query(value="select * from t_users where username = ?",nativeQuery=true) List<Users> queryUserByNameUseSQL(String name); @Query(value="select * from t_users where username like ?",nativeQuery=true) List<Users> queryUserByLikeNameUseSQL(String name); @Query(value="select * from t_users where username = ? and userage >= ?",nativeQuery=true) List<Users> queryUserByNameAndAgeUseSQL(String name,Integer age); }測試類
/** * Repository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 測試@Query查詢 SQL */ @Test public void test7(){ List<Users> list = this.usersDao.queryUserByNameUseSQL("王五"); for (Users users : list) { System.out.println(users); } } /** * 測試@Query查詢 SQL */ @Test public void test8(){ List<Users> list = this.usersDao.queryUserByLikeNameUseSQL("王%"); for (Users users : list) { System.out.println(users); } } /** * 測試@Query查詢 SQL */ @Test public void test9(){ List<Users> list = this.usersDao.queryUserByNameAndAgeUseSQL("王五", 22); for (Users users : list) { System.out.println(users); } } }3 通過@Query 注解完成數據更新
接口
/** * Repository接口講解 * @author Administrator * */ public interface UsersDao extends Repository<Users, Integer> { @Query("update Users set userage = ? where userid = ?") @Modifying //@Modifying當前語句是一個更新語句 void updateUserAgeById(Integer age,Integer id); }測試類
/** * Repository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 測試@Query update */ @Test @Transactional @Rollback(false) public void test10(){ this.usersDao.updateUserAgeById(24, 5); } }五、 CrudRepository 接口
1 創建接口
/** * CrudRepository接口講解 * @author Administrator * */ public interface UsersDao extends CrudRepository<Users, Integer> { }2 測試代碼
/** * CrudRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 添加單條數據 */ @Test public void test1(){ Users user = new Users(); user.setUserage(21); user.setUsername("趙小麗"); this.usersDao.save(user); } /** * 批量添加數據 */ @Test public void test2(){ Users user = new Users(); user.setUserage(21); user.setUsername("趙小麗"); Users user1 = new Users(); user1.setUserage(25); user1.setUsername("王小虎"); List<Users> list= new ArrayList<>(); list.add(user); list.add(user1); this.usersDao.save(list); } /** * 根據ID查詢單條數據 */ @Test public void test3(){ Users users = this.usersDao.findOne(13); System.out.println(users); } /** * 查詢全部數據 */ @Test public void test4(){ List<Users> list = (List<Users>)this.usersDao.findAll(); for (Users users : list) { System.out.println(users); } } /** * 刪除數據 */ @Test public void test5(){ this.usersDao.delete(13); } /** * 更新數據 方式一 */ @Test public void test6(){ Users user = this.usersDao.findOne(12); user.setUsername("王小紅"); this.usersDao.save(user); } /** * 更新數據 方式二 */ @Test @Transactional @Rollback(false) public void test7(){ Users user = this.usersDao.findOne(12);//持久化狀態的 user.setUsername("王小小"); } }六、 PagingAndSortingRepository 接口
1 分頁處理
1.1創建接口
/** * PagingAndSortingRepository接口講解 * @author Administrator * */ public interface UsersDao extends PagingAndSortingRepository<Users, Integer>{ }1.2測試代碼
/** * CrudRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 分頁 */ @Test public void test1(){ int page = 2; //page:當前頁的索引。注意索引都是從0開始的。 int size = 3;// size:每頁顯示3條數據 Pageable pageable= new PageRequest(page, size); Page<Users> p = this.usersDao.findAll(pageable); System.out.println("數據的總條數："+p.getTotalElements()); System.out.println("總頁數："+p.getTotalPages()); List<Users> list = p.getContent(); for (Users users : list) { System.out.println(users); } } }2 排序的處理
2.1測試代碼
/** * CrudRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 對單列做排序處理 */ @Test public void test2(){ //Sort:該對象封裝了排序規則以及指定的排序字段(對象的屬性來表示) //direction:排序規則 //properties:指定做排序的屬性 Sort sort = new Sort(Direction.DESC,"userid"); List<Users> list = (List<Users>)this.usersDao.findAll(sort); for (Users users : list) { System.out.println(users); } } /** * 多列的排序處理 */ @Test public void test3(){ //Sort:該對象封裝了排序規則以及指定的排序字段(對象的屬性來表示) //direction:排序規則 //properties:指定做排序的屬性 Order order1 = new Order(Direction.DESC,"userage"); Order order2 = new Order(Direction.ASC,"username"); Sort sort = new Sort(order1,order2); List<Users> list = (List<Users>)this.usersDao.findAll(sort); for (Users users : list) { System.out.println(users); } } }七、 JpaRepository 接口
JpaRepository 接口是我們開發時使用的最多的接口。其特點是可以幫助我們將其他接口的方法的返回值做適配處理。可以使得我們在開發時更方便的使用這些方法。創建接口
/** * JpaRepository接口講解 * @author Administrator * */ public interface UsersDao extends JpaRepository<Users, Integer>{ }測試類
/** * JpaRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 查詢全部數據 */ @Test public void test1(){ List<Users> list = this.usersDao.findAll(); for (Users users : list) { System.out.println(users); } } }八、 JpaSpecificationExecutor 接口
完成多條件查詢，並且支持分頁與排序1 單條件查詢
1.1創建接口
/** * JpaSpecificationExecutor接口講解 * @author Administrator *注意：JpaSpecificationExecutor<Users>:不能單獨使用，需要配合着jpa中的其他接口一起使用 */ public interface UsersDao extends JpaRepository<Users, Integer>,JpaSpecificationExecutor<Users>{ }測試接口
/** * JpaRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 需求：根據用戶姓名查詢數據 */ @Test public void test1(){ Specification<Users> spec = new Specification<Users>() { /** * @return Predicate:定義了查詢條件 * @param Root<Users> root:根對象。封裝了查詢條件的對象 * @param CriteriaQuery<?> query:定義了一個基本的查詢。一般不使用 * @param CriteriaBuilder cb:創建一個查詢條件 */ @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { Predicate pre = cb.equal(root.get("username"), "王五"); return pre; } }; List<Users> list = this.usersDao.findAll(spec); for (Users users : list) { System.out.println(users); } } }2 多條件查詢
2.1給定查詢條件方式一
/** * 多條件查詢 方式一 * 需求：使用用戶姓名以及年齡查詢數據 */ @Test public void test2(){ Specification<Users> spec = new Specification<Users>() { @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { List<Predicate> list = new ArrayList<>(); list.add(cb.equal(root.get("username"),"王五")); list.add(cb.equal(root.get("userage"),24)); //此時條件之間是沒有任何關系的。 Predicate[] arr = new Predicate[list.size()]; return cb.and(list.toArray(arr)); } }; List<Users> list = this.usersDao.findAll(spec); for (Users users : list) { System.out.println(users); } } 2.2 給定查詢條件方式二
/** * 多條件查詢 方式二 * 需求：使用用戶姓名或者年齡查詢數據 */ @Test public void test3(){ Specification<Users> spec = new Specification<Users>() { @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { return cb.or(cb.equal(root.get("username"),"王五"),cb.equal(root.get("userage"), 25)); } }; List<Users> list = this.usersDao.findAll(spec); for (Users users : list) { System.out.println(users); } }3 分頁
/** * 需求：查詢王姓用戶，並且做分頁處理 */ @Test public void test4(){ //條件 Specification<Users> spec = new Specification<Users>() { @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { return cb.like(root.get("username").as(String.class), "王%"); } }; //分頁 Pageable pageable = new PageRequest(2, 2); Page<Users> page = this.usersDao.findAll(spec, pageable); System.out.println("總條數："+page.getTotalElements()); System.out.println("總頁數："+page.getTotalPages()); List<Users> list = page.getContent(); for (Users users : list) { System.out.println(users); } }4 排序
/** * 需求：查詢數據庫中王姓的用戶，並且根據用戶id做倒序排序 */ @Test public void test5(){ //條件 Specification<Users> spec = new Specification<Users>() { @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { return cb.like(root.get("username").as(String.class), "王%"); } }; //排序 Sort sort = new Sort(Direction.DESC,"userid"); List<Users> list = this.usersDao.findAll(spec, sort); for (Users users : list) { System.out.println(users); } }5 分頁與排序
/** * 需求：查詢數據庫中王姓的用戶，做分頁處理，並且根據用戶id做倒序排序 */ @Test public void test6(){ //排序等定義 Sort sort = new Sort(Direction.DESC,"userid"); //分頁的定義 Pageable pageable = new PageRequest(2,2, sort); //查詢條件 Specification<Users> spec = new Specification<Users>() { @Override public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> query, CriteriaBuilder cb) { return cb.like(root.get("username").as(String.class), "王%"); } }; Page<Users> page = this.usersDao.findAll(spec, pageable); System.out.println("總條數："+page.getTotalElements()); System.out.println("總頁數："+page.getTotalPages()); List<Users> list = page.getContent(); for (Users users : list) { System.out.println(users); } } 九、 用戶自定義Repository接口
創建接口
public interface UsersRepository { public Users findUserById(Integer userid); }使用接口
/** * 用戶自定義Repository接口講解 * @author Administrator */ public interface UsersDao extends JpaRepository<Users, Integer>,JpaSpecificationExecutor<Users>,UsersRepository{ }創建接口實現類
public class UsersDaoImpl implements UsersRepository { @PersistenceContext(name="entityManagerFactory") private EntityManager em; @Override public Users findUserById(Integer userid) { System.out.println("MyRepository......"); return this.em.find(Users.class, userid); } }編寫測試代碼
/** * JpaRepository接口測試 * @author Administrator * */ @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class RepositoryTest { @Autowired private UsersDao usersDao; /** * 需求：根據用戶ID查詢數據 */ @Test public void test1(){ Users users = this.usersDao.findUserById(5); System.out.println(users); } }
十、.關於spring.jpa.properties.hibernate.hbm2ddl.auto的配置
spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop
該配置的的主要作用是：自動創建、更新、驗證數據庫表結構。該參數的幾種配置如下：
create：每次加載Hibernate時都會刪除上一次生成的表，然后根據你的model類再重新來生成新表，哪怕兩次沒有任何改變也要這樣執行，這就是導致數據庫表數據丟失的一個重要原因。create-drop：每次加載Hibernate時根據model類生成表，但是SessionFactory一關閉，表就會自動刪除update：最常用的屬性，第一次加載Hibernate時根據model類會自動建立起表的架構（前提是先建立好數據庫），以后加載Hibernate時根據model類自動更新表結構，即使表結構改變了，但表中的行仍然存在不會刪除以前的行。要注意的是，當部署到服務器后，表結構不會馬上建立起來的， 是要等應用第一次運行起來后才會。validate：每次加載Hibernate時，驗證創建數據庫表結構，只會和數據庫中的表進行比較，不會創建新表，但是會插入新值
十一、詳解Hibernate cascade級聯屬性的CascadeType的用法
@ManyToOne(cascade = CascadeType.REFRESH, optional = true) @JoinColumn(name = "user_id", unique = false) private UserBaseInfo userBaseInfo;
optional屬性的默認值是true。optional 屬性實際上指定關聯類與被關聯類的join 查詢關系，如optional=false 時join 查詢關系為inner join, optional=true 時join 查詢關系為left join。 但是實際運行中，
語句一直為innerjoin 設置為optional=true不起作用
@OneToOne
(cascade = {CascadeType.REFRESH,CascadeType.PERSIST,CascadeType.MERGE}, optional =
true
)
@JoinColumn
(name =
"user_id"
, unique =
false
)
private
UserBaseInfo userBaseInfo;
參考：https://www.jb51.net/article/105097.htm
十二、@OneToOne(mappedBy="wife") mapperBy相關說明
a) 只有OneToOne,OneToMany,ManyToMany上才有mappedBy屬性，ManyToOne不存在該屬性； b) mappedBy標簽一定是定義在the owned side(被擁有方的)，他指向the owning side(擁有方)； c) mappedBy的含義，應該理解為，擁有方能夠自動維護跟被擁有方的關系； d) mappedBy跟JoinColumn/JoinTable總是處於互斥的一方，可以理解為正是由於擁有方的關聯被擁有方的字段存在，擁有方才擁有了被擁有方。mappedBy這方定義的JoinColumn/JoinTable總是失效的，不會建立對應的字段或者表；
(1)、@Entity 代表此類映射為數據庫的表結構 (2)、@Table(name="tbl_dept")此注解用於配置實體類與表映射的關系,name代表映射的表名 (3)、 @Id注解代表此類為一個主鍵 (4)、@GeneratedValue注解用於配置主鍵相關信息,generator屬性用於配置生成策略有以下幾種枚舉值: 1、auto - 主鍵由程序控制 。 2、IDENTITY - 由數據庫自動生成。 3、enerator -指定生成主鍵使用的生成器 。 4、SEQUENCE - 根據底層數據庫的序列來生成主鍵 。 5、TABLE - 使用一個特定的數據庫表來保存主鍵。 6、system-uuid 代表使用系統生成的uuid進行配。 (5)、@Column用於配置列相關信息的注解 1、name字段用於指定映射到表結構的映射字段。 2、length代表此字段的長度約束,可以省略。 3、unique屬性代表此字段是否開啟唯一性約束，默認為false,唯一則為true 。 4、nullable代表此字段是否可以為空,默認為true 。 false代表不能為空 。