springBoot讲解，jpa使用，微服务架构，什么是RESTful API？

大家好，又见面了，我是你们的朋友全栈君。

1，什么是微服务架构

微服务是指开发一个单个 小型的但有业务功能的服务，每个服务都有自己的处理和轻量通讯机制，可以部署在单个或多个服务器上。

优点：

• 每个微服务都很小，这样能聚焦一个指定的业务功能或业务需求。
• 微服务能够被小团队单独开发，这个小团队是2到5人的开发人员组成。
• 微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的。
• 微服务能使用不同的语言开发。
• 微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如Jenkins, Hudson, bamboo 。
• 一个团队的新成员能够更快投入生产。
• 微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果。无需通过合作才能体现价值。
• 微服务允许你利用融合最新技术。
• 微服务只是业务逻辑的代码，不会和HTML,CSS 或其他界面组件混合。
• 微服务能够即时被要求扩展。
• 微服务能部署中低端配置的服务器上。
• 易于和第三方集成。
• 每个微服务都有自己的存储能力，可以有自己的数据库。也可以有统一数据库。

2，springboot特点介绍：springboot与springmvc的区别：

这两个问题可以放在一起回答，1，前者是后者的升级，但二者没有必然的联系。2，springboot可以理解成把spring ,spring mvc，jpa等常用的基础框架组合成各种starter，方便开发者使用这一咧技术，因为他排除了版本兼容性影响、各种繁琐配置等，达到快速开发，追求开箱即用。3，在功能等方面springboot沿用了springmvc的一套，比如事务原子性，都是使用@Transactional保持一致的。只是用springboot减少配置，更专注于业务。

如何在 Spring Boot 中添加通用的 JS 代码:

在源文件夹下，创建一个名为 static 的文件夹。然后，你可以把你的静态的内容放在这里面。

例如，myapp.js 的路径是 resources\static\js\myapp.js

JPA 和 Hibernate 有哪些区别？

• JPA 是一个规范或者接口

• Hibernate 是 JPA 的一个实现

2，案例

https://spring.io/tools/sts/all

大部分博文是在eclipse上安装spring tool suite插件，可是版本控制的比较严格，建议大家直接安装个sts，上面就是安装的官网路径。安装好启动就行了。

然后就是直接创建一个工程：

new —》spring starter project –>

这里我们先建个web工程：

finish就行了。

这里创建的是个maven工程，因为sts自动集成了maven，所以关于什么版本的都不用关了。但电脑环境变量jdk要是jdk1.8的。

下面我们看看项目结构：

src/main/resources 源文件目录，并在该目录下创建 application.properties 文件、static 和 templates 的文件夹。

application.properties：用于配置项目运行所需的配置数据。

static：用于存放静态资源，如：css、js、图片等。

templates：用于存放模板文件。

<?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>

	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.15.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<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>
	<!-- 上边引入 parent，因此 下边无需指定版本 -->
    <!-- 包含 mvc,aop 等jar资源 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

就简单的几个注解，spring-boot-starter-parent这个依赖包含了所需基本的所有jar包了，比如mvc,aop等jar，这样看pom依赖就很清爽了。

spring-boot-start-web是指定web工程的。这些配置都是我们在创建工程的时候勾选的，因此pom配置也不需要我们写。

下面看程序入口类：

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

/*
 * springbootAPPlication注解是把此类当做程序的入口，并指定工程为springboot工程
 * 自动装配web环境依赖
 */
@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, “--server.port=9999”);
		System.out.println("--------------");
	}
}

到这里就能够启动项目了，但是web界面是404因为我们什么输出都没写，下面写个控制器类。

package com.example.demo;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/*
 * 
 */
@RestController
public class HelloController {
	@RequestMapping(value="/hello",method=RequestMethod.GET)
	public String say(){
		return "Hello spring Boot!";
	}

}

然后在上面main入口类启动，

右键 run as–>spring boot app 就启动了。

然后重新启动，

在控制台可以看到：

可以看到springboot 已经帮我们集成了tomcat，因为这里我设置了tomcat端口是9999，tomcat默认的端口还是8080.

—————————————————————-

1，下面再稍微深入一点，这里我们也可以在配置文件上配置tomcat启动端口。

这里我们新建个application.yml文件在这个文件里面写配置，当然也可以使用application.propreties，但是前者结构稍微清晰一点，如上图，所示，改端口为9998，并配置应用的上下文路径为/xinixn，下面就启动，成功后在浏览器上访问如下：

————————————————————-

2，怎么获取配置文件的常量呢？

我在配置文件中随便加了个常量：

server:
  port: 9998
  context-path: /xinxin
age: 18

控制器代码：

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/*
 * 
 */
@RestController
public class HelloController {
	
