经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
SpringBoot的基础
来源：cnblogs　　作者：我想回家　　时间：2018/10/20 15:37:30　　对本文有异议

概念

Spring的优缺点

  1. 1. 优点(AOP和IOC简化开发)
  2.     Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。
  3. 2. 缺点(配置繁琐和pom.xml的坐标引入麻烦)
  4.     1. 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
  5.     2. 所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
  6.     3. 除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。
  7.

SpringBoot

  1. 1. springboot解决spring的缺点:
  2.     SpringBoot基于**约定优于配置**的思想,不必在配置与逻辑业务之间进行思维的切换,从而大大提高了开发的效率.
  3. 2. SpringBoot的特点:
  4.     1. 为基于Spring的开发提供更快的入门体验
  5.     2. 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
  6.     3. 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
  7.     4. SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式
  8. 3. 核心功能
  9.     1. 起步依赖(start dependence)
  10.         起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
  11.         简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
  12.     2. 自动配置(auto configuration)
  13.          SpringBoot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。
  14.

开始代码

快速开始

  1. 1. 创建普通的maven项目,简单的javase就好
  2. 2. 编写pom.xml文件
  3.     1. SpringBoot要求，项目要继承SpringBoot的起步依赖spring-boot-starter-parent
  4.         <parent>
  5.             <groupId>org.springframework.boot</groupId>
  6.             <artifactId>spring-boot-starter-parent</artifactId>
  7.             <version>2.0.5.RELEASE</version>
  8.         </parent>
  9.     2. SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启动依赖(以功能为单位的)
  10.         <dependencies>
  11.             <dependency>
  12.                 <groupId>org.springframework.boot</groupId>
  13.                 <artifactId>spring-boot-starter-web</artifactId>
  14.             </dependency>
  15.         </dependencies>
  16. 3. 编写启动引导类(引导类放置的位置在创建项目时指定的groupid包下)
  17.     package cn.wzlove;
  18.     import org.springframework.boot.SpringApplication;
  19.     import org.springframework.boot.autoconfigure.SpringBootApplication;
  20.     // 使用注解标注该类是SpringBoot的引导类
  21.     @SpringBootApplication
  22.     public class MySpringBootApplication {
  23.     
  24.         public static void main(String[] args) {
  25.             // run方法表示运行SpringBoot的引导类,参数是SpringBoot引导类的字节码文件
  26.             SpringApplication.run(MySpringBootApplication.class);
  27.         }
  28.     
  29.     }
  30. 4. 编写Controller进行测试
  31.     @Controller
  32.     public class QuickController {
  33.     
  34.         @RequestMapping("quick")
  35.         @ResponseBody
  36.         public String quickStart(){
  37.             return "quick start";
  38.         }
  39.     }
  40.     ====================================
  41.     或者使用RestController
  42.     @RestController
  43.     public class HelloController {
  44.     
  45.         @RequestMapping("hello")
  46.         public String hello(){
  47.             return "hello";
  48.         }
  49.     }
  50.

SpringBoot的热部署

  1. 1. 添加功能坐标:
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-devtools</artifactId>
  5.     </dependency>
  6. 2. idea的配置
  7.     file ---> setting,搜索compile,选中Compile,右侧会出现内容,这个时候选中Build project automatically.点击apply,点击ok
  8. 3. 快捷键ctrl+alt+shift+/,选中Registry,在aompiler.automake.allow.when.app.running后面打上对勾,之后关闭就好.
  9.

idea快速创建SpringBoot项目

  1. 1. file创建工程,这个时候不要选择maven,而是选择Spring Initializr,点击下一步,输入Group和Artifact,下一步,选择依赖,目前先选择Web下的Web,下一步,就可以一完成创建了.

SpringBoot的原理分析:

起步原理分析

  1. 1. SpringBoot继承的起步依赖spring-boot-starter-parent
  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.0.6.RELEASE</version>
  6.     </parent>
  7.     查看源码可以看到默认加载resources下的以application开头的配置文件和各种插件,并且还继承了spring-boot-dependencies.
  8.     
  9.     继续查看spring-boot-dependencies的源码,主要看<properties></properties>之间的内容,也就是版本控制,里面包含了各种依赖包的版本号,继续看<dependencyManagement>里面的内容,版本统一管理器.
  10.     
  11.     这下就可以看出来继承的起步依赖主要是为了进行jar包的版本控制的.这样我们在pom文件中导入依赖就不需要指定版本了.
  13. 2. web工程的起步依赖所做的事
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-web</artifactId>
  17.     </dependency>
  18.     查看源码可以看到这个依赖内部引入了更多的依赖,比如过spring-web,spring-webmvc,json等等,传递依赖.
  19.

