spring-boot 从零开始-03

spring-boot中的JPA

这里不介绍数据库如何安装，如需要安装请自行百度

1.什么是JPA?JPA用来干什么?
2.有哪些JPA的实现?
3.如果在spring boot如何实现JPA

1.什么是JPA?JPA用来干什么?

JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。
持久化（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在的数据库中，或者存储在磁盘文件中、XML数据文件中等等。
持久化是将程序数据在持久状态和瞬时状态间转换的机制。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。

题外话:换言之，JPA就是一个储存的标准，太规范了数据持久化的标准，用于数据持久化

1.1什么是Spring data

Spring Data是一个用于简化数据库访问，并支持云服务的开源框架。其主要目标是使得数据库的访问变得方便快捷，并支持map-reduce框架和云计算数据服务。此外，它还支持基于关系型数据库的数据服务，如Oracle RAC等。对于拥有海量数据的项目，可以用Spring Data来简化项目的开发，就如Spring Framework对JDBC、ORM的支持一样，Spring Data会让数据的访问变得更加方便。

2.有哪些JPA的实现?

Hibernate，EclipseLink(曾经的toplink)，OpenJPA等可供选择，所以使用JPA的一个好处是，可以更换实现而不必改动太多代码

3.如果在spring boot如何实现JPA–spring boot JPA

(1)在pom.xml添加mysql,spring-data-jpa依赖;
(2)在application.properties文件中配置mysql链接配置文件
(3)在application.properties文件中配置JPA配置信息;
(4)编写测试例子

(1)在pom.xml添加mysql,spring-data-jpa依赖

    <!-- 数据库mysql依赖包 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.13</version>
	</dependency>
	
	<!-- 配置spring-data-jpa依赖 -->
	<dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-data-jpa</artifactId>
	</dependency>

(2)在application.properties文件中配置mysql链接配置文件

新建文件夹src/main/resources，在resources目录下new->file, 取名字为application.properties固定写法。一定要在指定的路径下面新建，否则无法找到该文件。

(3)在application.properties文件中配置JPA配置信息

输入配置数据库配置信息

##################################
# 数据库基本配置
# 数据库username和password
# 驱动，链接方式
# 最大连接
# 初始大小
##################################
spring.datasource.url=jdbc:mysql://localhost:3306/avalanching_crm
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.max-active=20
spring.datasource.max-idle=8
spring.datasource.min-idle=8
spring.datasource.initial-size=10

##################################
# 数据库基本配置
# 数据库类型
# 是否现实sql语句
# 最大连接
# 初始大小
##################################
spring.jpa.database = MYSQL
spring.jpa.show-sql = true
spring.jpa.hibernate.ddl-auto = update
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

注意:spring.datasource.driverClassName，很多教程里面都是写com.mysql.jdbc.Driver，而非com.mysql.cj.jdbc.Driver，这里需要根据你当前mysql和驱动版本决定的，如果无法确定两者都尝试一下即可

(4)编写测试例子

新建package

model:随意创建的，名字自己取，后面都是这个package的子包
bean:是用来存放我们数据库实体类的，里面属性为private（私有的），提供public（公开的）setting和getting方法供外部调用
controller:处理请求类，控制器类，处理外部的请求，完成相应的操作，把结果返回给请求者
repository:这里需要一个接口类，这个定义了JPA的基本操作，例如增删查改
service:提供外部调用数据库操作

具体代码如下:
在bean package下创建：Dog实体类

package com.avalanching.spring_hellow.model.JPADemo.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 * 创建一个实体类
 * 1.使用@Entity进行实体类的持久化操作，当JPA检测到 
 * @Entity 将在数据库中创建表结构
 */
@Entity
public class Dog {
	/**
	 * @id 指定主键
	 * @GeneratedValue(strategy=GenerationType.AUTO) 指定主键的生成规则
	 * mysql默认自增长
	 **/
	@Id 
	@GeneratedValue(strategy=GenerationType.AUTO)
	private int id; // 主键
	private String name;
	private int age;
	private String remark;
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getRemark() {
		return remark;
	}
	public void setRemark(String remark) {
		this.remark = remark;
	}
}

repository package下创建：DogRepository接口

package com.avalanching.spring_hellow.model.JPADemo.repository;

import org.springframework.data.repository.CrudRepository;
import com.avalanching.spring_hellow.model.JPADemo.bean.Dog;

/**
 * DogRepository这个接口继承与CrudRepository
 * 源码定义:
 * public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID>
 * <T, ID extends Serializable>
 * T:是一个范型，这里传入的类型是一个实体类，需要操作那个数据实体就传入，
 *   这里需要操作Dog，所以传入Dog
 * ID extends Serializable: 这里传入的是主键的类型，Dog的主键是id，然后定义的是int
 * 							这里最好将组件定义为Integer，int长度非常有限
 * 此处为一个接口，暂无需要写方法，这里主要是一种规范行为
 */
