精华内容
下载资源
问答
  • spring data 简介(一)

    万次阅读 2018-09-05 11:19:48
    Spring Data 概述 JPA Spring Data 概述 Spring Data JPA HelloWorld Repository 接口 Repository 子接口 Spring DataRepository 查询方法定义规范 spring data 支持的关键字 级联查询 Spring Data 概述 ...

    目录

    Spring Data 概述

    JPA Spring Data 概述

    Spring Data JPA  HelloWorld

    Repository 接口

    Repository 子接口

    Spring Data  Repository 查询方法定义规范

    spring data 支持的关键字

    级联查询


    Spring Data 概述

    Spring Data:  Spring 的一个子项目。用于简化数据库访问,支持NoSQL关系数据库存储。其主要目标是使数据库的访问变得方便快捷。

    Spring Data 项目所支持NoSQL存储

          - - MongoDB(文档数据库)

          - - Neo4j (图形数据库)

          - - Redis(键/值存储)

          - - Hbase(列族数据库)

    Spring Data 项目所支持的关系数据存储技术

           - - JDBC

           - - JPA

    JPA Spring Data 概述

    JPA Spring Data:  致力于减少数据访问层(DAO)的开发量。开发者唯一要做的,就只是声明持久层的接口,其他都交给Spring Data JPA 来帮你完成!

    框架怎么可能代替开发者实现业务逻辑呢?比如:当有一个UserDao.findUserById()这样一个方法声明,大致应该能判断出这是根据给定条件的ID查询出满足条件的User对象。Spring Data JPA 做的便是规范方法的名字,根据符合规范的名字来确定方法需要实现什么样的逻辑。

    Spring Data JPA  HelloWorld

    使用Spring Data JPA进行持久层开发需要的四个步骤:

     - 配置Spring 整合 JPA

     - 在Spring 配置文件中配置Spring Data ,让Spring 为声明的接口创建代理对象。配置了<jpa:repositories>后,Spring 初始化容器将会扫描base-package 指定的包目录及其子目录,为继承Repository 或其子接口的接口创建代理对象,并将代理对象注册为Spring Bean ,业务层便可以通过Spring自动封装的特性来直接使用该对象。

     - 声明持久层的接口,该接口继承 Repository ,Repository是一个标记型接口,它不包含任何方法,如必要,Spring Data 可实现Repository其他子接口,其中定义了一些常用的增删改查,以及分页相关的方法。

     - 在接口中声明需要的方法。Spring Data 将根据给定的策略(具体策略稍后讲解)来为其生成实现代码。

    Repository 接口

    1、Repository是一个空接口,即是一个标记接口

    2、若我们定义的接口继承了Repository,则该接口会被IOC容器识别为一个Repository Bean 纳入到IOC容器中,进而可以在该接口中定义满足一定规范的方法

    3、实际上,也可以通@RepositoryDefinition(domainClass=Person.class,idClass=Integer.class)  注解来代替 extends Repository<Person, Integer>

    Repository 子接口

    在eclipse 中选中Repository  ,Ctrl + T  ,有多个子接口和实现类

    继承关系如下:

    ①、Repository  :仅仅是一个标识,表名任何继承它的均为仓库接口类

    ②、CurdRepository : 继承Repository ,实现了一组CURD相关的方法

    ③、PagingAndSortingRepository :继承CurdRepository ,实现了一组分页排序相关的方法

    ④、JpaRepository : 继承PagingAndSortingRepository ,实现一组Jpa 规范相关的方法

    ⑤、自定义 的 XXXRepository :需要继承JpaRepository  ,这样的XxxRepository 接口就具备了通用的数据访问控制层的能力。

    ⑥、JpaSpecificationExecutor :不属于Repository 体系,实现一组JpaCriteria 查询相关的方法

    Spring Data  Repository 查询方法定义规范

    简单查询条件 :查询某一个实体类或是集合

    在Repository  子接口中声明方法:

    ①、不是随便声明的,而需要符合一定的规范

    ②、查询方法以 find | read | get 开头

    ③、涉及条件查询时,条件的属性用条件关键字连接

    ④、要注意的是:条件属性以首字母大写

    ⑤、支持属性的级联查询。若当前类有符合条件的属性,则优先使用,而不使用级联属性。若需要使用级联属性,则属性之间使用_连接

    spring data 支持的关键字

    关键字 方法命名 sql where字句
    And findByNameAndPwd where name= ? and pwd =?
    Or findByNameOrSex where name= ? or sex=?
    Is,Equals findById,findByIdEquals where id= ?
    Between findByIdBetween where id between ? and ?
    LessThan findByIdLessThan where id < ?
    LessThanEquals findByIdLessThanEquals where id <= ?
    GreaterThan findByIdGreaterThan where id > ?
    GreaterThanEquals findByIdGreaterThanEquals where id > = ?
    After findByIdAfter where id > ?
    Before findByIdBefore where id < ?
    IsNull findByNameIsNull where name is null
    isNotNull,NotNull 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、创建address 表

    2、在person实体类中 添加属性

    3、PersonRepository 中

      //where address.id >?
    	List<Person> getByAddressIdGreaterThan(Integer id);

    4、测试类里面进行测试

    ①、先要测试是否生成数据表

    //生成数据表
    	@Test
    	public void testJpa(){
    		
    	}

    ②、测试查询

    //级联查询
    	@Test
    	public void testWords2(){
    		List<Person> persons = personRepository.getByAddressIdGreaterThan(1);
    		System.out.println(persons);
    	}
    	

    ③、结果  为[ ] 是因为 数据表里没有数据,只有字段

    如若:

    person实体类中本来就含有一个address_id 

    在执行级联查询的方法,会报错如下:

    在映射的时候列名重复

    更改如下:

    运行结果:

    含义:支持属性的级联查询。若当前类有符合条件的属性,则优先使用,而不使用级联属性。若需要使用级联属性,

    则属性之间使用_连接

     //where address.id >?
    	List<Person> getByAddress_IdGreaterThan(Integer id);

    查询结果: 连表查询

     

     

    以上是从某视频处所学!

     

     

    展开全文
  • SpringBoot整合SpringDataJPA

    万次阅读 多人点赞 2019-05-23 18:23:05
      SpringData:其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。   SpringData JPA:基于JPA的标准数据进行操作。简化操作持久层的...

    一、SpringBootData JPA介绍
      SpringData:其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。
      SpringData JPA:基于JPA的标准数据进行操作。简化操作持久层的代码。只需要编写接口就可以。
     
     
    二、SpringBoot整合SpringData JPA
     
    1、导入maven依赖
     在原有的SprigBoot的maven依赖的基础下加上JPA的依赖
    在这里插入图片描述
     
    2、application.properties文件中添加配置
    在这里插入图片描述
     
    3、实体类

    import javax.persistence.*;
    
    @Entity
    @Table(name="t_users")
    public class Users {
    
    	@Id	//主键id
    	@GeneratedValue(strategy=GenerationType.IDENTITY)//主键生成策略
    	@Column(name="id")//数据库字段名
    	private Integer id;
    	
    	@Column(name="name")
    	private String name;
    	
    	@Column(name="age")
    	private Integer age;
    	
    	@Column(name="address")
    	private String address;
    
    	@ManyToOne(cascade = CascadeType.PERSIST)	//表示多方
    	@JoinColumn(name ="role_id")	//维护一个外键,外键在Users一侧
    	private Roles roles;
    
    	public Roles getRoles() {
    		return roles;
    	}
    
    	public void setRoles(Roles roles) {
    		this.roles = roles;
    	}
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Integer getAge() {
    		return age;
    	}
    
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    
    	public String getAddress() {
    		return address;
    	}
    
    	public void setAddress(String address) {
    		this.address = address;
    	}
    
    	@Override
    	public String toString() {
    		final StringBuffer sb = new StringBuffer("Users{");
    		sb.append("id=").append(id);
    		sb.append(", name='").append(name).append('\'');
    		sb.append(", age=").append(age);
    		sb.append(", address='").append(address).append('\'');
    		sb.append(", roles=").append(roles);
    		sb.append('}');
    		return sb.toString();
    	}
    }
    

     
    4、编写Dao接口

    import org.springframework.data.jpa.repository.JpaRepository;
    
    import com.bjsxt.pojo.Users;
    /**
     * 参数一 T :当前需要映射的实体
     * 参数二 ID :当前映射的实体中的OID的类型
     *
     */
    public interface UsersRepository extends JpaRepository<Users,Integer> {
    
    }
    

     
    6、在pom文件中添加测试启动器的坐标
    在这里插入图片描述
     
    7、测试
    在这里插入图片描述

     
     
    三、SpringBoot JPA提供的核心接口
     
     1、Repository接口
     2、CrudRepository接口
     3、PagingAndSortingRepository接口
     4、JpaRepository接口
     5、JPASpecificationExecutor接口
     
     
    四、Repository接口的使用
     
     提供了方法名称命名查询方式
     提供了基于@Query注解查询与更新
     
    1、dao层接口(方法名称命名查询方式)

    import com.bjsxt.pojo.Users;
    import org.springframework.data.repository.Repository;
    
    import java.util.List;
    
    /**
     * Repository接口方法名称命名查询
     *
     */
    public interface UsersRepositoryByName extends Repository<Users,Integer> {
        //方法名称必须要遵循驼峰式命名规则,findBy(关键字)+属性名称(首字母大写)+查询条件(首字母大写)
        List<Users> findByName(String name);
    
        List<Users> findByNameAndAge(String name,Integer age);
    
        List<Users> findByNameLike(String name);
    
    }
    

     
    2、测试

    /**
    	 * Repository
    	 */
    	@Test
    	public void UsersRepositoryByName(){
    		List<Users> list=this.usersRepositoryByName.findByName("张三");
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	@Test
    	public void findByNameAndAge(){
    		List<Users> list=this.usersRepositoryByName.findByNameAndAge("张三",20);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	@Test
    	public void findByNameLike() {
    		List<Users> list = this.usersRepositoryByName.findByNameLike("张%");
    		for (Users users : list) {
    			System.out.println(users);
    		}
    	}
    

     
    3、dao层接口编写(基于@Query注解查询与更新)

    import com.bjsxt.pojo.Users;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.Modifying;
    import org.springframework.data.jpa.repository.Query;
    
    
    import java.util.List;
    
    /**
     * 〈一句话功能简述〉<br> 
     *  Repository    @Query
     *
     * @author admin
     * @create 2019/5/22
     * @since 1.0.0
     */
    public interface UsersRepositoryQueryAnnotation extends JpaRepository<Users,Integer> {
        @Query("from Users where name = ?")
        List<Users> queryByNameUseHQL(String name);
    
        @Query(value = "select * from t_user where name=?",nativeQuery = true)
        List<Users> queryByNameUseSQL(String name);
    
        @Query("update Users set name=? where id=?")
        @Modifying  //需要执行一个更新操作
        void updateUsersNameById(String name,Integer id);
    
    }
    

     
    4、测试

    	/**
    	 * Repository--@Query测试
    	 */
    	@Test
    	public void testQueryByNameUseSQL() {
    		List<Users> list = this.usersRepositoryQueryAnnotation.queryByNameUseSQL("张三");
    		for (Users users : list) {
    			System.out.println(users);
    		}
    	}
    
    	/**
    	 * Repository--@Query测试
    	 */
    	@Test
    	@Transactional //@Transactional与@Test 一起使用时 事务是自动回滚的。
    	@Rollback(false) //取消自动回滚
    	public void testUpdateUsersNameById() {
    		this.usersRepositoryQueryAnnotation.updateUsersNameById("张三三", 1);
    	}
    

     
     
    五、CrudRepository接口的使用
      CrudRepository接口,主要是完成一些增删改查的操作。注意:CrudRepository接口继承了Repository接口
     
    1、编写dao层接口

    import com.bjsxt.pojo.Users;
    import org.springframework.data.repository.CrudRepository;
    
    public interface UsersRepositoryCrudRepository extends CrudRepository<Users,Integer> {
    }
    
    

     
    2、测试

    @Test
    	public void testCrudRepositorySave() {
    		Users users=new Users();
    		users.setName("青衫");
    		users.setAge(30);
    		users.setAddress("湖南怀化");
    		this.usersRepositoryCrudRepository.save(users);
    	}
    
    	@Test
    	public void testCrudRepositoryUpdate() {
    		Users users=new Users();
    		users.setId(4);
    		users.setName("青");
    		users.setAge(18);
    		users.setAddress("怀化");
    		this.usersRepositoryCrudRepository.save(users);
    	}
    
    	@Test
    	public void testCrudRepositoryFindOne() {
    
    		Users users=this.usersRepositoryCrudRepository.findOne(4);
    		System.out.println(users);
    	}
    
    	@Test
    	public void testCrudRepositoryFindAll() {
    		List<Users> list= (List<Users>) this.usersRepositoryCrudRepository.findAll();
    		for (Users user:list){
    			System.out.println(user);
    		}
    	}
    
    	@Test
    	public void testCrudRepositoryDeleteById() {
    		this.usersRepositoryCrudRepository.delete(4);
    		
    	}
    

     
     
    六、PagingAndSortingRepository接口的使用
     该接口提供了分页与排序的操作,注意:该接口继承了CrudRepository接口
     
    1、编写dao层

    import com.bjsxt.pojo.Users;
    import org.springframework.data.repository.PagingAndSortingRepository;
    
    public interface UsersRepositoryPagingAndSorting extends PagingAndSortingRepository<Users,Integer> {
    
    }
    

     
    2、测试

    @Test
    	public void testPagingAndSortingRepositorySort() {
    		//Order	定义了排序规则
    		Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
    		//Sort对象封装了排序规则
    		Sort sort=new Sort(order);
    		List<Users> list= (List<Users>) this.usersRepositoryPagingAndSorting.findAll(sort);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	@Test
    	public void testPagingAndSortingRepositoryPaging() {
    		//Pageable:封装了分页的参数,当前页,煤业显示的条数。注意:它的当前页是从0开始
    		//PageRequest(page,size):page表示当前页,size表示每页显示多少条
    		Pageable pageable=new PageRequest(1,2);
    		Page<Users> page=this.usersRepositoryPagingAndSorting.findAll(pageable);
    		System.out.println("数据的总条数:"+page.getTotalElements());
    		System.out.println("总页数:"+page.getTotalPages());
    		List<Users> list=page.getContent();
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	@Test
    	public void testPagingAndSortingRepositorySortAndPaging() {
    		Sort sort=new Sort(new Sort.Order(Sort.Direction.DESC,"id"));
    		Pageable pageable=new PageRequest(0,2,sort);
    		Page<Users> page=this.usersRepositoryPagingAndSorting.findAll(pageable);
    		System.out.println("数据的总条数:"+page.getTotalElements());
    		System.out.println("总页数:"+page.getTotalPages());
    		List<Users> list=page.getContent();
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    

     
     
    七、JpaRepository接口
     
     该接口继承了PagingAndSortingRepository。对继承的父接口中方法的返回值进行适配。
     
    1、dao层接口编写

    /**
     * 参数一 T :当前需要映射的实体
     * 参数二 ID :当前映射的实体中的OID的类型
     *
     */
    public interface UsersRepository extends JpaRepository<Users,Integer> {
    
    }
    

     
    2、测试

    /**
    	 * JpaRepository	排序测试
    	 */
    	@Test
    	public void testJpaRepositorySort() {
    		//Order	定义了排序规则
    		Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
    		//Sort对象封装了排序规则
    		Sort sort=new Sort(order);
    		List<Users> list= this.usersRepository.findAll(sort);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    

     
     
    八、JPASpecificationExecutor接口
     
     该接口主要是提供了多条件查询的支持,并且可以在查询中添加排序与分页。注意JPASpecificationExecutor是单独存在的。完全独立
     
    1、dao层接口编写

    import com.bjsxt.pojo.Users;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
    
    /**
     * 〈一句话功能简述〉<br> 
     *  JpaSpecificationExecutor
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    public interface UserRepositorySpecification extends JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users> {
    }
    

     
    2、测试

    /**
    	 * JpaSpecificationExecutor		单条件查询
    	 */
    	@Test
    	public void testJpaSpecificationExecutor1() {
    		/**
    		 * Specification:用于封装查查询条件
    		 */
    		Specification<Users> spec=new Specification<Users>() {
    			//Predicate:封装了单个查询条件
    
    			/**
    			 * @param root		对查询对象属性的封装
    			 * @param criteriaQuery	封装了我们要执行的查询中的各个部分的信息,select from order
    			 * @param criteriaBuilder	查询条件的构造器
    			 * @return
    			 */
    			@Override
    			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    				//where name="张三"
    				/**
    				 * 参数一:查询的属性
    				 * 参数二:条件的值
    				 */
    				Predicate predicate=criteriaBuilder.equal(root.get("name"),"张三");
    				return predicate;
    			}
    		};
    		List<Users> list=this.userRepositorySpecification.findAll(spec);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	/**
    	 * JpaSpecificationExecutor		多条件查询方式一
    	 */
    	@Test
    	public void testJpaSpecificationExecutor2() {
    		/**
    		 * Specification:用于封装查查询条件
    		 */
    		Specification<Users> spec=new Specification<Users>() {
    			//Predicate:封装了单个查询条件
    
    			/**
    			 * @param root		对查询对象属性的封装
    			 * @param criteriaQuery	封装了我们要执行的查询中的各个部分的信息,select from order
    			 * @param criteriaBuilder	查询条件的构造器
    			 * @return
    			 */
    			@Override
    			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    				//where name="张三" and age=20
    				/**
    				 * 参数一:查询的属性
    				 * 参数二:条件的值
    				 */
    				List<Predicate> list=new ArrayList<>();
    				list.add(criteriaBuilder.equal(root.get("name"),"张三"));
    				list.add(criteriaBuilder.equal(root.get("age"),20));
    				Predicate[] arr=new Predicate[list.size()];
    				return criteriaBuilder.and(list.toArray(arr));
    			}
    		};
    		List<Users> list=this.userRepositorySpecification.findAll(spec);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    
    	/**
    	 * JpaSpecificationExecutor		多条件查询方式二
    	 */
    	@Test
    	public void testJpaSpecificationExecutor3() {
    		/**
    		 * Specification:用于封装查查询条件
    		 */
    		Specification<Users> spec=new Specification<Users>() {
    			//Predicate:封装了单个查询条件
    
    			/**
    			 * @param root		对查询对象属性的封装
    			 * @param criteriaQuery	封装了我们要执行的查询中的各个部分的信息,select from order
    			 * @param criteriaBuilder	查询条件的构造器
    			 * @return
    			 */
    			@Override
    			public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    				//where name="张三" and age=20
    				/**
    				 * 参数一:查询的属性
    				 * 参数二:条件的值
    				 */
    				/*List<Predicate> list=new ArrayList<>();
    				list.add(criteriaBuilder.equal(root.get("name"),"张三"));
    				list.add(criteriaBuilder.equal(root.get("age"),20));
    				Predicate[] arr=new Predicate[list.size()];*/
    				//(name='张三' and age=20) or id=2
    				return criteriaBuilder.or(criteriaBuilder.and(criteriaBuilder.equal(root.get("name"),"张三"),criteriaBuilder.equal(root.get("age"),20)),criteriaBuilder.equal(root.get("id"),1));
    			}
    		};
    
    		Sort sort=new Sort(new Sort.Order(Sort.Direction.DESC,"id"));
    		List<Users> list=this.userRepositorySpecification.findAll(spec,sort);
    		for (Users users:list){
    			System.out.println(users);
    		}
    	}
    

     
     
    九、关联映射操作
     
    1、一对多的关联关系
      需求:角色与用户的一对多的关联关系
      角色:一方
      用户:多方
     
    2、实体类

    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 〈〉
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    @Entity
    @Table(name = "t_roles")
    public class Roles {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "role_id")
        private Integer roleId;
        @Column(name = "role_name")
        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;
        }
    
        public Set<Users> getUsers() {
            return users;
        }
    
        public void setUsers(Set<Users> users) {
            this.users = users;
        }
    
    
    }
    

     

    package com.bjsxt.pojo;
    
    import javax.persistence.*;
    
    @Entity
    @Table(name="t_users")
    public class Users {
    
    	@Id	//主键id
    	@GeneratedValue(strategy=GenerationType.IDENTITY)//主键生成策略
    	@Column(name="id")
    	private Integer id;
    	
    	@Column(name="name")
    	private String name;
    	
    	@Column(name="age")
    	private Integer age;
    	
    	@Column(name="address")
    	private String address;
    
    	@ManyToOne(cascade = CascadeType.PERSIST)	//表示多方
    	@JoinColumn(name ="role_id")	//维护一个外键,外键在Users一侧
    	private Roles roles;
    
    	public Roles getRoles() {
    		return roles;
    	}
    
    	public void setRoles(Roles roles) {
    		this.roles = roles;
    	}
    
    	public Integer getId() {
    		return id;
    	}
    
    	public void setId(Integer id) {
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Integer getAge() {
    		return age;
    	}
    
    	public void setAge(Integer age) {
    		this.age = age;
    	}
    
    	public String getAddress() {
    		return address;
    	}
    
    	public void setAddress(String address) {
    		this.address = address;
    	}
    
    	@Override
    	public String toString() {
    		final StringBuffer sb = new StringBuffer("Users{");
    		sb.append("id=").append(id);
    		sb.append(", name='").append(name).append('\'');
    		sb.append(", age=").append(age);
    		sb.append(", address='").append(address).append('\'');
    		sb.append(", roles=").append(roles);
    		sb.append('}');
    		return sb.toString();
    	}
    }
    
    

     
    3、dao层接口编写

    /**
     * 参数一 T :当前需要映射的实体
     * 参数二 ID :当前映射的实体中的OID的类型
     *
     */
    public interface UsersRepository extends JpaRepository<Users,Integer> {
    
    }
    

     
    4、测试

    /**
     * Copyright (C), 2015-2019, XXX有限公司
     * FileName: ManyToManyTest
     * Author:   admin
     * Date:     2019/5/23 14:19
     * Description:
     * History:
     * <author>          <time>          <version>          <desc>
     * 作者姓名           修改时间           版本号              描述
     */
    package com.bjsxt.test;
    
    import com.bjsxt.App;
    import com.bjsxt.dao.RolesRepository;
    import com.bjsxt.pojo.Menus;
    import com.bjsxt.pojo.Roles;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 多对多的关联关系的测试
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringBootTest(classes = App.class)
    public class ManyToManyTest {
    
        @Autowired
        private RolesRepository rolesRepository;
    
        /**
         * 添加测试
         */
        @Test
        public void testSave(){
            //创建角色对象
            Roles roles=new Roles();
            roles.setRoleName("项目经理");
            //创建菜单对象
            Menus menus=new Menus();
            menus.setMenusName("xxxx管理系统");
            menus.setFatherId(0);
    
            Menus menus2=new Menus();
            menus2.setFatherId(1);
            menus2.setMenusName("项目管理");
            //关联
            roles.getMenus().add(menus);
            roles.getMenus().add(menus2);
            menus.getRoles().add(roles);
            menus2.getRoles().add(roles);
            //保存
            this.rolesRepository.save(roles);
        }
    
        /**
         * 查询操作
         */
        @Test
        public void testFind(){
            Roles roles=this.rolesRepository.findOne(2);
            System.out.println(roles.getRoleName());
            Set<Menus> menus=roles.getMenus();
            for (Menus menu:menus){
                System.out.println(menu);
            }
        }
    }
    
    

    &nbsp;
    5、多对多的关联关系
    &nbsp;
     角色与菜单多对多关联关系
     菜单:多方
     角色:多方
     
    6、实体类

    /**
     * Copyright (C), 2015-2019, XXX有限公司
     * FileName: Menus
     * Author:   admin
     * Date:     2019/5/23 14:06
     * Description:
     * History:
     * <author>          <time>          <version>          <desc>
     * 作者姓名           修改时间           版本号              描述
     */
    package com.bjsxt.pojo;
    
    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 〈〉
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    @Entity
    @Table(name = "t_menus")
    public class Menus {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "menus_id")
        private Integer menusId;
        @Column(name = "menus_name")
        private String menusName;
        @Column(name = "menus_url")
        private String menusUrl;
        @Column(name = "father_id")
        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() {
            final StringBuffer sb = new StringBuffer("Menus{");
            sb.append("menusId=").append(menusId);
            sb.append(", menusName='").append(menusName).append('\'');
            sb.append(", menusUrl='").append(menusUrl).append('\'');
            sb.append(", fatherId=").append(fatherId);
            sb.append('}');
            return sb.toString();
        }
    }
    
    

     

    /**
     * Copyright (C), 2015-2019, XXX有限公司
     * FileName: Roles
     * Author:   admin
     * Date:     2019/5/23 11:02
     * Description:
     * History:
     * <author>          <time>          <version>          <desc>
     * 作者姓名           修改时间           版本号              描述
     */
    package com.bjsxt.pojo;
    
    import javax.persistence.*;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 〈〉
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    @Entity
    @Table(name = "t_roles")
    public class Roles {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "role_id")
        private Integer roleId;
        @Column(name = "role_name")
        private String roleName;
    
        @OneToMany(mappedBy = "roles")
        private Set<Users> users=new HashSet<>();
    
        @ManyToMany(cascade = CascadeType.PERSIST,fetch = FetchType.EAGER)
        //映射中间表  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;
        }
    
        public Set<Users> getUsers() {
            return users;
        }
    
        public void setUsers(Set<Users> users) {
            this.users = users;
        }
    }
    
    

     
    7、dao层接口

    /**
     * Copyright (C), 2015-2019, XXX有限公司
     * FileName: RolesRepository
     * Author:   admin
     * Date:     2019/5/23 14:21
     * Description:
     * History:
     * <author>          <time>          <version>          <desc>
     * 作者姓名           修改时间           版本号              描述
     */
    package com.bjsxt.dao;
    
    import com.bjsxt.pojo.Roles;
    import org.springframework.data.jpa.repository.JpaRepository;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 〈〉
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    public interface RolesRepository extends JpaRepository<Roles,Integer> {
    
    }
    
    

     
    8、测试

    /**
     * Copyright (C), 2015-2019, XXX有限公司
     * FileName: ManyToManyTest
     * Author:   admin
     * Date:     2019/5/23 14:19
     * Description:
     * History:
     * <author>          <time>          <version>          <desc>
     * 作者姓名           修改时间           版本号              描述
     */
    package com.bjsxt.test;
    
    import com.bjsxt.App;
    import com.bjsxt.dao.RolesRepository;
    import com.bjsxt.pojo.Menus;
    import com.bjsxt.pojo.Roles;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br> 
     * 多对多的关联关系的测试
     *
     * @author admin
     * @create 2019/5/23
     * @since 1.0.0
     */
    @RunWith(SpringJUnit4ClassRunner.class)
    @SpringBootTest(classes = App.class)
    public class ManyToManyTest {
    
        @Autowired
        private RolesRepository rolesRepository;
    
        /**
         * 添加测试
         */
        @Test
        public void testSave(){
            //创建角色对象
            Roles roles=new Roles();
            roles.setRoleName("项目经理");
            //创建菜单对象
            Menus menus=new Menus();
            menus.setMenusName("xxxx管理系统");
            menus.setFatherId(0);
    
            Menus menus2=new Menus();
            menus2.setFatherId(1);
            menus2.setMenusName("项目管理");
            //关联
            roles.getMenus().add(menus);
            roles.getMenus().add(menus2);
            menus.getRoles().add(roles);
            menus2.getRoles().add(roles);
            //保存
            this.rolesRepository.save(roles);
        }
    
        /**
         * 查询操作
         */
        @Test
        public void testFind(){
            Roles roles=this.rolesRepository.findOne(2);
            System.out.println(roles.getRoleName());
            Set<Menus> menus=roles.getMenus();
            for (Menus menu:menus){
                System.out.println(menu);
            }
        }
    }
    
    
    展开全文
  • SpringData课程

    万人学习 2015-06-01 14:58:28
    Spring Data 是 Spring 的一个子项目。用于简化数据库访问,支持NoSQL 和...使用 SpringData 可以大幅减少数据访问层 (DAO) 的开发量. 开发者唯一要做的,就是声明持久层接口,其他都交给 Spring Data JPA 来帮你完成!
  • Spring Data实战

    千次下载 热门讨论 2014-11-13 10:57:51
    Spring Data实战》介绍了Spring Data、Repository、Querydsl的基础理念,然后阐述了借助Spring Data如何简化NoSQL和大数据的访问,并且涵盖了使用Spring Roo和Spring Data REST导出功能如何实现应用的快速开发,除...
  • Spring Data JPA 与Spring Data mongodb

    千次阅读 2019-03-06 20:46:40
    Spring Data JPA 与Spring Data mongodb 都提供了自定义方法的规则,如下 如果要看JPA的规则看这篇文章 https://blog.csdn.net/xiaoxin0630/article/details/88252548 按照findByXXX,findByXXXAndYYY、...

    Spring Data JPA 与Spring Data mongodb

    都提供了自定义方法的规则,如下

    如果要看JPA的规则看这篇文章

    https://blog.csdn.net/xiaoxin0630/article/details/88252548

    按照findByXXX,findByXXXAndYYY、countByXXXAndYYY等规则定义方法,实现查询

     

    CmsPage findByPageName(String pageName);这个根据name查询

    public interface CmsPageRepository extends MongoRepository<CmsPage,String> {
    //根据页面名称查询
    CmsPage findByPageName(String pageName);
    //根据页面名称和类型查询
    CmsPage findByPageNameAndPageType(String pageName,String pageType);
    //根据站点和页面类型查询记录数
    int countBySiteIdAndPageType(String siteId,String pageType);
    //根据站点和页面类型分页查询
    Page<CmsPage> findBySiteIdAndPageType(String siteId,String pageType, Pageable pageable);
    }

     

    展开全文
  • Spring Data JPA 106精讲

    千人学习 2019-08-02 17:28:32
    使用 SpringData 可以大幅减少数据访问层 (DAO) 的开发量. 开发者要做的,就是声明持久层接口,其他都交给 Spring Data JPA 来帮你完成!本套课程从最基础JPA到SpringData JPA面面俱到!一共有106讲, 本系列课程会...
  • 什么是SpringData JPA SpringData JPA的配置 SpringData JPA接口继承 SpringData JPA查询方式(排序,分页) 一、SpringData JPA SpringData是一个用于简化数据库访问,支持云服务的开源框架。目标是使数据库...

    目录:

    • 什么是SpringData JPA
    • SpringData JPA的配置
    • SpringData JPA接口继承
    • SpringData JPA查询方式(排序,分页)

    一、SpringData JPA

    SpringData是一个用于简化数据库访问,支持云服务的开源框架。目标是使数据库访问变得方便快捷。公司的ORM框架,均采用SpringData JPA。

    这时候你可能会有疑问,什么是SpringData,什么是JPA,两者之间又有什么关系呢?

     

    刚刚提到,SpringData是数据库开源框架,包含对关系数据库,非关系数据库,云数据服务访问支持等。

    1.1、SpringData包含模块

    1. Spring Data for Apache Cassandra
    2. Spring Data Commons
    3. Spring Data Couchbase
    4. Spring Data Elasticsearch
    5. Spring Data Envers
    6. Spring Data for Pivotal GemFire
    7. Spring Data Graph
    8. Spring Data JDBC
    9. Spring Data JDBC Extensions
    10. Spring Data JPA
    11. Spring Data LDAP
    12. Spring Data MongoDB
    13. Spring Data Neo4J
    14. Spring Data Redis
    15. Spring Data REST
    16. Spring Data for Apache Solr
    17. Spring for Apache Hadoop

     

    SpringData大概理解清楚了,接下来了解一下JPA。

    JPA的全称是Java Persistence API,Persistence 是持久化的意思。所以,中文全称是【JAVA对象持久化的 API】。简单来说,可以理解为是一种JAVA的标准规范,这个规范为JAVA对象的持久化制定了一些标准的接口。

    要注意的是,JPA只是一个接口规范,而不是实现。具体实现由各供应商来完成,例如Hibernate,TopLink,OpenJPA都很好地实现了JPA接口。

     

    1.2、Hibernate和JPA的关系

    JPA是Hibernate的一个抽象,提供 一些编程的API接口,但具体实现则由ORM厂商提供实现。

     

    展开全文
  • Spring Data 什么是Spring Data 理解

    千次阅读 2020-02-23 00:27:03
    Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型,同时仍保留底层数据存储的特​​殊特性。 它使数据访问技术,关系数据库和非关系数据库,map-reduce框架和基于云的数据服务变得简单易用。这...
  • Spring Data Jpa 概述(Spring Data Jpa 1)

    万次阅读 2016-10-27 14:50:01
    1、Spring Data Jpa是什么  它是Spring基于ORM 框架、 JPA规范封装的一套JPA应用框架,可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能, 且易于扩展!学习并使用...
  • Spring Boot 2.0之Spring Data和JPA

    千人学习 2018-11-14 15:52:43
    基于Spring Boot 2.0.2讲解了如何在Spring Boot中使用Spring Data和JPA。对于Spring Data主要讲解了几个Respository和自定义Respository;对于JPA主要讲解了几种关联关系,多对一、一对多、多对多等。
  • 源码 GitHub: ...SpringDataJPA支持自定义关键字查询,在方法中含有关键字,SpringDataJPA会为你自动生成SQL SpringDataJPA提供的关键字 关键字 方法名...
  • 源码 GitHub: ...SpringDataJPA是什么? SpringDataJPA是Spring提供的持久层的解决方案,Spring Data JPA旨在通过减少实际需要的工作量来显着改善数据访问层的实现 SpringDa...
  • Spring DataSpring Data JPA详解

    千次阅读 2018-09-23 10:33:58
    Spring Data 是持久层通用解决方案,支持 关系型数据库 Oracle、MySQL、非关系型数据库NoSQL、Map-Reduce 框架、云基础数据服务 、搜索服务等等 。 Commons - 提供共享的基础框架,适合各个子项目使用,支持跨数据库...
  • SpringDataJpa使用详解

    万次阅读 2020-02-26 14:16:46
    SpringDataJpa==Jpa规范+Hibernate底层 为什么要用jpa Jpa适合什么样的项目呢?我觉得适合非互联网项目,或者说中小型项目,或者说对sql优化不高的项目,或者说需求变更不是太频繁的项目。我们可以一个项目中mybatis...
  • Spring Data REST 快速构建 restful api 应用 Spring Data REST 快速构建 restful api 应用 什么是Spring Data REST restful api 实现 添加依赖 定义domain 定义 Repository 配置 测试 小功能 什么是Spring...
  • Spring Data JPA

    千次阅读 2019-08-09 13:45:03
    Spring Data JPA 入门
  • Spring Data 注解介绍

    千次阅读 2019-07-25 15:23:56
    Spring DataSpring 的一个子项目,用于简化数据库访问。Spring Data提供了对数据存储技术的抽象。使业务逻辑代码可以更加独立于底层的持久化实现。目前Spring Data支持NoSQL和关系数据库存储。 在本文中,我们将...
  • SpringDataJpa:JpaRepository增删改查

    万次阅读 多人点赞 2017-11-17 08:32:19
    基本查询也分为两种,一种是spring data默认已经实现,一种是根据查询的方法来自动解析成SQL。 预先生成方法 spring data jpa 默认预先生成了一些基本的CURD的方法,例如:增、删、改等等 继承JpaRepository ...
  • Spring Boot 之Spring data JPA简介

    万次阅读 2020-02-25 08:45:18
    文章目录添加依赖添加entity bean创建 DaoSpring Data Configuration测试 Spring Boot 之Spring data JPA简介 JPA的全称是Java Persistence API (JPA),他是一个存储API的标准,而Spring data JPA就是对JPA的一种...
  • Spring Boot整合Spring Data JPA详解

    千次阅读 2020-03-01 22:42:48
    Spring Boot整合Spring Data JPA理解 官方文档: Spring Data JPA 官方文档 一、 Sping Data JPA 简介 在此之前我们首先来认识一下,**Spring Data JPA** 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的JPA ...
  • Spring DataSpring MVC的基础知识

    千次阅读 2020-04-15 18:27:10
    Spring Data Spring MVC 原理及实现 Spring Data Spring 提供集成关系数据库、noSQL 数据库进行数据操作的一套完整解决方案 Spring Data Spring Data JDBC Spring Data JPA Spring Data MongoDB Spring ...
  • spring dataSpring Data JPA

    万次阅读 2013-12-02 23:52:49
    Spring Data 是一些令人兴奋的技术公司和开发人员开发的,让用新的数据库访问技术使用更方便。包含了多个子项目。 http://spring.io/guides/gs/accessing-data-jpa/ 定义简单的实体类Customer: //@Entity...
  • 源码 GitHub: ...SpringDataJPA支持关键字查询,继承Repository或者继承其子接口的接口中声明方法,方法名中含有关键字,即可根据方法名自动生成SQL SpringDataJPA支...
  • SpringCloud集成Spring Data Redis

    千次阅读 2019-03-10 22:02:18
    文章目录Spring Data Redis源码springcloud...  如同使用SpringData进行关系型数据库访问一样,使用Spring Data Redis的第一步就是连接到Redis服务器。要想实现连接,就需要获取RedisConnection,而获取RedisConne...
  • SpringCloud集成Spring Data JPA

    千次阅读 2019-03-10 16:48:51
    文章目录Spring Data源码springcloud-parent2父Maven模块spring-data子Maven模块分析 Spring Data   Spring DataSpring家族中最重要的核心成员之一,在Spring Data中,其专门为Spring提供了用于数据访问的抽象...
  • Spring Data的使命是为数据访问提供熟悉且一致的基于Spring的编程模型,同时仍保留底层数据存储的特​​殊特性。 它使数据访问技术,关系数据库和非关系数据库,map-reduce框架和基于云的数据服务变得简单易用。这是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,018
精华内容 23,607
关键字:

springdata

spring 订阅