springboot+jpa项目演示

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



其他要说的话，看注解