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



其他要說的話，看註解