2. 程式人生 > >Spring Boot 整合Spring Data JPA 資料介面開發測試(二)

Spring Boot 整合Spring Data JPA 資料介面開發測試(二)

阿新 • • 發佈：2019-01-17

核心介面程式碼:

1.實體類

package com.weichai.SpringDataJpaQuery.entity;

import java.io.Serializable;

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.ManyToOne;
import javax.persistence.Table;

/**
 * 學生實體類
 * @author lhy
 * @date 2018.11.10
 */
@Entity
@Table(name="tb_student")
public class Student implements Serializable {

	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;
	private String name ;
	private String address ;
	private int age ; 
	private char sex;
	// 學生與班級是多對一的關係，這裡配置的是雙向關聯
	@ManyToOne(fetch=FetchType.LAZY,targetEntity=Clazz.class)
	@JoinColumn(name="clazzId",referencedColumnName="code")
	private Clazz clazz;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String address, int age, char sex, Clazz clazz) {
		super();
		this.name = name;
		this.address = address;
		this.age = age;
		this.sex = sex;
		this.clazz = clazz;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	public Clazz getClazz() {
		return clazz;
	}
	public void setClazz(Clazz clazz) {
		this.clazz = clazz;
	}
	
	
}

 
package com.weichai.SpringDataJpaQuery.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

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

/**
 * 班級實體類
 * @author lhy
 * @date 2018.11.10
 */
@Entity
@Table(name="tb_clazz")
public class Clazz implements Serializable {

	private static final long serialVersionUID = 1L;
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private int code ;
	private String name ;
	// 班級與學生是一對多的關聯
	@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="clazz")
	private Set<Student> students = new HashSet<Student>();
	public Clazz() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Clazz(String name) {
		super();
		this.name = name;
	}
	public int getCode() {
		return code;
	}
	public void setCode(int code) {
		this.code = code;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
}

 
package com.weichai.SpringDataJpaQuery.pageUtil;

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

/**
 * 定義一個物件用於封裝一頁資料
 * @author lhy
 * @date 2018.11.12
 */
public class PageData {
	// 定義一個變數用於存放當前頁碼
	private int pageIndex;
	// 定義一個變數用於儲存滿足查詢條件下用於分頁的資料總量
	private long totalCount;
	// 定義一個變數用於儲存當前條件下總共可以分的總頁數
	private int pageSize;
	// 定義一個變數用於儲存當前頁碼查詢出的資料總量
	private int pageNum;
	// 定義一個變數用於儲存當前查詢出來的學生資訊
	private List<Map<String, Object>> stuDatas = new ArrayList<Map<String,Object>>();

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getPageIndex() {
		return pageIndex;
	}

	public void setPageIndex(int pageIndex) {
		this.pageIndex = pageIndex;
	}

	public long getTotalCount() {
		return totalCount;
	}

	public void setTotalCount(long totalCount) {
		this.totalCount = totalCount;
	}

	public int getPageNum() {
		return pageNum;
	}

	public void setPageNum(int pageNum) {
		this.pageNum = pageNum;
	}

	public List<Map<String, Object>> getStuDatas() {
		return stuDatas;
	}

	public void setStuDatas(List<Map<String, Object>> stuDatas) {
		this.stuDatas = stuDatas;
	}
}

2.資料訪問持久層

package com.weichai.SpringDataJpaQuery.dao;

import java.util.List;
import java.util.Map;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import com.weichai.SpringDataJpaQuery.entity.Student;

public interface StudentDao extends JpaRepository<Student, Integer>,JpaSpecificationExecutor<Student>{

	//1.關聯查詢和Query查詢
	/**
	 * 根據班級名稱查詢這個班級下所有的學生資訊
	 * 相當於JPQL語句： select s from Student s where s.clazz.name = ?1
	 * @param clazzName
	 * @return
	 */
	List<Student> findByClazz_name(String clazzName);
	
	/**
	 * @Query寫法
	 * 根據班級名稱查詢這個班級下所有的學生資訊
	 * ?1此處使用的是引數的位置，代表的是第一個引數
	 * 此寫法與 findByClazz_name方法實現的功能完全一致
	 * @param clazzName
	 * @return
	 */
//	@Query("select s from Student s where s.clazz.name = ?1")
//	List<Student> findStudentsByClazzName(String clazzName);
	
