springboot入门一

139次阅读

共计 4832 个字符,预计需要花费 13 分钟才能阅读完成。

1、Spring Boot 2.0 更新了什么

  • 基础环境升级

    Spring Boot 2.0 要求 Java 8 作为最低版本。
    Spring Boot 2.0 通过了在 JDK 9 下的测试,可以在 JDK 9 下正常运行,同时 Spring Boot 2.0 宣布不再⽀支持
    Java 6 和 7,最低 JDK 8,支持 JDK 9。

  • 依赖组件升级

    本次 Spring Boot 2.0 的升级,同时也升级了部分其依赖的第三方组件,主要有以下几个:

    • Jetty 9.4,Jetty 是⼀个开源的 Servlet 容器器,它是基于 Java 的 Web 内容,例如 JSP 和 Servlet 提供运行环境。Jetty 是使用 Java 语言编写的,它的 API 以一组 JAR 包的形式发布。
    • Tomcat 8.5,Apache Tomcat 8.5.x 旨在取代 8.0.x,完全⽀持 Java 9。
    • Flyway 5,Flyway 是独⽴于数据库的应用、管理并跟踪数据库变更的数据库版本管理工具。用通俗的话讲,Flyway 可以像 SVN 管理不同人的代码那样,管理不同人的 SQL 脚本,从而做到数据库同步。
    • Hibernate 5.2,Hibernate 是⼀一款非常流行的 ORM 框架。
    • Gradle 3.4,Spring Boot 的 Gradle 插件在很⼤大程度上已被重写,有了了重⼤大的改进。
    • Thymeleaf 3.0,Thymeleaf 3 相对于 Thymeleaf 2 有非常大的性能提升。
  • 默认软件替换和优化

    默认连接池已从 Tomcat 切换到 HikariCP,HikariCP 是一个高性能的 JDBC 连接池。

    HikariCP 号称是 Java 业界最快的数据库连接池。

    HikariCP 性能为什什么如此突出?

    • 字节码精简:优化代码,直到编译后的字节码最少,这样 CPU 缓存可以加载更多的程序代码。
    • 优化代理和拦截器:减少代码,例如 HikariCP 的 Statement proxy 只有 100 行代码。
    • 自定义数组类型(FastStatementList)代替 ArrayList:避免每次 get() 调用都要行 range check,避
      免调用 remove() 时从头到尾的扫描。
    • 自定义集合类型(ConcurrentBag):提高并发读写的效率。
    • 其他针对 BoneCP 缺陷的优化,比如对于耗时超过一个 CPU 时间片的方法调用的研究。
  • Spring Security

    Spring Security 是 Spring 社区的一个顶级项目,是 Spring Boot 官方推荐使用的 Security 框架。

    除了常规
    的 Authentication 和 Authorization 之外,Spring Security 还提供了了诸如 ACLs、LDAP、JAAS、CAS 等高级性以满足复杂场景下的安全需求。

    而 Spring Boot 中基于 Java 配置实现 Spring Security 功
    能。Spring Boot 2 极大地简化了默认的安全配置,并使添加定制安全变得简单。
    Spring Boot 2.0 ⾮常容易使用 Spring Security 5.0 保护响应式应用,当检测到 Spring Security 存在的时候会自动进行默认配置。

  • OAuth 2.0

    OAuth 2.0 是 OAuth 协议的延续版本,不向后兼容 OAuth 1.0。OAuth 2.0 关注客户端开发者的简易性。要么通过组织在资源拥有者和 HTTP 服务商之间的被批准的交互动作代表用户,要
    么允许第三方应用代表用户获得访问的权限。

    OAuth 2 是一个授权框架,它可以使第三方应⽤用程序或客户端获得对 HTTP 服务上(如
    Google、GitHub)用户帐户信息的有限访问权限。OAuth 2 通过将用户身份验证委派给托管用户帐户的服务以及授权客户端访问用户帐户进行工作。

    Spring Boot 2.0 将 Spring Security OAuth 项目迁移到 Spring Security。不再提供单独的依赖包,Spring
    Boot 2.0 通过 Spring Security 5 提供 OAuth 2.0 客户端支持。

  • Micrometer

    Micrometer 是一款监控指标的度量类库,可以让你在没有供应商锁定的情况下对 JVM 的应用程序代码进⾏调整。

    集成后提供 JVM 指标(包括 CPU、内存、线程和 GC)、Logback、Tomcat、Spring MVC 并且提供
    RestTemplate。

  • Redis

    Redis 默认引入了 Lettuce,替代了之前的 Jedis 作为底层的 Redis 连接方式。

    Lettuce 是一个可伸缩的线程安全的 Redis 客户端,用于同步、异步和反应使用。多个线程可以共享同⼀一个
    RedisConnection,它利用优秀 Netty NIO 框架来高效地管理多个连接,支持先进的 Redis 功能,如
    Sentinel、集群、流水线、自动重新连接和 Redis 数据模型。

  • 支持 HTTP/2

    HTTP/2 是第二代的 HTTP 协议,Spring Boot 的 Web 容器选择中 Tomcat,Undertow 和 Jetty 均已⽀支持
    HTTP/2。

  • JOOQ 的⽀支持

    JOOQ 是基于 Java 访问关系型数据库的工具包。JOOQ 既吸取了传统 ORM 操作数据的简单性和安全性,
    又保留了原生 SQL 的灵活性,它更像是介于 ORMS 和 JDBC 的中间层。

    对于喜欢写 SQL 的码农来说,
    JOOQ 可以完全满足,可以是用 Java 代码写出 SQL 的感觉来。

