springdatajpa命名规则_Spring Data JPA

最新推荐文章于 2024-07-08 16:16:33 发布

weixin_39734458

最新推荐文章于 2024-07-08 16:16:33 发布

阅读量226

点赞数

文章标签： springdatajpa命名规则

本文链接：https://blog.csdn.net/weixin_39734458/article/details/111689500

版权

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 注解查询

CrudRepository接口

public interface UsersDao  extends CrudRepository<Users, Integer>{

RepositoryTest测试类

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.Users;

/**
 * Repository
 * 
 * @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(22);
		user.setUsername("赵小丽");
		  this.usersDao.save(user);
	}
	/**
	 * 批量添加数据
	 */
	@Test
	public void test2() {
		Users user = new Users();
		user.setUserage(22);
		user.setUsername("李小四");
		
		Users user1 = new Users();
		user1.setUserage(23);
		user1.setUsername("王小虎");
		List<Users>  list = new ArrayList<Users>();
		list.add(user);
		list.add(user1);
		this.usersDao.save(list);
	}
	/**
	* 根据 ID 查询单条数据
	*/
	@Test
	public void test3(){
		Users users = this.usersDao.findOne(5);
		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("王小红1");
		
	}
}

PagingAndSortingRepository 接口

分页处理

PagingAndSortingRepository接口

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

RepositoryTest测试类

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.Users;

/**
 * Repository
 * 
 * @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);
		}
	}
	/**
	* 对单列做排序处理
	*/
	@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 接口是我们开发时使用的最多的接口。其特点是可以帮助我们将其他接口
的方法的返回值做适配处理。可以使得我们在开发时更方便的使用这些方法。

Dao接口

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

RepositoryTest测试类

import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.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);
		}
	}
	/**
	* 多条件查询 方式一
	* 需求：使用用户姓名以及年龄查询数据
	*/
	@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);
			}
	}
	/**
	* 多条件查询 方式二
	* 需求：使用用户姓名或者年龄查询数据
	*/
	@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);
		}
	}
	/**
	* 需求：查询王姓用户，并且做分页处理
	*/
	@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);
		}
	}
	
}

JpaSpecificationExecutor 接口

/**
* JpaSpecificationExecutor 接口讲解
* @author Administrator
*注意：JpaSpecificationExecutor<Users>:不能单独使用，需要配合着 jpa 中的其他接口一起使用
*/
public interface UsersDao  extends  JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users>{
		
}

JpaRepository接口测试

package com.sxt.test;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.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);
			}
	}
	/**
	* 多条件查询 方式一
	* 需求：使用用户姓名以及年龄查询数据
	*/
	@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);
		}
	}
	/**
	* 多条件查询 方式二
	* 需求：使用用户姓名或者年龄查询数据
	*/
	@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);
		}
	}
	/**
	 * 分页
	* 需求：查询王姓用户，并且做分页处理
	*/
	@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);
				}
			}
	/**
	 * 排序
	* 需求：查询数据库中王姓的用户，并且根据用户 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);
		}
	}
	/**
	 * 分页与排序
	* 需求：查询数据库中王姓的用户，做分页处理，并且根据用户 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 接口

package com.sxt.dao;
import com.sxt.pojo.Users;

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

UsersDao添加继承自定义接口

public interface UsersDao extends JpaRepository<Users,Integer>,JpaSpecificationExecutor<Users>,UsersRepository{


}

UsersDao实现UsersDaoImpl

package com.sxt.dao;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

import com.sxt.pojo.Users;

public class UsersDaoImpl implements UsersRepository {
	
	@PersistenceContext(name="entityManagerFactory")
	@Autowired
	private EntityManager em;
	@Override
	public Users findUserById(Integer userid) {
		System.out.println("MyRepository");
		return this.em.find(Users.class,userid);
	}


}

测试类：

package com.sxt.test;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.Users;

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

关联映射操作

一对一的关联关系
需求：用户与角色的一对一的关联关系
用户：一方
角色：一方
创建 Users 实体

package com.sxt.pojo;

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

/**
 * @author Administrator
 *
 */
@Entity
@Table(name="t_users")
public class Users implements Serializable {
		@Id
		//strategy=GenerationType.IDENTITY 自增长
		@GeneratedValue(strategy=GenerationType.IDENTITY)
		@Column(name="userid")
		private Integer userid;
		@Column(name="username")
		private String username;
		@Column(name="userage")
		private Integer userage;
		
		@OneToOne(cascade=CascadeType.PERSIST)
		//@JoinColumn：就是维护一个外键
		@JoinColumn(name="roles_id")
		private Roles roles;
		
		public Roles getRoles() {
			return roles;
		}
		public void setRoles(Roles roles) {
			this.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 + "]";
		}
		
}

创建 Roles 实体

package com.sxt.pojo;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@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 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 Users getUsers() {
			return users;
		}
		public void setUsers(Users users) {
			this.users = users;
		}
		@Override
		public String toString() {
			return "Roles [roleid=" + roleid + ", rolename=" + rolename + ", users=" + users + "]";
		}
}

一对一关联关系测试

package com.sxt.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.Roles;
import com.sxt.pojo.Users;

/**
* 一对多的关联关系接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
	@Autowired
	private UsersDao usersDao;
	/**
	* 需求：根据用户 ID 查询数据
	*/
	@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);
		}
}

一对多的关联关系

需求：从角色到用户的一对多的关联关系
角色：一方
用户：多方
创建Users实体类