	/**
	 * 使用@Query註解的形式，查詢某個班級下所有學生的姓名和性別 
	 * @param clazzName
	 * @return
	 */
	@Query("select new Map(s.name as name , s.sex as sex) "
			+ "from Student s where s.clazz.name = ?1")
	List<Map<String, Object>> findNameAndSexByClazzName(String clazzName);
	
	/**
	 *  使用@Query註解的形式，查詢某個班級下某種性別的所有學生的姓名
	 *  上面方法是用的是引數的位置來查詢的，Spring Data JPA中還支援用
	 *  名稱來匹配查詢使用格式 “:引數名稱” 引用
	 * @param clazzName
	 * @param sex
	 * @return
	 */
	@Query("select s.name from Student s "
			+ "where s.clazz.name = :clazzName and s.sex = :sex ")
	List<String> findNameByClazzNameAndSex(@Param("clazzName")String clazzName , @Param("sex")char sex);
	
	/**
	 *  使用@Query註解的形式，查詢某個學生屬於哪個班級
	 * @param stuName
	 * @return
	 */
	@Query("select c.name from Clazz c inner join c.students s "
			+ "where s.name = ?1 ")
	String findClazzNameByStuName(String stuName);
	
	/**
	 * 執行更新查詢，使用@Query與@Modifying可以執行更新操作
	 * 例如刪除牛魔王這個學生
	 * @param stuName
	 */
	@Modifying
	@Query("delete from Student s where s.name = ?1")
	void deleteStuByStuName(String stuName);
	
	//2. NamedQuery查詢
	/**
	 * 查詢班級下的所有學生
	 * @param clazzName
	 * @return
	 */
	List<Student> findStudentsByClazzName(String clazzName);
	
	//3.Specification 查詢
	//此處直接繼承介面,在服務層中編寫程式碼即可
} 

package com.weichai.SpringDataJpaQuery.dao;

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

import com.weichai.SpringDataJpaQuery.entity.Clazz;

public interface ClazzDao extends JpaRepository<Clazz, Integer>,JpaSpecificationExecutor<Clazz> {

}

3.資料服務封裝層

package com.weichai.SpringDataJpaQuery.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.transaction.Transactional;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import com.weichai.SpringDataJpaQuery.dao.ClazzDao;
import com.weichai.SpringDataJpaQuery.dao.StudentDao;
import com.weichai.SpringDataJpaQuery.entity.Clazz;
import com.weichai.SpringDataJpaQuery.entity.Student;

@Service
public class SchoolService {

	// 注入資料訪問層介面物件 
	@Resource
	private StudentDao studentDao;
	
	@Resource
	private ClazzDao clazzDao;
	
	//1.關聯查詢和Query查詢
	@Transactional
	public void SaveClazzAll(List<Clazz> clazzs){
		clazzDao.saveAll(clazzs);
	}
	
	@Transactional
	public void SaveStudentAll(List<Student> students) {
		studentDao.saveAll(students);
	}
	
//	public List<Map<String, Object>> getStusByClazzName(String clazzName) {
//		// 使用"_" 和 @Query查詢方式結果一致
//		List<Student> students = studentDao.findByClazz_name(clazzName);
//		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
//		
//		// 遍歷查詢出的學生物件，提取姓名，年齡，性別資訊
//		for(Student student:students){
//			Map<String , Object> stu = new HashMap<String , Object>();
//			stu.put("name", student.getName());
//			stu.put("age", student.getAge());
//			stu.put("sex", student.getSex());
//			results.add(stu);
//		}
//		return results;
//	}
	
