Spring Data JPA 基本使用

接口说明

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=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(关键字)+属性名称(属性名称的首字母大写)+查询条件(首字母大写)

创建接口

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

/**
@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代表不能为空 。

 setFirstResult ,setMaxResults