package com.sxt.pojo;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name="t_users")
public class Users {
	@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(cascade=CascadeType.PERSIST)
	@JoinColumn(name="roles_id")
	private Roles roles;
	
	

	public Roles getRoles() {
		return roles;
	}

	public void setRoles(Roles roles) {
		this.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 + "]";
	}

}

创建Roles实体类

package com.sxt.pojo;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@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<>();

	@Override
	public String toString() {
	return "Roles [roleid=" + roleid + ", rolename=" + rolename + "]";
	}
	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;
	}
}

一对多测试类

package com.sxt.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.sxt.dao.UsersDao;
import com.sxt.pojo.Roles;
import com.sxt.pojo.Users;

/**
*一对多的关联关系测试接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
	@Autowired
	private UsersDao usersDao;
	/**
	* 添加用户同时添加角色
	*/
	@Test
	public void test1(){
	//创建角色
	Roles roles = new Roles();
		roles.setRolename("管理员");
		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);
		}
}

多对多的关联关系

需求：一个角色可以拥有多个菜单，一个菜单可以分配多个角色。多对多的关联关系
角色：多方
菜单：多方
创建 Roles 实体

package com.sxt.pojo;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@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(cascade=CascadeType.PERSIST,fetch = FetchType.EAGER)
	//@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;
	}

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

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

Menus实体类

package com.sxt.pojo;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

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

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

	@ManyToMany(mappedBy="menus")
	private Set<Roles> roles = new HashSet<>();

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

RolesDao接口

package com.sxt.dao;

import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

import com.sxt.pojo.Roles;
/**
* 多对多关联关系操作
* @author Administrator
*/
public interface RolesDao  extends  JpaRepository<Roles, Integer>{
		
}

测试类

package com.sxt.test;

import java.util.Set;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.sxt.dao.RolesDao;
import com.sxt.pojo.Menus;
import com.sxt.pojo.Roles;

/**
*多对多的关联关系测试接口测试
* @author Administrator
*
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RepositoryTest {
	@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);
	}
	}
}

Spring Data Redis

Spring Data Redis是较大的Spring数据系列的一部分，它提供了从Spring应用程序轻松配置和访问Redis的功能。
它提供了与存储交互的低级和高级抽象，从而使用户不必担心基础设施问题。

安装环境：

Redis 版本：3.0.0
环境：Linux

搭建整合环境

整合配置文件

<?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"
	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/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 配置读取properties文件的工具类 -->
	<context:property-placeholder location="classpath:redis.properties"/>
	
	<!-- Jedis连接池 -->
	<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
		<property name="maxTotal" value="${redis.pool.maxTotal}"/>
		<property name="maxIdle" value="${redis.pool.maxIdle}"/>
		<property name="minIdle" value="${redis.pool.minIdle}"/>
	</bean>
	<!-- Jedis的连接工厂 -->
	<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
		<property name="hostName" value="${redis.conn.hostName}"/>
		<property name="port" value="${redis.conn.port}"/>
		<property name="poolConfig" ref="poolConfig"/>
	</bean>
	<!-- Redis模板对象 -->
	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
		<property name="connectionFactory" ref="jedisConnectionFactory"/>
		<!-- 序列化器：能够把我们储存的key与value做序列化处理的对象 -->
		<!-- 配置默认的序列化器 -->
		<!-- keySerializer、valueSerializer 配置Redis中的String类型key与value的序列化器 -->
		<!-- HashKeySerializer、HashValueSerializer 配置Redis中的Hash类型key与value的序列化器 -->
		<property name="keySerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
		</property>
		<property name="valueSerializer">
			<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
		</property>
	</bean>
</beans>

redis.properties

redis.pool.maxTotal=20
redis.pool.maxIdle=10
redis.pool.minIdle=5
redis.conn.hostName=192.168.176.131
redis.conn.port=6379

Spring Data Redisd 存储实体对象

package com.bjsxt.pojo;

import java.io.Serializable;

public class Users implements Serializable{
	
	private Integer id;
	private String name;
	private Integer age;
	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;
	}
	@Override
	public String toString() {
		return "Users [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
}

测试代码

package com.bjsxt.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.bjsxt.pojo.Users;

/**
 * Redis测试
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RedisTest {

	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	
	/**
	 * 添加键值对
	 */
	@Test
	public void test1(){
		this.redisTemplate.opsForValue().set("key", "test");
	}
	
	/**
	 * 获取redis中的数据
	 */
	@Test
	public void test2(){
		String str = (String)this.redisTemplate.opsForValue().get("key");
		System.out.println(str);
	}
	
	/**
	 * 添加Users
	 */
	@Test
	public void test3(){
		Users users = new Users();
		users.setAge(30);
		users.setId(1);
		users.setName("张三");
		//更换序列化器
		this.redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
		this.redisTemplate.opsForValue().set("users", users);
	}
	
	/**
	 * 获取Users
	 * 
	 */
	@Test
	public void test4(){
		//更换序列化器
		this.redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
		Users users = (Users)this.redisTemplate.opsForValue().get("users");
		System.out.println(users);
	}

	/**
	 * 添加Users JSON格式
	 */
	@Test
	public void test5(){
		Users users = new Users();
		users.setAge(23);
		users.setId(2);
		users.setName("李四");
		
		this.redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Users.class));
		this.redisTemplate.opsForValue().set("usersjson", users);
	}
	
	/**
	 * 获取Uesrs JSON格式
	 */
	@Test
	public void test6(){
		this.redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Users.class));
		Users users = (Users)this.redisTemplate.opsForValue().get("usersjson");
		System.out.println(users);
	}
}