	public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName) {
		return studentDao.findNameAndSexByClazzName(clazzName);
	}
	
	public List<String> findNameByClazzNameAndSex(String clazzName, char sex) {
		return studentDao.findNameByClazzNameAndSex(clazzName, sex);
	}
	
	public String findClazzNameByStuName(String stuName) {
		return studentDao.findClazzNameByStuName(stuName);
	}
	
	@Transactional
	public void deleteStuByStuName(String stuName) {
		studentDao.deleteStuByStuName(stuName);
	}
	
	//2. NamedQuery查詢
	public List<Map<String, Object>> getStusByClazzName(String clazzName) {
		// 查詢班級下的所有學生
		List<Student> students = studentDao.findStudentsByClazzName(clazzName);
		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
		// 遍歷查詢出的學生物件，提取姓名，年齡，性別資訊
		for(Student student:students){
			Map<String , Object> stu = new HashMap<String, Object>();
			stu.put("name", student.getName());
			stu.put("age", student.getAge());
			stu.put("sex", student.getSex());
			results.add(stu);
		}
		return results;
	}
	
	//3.Specification 查詢
	
	/**
	 * 根據性別查詢學生資訊
	 * @param sex
	 * @return
	 */
	@SuppressWarnings("serial")
	public List<Map<String, Object>> getStusBySex(final char sex) {
		List<Student> students = studentDao.findAll(new Specification<Student>() {

			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// TODO Auto-generated method stub
				// root.get("sex")表示獲取sex這個欄位名稱,equal表示執行equal查詢
				// 相當於 select s from Student s where s.sex = ?1
				Predicate p1 = cb.equal(root.get("sex"), sex);
				return p1;
			}
		});
		List<Map<String, Object>>  results = new ArrayList<Map<String,Object>>();
		// 遍歷查詢出的學生物件，提取姓名，年齡，性別資訊
		for(Student student:students){
			Map<String , Object> stu = new HashMap<String, Object>(); 
			stu.put("name", student.getName());
			stu.put("age", student.getAge());
			stu.put("sex", student.getSex());
			results.add(stu);
		}
		return results;
	}
	
	/**
	 * 動態查詢學生資訊 ：可以根據學生物件的姓名(模糊匹配)， 地址查詢(模糊匹配),性別,班級查詢學生資訊 
	 *               如果沒有傳輸引數,預設查詢所有的學生資訊
	 * @param student
	 * @return
	 */
	@SuppressWarnings("serial")
	public List<Map<String, Object>> getStusByDynamic(final Student student) {
		List<Student> students = studentDao.findAll(new Specification<Student>() {
			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
				// 本集合用於封裝查詢條件
				List<Predicate> predicates = new ArrayList<Predicate>();
				if (student != null) {
					/** 是否傳入了姓名來查詢 */
					if (!StringUtils.isEmpty(student.getName())) {
						predicates.add(cb.like(root.<String> get("name"), "%" + student.getName() + "%"));
					}
					/** 是否傳入了地址來查詢 */
					if (!StringUtils.isEmpty(student.getAddress())) {
						predicates.add(cb.like(root.<String> get("address"), "%" + student.getAddress() + "%"));
					}
					/** 是否傳入了性別來查詢 */
					if (student.getSex() != '\0') {
						predicates.add(cb.equal(root.<String> get("sex"), student.getSex()));
					}
					/** 判斷是否傳入了班級資訊來查詢 */
					if (student.getClazz() != null && !StringUtils.isEmpty(student.getClazz().getName())) {
						root.join("clazz", JoinType.INNER);
						Path<String> clazzName = root.get("clazz").get("name");
						predicates.add(cb.equal(clazzName, student.getClazz().getName()));
					}
				}
				return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
			}
		});
		List<Map<String, Object>> results = new ArrayList<Map<String,Object>>();
		// 遍歷查詢出的學生物件，提取姓名，年齡，性別資訊
		for (Student stu : students) {
			Map<String, Object> stuMap = new HashMap<String, Object>();
			stuMap.put("name", stu.getName());
			stuMap.put("age", stu.getAge());
			stuMap.put("sex", stu.getSex());
			stuMap.put("address", stu.getAddress());
			stuMap.put("clazzName", stu.getClazz().getName());
			results.add(stuMap);
		}
		return results;
	}
	
	/**
	 * 分頁查詢某個班級的學生資訊
	 * @param clazzName
	 * @param pageIndex
	 * @param pageSize
	 * @return
	 */
	@SuppressWarnings("serial")
	public Page<Student> getStusByPage(final String clazzName , int pageIndex , int pageSize) {
		// 指定排序引數物件：根據id，進行降序查詢
		Sort sort = new Sort(Sort.Direction.DESC,"id");
		Page<Student> pages = studentDao.findAll(new Specification<Student>() {
			public Predicate toPredicate(Root<Student> root, CriteriaQuery<?> query,CriteriaBuilder cb) {
				root.join("clazz",JoinType.INNER);
				Path<String> cn = root.get("clazz").get("name");
				Predicate p1 = cb.equal(cn, clazzName);
				return p1 ;
			}
		},PageRequest.of(pageIndex-1, pageSize, sort));
		return pages;
	}
}

