微服务架构 spring boot 那些最基础的知识点

编程语言 2018-05-09 22:09:36 阅读次数: 1

一、创建SpringBoot项目

概念

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

Spring Boot特点

  1. 创建独立的Spring应用程序
  2. 嵌入的Tomcat，无需部署WAR文件
  3. 简化Maven配置
  4. 自动配置Spring
  5. 提供生产就绪型功能，如指标，健康检查和外部配置
  6. 绝对没有代码生成和对XML没有要求配置

构建Spring Boot项目

（1）创建项目，选择Spring starter Project(需先在Eclipse安装Spring Tool Suite),按Next: 
这里写图片描述

（2）填写跟项目相关的各种信息，然后Next： 
这里写图片描述

（3）选择需要的Dependency，然后Next： 
这里写图片描述 
（4）最后”Finish”,就开始下载jar包了，这个过程需要的时间比较长。

运行项目

项目结构介绍

这里写图片描述

如上图所示，Spring Boot的基础结构共三个文件:

  1. src/main/java 程序开发以及主程序入口
  2. src/main/resources 配置文件
  3. src/test/java 测试程序

另外，spingboot建议的目录结果如下： 
root package结构：com.example.myproject

com
  +- example
    +- myproject
      +- Application.java
      |
      +- domain
      |  +- Customer.java
      |  +- CustomerRepository.java
      |
      +- service
      |  +- CustomerService.java
      |
      +- controller
      |  +- CustomerController.java
      |

1、Application.java 建议放到根目录下面,主要用于做一些框架配置 
2、domain目录主要用于实体（Entity）与数据访问层（Repository） 
3、service 层主要是业务类代码 
4、controller 负责页面访问控制

pom.xml

pom.xml文件中默认有两个模块：

spring-boot-starter ：核心模块，包括自动配置支持、日志和YAML；

spring-boot-starter-test ：测试模块，包括JUnit、Hamcrest、Mockito。

启动单个controller

1，创建controller

package com.ailianshuo.helloword.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloWorldController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }
}

@RestController 的意思就是controller里面的方法都以json格式输出，不用再写什么jackjson配置的了

2，启动controller准备 
按上面的代码还不能启动单个controller，需要添加下面代码才可以： 
（1）@EnableAutoConfiguration ：作用在于让 Spring Boot 根据应用所声明的依赖来对 Spring 框架进行自动配置，这就减少了开发人员的工作量。(也可以使用@SpringBootApplication 等价于以默认属性使用 @Configuration ， @EnableAutoConfiguration 和 @ComponentScan) 
（2）启动程序： 
public static void main(String[] args) throws Exception { 
SpringApplication.run(**.class, args); 
} 
完整代码如下：

@EnableAutoConfiguration
@RestController
public class HelloWorldController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }

    public static void main(String[] args) {  
           SpringApplication.run(HelloWorldController.class);  
    } 
}

3，启动单个controller 
（1）右键HelloWorldController中的main方法，Run As -> Spring Boot App，项目就可以启动了。

这里写图片描述

(2) 编译器显示如下内容，即为启动成功。 
2017-08-19 11:12:49.814 INFO 4164 — [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http) 
2017-08-19 11:12:49.819 INFO 4164 — [ main] c.a.h.controller.HelloWorldController : Started HelloWorldController in 3.351 seconds (JVM running for 4.573)

（3）在浏览器访问http://localhost:8080/hello ，就可以看到效果了。

在此我向大家推荐一个架构学习交流群。交流学习群号：575745314 里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多


二、RESTfull API简单项目的快速搭建

编辑pom.xml

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  4.     <modelVersion>4.0.0</modelVersion>  
  5.   
  6.     <groupId>com.lyw</groupId>  
  7.     <artifactId>springboot02</artifactId>  
  8.     <version>0.0.1-SNAPSHOT</version>  
  9.     <packaging>jar</packaging>  
  10.   
  11.     <name>springboot02</name>  
  12.   
  13.     <parent>  
  14.         <groupId>org.springframework.boot</groupId>  
  15.         <artifactId>spring-boot-starter-parent</artifactId>  
  16.         <version>1.4.0.RELEASE</version>  
  17.         <relativePath/> <!-- lookup parent from repository -->  
  18.     </parent>  
  19.   
  20.     <properties>  
  21.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  22.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>  
  23.         <java.version>1.8</java.version>  
  24.     </properties>  
  25.   
  26.     <dependencies>  
  27.         <dependency>  
  28.             <groupId>org.springframework.boot</groupId>  
  29.             <artifactId>spring-boot-starter-web</artifactId>  
  30.         </dependency>  
  31.   
  32.         <dependency>  
  33.             <groupId>org.springframework.boot</groupId>  
  34.             <artifactId>spring-boot-starter-test</artifactId>  
  35.             <scope>test</scope>  
  36.         </dependency>  
  37.         <dependency>  
  38.             <groupId>org.springframework.boot</groupId>  
  39.             <artifactId>spring-boot-devtools</artifactId>  
  40.         </dependency>  
  41.     </dependencies>  
  42.   
  43.     <build>  
  44.         <plugins>  
  45.             <plugin>  
  46.                 <groupId>org.springframework.boot</groupId>  
  47.                 <artifactId>spring-boot-maven-plugin</artifactId>  
  48.             </plugin>  
  49.         </plugins>  
  50.     </build>  
  51. </project>  