2、Spring Boot 2.0 入门程序

  • 新建 spring-boot-web 项目,在 pom.xml 中添加如下依赖。

    <?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.5.RELEASE</version>
            <relativePath/> <!-- lookup parent from repository -->
        </parent>
        <groupId>com.rookie</groupId>
        <artifactId>springboot-web</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-web</name>
        <description>Demo project for Spring Boot web</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.4</version>
            </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>
                    <configuration>
                        <fork>true</fork>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>
  • 创建实体对象 User

    @Getter
    @Setter
    @ToString
    public class User {
        private String name;
        private String address;
        private int age;
    }

    上面代码使用 lombok 插件,只需要注解即可省略 getter/setter/toString 等方法

  • 新建一个类 WebController,用于测试

    @RestController
    public class WebController {@RequestMapping(value = "/getUser", method = RequestMethod.POST)
        public User getUserInfo() {User user = new User();
            user.setName("我是菜鸟 A");
            user.setAddress("北京");
            user.setAge(18);
    
            return user;
        }
    
        @RequestMapping(value = "/getUsers", method = RequestMethod.POST)
        public List<User> getUserListInfo() {List<User> users = new ArrayList<>();
    
            User user = new User();
            user.setName("我是菜鸟 A");
            user.setAddress("北京");
            user.setAge(18);
            users.add(user);
    
            User user2 = new User();
            user2.setName("我是菜鸟 B");
            user2.setAddress("南京");
            user2.setAge(28);
            users.add(user2);
    
            return users;
        }
    
        @RequestMapping(value = "/get/{name}", method = RequestMethod.GET)
        public String getName(@PathVariable String name) {return name;}
    }

    测试结果,使用 postman 进行模拟访问(使用 postman 的时候注意对应正确的请求的方式)

    localhost:8080/getUser

    {“name”: “ 我是菜鸟 A ”,”address”: “ 北京 ”,”age”: 18}

    localhost:8080/getUsers

    [{“name”: “ 我是菜鸟 A ”, “address”: “ 北京 ”, “age”: 18},
    {“name”: “ 我是菜鸟 B ”, “address”: “ 南京 ”,”age”: 28} ]

    localhost:8080/get/rookie

    control 控制台会返回:rookie

正文完
 0

Spring-Boot-入门一

139次阅读

共计 4702 个字符,预计需要花费 12 分钟才能阅读完成。

1、Spring Boot 简介
简化 Spring 应用开发的一个框架;整个 Spring 技术栈的一个大整合;J2EE 开发的一站式解决方案;

2、微服务
2014,martin fowler

微服务:架构风格(服务微化)

一个应用应该是一组小型服务;可以通过 HTTP 的方式进行互通;单体应用:ALL IN ONE

微服务:每一个功能元素最终都是一个可独立替换和独立升级的软件单元;

3、环境准备
–jdk1.8:Spring Boot 推荐 jdk1.7 及以上;java version“1.8.0_112”

–maven3.x:maven 3.3 以上版本;Apache Maven 3.3.9

–IntelliJIDEA2017:IntelliJ IDEA 2017.2.2 x64、STS

–SpringBoot 1.5.9.RELEASE:1.5.9;统一环境;

1、MAVEN 设置;
给 maven 的 settings.xml 配置文件的 profiles 标签添加

<profile>
    <id>jdk‐1.8</id>
<activation>
<activeByDefault>true</activeByDefault> 5    <jdk>1.8</jdk>
</activation>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
</properties>
</profile>

2、IDEA 设置
整合 maven 进来;

4、Spring Boot HelloWorld
一个功能:

浏览器发送 hello 请求,服务器接受请求并处理,响应 Hello World 字符串;

1、创建一个 maven 工程;(jar)
2、导入 spring boot 相关的依赖

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐parent</artifactId>
<version>1.5.9.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
</dependency>
</dependencies>