4.控制層

package com.weichai.SpringDataJpaQuery.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.weichai.SpringDataJpaQuery.entity.Clazz;
import com.weichai.SpringDataJpaQuery.entity.Student;
import com.weichai.SpringDataJpaQuery.pageUtil.PageData;
import com.weichai.SpringDataJpaQuery.service.SchoolService;

@RestController
@RequestMapping("/student")
public class StudentController {

	// 注入ShcoolService
	@Resource
	private SchoolService schoolService;

	//1.關聯查詢和Query查詢
	@RequestMapping("/Save")
	public String Save() {
		Clazz clazz1 = new Clazz("軟體1班");
		Clazz clazz2 = new Clazz("軟體2班");
		// 儲存班級物件資料
		List<Clazz> clazzs = new ArrayList<Clazz>();
		clazzs.add(clazz1);
		clazzs.add(clazz2);
		schoolService.SaveClazzAll(clazzs);

		Student swk = new Student("孫悟空", "廣州", 700, '男', clazz1);
		Student zzj = new Student("蜘蛛精", "廣州", 700, '女', clazz1);
		Student nmw = new Student("牛魔王", "廣州", 500, '男', clazz2);

		List<Student> students = new ArrayList<Student>();
		students.add(swk);
		students.add(zzj);
		students.add(nmw);
		schoolService.SaveStudentAll(students);
		return "儲存學生物件成功";
	}
	
	/**
	 * 查詢某個班級下所有的學生姓名，年齡，性別
	 * @param clazzName
	 * @return
	 */
//	@RequestMapping("/getClazzStus")
//	public List<Map<String, Object>> getClazzStus(String clazzName){
//		return schoolService.getStusByClazzName(clazzName);
//	}
	
	/**
	 * 查詢某個班級下所有的學生姓名，性別
	 * @param clazzName
	 * @return
	 */
	@RequestMapping("/findNameAndSexByClazzName")
	public List<Map<String, Object>> findNameAndSexByClazzName(String clazzName){
		return schoolService.findNameAndSexByClazzName(clazzName);
	} 
	
	/**
	 * ，查詢某個班級下某種性別的所有學生的姓名
	 * @param clazzName
	 * @param sex
	 * @return
	 */
	@RequestMapping("/findNameByClazzNameAndSex")
	public List<String> findNameByClazzNameAndSex(String clazzName ,Character sex){
		return schoolService.findNameByClazzNameAndSex(clazzName ,sex);
	} 
	
	/**
	 * http://localhost:8080/student/findClazzNameByStuName?stuName=孫悟空
	 * 查詢某個學生屬於哪個班級
	 * @param stuName
	 * @return
	 */
	@RequestMapping("/findClazzNameByStuName")
	public String findClazzNameByStuName(String stuName){
		return schoolService.findClazzNameByStuName(stuName);
	} 
	
	/**
	 * http://localhost:8080/student/deleteStuByStuName?stuName=孫悟空
	 * 刪除某個學生物件
	 * @param stuName
	 */
	@RequestMapping("/deleteStuByStuName")
	public void deleteStuByStuName(String stuName){    //連結的引數必須與定義的引數一致,而不是實體類的引數欄位
		schoolService.deleteStuByStuName(stuName);
	} 
	
	//2. NamedQuery查詢
	/**
	 * http://localhost:8080/student/getClazzStus?clazzName=軟體1班
	 * @param clazzName
	 * @return
	 */
	@RequestMapping("/getClazzStus")
	public List<Map<String, Object>> getClazzStus(String clazzName){
		return schoolService.getStusByClazzName(clazzName);
	} 
	
