Spring Data JPA 基本使用

大體內容

一、 創建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接口
十、 關聯映射操作 
	1 一對一的關聯關系
	2 一對多的關聯關系
	3 多對多的關聯關系

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=trace

3 編寫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
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);
	}
}

十、 關聯映射操作

1 一對一的關聯關系

需求:用戶與角色的一對一的關聯關系
用戶:一方
角色:一方

1.1創建 Users 實體

@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 Roles getRoles() {
		return roles;
	}

	public void setRoles(Roles roles) {
		this.roles = roles;
	}

	@OneToOne(cascade=CascadeType.PERSIST)
	//@JoinColumn：就是維護一個外鍵
	@JoinColumn(name="roles_id")
	private Roles roles;

	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 + "]";
	}
}

1.2創建 Roles 實體

@Entity
@Table(name="t_roles")
public class Roles {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="roleid")
	private Integer roleid;
	
	@Column(name="rolename")
	private String rolename;
	
	@OneToOne(mappedBy="roles")
	private Users users;
	
	public Users getUsers() {
		return users;
	}

	public void setUsers(Users users) {
		this.users = users;
	}

	public Integer getRoleid() {
		return roleid;
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public String getRolename() {
		return rolename;
	}

	public void setRolename(String rolename) {
		this.rolename = rolename;
	}

	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}
}

1.3一對一關聯關系操作

/**
 * 一對一關聯關系測試
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class OneToOneTest {

	@Autowired
	private UsersDao usersDao;
	
	/**
	 * 添加用戶同時添加角色
	 */
	@Test
	public void test1(){
		//創建角色
		Roles roles = new Roles();
		roles.setRolename("管理員");
		
		//創建用戶
		Users users = new Users();
		users.setUserage(30);
		users.setUsername("趙小剛");
		
		//建立關系
		users.setRoles(roles);
		roles.setUsers(users);
		
		//保存數據
		this.usersDao.save(users);
	}
	
	/**
	 * 根據用戶ID查詢用戶，同時查詢用戶角色
	 */
	@Test
	public void test2(){
		Users users = this.usersDao.findOne(13);
		System.out.println("用戶信息："+users);
		Roles roles = users.getRoles();
		System.out.println(roles);
	}
}

接口

/**
 * 一對一關聯關系操作
 * @author Administrator
 */
public interface UsersDao extends JpaRepository<Users, Integer>,JpaSpecificationExecutor<Users>{
	
}

2 一對多的關聯關系

需求:從角色到用戶的一對多的關聯關系
角色:一方
用戶:多方

2.1創建 Users 實體

....

2.2創建 Roles 實體

...

2.3一對多的關聯關系操作

/**
 * 一對多的關聯關系測試
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class OneToManyTest {

	@Autowired
	private UsersDao usersDao;
	
	
	/**
	 * 添加用戶同時添加角色
	 */
	@Test
	public void test1(){
		//創建角色
		Roles roles = new Roles();
		roles.setRolename("管理員");
		//創建用戶
		Users users =new Users();
		users.setUserage(30);
		users.setUsername("小王");
		//建立關系
		roles.getUsers().add(users);
		users.setRoles(roles);
		//保存數據
		this.usersDao.save(users);
	}
	
	/**
	 * 根據用戶ID查詢用戶信息，同時查詢角色
	 */
	@Test
	public void test2(){
		Users users = this.usersDao.findOne(14);
		System.out.println("用戶姓名："+users.getUsername());
		Roles roles = users.getRoles();
		System.out.println(roles);
	}
}

3 多對多的關聯關系

需求:一個角色可以擁有多個菜單，一個菜單可以分配多個角色。多對多的關聯關系 角色:多方
菜單:多方

3.1創建 Roles 實體

@Entity
@Table(name="t_roles")
public class Roles {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="roleid")
	private Integer roleid;
	
	@Column(name="rolename")
	private String rolename;
	
	@OneToMany(mappedBy="roles")
	private Set<Users> users = new HashSet<>();
	
	public Set<Users> getUsers() {
		return users;
	}

	public void setUsers(Set<Users> users) {
		this.users = users;
	}

	public Integer getRoleid() {
		return roleid;
	}

	public void setRoleid(Integer roleid) {
		this.roleid = roleid;
	}

	public String getRolename() {
		return rolename;
	}

	public void setRolename(String rolename) {
		this.rolename = rolename;
	}

	@Override
	public String toString() {
		return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}

}

3.2創建 Menus 實體

@Entity
@Table(name="t_menus")
public class Menus {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	@Column(name="menusid")
	private Integer menusid;
	
	@Column(name="menusname")
	private String menusname;
	
	@Column(name="menusurl")
	private String menusurl;
	
	@Column(name="fatherid")
	private Integer fatherid;

	@ManyToMany(mappedBy="menus")
	private Set<Roles> roles = new HashSet<>();
	
	public Set<Roles> getRoles() {
		return roles;
	}

	public void setRoles(Set<Roles> roles) {
		this.roles = roles;
	}

	public Integer getMenusid() {
		return menusid;
	}

	public void setMenusid(Integer menusid) {
		this.menusid = menusid;
	}

	public String getMenusname() {
		return menusname;
	}

	public void setMenusname(String menusname) {
		this.menusname = menusname;
	}

	public String getMenusurl() {
		return menusurl;
	}

	public void setMenusurl(String menusurl) {
		this.menusurl = menusurl;
	}

	public Integer getFatherid() {
		return fatherid;
	}

	public void setFatherid(Integer fatherid) {
		this.fatherid = fatherid;
	}

	@Override
	public String toString() {
		return "Menus [menusid=" + menusid + ", menusname=" + menusname + ", menusurl=" + menusurl + ", fatherid="
				+ fatherid + "]";
	}
}

3.3多對多關聯關系操作

/**
 * 多對多關聯關系測試
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ManyToManyTest {
	
	
	@Autowired
	private RolesDao rolesDao;
	
	/**
	 * 添加角色同時添加菜單
	 */
	@Test
	public void test1(){
		//創建角色對象
		Roles roles = new Roles();
		roles.setRolename("超級管理員");
		
		//創建菜單對象    XXX管理平台 --->用戶管理
		Menus menus = new Menus();
		menus.setMenusname("XXX管理平台");
		menus.setFatherid(-1);
		menus.setMenusurl(null);
		
		//用戶管理菜單
		Menus menus1 = new Menus();
		menus1.setMenusname("用戶管理");
		menus1.setFatherid(1);
		menus1.setMenusurl(null);
		
		
		//建立關系
		roles.getMenus().add(menus);
		roles.getMenus().add(menus1);
		
		menus.getRoles().add(roles);
		menus1.getRoles().add(roles);
		
		
		//保存數據
		this.rolesDao.save(roles);
	}
	
	/**
	 * 查詢Roles
	 */
	@Test
	public void test2(){
		Roles roles = this.rolesDao.findOne(3);
		System.out.println("角色信息："+roles);
		Set<Menus> menus = roles.getMenus();
		for (Menus menus2 : menus) {
			System.out.println("菜單信息："+menus2);
		}
	}

}