3、编写一个主程序;启动 Spring Boot 应用

/**
* @SpringBootApplication 来标注一个主程序类,说明这是一个 Spring Boot 应用
*/ @SpringBootApplication
public class HelloWorldMainApplication {public static void main(String[] args) {

// Spring 应用启动起来
SpringApplication.run(HelloWorldMainApplication.class,args);

 }
}

4、编写相关的 Controller、Service

@Controller
public class HelloController {
@ResponseBody
@RequestMapping("/hello")
public String hello(){return "Hello World!";}    
   }

5、运行主程序测试

6、简化部署

<!‐‐ 这个插件,可以将应用打包成一个可执行的 jar 包;‐‐>
<build>
<plugins>
    <plugin>
<groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐maven‐plugin</artifactId>
</plugin>
</plugins>
</build>

将这个应用打成 jar 包,直接使用 java -jar 的命令进行执行;

5、Hello World 探究
1、POM 文件
1、父项目

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐starter‐parent</artifactId>
    <version>1.5.9.RELEASE</version> 
    </parent>
   他的父项目是
     <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring‐boot‐dependencies</artifactId>
    <version>1.5.9.RELEASE</version>
    <relativePath>../../spring‐boot‐dependencies</relativePath>
    </parent>

Spring Boot 的版本仲裁中心;

以后我们导入依赖默认是不需要写版本;(没有在 dependencies 里面管理的依赖自然需要声明版本号)

2、启动器

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId> 
</dependency>

spring-boot-starter-web:

spring-boot-starter:spring-boot 场景启动器;帮我们导入了 web 模块正常运行所依赖的组件;

Spring Boot 将所有的功能场景都抽取出来,做成一个个的 starters(启动器),只需要在项目里面引入这些 starter

相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

2、主程序类,主入口类

/**
*  @SpringBootApplication 来标注一个主程序类,说明这是一个 Spring Boot 应用
*/
@SpringBootApplication
public class HelloWorldMainApplication {public static void main(String[] args) { 
// Spring 应用启动起来
SpringApplication.run(HelloWorldMainApplication.class,args);
}
 }

@SpringBootApplication: Spring Boot 应用标注在某个类上说明这个类是 SpringBoot 的主配置类,SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

@SpringBootConfiguration:Spring Boot 的配置类;

标注在某个类上,表示这是一个 Spring Boot 的配置类;

@Configuration: 配置类上来标注这个注解;

配置类 —– 配置文件;配置类也是容器中的一个组件;@Component

@EnableAutoConfiguration:开启自动配置功能;

以前我们需要配置的东西,Spring Boot 帮我们自动配置;@EnableAutoConfiguration 告诉 SpringBoot 开启自动配置功能;这样自动配置才能生效;

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

@AutoConfigurationPackage:自动配置包

@Import(AutoConfigurationPackages.Registrar.class):

Spring 的底层注解 @Import,给容器中导入一个组件;导入的组件由 AutoConfigurationPackages.Registrar.class;

将主配置类(@SpringBootApplication 标注的类)的所在包及下面所有子包里面的所有组件扫描到 Spring 容器;

@Import(EnableAutoConfigurationImportSelector.class);

给容器中导入组件?

EnableAutoConfigurationImportSelector:导入哪些组件的选择器;

将所有需要导入的组件以全类名的方式返回;这些组件就会被添加到容器中;

会给容器中导入非常多的自动配置类(xxxAutoConfiguration);就是给容器中导入这个场景需要的所有组件,并配置好这些组件;
在这里插入图片描述

有了自动配置类,免去了我们手动编写配置注入功能组件等的工作;SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader);

Spring Boot 在启动的时候从类路径下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作;以前我们需要自己配置的东西,自动配置类都帮我们;

J2EE 的整体整合解决方案和自动配置都在 spring-boot-autoconfigure-1.5.9.RELEASE.jar;

Spring 注解版

6、使用 Spring Initializer 快速创建 Spring Boot 项目
1、IDEA:使用 Spring Initializer 快速创建项目

IDE 都支持使用 Spring 的项目创建向导快速创建一个 Spring Boot 项目;

选择我们需要的模块;向导会联网创建 Spring Boot 项目;

默认生成的 Spring Boot 项目;

主程序已经生成好了,我们只需要我们自己的逻辑

resources 文件夹中目录结构

static:保存所有的静态资源;js css images;

templates:保存所有的模板页面;(Spring Boot 默认 jar 包使用嵌入式的 Tomcat,默认不支持 JSP 页面);可以使用模板引擎(freemarker、thymeleaf);

application.properties:Spring Boot 应用的配置文件;可以修改一些默认设置;

2、STS 使用 Spring Starter Project 快速创建项目

正文完
 0