	//3.Specification 查詢
	/**
	 * http://localhost:8080/student/getStusBySex?sex=男
	 * @param sex
	 * @return
	 */
	@RequestMapping("/getStusBySex")
	public List<Map<String, Object>> getStusBySex(char sex){
		return schoolService.getStusBySex(sex);
	} 
	
	/**
	 * http://localhost:8080/student/getStusByDynamic?clazz.name=軟體1班&sex=男
	 * 動態的查詢學生資訊
	 * 可以根據學生物件的姓名(模糊匹配)， 地址查詢(模糊匹配),性別,班級查詢學生資訊 
	 * @param student
	 * @return
	 */
	@RequestMapping("/getStusByDynamic")
	public List<Map<String, Object>> getStusByDynamic(Student student) {
		return schoolService.getStusByDynamic(student);
	} 
	
	/**
	 * http://localhost:8080/student/getStusByPage?clazzName=軟體1班&pageIndex=1&pageSize=2
	 * 分頁查詢某個班級下的學生資訊
	 * @param clazzName 班級名稱
	 * @param pageIndex 當前頁碼
	 * @param pageSize  每頁資料條數
	 * @return
	 */
	@RequestMapping("/getStusByPage")
	public PageData getStusByPage(String clazzName , int pageIndex , int pageSize ) {
		// 分頁查詢某個班級的學生資訊
		Page<Student> page = schoolService.getStusByPage(clazzName, pageIndex, pageSize);
		// 對查詢出來的結果資料進行分析
		List<Student> students = page.getContent();
		List<Map<String,Object>> stuDatas = new ArrayList<Map<String,Object>>();
		for(Student stu :students){
			Map<String , Object> stuMap = new HashMap<String, Object>();
			stuMap.put("id", stu.getId());
			stuMap.put("name", stu.getName());
			stuMap.put("age", stu.getAge());
			stuMap.put("sex", stu.getSex());
			stuMap.put("address", stu.getAddress());
			stuMap.put("clazzName", clazzName);
			stuDatas.add(stuMap);
		}
		// 將分頁查詢出的結果資料進行分析，然後把資料存入到PageData物件中去儲存起來響應給瀏覽器展示 
		PageData data = new PageData();
		data.setStuDatas(stuDatas);
		data.setPageIndex(page.getNumber()+1);
		data.setPageSize(page.getTotalPages());
		data.setTotalCount(page.getTotalElements());
		data.setPageNum(page.getSize());
		return data ;
	}
}

5.專案介面啟動類

package com.weichai.SpringDataJpaQuery;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @SpringBootApplication指定這是一個 spring boot的應用程式.
 */
@SpringBootApplication
public class App 
{
    public static void main( String[] args )
    {
    	// SpringApplication 用於從main方法啟動Spring應用的類。
        SpringApplication.run(App.class, args);
    }
}

 同樣的,開啟瀏覽器,輸入介面訪問連結進行測試即可.如

相關推薦

Spring Boot 整合Spring Data JPA 資料介面開發測試(二)

核心介面程式碼: 1.實體類 package com.weichai.SpringDataJpaQuery.entity; import java.io.Serializable; import javax.persistence.Entity; import jav

Spring Boot整合Spirng-data-jpa及使用

Spring-data-jpa可根據實體類自動建立表結構，提供基本的增刪改查方法，資料訪問層非常簡潔，只是一層介面。 1.pom引進依賴 <!--dataSource--> <dependency> <groupI

Spring boot 整合spring Data JPA+Spring Security+Thymeleaf框架(上)

current 不可 src rac 分享圖片 正在 html AC ren 近期上班太忙所以耽擱了給大家分享實戰springboot 框架的使用。 以下是spri

Spring Boot 整合 Spring Data Jpa 增刪改查示例

原文地址：https://renguangli.com/articles/spring-boot-jpa 使用 Spring Data Jpa 對資料庫進行操作 Jpa 與 Spring Data Jpa 的關係 JPA 是Java Persistence API 的簡稱，中

Spring Boot整合Spring MVC、Spring、Spring Data JPA(Hibernate)

一句話總結：Spring Boot不是新的功能框架，而是為了簡化如SSH、SSM等等多個框架的搭建、整合及配置。使用Spring Boot 10分鐘搭建起Spring MVC、Spring、Spring Data JPA(Hibernate)基礎後臺架構。基本零配置，全註解。 步驟一： 使用Sprin