public interface DogRepository extends CrudRepository<Dog, Integer> {

}

在service package下创建：DogService类

package com.avalanching.spring_hellow.model.JPADemo.service;

import javax.annotation.Resource;
import javax.transaction.Transactional;

import org.springframework.stereotype.Service;
import com.avalanching.spring_hellow.model.JPADemo.bean.Dog;
import com.avalanching.spring_hellow.model.JPADemo.repository.DogRepository;
/**
 * @Service对应的是业务层Bean 
 * 告诉spring这是一个业务层
 * 相当于在.xml文件配置如下代码
 * <Bean class="com.avalanching.spring_hellow.model.JPADemo.service.DogService">
 * 	........
 * </Bean>
 */
@Service
public class DogService {
	/**
	 * @Resource（这个注解属于J2EE的），
	 * 默认安照名称进行装配，名称可以通过name属性进行指定。  
	 * 简单来说就是自动new DogRepository的对象，并赋值给dogRepository这个属性
	 * 自动装配属性
	 */
	@Resource
	private DogRepository dogRepository;
	
	/**
	 * @Transactional 标签进行事务绑定
	 * 可以简单理解，只要对数据库里面的内容操作就最好绑定事务
	 * insert, update, delete等操作
	 **/
	@Transactional
	public void save(Dog dog) {
		dogRepository.save(dog);
	}
	
	@Transactional
	public void delete(int id) {
		dogRepository.delete(id);
	}
	
	@Transactional
	public void deleteAll() {
		dogRepository.deleteAll();
	}
	
	public Iterable<Dog> getAll() {
		return dogRepository.findAll();
	}
}

在controller package下创建：DogController类

package com.avalanching.spring_hellow.model.JPADemo.controller;

import javax.annotation.Resource;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.avalanching.spring_hellow.model.BaseJSONEntity;
import com.avalanching.spring_hellow.model.JPADemo.bean.Dog;
import com.avalanching.spring_hellow.model.JPADemo.service.DogService;

@RestController
@RequestMapping("/dog")
public class DogController {
	
	@Resource
	private DogService dogservice;
	
	@RequestMapping("/save")
	public String save() {
		Dog dog = new Dog();
		dog.setAge(3);
		dog.setName("不二");
		dog.setRemark("666");
		dogservice.save(dog);
		return "success";
	}
	
	@RequestMapping("/delete") 
	public String delete() {
		dogservice.delete(1);		
		return "success";
	}
	
	@RequestMapping("/clean")
	public String clean() {
		dogservice.deleteAll();
		return "success";
	}
	
	@RequestMapping("/find")
	public BaseJSONEntity findDog() {
		Iterable<Dog> list = dogservice.getAll();
		BaseJSONEntity entity = new BaseJSONEntity();
		entity.setCode(0);
		entity.setData(list);
		entity.setMessage("success");
		return entity;
	}
}

启动程序: 输入网址测试，或打开数据库查看

这里建议：使用Postman去测试，safari浏览器修改一次网址它就能自动调用一次，会出现重复调用的现象

自定义Repository

package com.avalanching.spring_hellow.model.JPADemo.repository;

import org.springframework.data.repository.Repository;
import com.avalanching.spring_hellow.model.JPADemo.bean.Dog;


public interface Dog2Repository extends Repository<Dog, Integer> {
	
	/**
	 * 1.查询方法以get | find | read 开头 
	 * 2.条件的属性用关键字链接，要注意条件属性以首字母大写
	 */
	public Iterable<Dog> findByName(String name);
	
}

相应的service和controller添加相应代码

/**
 * DogService代码
 */
// 添加一个Dog2Repository类属性
@Resource
private Dog2Repository dog2Repository;

// 创建一个方法供controller调用
public Iterable<Dog> findDogByName(String name) {
	return dog2Repository.findByName(name);
}

// 在controller中添加一个方法
@RequestMapping("/findname")	
public BaseJSONEntity findDogByName(String name) {
	Iterable<Dog> dog = dogservice.findDogByName(name);
	BaseJSONEntity entity = new BaseJSONEntity();
	entity.setCode(0);
	entity.setData(dog);
	entity.setMessage("success");
	return entity;
}

启动程序之后输入网址:localhost:8080/dog/findname?name=“Dog名字”
这里需要注意的是findBy后面必须给查询到属性名，并且首字母大写

编写JPQL语句查询:

/**
	 * 如果编写JPQL语句
	 * Hibernate --HQL语句
	 * JPQL 语句与HQL语句相似
	 * @Query标示一个查询语句
	 * :name此处为一个占位符，可以任选书写
	 **/
	@Query("from Dog where name=:name")
	public Dog findMyDogByName(@Param("name")String name);

如果你的表名为user_table，请换成UserTable，首字母大写，并且没有下划线，后面遵循驼峰命名法