Spring Data JPA

       Spring Data JPA：Spring Data JPA 是spring data 項目下的一個模塊。提供了一套基於JPA標準操作數據庫的簡化方案。底層默認的是依賴 Hibernate JPA 來實現的。Spring Data JPA 的技術特點：我們只需要定義接口並集成 Spring Data JPA 中所提供的接口就可以了。不需要編寫接口實現類。

一：創建 Spring Data JPA項目

1：導入jar包

https://download.csdn.net/download/qq_36297434/11890694

2：配置文件

2.1：jdbc.properties

jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.driver.class=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=root

2.2：applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/data/jpa 
	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 配置讀取properties文件的工具類 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置c3p0數據庫連接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="driverClass" value="${jdbc.driver.class}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- Spring整合JPA  配置EntityManagerFactory-->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource"/>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<!-- hibernate相關的屬性的注入 -->
				<!-- 配置數據庫類型 -->
				<property name="database" value="MYSQL"/>
				<!-- 正向工程 自動創建表 -->
				<property name="generateDdl" value="true"/>
				<!-- 顯示執行的SQL -->
				<property name="showSql" value="true"/>
			</bean>
		</property>
		<!-- 掃描實體的包 -->
		<property name="packagesToScan">
			<list>
				<value>hhxy.pojo</value>
			</list>
		</property>
	</bean>

	<!-- 配置Hibernate的事務管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory"/>
	</bean>
	
	<!-- 配置開啓註解事務處理 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	
	<!-- 配置springIOC的註解掃描 -->
	<context:component-scan base-package="hhxy"/>
	
	<!-- Spring Data JPA 的配置 -->
	<!-- base-package：掃描dao接口所在的包 -->
	<jpa:repositories base-package="hhxy.dao"/>
</beans>

3：編寫Dao

public interface UsersDao extends JpaRepository<Users, Integer> {
}

4：編寫測試代碼

@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.SimpleJpaRepository@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 提供了兩種查詢方式的支持：基於方法名稱命名規則查詢，基於@Query 註解查詢。

1：方法名稱命名規則查詢

規則：findBy(關鍵字)+屬性名稱(屬性名稱的首字母大寫)+查詢條件(首字母大寫)

關鍵字	方法命名	sql where 字句
And	findByNameAndPwd	where name= ? and pwd =?
Or	findByNameOrSex	where name= ? or sex=?
Is,Equal	findById,findByIdEquals	where id= ?
Between	findByIdBetween	where id between ? and ?
LessThan	findByIdLessThan	where id < ?
LessThanEqual	findByIdLessThanEqual	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 Null
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(?)

1.1：創建接口

/**
* Repository 接口講解
* @author 李偉康
*
*/
public interface UsersDao extends Repository<Users, Integer> {
    List<Users> findByUsernameIs(String string);
    List<Users> findByUsernameLike(String string);
    List<Users> findByUsernameAndUserageGreaterThanEqual(String name,Integer age);
}

1.2：測試類

/**
* Repository 接口測試
* @author 李偉康
*
*/
@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 語法及其相似。

2.1.1：創建接口

/**
* Repository 接口講解
* @author 李偉康
*
*/
public interface UsersDao extends Repository<Users, Integer> {
    //方法名稱命名規則
    List<Users> findByUsernameIs(String string);
    List<Users> findByUsernameLike(String string);
    List<Users> findByUsernameAndUserageGreaterThanEqual(String name,Integer age);
    //使用@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);
}

2.1.2：測試類

/**
* 測試@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語句查詢

2.2.1：創建接口

/**
* Repository 接口講解
* @author 李偉康
*
*/
public interface UsersDao extends Repository<Users, Integer> {
    //方法名稱命名規則
    List<Users> findByUsernameIs(String string);
    List<Users> findByUsernameLike(String string);
    List<Users> findByUsernameAndUserageGreaterThanEqual(String name,Integer age);
    //使用@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);
    //使用@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);
}

2.2.2：測試類

/**
* 測試@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註解完成數據更新

3.1：創建接口

@Query("update Users set userage = ? where userid = ?")
@Modifying //@Modifying 當前語句是一個更新語句
void updateUserAgeById(Integer age,Integer id);

3.2：測試類

/**
* 測試@Query update
*/
@Test
@Transactional
@Rollback(false)
public void test10(){
    this.usersDao.updateUserAgeById(24, 5);
}

五：CrudRepository接口

1：創建接口

/**
* CrudRepository 接口講解
* @author 李偉康
*
*/
public interface UsersDao extends CrudRepository<Users, Integer> {
}

2：測試代碼

/**
* CrudRepository 接口測試
* @author 李偉康
*
*/
@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 李偉康
*
*/
@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：測試代碼

/**
* 對單列做排序處理
*/
@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 接口是我們開發時使用的最多的接口。其特點是可以幫助我們將其他接口的方法的返回值做適配處理。可以使得我們在開發時更方便的使用這些方法。

1：創建接口

/**
* JpaRepository 接口講解
* @author Administrator
*
*/
public interface UsersDao extends JpaRepository<Users, Integer>{
}

2：測試代碼

/**
* JpaRepository 接口測試
* @author 李偉康
*
*/
@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 李偉康
*注意：JpaSpecificationExecutor<Users>:不能單獨使用，需要配合着jpa中的其他接口一起使用
*/
public interface UsersDao extends JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users>{
}

1.2：測試代碼

/**
* 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 

1：創建接口

public interface UsersRepository {
    public Users findUserById(Integer userid);
}

2：使用接口

/**
* 用戶自定義 Repository 接口講解
* @author 李偉康
*/
public interface UsersDao extends JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users>,UsersRepository{
}

3：創建接口實現類

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);
    }
}

4：編寫測試代碼

/**
* JpaRepository 接口測試
* @author 李偉康
*
*/
@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
    //@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;
    }
}

1.3：一對一關聯關係操作

/**
* 一對一關聯關係測試
* @author 李偉康
*
*/
@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);
    }
}

2：一對多的關聯關係

需求：從角色到用戶的一對多的關聯關係

角色：一方

用戶：多方

2.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;
    @ManyToOne()
    @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 + "]";
    }
}

2.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;
    @OneToMany(mappedBy="roles")
    private Set<Users> users = new HashSet<>();
    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 + "]";
    }
}

2.3：一對多的關聯關係操作

/**
* 一對多的關聯關係測試
* @author 李偉康
*
*/
@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;
    @ManyToMany
    //@JoinTable:配置中間表信息
    //joinColumns:建立當前表在中間表中的外鍵字段
    @JoinTable(name="t_roles_menus",joinColumns=@JoinColumn(name="role_id"),inverseJoinColumns=@JoinColumn(name="menu_id"))
    private Set<Menus> menus = new HashSet<>();
    public Set<Menus> getMenus() {
        return menus;
    }
    public void setMenus(Set<Menus> menus) {
        this.menus = menus;
    }
    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 李偉康
*
*/
@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);
        }
    }
}