自动配置

  1. 1. 从@SpringBootApplication开始研究,自动配置就是从这开始的.查看源码主要看:
  2.     // SpringBootConfiguration其实就是@Configuration,指定配置文件的
  3.     @SpringBootConfiguration
  4.     // 自动配置
  5.     @EnableAutoConfiguration
  6.     // 根据约定大于配置,所以默认的扫描包是启动类下及其子包下的所有Bean
  7.     @ComponentScan(excludeFilters = {
  8.             @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
  9.             @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
  10. 2. @EnableAutoConfiguration代表是否可以自动配置  ,查看源码主要看@Import(AutoConfigurationImportSelector.class),查看AutoConfigurationImportSelector类下的selectImports方法,看List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);其实应该就是全包名的集合,点进去看看,会让去查找META-INF/spring.factories下的这个文件,这个文件在当前类所在的包下,打开看看就是各种全类名.可以继续向下研究,查看各种AutoConfiguration类的源码

创建配置文件修改端口号和web应用的名称

  1. resources下创建application.properties,内容为:
  2.     # 设置启动端口号为8081
  3.     server.port=8081
  4.     # 当前web的应用名称
  5.     server.servlet.context-path=/springboot
  6.

SpringBoot的配置文件:

配置文件类型和作用:

  1. 1. 覆盖默认配置: SpringBoot是基于约定的，所以很多配置都有默认值，但如果想替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
  2. 2. 配置额外信息,比如数据源等等
  3. 3. 配置文件放在resources目录下.默认加载application.properties或application.yml（application.yaml）文件
  4. 4. application.properties文件是键值对类型的文件.yml文件类似于json.
  5.

yml文件

  1. 1. YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。
  3. 2. YML文件的扩展名可以使用.yml或者.yaml。(SpringBoot是有默认加载顺序的,源码可以看到,先加载yml的,后加载yaml的,最后加载properties,后面的会覆盖前面的).
  4. 3. 语法形式:
  5.     1. 配置普通数据
  6.         name: wangzhi  =====> 冒号后面有空格
  7.     2. 配置对象数据(person对象为例),两种,推荐第一种
  8.         person:
  9.             name: zhangsan
  10.             age: 18
  11.             addr: beijing
  12.         =============================
  13.         person: {name: zhangsan,age: 18,addr: beijing}
  14.     3. 配置数组
  15.         普通数组:
  16.             city:
  17.                 - beijing
  18.                 - tianjin
  19.                 - chongqing
  20.                 - shanghai
  21.             =============================
  22.             city: [beijing,tianjin,chongqing,shanghai]
  23.         对象集合:
  24.             student:
  25.                 - name: tom
  26.                   age: 18
  27.                   addr: beijing
  28.                 - name: lucy
  29.                   age: 17
  30.                   addr: yuncheng
  31.             ============================
  32.             student: [{name: zhangsan,age: 18,addr: beijing},{name: tom,age: 18,addr: beijing}]
  33.     4. map配置:
  34.         map:
  35.             key1: value1
  36.             key2: value2
  37. 4. 测试注入:
  38.     application.yml的内容为:
  39.         name: wangzhi
  40.         person:
  41.           name: lucy
  42.           age: 24
  43.           addr: 运城
  44.     代码内的注入(使用@Value注解):
  45.         @Value("${name}")
  46.         private String name;
  47.         @Value("${person.addr}")
  48.         private String addr;
  49.         @Value("${person.age}")
  50.         private int age;
  51.     代码内的注入方式2:
  52.         通过注解@ConfigurationProperties(prefix="配置文件中的key的前缀")可以将配置文件中的配置自动与实体进行映射,需要提供get和set方法
  53. 2. 执行器的配置(编写yml的文件的时候有代码提示,不配置也可以完成功能)
  54.     <!--@ConfiguaritionProperties的执行器的配置-->
  55.     <dependency>
  56.         <groupId>org.springframework.boot</groupId>
  57.         <artifactId>spring-boot-configuration-processor</artifactId>
  58.         <optional>true</optional>
  59.     </dependency>
  60.

SpringBoot与其他技术的整合

与Mybatis的整合

  1. 1. 添加Mybatis的起步依赖
  2.     <!--mybatis起步依赖-->
  3.     <dependency>
  4.         <groupId>org.mybatis.spring.boot</groupId>
  5.         <artifactId>mybatis-spring-boot-starter</artifactId>
  6.         <version>1.3.2</version>
  7.     </dependency>
  8. 2. 添加数据库驱动坐标
  9.     <dependency>
  10.         <groupId>mysql</groupId>
  11.         <artifactId>mysql-connector-java</artifactId>
  12.     </dependency>
  13. 3. 添加数据库的连接信息(在resources下的application.properties添加内容):
  14.     # 数据库的连接信息
  15.     spring.datasource.driverClassName=com.mysql.jdbc.Driver
  16.     spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
  17.     spring.datasource.username=root
  18.     spring.datasource.password=nrblwbb7
  19. 4. 创建数据库和表结构:
  20.     CREATE DATABASE test;
  21.     USER test;
  22.     DROP TABLE IF EXISTS `user`;
  23.     CREATE TABLE `user` (
  24.       `id` INT(11) NOT NULL AUTO_INCREMENT,
  25.       `username` VARCHAR(50) DEFAULT NULL,
  26.       `password` VARCHAR(50) DEFAULT NULL,
  27.       `name` VARCHAR(50) DEFAULT NULL,
  28.       PRIMARY KEY (`id`)
  29.     ) ENGINE=INNODB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
  30.     INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三');
  31.     INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');
  32.     SELECT * FROM USER;
  33. 5. 创建实体类
  34.     public class User {
  35.         // 主键
  36.         private Long id;
  37.         // 用户名
  38.         private String username;
  39.         // 密码
  40.         private String password;
  41.         // 姓名
  42.         private String name;
  43.       
  44.         //此处省略getter和setter方法 .. ..
  45.     }
  46. 6. 创建mapper接口
  47.     public interface UserMapper {
  48.         List<User> queryUserList();
  49.     }
  50. 7. 创建映射配置文件(在resources下新建mapper文件夹,在下面创建UserMapper.xml)
  51.     <?xml version="1.0" encoding="utf-8" ?>
  52.     <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  53.             "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
  54.     <mapper namespace="cn.wzlove.mapper.UserMapper">
  55.         <select id="queryUserList" resultType="user">
  56.             select * from user
  57.         </select>
  58.     </mapper>
  59. 8. 配置文件配置mybatis的信息:
  60.     #spring集成Mybatis环境
  61.     #pojo别名扫描包
  62.     mybatis.type-aliases-package=cn.wzlove.domain
  63.     #加载Mybatis映射文件
  64.     mybatis.mapper-locations=classpath:mapper/*Mapper.xml
  65. 9. 写个Controller进行代码测试
  66.     @RestController
  67.     public class Controller {
  68.     
  69.         @Autowired
  70.         private UserMapper userMapper;
  71.     
  72.         @RequestMapping("mybatis")
  73.         public String testMyBatis(){
  74.             List<User> users = userMapper.queryUserList();
  75.             System.out.println(users);
  76.             return "success";
  77.     
  78.         }
  79.     }

与Junit的整合

  1. 1. 添加SpringBoot集成Junit测试的起步依赖(如果使用idea创建的话会直接引入,不需要重复导入)
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-test</artifactId>
  5.         <scope>test</scope>
  6.     </dependency>
  7. 2. 编写测试类:
  8.     // SpringRunner继承自SpringJUnit4ClassRunner，使用哪一个Spring提供的测试测试引擎都可以
  9.     @RunWith(SpringRunner.class)
  10.     // classes后面的字节码是启动类的字节码
  11.     @SpringBootTest(classes = SpringbootMybatisApplication.class)
  12.     public class UserMapperTest {
  13.     
  14.         @Autowired
  15.         private UserMapper userMapper;
  16.     
  17.         @Test
  18.         public void testMyBatis(){
  19.             List<User> users = userMapper.queryUserList();
  20.             System.out.println(users);
  21.         }
  22.     }

与SpringDataJPA的整合

  1. 1. 添加Spring Data JPA的起步依赖
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-data-jpa</artifactId>
  5.     </dependency>
  6. 2. 添加mysql连接驱动依赖
  7.     <dependency>
  8.         <groupId>mysql</groupId>
  9.         <artifactId>mysql-connector-java</artifactId>
  10.     </dependency>
  11. 3. 在application.properties中配置数据库和jpa的相关属性
  12.     # 配置数据库的连接信息
  13.     spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  14.     spring.datasource.url=jdbc:mysql:////127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8
  15.     spring.datasource.username=root
  16.     spring.datasource.password=nrblwbb7
  17.     
  18.     # 配置Spring Data JPA的相关信息
  19.     spring.jpa.database=mysql
  20.     spring.jpa.show-sql=true
  21.     spring.jpa.generate-ddl=true
  22.     spring.jpa.hibernate.ddl-auto=update
  23. 4. 创建实体并使用springdatajpa进行配置
  24.     @Entity
  25.     public class User {
  26.         // 主键(mysql主键自增)
  27.         @Id
  28.         @GeneratedValue(strategy = GenerationType.IDENTITY)
  29.         private Long id;
  30.         // 用户名
  31.         private String username;
  32.         // 密码
  33.         private String password;
  34.         // 姓名
  35.         private String name;
  36.      
  37.         //此处省略setter和getter方法... ...
  38.     }
  39. 5. 创建repository接口(也就是dao)
  40.     /**
  41.      * @ClassName UserRepository
  42.      * @Author wz157
  43.      * @Date 2018/10/19 23:18
  44.      * @Description TODO
  45.      * 两个泛型,第一个是实体,第二个是主键类型
  46.      */
  47.     public interface UserRepository extends JpaRepository<User,Long> {
  48.     
  49.         List<User> findAll();
  50.     }
  51. 6. 创建测试类进行测试
  52.     @RunWith(SpringRunner.class)
  53.     @SpringBootTest(classes = SpringbootSpringdatajpaApplication.class)
  54.     public class JpaTest {
  55.     
  56.         @Autowired
  57.         private UserRepository userRepository;
  58.     
  59.         @Test
  60.         public void testJps(){
  61.             List<User> all = userRepository.findAll();
  62.             System.out.println(all);
  63.         }
  64.     }
  65. 7. 如果是jdk9可能报错,需要额外引入依赖
  66.     <dependency>
  67.         <groupId>javax.xml.bind</groupId>
  68.         <artifactId>jaxb-api</artifactId>
  69.         <version>2.3.0</version>
  70.     </dependency>
  71.

与Redis的整合

  1. 1. 配置redis的起步依赖:
  2.     <!-- 配置使用redis启动器 -->
  3.     <dependency>
  4.         <groupId>org.springframework.boot</groupId>
  5.         <artifactId>spring-boot-starter-data-redis</artifactId>
  6.     </dependency>
  7. 2. 配置redis的连接信息(本地需要安装有Redis)
  8.     #Redis
  9.     spring.redis.host=127.0.0.1
  10.     spring.redis.port=6379
  11. 3. 编写测试类:
  12.     @RunWith(SpringRunner.class)
  13.     @SpringBootTest(classes = SpringbootSpringdatajpaApplication.class)
  14.     public class RedisTest {
  15.     
  16.         // 转化成json各执字符串
  17.         @Autowired
  18.         private RedisTemplate<String,String> redisTemplate;
  19.     
  20.         @Autowired
  21.         private UserRepository userRepository;
  22.     
  23.         @Test
  24.         public void testRedis() throws JsonProcessingException {
  25.             // 1. 从redis中获取数据,习惯json字符串
  26.             String userListJson = redisTemplate.boundValueOps("user.findAll").get();
  27.             // 2. 判断redis是否存在数据
  28.             if(null == userListJson){
  29.                 // 3. 如果不存在数据,从数据库查询
  30.                 List<User> all = userRepository.findAll();
  31.                 // 将查询出的数据存储到缓存中
  32.                 // 先将集合转换成json格式的字符串, 使用jackson进行转换
  33.                 ObjectMapper objectMapper = new ObjectMapper();
  34.                 userListJson = objectMapper.writeValueAsString(all);
  35.                 redisTemplate.boundValueOps("user.findAll").set(userListJson);
  36.                 System.out.println("=============从数据库中查询=============");
  37.             } else{
  38.                 System.out.println("从缓存中查询");
  39.             }
  40.             // 4. 如果存在,将结果返回(测试直接打印就好)
  41.             System.out.println(userListJson);
  42.         }
  43.     
  44.     }
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号