简单解释一下上面的配置 

首先看看Spring-boot-start-web包的依赖

可以看到 其实这个包就是一些 日志包 还有内置Tomcat JSON包 SpringMVC/Web包 这也就差不多解释了为什么直接跑起来了

其实这个就是可以理解为简单封装了一下Spring 使得我们配置更加便捷。

spring-boot-devtools的引入，其依赖包的学习

这个包 包含一些Spring的核心包。。。

spring-boot-maven-plugin 最后还加入了 一个SpringBoot的Maven插件

开始写代码。。。

Springboot2Application.java

[java] view plain copy

  1. package com.lyw;  
  2.   
  3. import org.springframework.boot.SpringApplication;  
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;  
  5.   
  6. @SpringBootApplication  
  7. public class Springboot02Application {  
  8.   
  9.     public static void main(String[] args) {  
  10.         SpringApplication.run(Springboot02Application.class, args);  
  11.     }  
  12. }  

User.java

[java] view plain copy

  1. package com.lyw.bean;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  * Title: User Description: 实体类 Company: blog.csdn.net/lu1005287365/ 
  7.  *  
  8.  * @author L lulu 
  9.  */  
  10. public class User {  
  11.     private Integer id;  
  12.     private String name;  
  13.     private Date date;  
  14.     private char sex;  
  15.   
  16.     public Integer getId() {  
  17.         return id;  
  18.     }  
  19.   
  20.     public void setId(Integer id) {  
  21.         this.id = id;  
  22.     }  
  23.   
  24.     public String getName() {  
  25.         return name;  
  26.     }  
  27.   
  28.     public void setName(String name) {  
  29.         this.name = name;  
  30.     }  
  31.   
  32.     public Date getDate() {  
  33.         return date;  
  34.     }  
  35.   
  36.     public void setDate(Date date) {  
  37.         this.date = date;  
  38.     }  
  39.   
  40.     public char getSex() {  
  41.         return sex;  
  42.     }  
  43.   
  44.     public void setSex(char sex) {  
  45.         this.sex = sex;  
  46.     }  
  47.   
  48. }  



UserControoler.java

[java] view plain copy

  1. package com.lyw.controller;  
  2.   
  3. import java.util.Date;  
  4. import java.util.HashMap;  
  5. import java.util.Map;  
  6.   
  7. import org.springframework.web.bind.annotation.PathVariable;  
  8. import org.springframework.web.bind.annotation.RequestMapping;  
  9. import org.springframework.web.bind.annotation.RestController;  
  10.   
  11. import com.lyw.bean.User;  
  12.   
  13. @RestController  
  14. @RequestMapping(value = "/user")  
  15. public class UserController {  
  16.   
  17.     @RequestMapping  
  18.     public String index() {  
  19.         return "Hello BeiJing";  
  20.     }  
  21.   
  22.     @RequestMapping(value = "/getMap")  
  23.     public Map<String, Object> getThisMap(String msg) {  
  24.         Map<String, Object> map = new HashMap<>();  
  25.         map.put("Name", "LYW");  
  26.         map.put("Sex", "大老爷们");  
  27.         map.put("Message", msg);  
  28.         return map;  
  29.     }  
  30.   
  31.     @RequestMapping(value = "/getUser/{name}/{sex}")  
  32.     public User getUser(@PathVariable String name, @PathVariable char sex) {  
  33.         User user = new User();  
  34.         user.setId(12);  
  35.         user.setName(name);  
  36.         user.setDate(new Date());  
  37.         user.setSex(sex);  
  38.         return user;  
  39.     }  
  40.   
  41. }  

运行项目:

直接运行main方法或者使用maven命令: spring-boot:run


上面就是运行的结果。。

解释

@RestController注解：看看源码 其实就是 又封装了一层 将@Controller和@RsponseBody两个注解合在一起

这样一来应该对SpringBoot 也有了初步的认识。。。并且会简单的使用