Spring Boot整合Spring-data-JPA

一.整合Spring-data-JPA JPA(Java Persistence API的簡稱,中文名Java持久層API) 基於註解來去配置對映,實體類,資料庫表的規範(增刪改查的規範) 1.需求

spring boot 整合spring data jpa

本文結構： - 什麼是springdata jpa - springboot 整合spring data jpa Spring Data Repository的核心介面是Repository(好像也沒什麼好驚訝的)。這個介面需要領域類(Doma

spring boot 整合 spring data jpa

    因為最近在實習過程中，需要學習jpa框架，所以在學習後，簡單總結一下 spring boot 和 spring data jpa的整合。 因為之前學習了一下 spring boot ，所以這次就將二者整合一下，也是實踐一下spring boot吧  

Spring Boot整合Spring Data

之前打算把Spring Data的整合放在前面給大家分享和交流，但實際操作的時候覺得這塊的知識雖然和之前的jpa有相似之處但用下來發現還是不一樣就找了Spring Data的視訊和資料學了一遍，就像之前說的學習Spring Boot需要懂得Spring體系的框架。 一  

Spring Boot整合Spring Data Elasticsearch 踩坑

首先來看官網給的版本要求： 紅框這欄指的是：Elasticsearch安裝版本（windows安裝版本或Linux按照版本） 最新因為專案需要elasticsearch，採用今天搞了好久，專案啟動就報如下錯誤： org.elasticsearch.transport

Spring Boot整合Echarts繪製靜態資料柱狀圖、餅圖

idea建立spring boot專案 下載echarts 把echarts.min.js檔案放到專案中。 專案目錄 pom.xml <?xml version="1.0" encoding="UTF-8"?> <pro

Spring Boot整合Spring Security

只開啟了簡單的登陸驗證 新增依賴 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star

spring boot 整合thyemleaf基本使用 字串的操作（二）

thyemleaf基本使用 字串的操作的基本使用，其他的以後用到可以檢視文件或者百度。 <!--在輸入框中顯示msg的值--> <input type="text" name="username" th:value="${msg}"> <hr/> <!

高併發架構實戰(五) Spring Boot 整合 spring-cloud-config

一、配置config服務端 新建配置服務專案，如config-server。 1. 在config-server專案中新增依賴 <dependencyManagement> <dependencies> <

spring boot整合spring security筆記

最近自己做了一個小專案，正在進行springboot和spring Security的整合，有一丟丟的感悟，在這裡分享一下：     首先，spring boot整合spring security最好是使用Thymleaf，因為spring boot官方支援使用thymleaf,這樣的話

第七篇：Spring Boot整合Spring Cache

為了提高效能，減少資料庫的壓力，使用快取是非常好的手段之一。因此本文講解 Spring Boot 如何整合快取管理。 宣告式快取 Spring 定義 CacheManager 和 Cache 介面用來統一不同的快取技術。例如 JCache、 EhCache、 Hazelcast、

spring-boot整合spring-security實現簡單登入(ajax登入實現)

平常再做一些專案時,有些專案並不需要複雜的登入許可權驗證 只需要簡單登入許可權驗證(保證安全可靠的前提下)，找來找去只有spring-security最適合不過了，在spring-boot下配置簡單 便捷 快速 能滿足基本的登入許可權控制需求。 第一步：引入spring

Spring Boot 整合Spring Security

整合Spring Security 效果：訪問hello.html會被重定向到login.html，登入成功後，轉到hello，登入失敗，轉到error  一：新增依賴 <!-- spring security依賴 -->

spring-boot 整合spring-session redis

Spring Session 提供了一套用於管理使用者 session 資訊的API和實現。 Spring Session為企業級Java應用的session管理帶來了革新，使得以下的功能更加容易實現： 編寫可水平擴充套件的原生雲應用。將session所儲存的狀態解除安裝到

Spring Boot 整合Spring Session 通過Redis實現分散式共享Session

一、首先我們要引入依賴，修改pom.xml新增： //引入spring session <dependency> <groupId>org.springframework.session</groupId> <artifactId>