	@Value("${age}")
	private int age;
	@RequestMapping(value="/hello",method=RequestMethod.GET)
	public String say(){
//		return "Hello spring Boot!";
		System.out.println(age);
		return age+"";
	}

}

运行：

ok;

3,在配置里面加配置，如下：

server:
  port: 9998
  context-path: /xinxin
age: 18
name: xiaoming
content: "age: ${age}, name: ${name}"

package com.example.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/*
 * 
 */
@RestController
public class HelloController {
	
	@Value("${age}")
	private int age;
	@Value("${content}")
	private String content;
	@RequestMapping(value="/hello",method=RequestMethod.GET)
	public String say(){
//		return "Hello spring Boot!";
		System.out.println(age);
//		return age+"";
		return content;
	}

}

结果：

3，还有一种加载方式：

content2:
  age: 19
  name: xiaohua

package com.example.demo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/*
 * perfix前缀的意思，找到配置文件前缀是content2的
 * 
 * @Component是跟@Service差不多的注释，把这类交给spring管理，使用bean加载
 */
@Component
@ConfigurationProperties(prefix="content2")
public class ContentProperties {

	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释，而用 @Component 对那些比较中立的类进行注释

这里就是说把这个类交给Spring管理，重新起个名字叫userManager，由于不好说这个类属于哪个层面，就用@Component

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
	
	@Value("${age}")
	private int age;
	@Value("${content}")
	private String content;
	
	@Autowired
	private ContentProperties contentProperties;
	@RequestMapping(value="/hello",method=RequestMethod.GET)
	public String say(){
//		return "Hello spring Boot!";
		System.out.println(age);
//		return age+"";
//		return content;
		return contentProperties.getName();
		
	}

}

这种方式是把同一类的配置交到一个对象中，用spring容器管理注入，

启动成功后如下：

注：说明控制器的@RestController  等同于 @Controller + @ResponseBody

顺便回忆一下，@RepuestMapping注解是一个url的映射；

———————————————————————————————-

4数据库

先说一下JPA，jpa是java persistence API java持久化API，他定义了一系列对象持久化标准，因此它不是组件也不是个工具，而是个书面规范。

这里使用springboot特性，不用通过注解来创建数据库表：

首先加mysql依赖，其实不用加也行，因为starter里面已经包含有了。但是出于各自mysql版本的一直我这里还是配置了一下：

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>5.1.23</version>
        </dependency>

下面配置文件：

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mysql
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true

ddl-auto：create 是在启动的时候就检查对应的表没有在数据库生成：

show-sql:ture 是在控制台打印sql，方便调试。

表–实体类：

package com.example.demo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
//JPA特性
@Entity
public class Content {
	@Id
	@GeneratedValue
	private int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	

}

上面有主键，有自增长，然后启动程序，就能够在数据库生成相应的content表了。

—————————————————

5，下面我们使用spring-data-jpa（这个说法可以认为出自于pom的jpa的配置）操作数据库，增删改查

下面我们先看查：

首先把配置文件的

 jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

ddl-auto:create该成update.这样每次启动就是更新数据库操作了。

然后，创建jpa链接数据库操作的接口类：

package com.example.demo;

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

public interface ContentRepository extends JpaRepository<Content, Integer>{

}

然后在写个控制器：

package com.example.demo;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ContentController {
	
	@Autowired
	private ContentRepository contentRepository;
	@GetMapping(value="/getContent")
	public List<Content> contents(){
		return contentRepository.findAll();
	}

}

然后就可以启动程序了；

启动好了后会在数据库生成一张content的表，然后我们随便向里面加两条数据，测试下能不能查。

这里我们使用postman测试：

说明没问题。

——–增

控制器加个方法：

@PostMapping(value="/addContent")
	public Content addContent(@RequestParam("age") Integer age,
								@RequestParam("name") String name){
		Content content=new Content();
		content.setAge(age);
		content.setName(name);
		return contentRepository.save(content);
	}

postman测试

6，什么是RESTful API？

REST — REpresentational State Transfer，英语的直译就是“表现层状态转移。

通俗解释就是：URL定位资源，用HTTP动词（GET,POST,PUT,DELETE)描述操作。也就是定义了一套规范，在上面我们使用@RestController，就说明我们使用restfulApi方式，比如我们在下面是用，@GetMapping，@PostMapping等前后端的通讯方式协议。

   所以RESTful API就是REST风格的API。 那么在什么场景下使用RESTful API呢？在当今的互联网应用的前端展示媒介很丰富。有手机、有平板电脑还有PC以及其他的展示媒介。那么这些前端接收到的用户请求统一由一个后台来处理并返回给不同的前端肯定是最科学和最经济的方式，RESTful API就是一套协议来规范多种形式的前端和同一个后台的交互方式。