三、Spring Boot 实现多环境配置

在实际项目中，我们一般会放置一些配置文件，这些配置文件是区分环境的，一般环境有dev，test，prep，prod，分别对应开发，测试，预发布，生产。那么在spring boot项目中如何实现不同环境，使用不同的配置文件呢。

第一步:定义好不同环境的application.properties

image.png

application.properties 存放公用的一些配置。 
以及最重要的配置 [email protected]@ 
application-dev.properties 对应开发环境 
application-test.properties 对应测试环境 
application-prep.properties 对应预生产环境 
application-prod.properties 对应生产环境

第二步：pom中定义profile 
image.png

第三步:maven命令打包 
package -Dmaven.test.skip=true -Pdev

那么此时就会将application-dev.properties 和application.properties 的配置都打入包中了。

在此我向大家推荐一个架构学习交流群。交流学习群号：575745314 里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多
 

四、Spring Boot应用监控

入门使用：Actuator插件

Actuator插件是SpringBoot原生提供的一个服务，可以通过暴露端点路由，用来输出应用中的诸多 端点信息。实战一下！

  • pom.xml中添加依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

启动Spring Boot应用程序之后，只要在浏览器中输入端点信息就能获得应用的一些状态信息。

常用端点列举如下，可以一个个详细试一下：

当然此时只能使用/health 和 /info端点，其他因为权限问题无法访问。想访问指定端点的话可以在yml配置中添加相关的配置项，比如/metrics端点则需要配置：

endpoints:
  metrics:
    sensitive: false

此时浏览器访问/metrics端点就能得到诸如下面所示的信息：

当然也可以开启全部端点权限，只需如下配置即可：

endpoints:
  sensitive: false

于Actuator插件提供的监控能力毕竟有限，而且UI比较简陋，因此需要一个更加成熟一点的工具

Spring Boot Admin监控系统

SBA则是基于Actuator更加进化了一步，其是一个针对Actuator接口进行UI美化封装的监控工具。我们来实验一下。

  • 首先来创建一个Spring Boot Admin Server工程作为服务端

pom.xml中加入如下依赖：

然后在应用主类上通过加注解来启用Spring Boot Admin

启动程序，浏览器打开 localhost:8081 查看Spring Boot Admin主页面：

Spring Boot Admin主页面

此时Application一栏空空如也，等待待监控的应用加入

  • 创建要监控的Spring Boot应用

pom.xml中加入以下依赖

然后在yml配置中添加如下配置，将应用注册到Admin服务端去：

Client应用一启动，Admin服务立马推送来了消息，告诉你AdminTest上线了：

应用上线推送消息

此时去Admin主界面上查看，发现Client应用确实已经注册上来了：

Client应用已注册上来

  • 查看Detail

Detail信息

  • 查看 Metrics

Metrics信息

  • 查看 Enviroment

Enviroment信息

  • 查看JMX

JMX信息

  • 查看Threads

Threads信息

  • 查看Trace与详情

Trace信息

点击最上方JOURNAL，会看到被监控应用程序的事件变化：

应用程序的事件变化信息

图中可以清晰地看到，应用从 REGISTRATION → UNKNOWN → UP 的状态跳转。

这样就将Actuator插件提供的所有端点信息在SBA中全部尝试了一遍。

在此我向大家推荐一个架构学习交流群。交流学习群号：575745314 里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多
图片描述

五、Spring Boot的日志管理

默认情况下，Spring Boot的日志是输出到控制台的，不写入任何日志文件。

要让Spring Boot输出日志文件，最简单的方式是在application.properties配置文件中配置logging.path键值，如下：（日志文件为spring.log）

logging.path=/var/log

二种方法是在application.properties配置文件中配置logging.file键值，如下：

logging.file=/var/log/myapp.log

两种配置方法适用于开发阶段，对于部署则存在一定的问题。比如部署到不同的环境，可能就存在需要修改application.properties文件的情况，这就意味着需要重新打包，再次部署，显得不便捷。

有鉴于此，Spring Boot提供了一种覆写application.properties配置文件中键值的方法，在命令行通过指定参数来实现覆写——在运行时把命令行参数当作标准的系统属性，如下：

java -jar -Dlogging.path=/tmp myapp.jar

后，还可以在命令行调用Spring Boot的Maven插件时覆写这个值。但是，直接使用系统属性对于插件方式是无效的。需要使用run.jvmArguments参数来指定系统属性，设置想要的值：

mvn spring-boot:run -Drun.jvmArguments="-Dlogging.path=/tmp"

猜你喜欢

转载自my.oschina.net/u/3636867/blog/1809823
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022