dao层只要继承Jpa的接口,就有了封装好的增删改查
支持本地查询,自定义查询,jpql等
实体类加@Entity,@Table,主键注解,主键策略,列注解,关联映射注解,忽略json序列化为空的值的注解等等,基本都是注解,就可以完成映射
pom
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.xyy</groupId>
<artifactId>cache</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>cache</name>
<description>Demo project for Spring Boot</description>
<packaging>jar</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--alibb数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.31</version>
</dependency>
<!--ceshi-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--自动提示-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
以shiro的User,role,permission,user_role,role_permission五张表为例子,user_role表有两个外键,role_permission也有两个外键,分别对应他们的主键
User
package com.xyy.cache.bean.mysqljpa;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import javax.persistence.*;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;
import java.io.Serializable;
import java.util.List;
@JsonIgnoreProperties(value = { "hibernateLazyInitializer", "handler" })
@Entity
@Table(name = "user")
public class User implements Serializable {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
@Column(name = "id")
private Integer uid;
@NotEmpty(message = "账号不能为空")
@Size(min=3, max=20)
@Column(name = "username",nullable = false, length = 20, unique = true)
private String username;
@NotEmpty(message = "密码不能为空")
@Size(max=100)
@Column(name = "password")
private String password;
//1、关系维护端,负责多对多关系的绑定和解除
//2、@JoinTable注解的name属性指定关联表的名字,joinColumns指定外键的名字,关联到关系维护端(User)
//3、inverseJoinColumns指定外键的名字,要关联的关系被维护端(Authority)
//4、其实可以不使用@JoinTable注解,默认生成的关联表名称为主表表名+下划线+从表表名,
//即表名为user_authority
//关联到主表的外键名:主表名+下划线+主表中的主键列名,即user_id
//关联到从表的外键名:主表中用于关联的属性名+下划线+从表的主键列名,即authority_id
//主表就是关系维护端对应的表,从表就是关系被维护端对应的表
@ManyToMany(fetch = FetchType.LAZY) //多对多
@JoinTable( //jointable维护方加此注释
name="user_role", //name是表名,
//joincolumns需要将此entity中的什么字段添加到表的什么字段,name是存储在多对多关系表中的字段名,referencedColumnName为此外键
joinColumns={@JoinColumn(name="user_id", referencedColumnName="id")},
//inverseJoinColumns,name字段是关系entity Role的id以role_id存储在关系表user_role中
inverseJoinColumns={@JoinColumn(name="role_id", referencedColumnName="id")})
private List<Role> roles;
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@JsonBackReference
public List<Role> getRoles() {
return roles;
}
public void setRoles(List<Role> roles) {
this.roles = roles;
}
public User(@NotEmpty(message = "账号不能为空") @Size(min = 3, max = 20) String username, @NotEmpty(message = "密码不能为空") @Size(max = 100) String password) {
this.username = username;
this.password = password;
}
public User() {
}
@Override
public String toString() {
return "User{" +
"uid=" + uid +
", username='" + username + '\'' +
", password='" + password + '\'' +
", roles=" + roles +
'}';
}
}
UserRepository
package com.xyy.cache.repository;
import com.xyy.cache.bean.mysqljpa.User;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Transactional
@Repository
public interface UserRepository extends JpaRepository<User,Integer> {
//1.Jpa命名规范,查询
//通过账户和密码查询用户
User findByUsernameAndPassword(String username,String password);
User findByUsername(String username);
//本地查询,命名参数查询
@Modifying
@Query(value = "update user set username = ?1 where id = ?2",nativeQuery = true)
int updateUsernameById(String userName,Integer id);
//自定义repository。手写sql,nativeQyery指是否使用原生sql查询
//在更新数据的情况下不能单独使用query,要加modify注解
//更好的支持多表查询的工具框架 QueryDSL
//2.本地查询
//3.使用仓库封装的常见增删改查
//List<User> findAll();
//4.分页和排序
void deleteById(Integer id);
List<User> findAll();
Page<User> findAll(Pageable pageable);
List<User> findAll(Sort sort);
@Query(value = "select * from user u where u.id in (select user_id from user_role where role_id > ?1)",nativeQuery = true)
List<User> findByUidGreaterThan(@Param(value = "id") Integer id);
}
UserService
package com.xyy.cache.service;
import com.xyy.cache.bean.mysqljpa.Role;
import com.xyy.cache.bean.mysqljpa.User;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface UserService {
public void deleteById(Integer id);
User findByUsername(String username);
/** 增加*/
public void save(User user);
/** 更新*/
public int updateUsernameById(String username,Integer id);
/** 查询单个*/
public User findById(Integer id);
List<User> findAll();
User findByUsernameAndPassword(String username,String password);
Page<User> findAll(Pageable pageable);
List<User> findAll(Sort sort);
List<User> findByUidGreaterThan(@Param(value = "id") Integer id);
}
实现
package com.xyy.cache.service.Impl;
import com.alibaba.fastjson.JSON;
import com.xyy.cache.repository.UserRepository;
import com.xyy.cache.bean.mysqljpa.User;
import com.xyy.cache.service.UserService;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserRepository userRepository;
@Override
public void deleteById(Integer id) {
userRepository.deleteById(id);
}
@Override
public User findByUsername(String username) {
return userRepository.findByUsername(username);
}
@Override
public void save(User user) {
User user1=userRepository.save(user);
System.out.println(user1);
}
@Override
public int updateUsernameById(String username,Integer id) {
return userRepository.updateUsernameById(username,id);
}
@Override
public User findById(Integer id) {
Optional<User> one = userRepository.findById(id);
if(one.isPresent()){
System.out.println(one.get());
return one.get();
}else {
return null;
}
}
@Override
public User findByUsernameAndPassword(String userName, String password) {
return userRepository.findByUsernameAndPassword(userName,password);
}
@Override
public Page<User> findAll(Pageable pageable) {
Page<User> p=userRepository.findAll(pageable);
return p;
}
@Override
public List<User> findAll(Sort sort) {
return userRepository.findAll(sort);
}
@Override
public List<User> findByUidGreaterThan(Integer id) {
return userRepository.findByUidGreaterThan(id);
}
}
application.yml
服务端口
server:
port: 8082
#连接数据库
spring:
datasource:
username: root
password: 123456
url: jdbc:mysql://localhost:3306/blog?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT%2B8
driver-class-name: com.mysql.cj.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource #使用阿里数据源
jpa:
hibernate:
ddl-auto: update
show-sql: true
database-platform:
role
package com.xyy.cache.bean.mysqljpa;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import javax.persistence.*;
import java.util.List;
import java.util.Set;
@JsonIgnoreProperties(value = { "hibernateLazyInitializer", "handler" })
@Entity
@Table(name = "role")
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Integer rid;
@Column(name = "name")
private String rname;
@ManyToMany(fetch = FetchType.LAZY) //多对多
@JoinTable( //jointable维护方加此注释
name="role_permission", //name是表名,
//joincolumns需要将此entity中的什么字段添加到表的什么字段,name是存储在多对多关系表中的字段名,referencedColumnName为此外键
joinColumns={@JoinColumn(name="role_id", referencedColumnName="id")},
//inverseJoinColumns,name字段是关系entity Role的id以role_id存储在关系表user_role中
inverseJoinColumns={@JoinColumn(name="permission_id", referencedColumnName="id")})
private Set<Permission> permissions;
public Set<Permission> getPermissions() {
return permissions;
}
public void setPermissions(Set<Permission> permissions) {
this.permissions = permissions;
}
public Integer getRid() {
return rid;
}
public void setRid(Integer rid) {
this.rid = rid;
}
@JsonBackReference
public String getRname() {
return rname;
}
public void setRname(String rname) {
this.rname = rname;
}
@Override
public String toString() {
return "Role{" +
"rid=" + rid +
", rname='" + rname + '\'' +
'}';
}
}
Permission
package com.xyy.cache.bean.mysqljpa;
import javax.persistence.*;
@Entity
@Table(name = "permission")
public class Permission {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
@Column(name = "id")
private Integer pid;
@Column(name = "name")
private String name;
@Column(name = "url")
private String url;
public Integer getPid() {
return pid;
}
public void setPid(Integer pid) {
this.pid = pid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}
roleDao
package com.xyy.cache.repository;
import com.xyy.cache.bean.mysqljpa.Role;
import com.xyy.cache.bean.mysqljpa.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface RoleRepositoty extends JpaRepository<Role,Integer> {
@Query(value = "select * from role r where r.id in (select role_id from user_role where user_id > ?1)",nativeQuery = true)
List<Role> findByUidGreaterThan(@Param(value = "id") Integer id);
@Query(value = "select * from role inner join user_role on role.id=user_role.role_id inner join user on user.id=user_role.user_id",nativeQuery = true)
List<Role> findByUser(User user);
}
perssionDao
package com.xyy.cache.repository;
import com.xyy.cache.bean.mysqljpa.Permission;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface PermissionRepositity extends JpaRepository<Permission,Integer> {
}
UserController
package com.xyy.cache.controller;
import com.xyy.cache.repository.RoleRepositoty;
import com.xyy.cache.bean.mysqljpa.User;
import com.xyy.cache.service.Impl.UserServiceImpl;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpSession;
import java.util.List;
@Controller
public class UserController {
@Autowired
private UserServiceImpl userService;
@Autowired
private RoleRepositoty roleRepositoty;
@RequestMapping("/login")
@ResponseBody
public User login(User user, ModelAndView model) throws Exception{
String username = user.getUsername();
String password = user.getPassword();
User user1 = userService.findByUsernameAndPassword(username,password);
if(user1!=null){
return user1;
}
else {
user.setUsername("请检查用户名和密码");
return user;
}
}
@ResponseBody
@GetMapping("/findByUserNameAndPassword")
public User findByUserNameAndPassword(String username,String password){
User user = userService.findByUsernameAndPassword(username, password);
System.out.println(user);
return user;
}
@ResponseBody
@RequestMapping("/findAllUser")
public List<User> findAll(){
List<User> stuList = userService.findAll();
return stuList;
}
@ResponseBody
@RequestMapping("/findById/{id}")
public User findById(@PathVariable Integer id){
return userService.findById(id);
}
@ResponseBody
@RequestMapping("/page")
public Page<User> findAlls(){
//Pageable是接口,PageRequest是接口实现
// PageRequest的对象构造函数有多个,page是页数,初始值是0,size是查询结果的条数,
// 后两个参数参考Sort对象的构造方法Pageable pageable = new PageRequest(0,3, Sort.Direction.DESC,"id");
Page<User> page=userService.findAll(new PageRequest(0,3, Sort.Direction.DESC,"uid"));
//查询结果总行数
System.out.println(page.getTotalElements());
//按照当前分页大小,总页数
System.out.println(page.getTotalPages());
//按照当前页数、分页大小,查出的分页结果集合
return page;
}
@ResponseBody
@RequestMapping("/gts/{id}")
public List<User> findByUidGreaterThan(@PathVariable Integer id){
System.out.println(id);
return userService.findByUidGreaterThan(id);
}
}
演示结果:
自定义的方法
rolecontroller
其他要说的话,看注解