wtr@helloworld
wtr@helloworld

Springboot & Springcloud框架

1、什么是 Spring Boot？

Spring Boot 是 Spring 开源组织下的子项目，是 Spring 组件一站式解决方案，主要是简化了使用 Spring 的难度，简省了繁重的配置，提供了各种启动器，开发者能快速上手。

更多 Spring Boot 详细介绍请看这篇文章《什么是Spring Boot?》。

2、为什么要用 Spring Boot？

Spring Boot 优点非常多，如：

  • 独立运行
  • 简化配置
  • 自动配置
  • 无代码生成和XML配置
  • 应用监控
  • 上手容易
  • ...

Spring Boot 集这么多优点于一身，还有理由不使用它呢？

3、Spring Boot 的核心配置文件有哪几个？它们的区别是什么？

Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。

application 配置文件这个容易理解，主要用于 Spring Boot 项目的自动化配置。

bootstrap 配置文件有以下几个应用场景。

  • 使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；
  • 一些固定的不能被覆盖的属性；
  • 一些加密/解密的场景；

具体请看这篇文章《Spring Boot 核心配置文件详解》。

4、Spring Boot 的配置文件有哪几种格式？它们有什么区别？

.properties 和 .yml，它们的区别主要是书写格式不同。

1).properties

app.user.name = javastack

2).yml

app:
  user:
    name: javastack

另外，.yml 格式不支持 @PropertySource 注解导入配置。

5、Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：

@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。

@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。

@ComponentScan：Spring组件扫描。

6、开启 Spring Boot 特性有哪几种方式？

1）继承spring-boot-starter-parent项目

2）导入spring-boot-dependencies项目依赖

具体请参考这篇文章《Spring Boot开启的2种方式》。

7、Spring Boot 需要独立的容器运行吗？

可以不需要，内置了 Tomcat/ Jetty 等容器。

8、运行 Spring Boot 有哪几种方式？

1）打包用命令或者放到容器中运行

2）用 Maven/ Gradle 插件运行

3）直接执行 main 方法运行

9、Spring Boot 自动配置原理是什么？

注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心，首先它得是一个配置文件，其次根据类路径下是否有这个类去自动配置。

具体看这篇文章《Spring Boot自动配置原理、实战》。这里必看

10、Spring Boot 的目录结构是怎样的？

cn
 +- javastack
     +- MyApplication.java
     |
     +- customer
     |   +- Customer.java
     |   +- CustomerController.java
     |   +- CustomerService.java
     |   +- CustomerRepository.java
     |
     +- order
         +- Order.java
         +- OrderController.java
         +- OrderService.java
         +- OrderRepository.java

这个目录结构是主流及推荐的做法，而在主入口类上加上 @SpringBootApplication 注解来开启 Spring Boot 的各项能力，如自动配置、组件扫描等。具体看这篇文章《Spring Boot 主类及目录结构介绍》。

11、你如何理解 Spring Boot 中的 Starters？

Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成 Spring 及其他技术，而不需要到处找示例代码和依赖包。如你想使用 Spring JPA 访问数据库，只要加入 spring-boot-starter-data-jpa 启动器依赖就能使用了。

Starters包含了许多项目中需要用到的依赖，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖。具体请看这篇文章《Spring Boot Starters启动器》。

Starters是什么？

Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成Spring及其他技术，而不需要到处找示例代码和依赖包。如你想使用Spring JPA访问数据库，只要加入spring-boot-starter-data-jpa启动器依赖就能使用了。

Starters包含了许多项目中需要用到的依赖，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖。

Starters命名

Spring Boot官方的启动器都是以spring-boot-starter-命名的，代表了一个特定的应用类型。

第三方的启动器不能以spring-boot开头命名，它们都被Spring Boot官方保留。一般一个第三方的应该这样命名，像mybatis的mybatis-spring-boot-starter。

Starters分类

1. Spring Boot应用类启动器

启动器名称 功能描述
spring-boot-starter 包含自动配置、日志、YAML的支持。
spring-boot-starter-web 使用Spring MVC构建web 工程，包含restful，默认使用Tomcat容器。
... ...

2. Spring Boot生产启动器

启动器名称 功能描述
spring-boot-starter-actuator 提供生产环境特性，能监控管理应用。

3. Spring Boot技术类启动器

启动器名称 功能描述
spring-boot-starter-json 提供对JSON的读写支持。
spring-boot-starter-logging 默认的日志启动器，默认使用Logback。
... ...

4. 其他第三方启动器

更多可以参考下面链接。

https://github.com/spring-projects/spring-boot/blob/master/spring-boot-starters/README.adoc

12、如何在 Spring Boot 启动的时候运行一些特定的代码？

可以实现接口 ApplicationRunner 或者 CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个 run 方法，具体请看这篇文章《Spring Boot Runner启动器》。

Runner启动器

如果你想在Spring Boot启动的时候运行一些特定的代码，你可以实现接口 ApplicationRunner或者 CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个run方法。

CommandLineRunner：启动获取命令行参数。

Springboot & Springcloud框架_第1张图片

ApplicationRunner：启动获取应用启动的时候参数。

 
  
使用方式
 
  
 
  
或者这样
 
  
Springboot & Springcloud框架_第2张图片
 
  
启动顺序
 
  
如果启动的时候有多个ApplicationRunner和CommandLineRunner，想控制它们的启动顺序，可以实现 org.springframework.core.Ordered接口或者使用 org.springframework.core.annotation.Order注解。
 
  
 
  
13、Spring Boot 有哪几种读取配置的方式？
 
  
Spring Boot 可以通过 @PropertySource,@Value,@Environment, @ConfigurationProperties 来绑定变量，具体请看这篇文章《Spring Boot读取配置的几种方式》。
 
  
 
  
14、Spring Boot 支持哪些日志框架？推荐和默认的日志框架是哪个？
 
  
Spring Boot 支持 Java Util Logging, Log4j2, Lockback 作为日志框架，如果你使用 Starters 启动器，Spring Boot 将使用 Logback 作为默认日志框架，具体请看这篇文章《Spring Boot日志集成》。
 
  
 
  
15、SpringBoot 实现热部署有哪几种方式？
 
  
主要有两种方式：
 
  
     
   
  • Spring Loaded
    •  
   
  • Spring-boot-devtools
    •  
  
 
  
Spring-boot-devtools 使用方式可以参考这篇文章《Spring Boot实现热部署》。
 
  
引用devtools依赖
 
  


   org.springframework.boot

   spring-boot-devtools

   true


 
  
这样，当修改一个java类时就会热更新。
 
  
自定义配置热部署
 
  
以下配置用于自定义配置热部署，可以不设置。
 
  
 
  
Intellij Idea修改
 
  
如果是idea，需要改以下两个地方：
 
  
1、勾上自动编译或者手动重新编译
 
  
 
   
File > Settings > Compiler-Build Project automatically
 
  
 
  
2、注册
 
  
 
   
ctrl + shift + alt + / > Registry > 勾选Compiler autoMake allow when app running
 
  
 
  
注意事项
 
  
1、生产环境devtools将被禁用，如java -jar方式或者自定义的类加载器等都会识别为生产环境。
 
  
2、打包应用默认不会包含devtools，除非你禁用SpringBoot Maven插件的 excludeDevtools属性。
 
  
3、Thymeleaf无需配置 spring.thymeleaf.cache:false，devtools默认会自动设置，参考完整属性。
 
  
 
  
16、你如何理解 Spring Boot 配置加载顺序？
 
  
在 Spring Boot 里面，可以使用以下几种方式来加载配置。
 
  
1）properties文件；
 
  
2）YAML文件；
 
  
3）系统环境变量；
 
  
4）命令行参数；
 
  
等等……
 
  
具体请看这篇文章《Spring Boot 配置加载顺序详解》。
 
  
 
  
17、Spring Boot 如何定义多套不同环境配置？
 
  
提供多套配置文件，如：
 
  
applcation.properties

application-dev.properties

application-test.properties

application-prod.properties

 
  
运行时指定具体的配置文件，具体请看这篇文章《Spring Boot Profile 不同环境配置》。
 
  
 
  
18、Spring Boot 可以兼容老 Spring 项目吗，如何做？
 
  
可以兼容，使用 @ImportResource 注解导入老 Spring 项目配置文件。
 
  
 
  
19、保护 Spring Boot 应用有哪些方法？
 
  
     
   
  • 在生产中使用HTTPS
    •  
   
  • 使用Snyk检查你的依赖关系
    •  
   
  • 升级到最新版本
    •  
   
  • 启用CSRF保护
    •  
   
  • 使用内容安全策略防止XSS攻击
    •  
   
  • ...
    •  
  
 
  
更多请看这篇文章《10 种保护 Spring Boot 应用的绝佳方法》。
 
  
 
  
20、Spring Boot 2.X 有什么新特性？与 1.X 有什么区别？
 
  
     
   
  • 配置变更
    •  
   
  • JDK 版本升级
    •  
   
  • 第三方类库升级
    •  
   
  • 响应式 Spring 编程支持
    •  
   
  • HTTP/2 支持
    •  
   
  • 配置属性绑定
    •  
   
  • 更多改进与加强...
    •  
  
 
  
 
  
 
 
  
1. Spring Boot简介
 
  
 Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的
 
  
轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级
 
  
Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。
 
  
虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。
 
  
第一阶段：xml配置
 
  
在Spring 1.x时代，使用Spring开发满眼都是xml配置的Bean，随着项目的扩大，我们需要把xml配置文件放到不同的配置文件里，那时需要频繁的在开发的类和配置文件之间进行切换
 
  
第二阶段：注解配置
 
  
在Spring 2.x 时代，随着JDK1.5带来的注解支持，Spring提供了声明Bean的注解（例如@Component、@Service），大大减少了配置量。主要使用的方式是应用的基本配置（如数据库配置）用xml，业务配置用注解
 
  
第三阶段：java配置
 
  
Spring 3.0 引入了基于 Java 的配置能力，这是一种类型安全的可重构配置方式，可以代替 XML。我们目前刚好处于这个时代，Spring4.x和Spring Boot都推荐使用Java配置。
 
  
所有这些配置都代表了开发时的损耗。 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。
 
  
Spring Boot 让这一切成为了过去。
 
  
Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。
 
  
Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。
 
  
我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，或者采用传统的war部署方式。
 
  
Spring Boot 主要目标是：
 
  
l 为所有 Spring 的开发提供一个从根本上更快的入门体验
 
  
l 开箱即用，但通过自己设置参数，即可快速摆脱这种方式。
 
  
l 提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
 
  
l 绝对没有代码生成，也无需 XML 配置。
 
  
2. Spring Boot 入门
 
  

2.1. 环境准备
 
  

  数据库：MySQL
 
  
 IDE：Eclipse Mars2，idea
 
  
Spring-Boot：1.4.4
 
  
Maven： 3.3.9（官方声明1.4.4版本需要Maven 3.2+）
 
  
本地仓库：需要使用资料中的仓库
 
  
2.2. 起步依赖
 
  
 
  2.2.1. 创建一个Maven工程
  2.2.2. 添加依赖
 在pom.xml中添加依赖，效果如下
 
  


org.springframework.boot

spring-boot-starter-parent

1.4.4.RELEASE



  cn.cnn.springboot

  cnn-springboot

  0.0.1-SNAPSHOT




 

   org.springframework.boot

   spring-boot-starter-web

  


 
  
我们会惊奇地发现，我们的工程自动添加了好多好多jar 包，而这些jar 包正是我们做开发时需要导入的jar 包。
 
  
因为这些jar 包被我们刚才加入的spring-boot-starter-web 所引用了，所以添加spring-boot-starter-web后会自动把依赖传递过来。
 
  
2.3. 变更JDK版本
 我们发现默认情况下工程的JDK版本是1.6，但是通常使用的是1.7的版本
 
  
修改JDK为1.7，需要在pom.xml中添加以下配置：
 
  


1.7


 
  
使用Maven更新工程后，就发现版本已经变成1.8了
 
  
注意：
 
  
虽然JDK1.6或者1.7都可以使用Spring-Boot，但Spring-Boot官方建议使用JDK1.8。要使用JDK1.8，首先必须要配置JDK1.8后，才可以使用上述方法设置。
 
  
 
 
  
2.4. 引导类
 需要创建一个引导类：
 
  
import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class Demo {

public static void main(String[] args) {

  SpringApplication.run(Demo.class, args);

  }

}
 
  
这里多了一个@SpringBootApplication注解
 
  
@Configuration： 用于定义一个配置类
 
  
@EnableAutoConfiguration ：Spring Boot 会自动根据你jar 包的依赖来自动配置
 
  
项目。
 
  
@ComponentScan： 告诉Spring 哪个packages 的用注解标识的类会被spring
 
  
自动扫描并且装入bean 容器。
 
  
 
 
  
Banner
 
  
直接启动，控制台出现以下标识。
 
  
  .   ____          _            __ _ _
 
  
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
 
  
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 
  
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
 
  
  '  |____| .__|_| |_|_| |_\__, | / / / /
 
  
 =========|_|==============|___/=/_/_/_/
 
  
 :: Spring Boot ::        (v1.4.4.RELEASE)
 
  
 
 
  
这个标识是Spring启动标识，如果不想要，可以设置取消
 
  
import org.springframework.boot.Banner.Mode;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;



@SpringBootApplication
public class Application {

public static void main(String[] args) {

// SpringApplication.run(Application.class, args);

SpringApplication application = new SpringApplication(Application.class);

application.setBannerMode(Mode.OFF);

application.run(args);

}

}
 
  
 
 
  
参考附录二的banner设置，可以通过修改配置文件制定自己的标识。
 
  
 
 
  
2.5. 入门程序
 需求：使用Spring MVC实现Hello World输出
 
  
 
 
  
2.5.1. 原来的实现
 我们现在开始使用spring MVC 框架，实现json 数据的输出。如果按照我们原来的做法，需要在web.xml 中添加一个DispatcherServlet 的配置，还需要添加一个spring的配置文件，配置文件如下配置
 
  

  
 
  
spring加入配置










web.xml加入配置





 cnn-springboot

org.springframework.web.servlet.DispatcherServlet



contextConfigLocation

classpath:spring/*.xml







 cnn-springboot

/




 
  
还要编写Controller。。。
 
  
2.5.2. Spring-Boot的实现
 我们不需要配置文件，直接编写Controller类即可
 
  
import org.springframework.web.bind.annotation.RequestMapping;

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


@RestController
public class HelloWorldController {

@RequestMapping("info")
 public String info() {

  return "Hello world!";

 }

}


 
  
@RestController注解:其实就是@Controller和@ResponseBody注解加在一起
 
  
启动方式一：启动之前编写的引导类即可
 
  
启动方式二：使用Maven命令spring-boot:run执行即可
 
  
选择 Maven Build
 
  
在浏览器地址栏输入http://localhost:8080/info 即可看到运行结果
 
  
 
 
  
2.6. 热部署
 我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间。
 
  
能不能在我修改代码后不重启就能生效呢？可以，由于Spring Boot应用只是普通的Java应用，所以JVM热交换（hot-swapping）也能开箱即用。不过JVM热交换能替换的字节码有限制，想要更彻底的解决方案可以使用Spring Loaded项目或JRebel。
 
  
 spring-boot-devtools 模块也支持应用快速重启(restart)。
 
  
我们只需要在pom.xml加入如下配置即可
 
  


org.springframework.boot

spring-boot-devtools


 
  
3. SpringBoot整合
 
  

3.1. 整合Spring Data JPA
 3.1.1. 需求
 使用Spring Boot + Spring MVC + Spring Data JPA + EasyUI 框架组合实现部门列表查询，效果如下：
 
  
DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (

  `id` bigint(20) NOT NULL AUTO_INCREMENT,

  `user_name` varchar(100) DEFAULT NULL COMMENT '用户名',

  `password` varchar(100) DEFAULT NULL COMMENT '密码',

  `name` varchar(100) DEFAULT NULL COMMENT '姓名',

  PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;



INSERT INTO `user` VALUES ('1', 'zhangsan', '123456', '张三');

INSERT INTO `user` VALUES ('2', 'lisi', '123456', '李四');

INSERT INTO `user` VALUES ('3', 'wangwu', '123456', '王五');

INSERT INTO `user` VALUES ('4', 'zhangwei', '123456', '张伟');

INSERT INTO `user` VALUES ('5', 'lina', '123456', '李娜');

INSERT INTO `user` VALUES ('6', 'lilei', '123456', '李磊');


 
  
3.1.2. 环境准备
 3.1.2.1. 导入数据库表
 
  
在MySQL数据库执行以下语句
 
  
3.1.2.2. 创建Maven工程
 
  
cnn-info(打jar包)，在pom.xml中进行如下配置
 
  


org.springframework.boot

spring-boot-starter-parent

1.4.4.RELEASE







org.springframework.boot

spring-boot-starter-web

1.4.4.RELEASE





org.springframework.boot

spring-boot-devtools

1.4.4.RELEASE





org.springframework.boot

spring-boot-starter-data-jpa

1.4.4.RELEASE





mysql

mysql-connector-java

5.1.6






 
  
3.1.2.3. 加入Spring-Boot配置文件
 
  
在src/main/resources 下添加application.properties 配置文件，内容如下：
 
  
#DB Configuration:

spring.datasource.driverClassName=com.mysql.jdbc.Driver

spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao

spring.datasource.username=root

spring.datasource.password=root


#JPA Configuration:

spring.jpa.database=MySQL

spring.jpa.show-sql=true

spring.jpa.generate-ddl=true

spring.jpa.hibernate.ddl-auto=update

spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
 
  
此文件用于覆盖Spring Boot的默认配置，完整的配置信息参考“附录2”
 
  
 
 
  
3.1.3. 后端实现
 3.1.3.1. 创建实体类
 
  
import javax.persistence.Entity;

import javax.persistence.Id;



@Entity

public class User {

@Id

private Long id;

private String userName;

private String password;

private String name;



//添加 get 和set 方法

}



3.1.3.2. 创建DAO接口

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

import cn.cnn.info.pojo.User;



public interface UserDao extends JpaRepository {

}


3.1.3.3. 创建业务逻辑接口

import java.util.List;

import cn.cnn.info.pojo.User;



public interface UserService {

List findAll();

}



3.1.3.4. 创建业务逻辑实现类

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import cn.cnn.info.dao.UserDao;

import cn.cnn.info.pojo.User;

import cn.cnn.info.service.UserService;


@Service

public class UserServiceImpl implements UserService {


@Autowired

private UserDao userDao;


@Override

public List findAll() {

List list = this.userDao.findAll();

return list;

}

}



3.1.3.5. 创建Controller

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

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

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

import cn.cnn.info.pojo.User;

import cn.cnn.info.service.UserService;



@RestController

@RequestMapping("user")

public class UserControlelr {



@Autowired

private UserService userService;


@RequestMapping("list")

public List queryUserAll() {

List list = this.userService.findAll();

return list;

}


}


3.1.3.6. 创建引导类

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;



@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}


}
 
  
运行引导类Application，打开浏览器输入http://127.0.0.1:8080/user/list
 
  
3.1.4. 前端实现
 把资料中的static文件夹，拷贝到src/main/resources路径下
 
  
 
 
  
浏览器地址栏输入：http://127.0.0.1:8080/user.html，效果如下
 
  
 
 
  
运行引导类Application
 
  
 
 
  
3.2. 整合MyBatis
 3.2.1. 简单整合
 3.2.1.1. 加入依赖
 
  
在pom.xml中加入以下依赖
 
  




org.mybatis.spring.boot

mybatis-spring-boot-starter

1.1.1




 
  
3.2.1.2. 编写Mapper
 
  
和之前的方式一样，只是多了两个注解
 
  
@Mapper：声明Mapper接口
 
  
@Select：声明这个接口所需要使用的sql，当然，有查询的注解，肯定就有增删改的注解。
 
  
import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import org.apache.ibatis.annotations.Select;

import cn.cnn.info.pojo.User;



@Mapper

public interface UserMapper {



@Select("select * from user where name like '%${value}%'")

public List queryUserByName(String name);



}



3.2.1.3. 编写Service和Controller

添加Service调用Mapper

@Service

public class UserServiceImpl implements UserService {



@Autowired

private UserDao userDao;



@Autowired

private UserMapper userMapper;



@Override

public List findAll() {

List list = this.userDao.findAll();

return list;

}



@Override

public List queryUserByName(String name) {

List list = this.userMapper.queryUserByName(name);

return list;

}



}





修改Controller

@RestController

@RequestMapping("user")

public class UserControlelr {



@Autowired

private UserService userService;



@RequestMapping("list")

public List queryUserAll() {

List list = this.userService.findAll();

return list;

}



@RequestMapping("list/{name}")

public List queryUserAll(@PathVariable String name) {

List list = this.userService.queryUserByName(name);

return list;

}



}


 
  
3.2.1.4. 测试
 
  
浏览器地址栏输入：http://127.0.0.1:8080/user/list/张
 
  
显示效果：
 
  
 
 
  
3.2.2. 整合通用Mapper和分页助手
 以上所有的配置都是使用的默认配置，我们只需要专注java代码的开发即可，不需要加入配置文件了。
 
  
 
 
  
但并不是所有得场景都是简单的业务，有时候业务复杂，需要我们加入自定义的配置文件；有时候需要载入例如分页助手这样的插件，辅助开发，所以我们也需要了解如何加载这些配置。
 
  
 
 
  
3.2.2.1. 加入依赖
 
  
我们需要加入通用Mapper和分页插件，所以需要在pom.xml加入以下依赖
 
  
 
  
 
  
com.github.abel533
 
  
mapper
 
  
2.3.4
 
  
 
  
 
  
 
  
com.github.pagehelper
 
  
pagehelper
 
  
3.7.5
 
  
 
  
 
  
com.github.jsqlparser
 
  
jsqlparser
 
  
0.9.1
 
  
 
  
 
 
  
3.2.2.2. 修改配置文件
 
  
在application.properties添加配置
 
  
#spring集成Mybatis环境
 
  
#pojo别名扫描包
 
  
mybatis.type-aliases-package=cn.cnn.info.pojo
 
  
#加载Mybatis核心配置文件
 
  
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
 
  
mybatis.config-location=classpath:mybatis/SqlMapConfig.xml
 
  
#配置连接池，还需要在pom.xml中加入该连接池的依赖
 
  
#spring.datasource.type=com.jolbox.bonecp.BoneCPDataSource
 
  
 
 
  
在src\main\resources\mapper路径下加入UserMapper.xml配置文件
 
  
 
  
 
  
 
  
 
  
select * from user
 
  
 
  
 
  
 
 
  
在src\main\resources\mybatis加入SqlMapConfig.xml配置文件，用以加载通用Mapper和分页助手
 
  
 
  
 
  
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 
  
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
 
  
 
 
  
3.2.2.3. 编写Mapper
 
  
import java.util.List;
 
  
import org.apache.ibatis.annotations.Mapper;
 
  
import org.apache.ibatis.annotations.Select;
 
  
import cn.cnn.info.pojo.User;
 
  
 
 
  
//extends com.github.abel533.mapper.Mapper:需要继承通用Mapper
 
  
@Mapper
 
  
public interface UserMapper extends com.github.abel533.mapper.Mapper {
 
  
 
 
  
@Select("select * from user where name like '%${value}%'")
 
  
public List queryUserByName(String name);
 
  
 
 
  
// 使用UserMapper.xml配置文件
 
  
public List queryAll();
 
  
}
 
  
 
 
  
3.2.2.4. 编写Service和Controller
 
  
Service编写
 
  
import java.util.List;
 
  
import org.springframework.beans.factory.annotation.Autowired;
 
  
import org.springframework.stereotype.Service;
 
  
import com.github.pagehelper.PageHelper;
 
  
import cn.cnn.info.dao.UserDao;
 
  
import cn.cnn.info.dao.UserMapper;
 
  
import cn.cnn.info.pojo.User;
 
  
import cn.cnn.info.service.UserService;
 
  
 
 
  
@Service
 
  
public class UserServiceImpl implements UserService {
 
  
 
 
  
@Autowired
 
  
private UserDao userDao;
 
  
 
 
  
@Autowired
 
  
private UserMapper userMapper;
 
  
 
 
  
@Override
 
  
public List findAll() {
 
  
List list = this.userDao.findAll();
 
  
return list;
 
  
}
 
  
 
 
  
@Override
 
  
public List queryUserByName(String name) {
 
  
List list = this.userMapper.queryUserByName(name);
 
  
return list;
 
  
}
 
  
 
 
  
// 调用使用UserMapper.xml的Mapper
 
  
@Override
 
  
public List queryAll() {
 
  
List list = this.userMapper.queryAll();
 
  
return list;
 
  
}
 
  
 
 
  
// 使用通用Mapper和分页助手
 
  
@Override
 
  
public List queryUserByPage(Integer page, Integer rows) {
 
  
// 设置分页
 
  
PageHelper.startPage(page, rows);
 
  
// 使用通用Mapper的方法进行查询所有数据
 
  
List list = this.userMapper.select(null);
 
  
return list;
 
  
}
 
  
}
 
  
 
 
  
Controller编写
 
  
import java.util.List;
 
  
import org.springframework.beans.factory.annotation.Autowired;
 
  
import org.springframework.web.bind.annotation.PathVariable;
 
  
import org.springframework.web.bind.annotation.RequestMapping;
 
  
import org.springframework.web.bind.annotation.RestController;
 
  
import cn.cnn.info.pojo.User;
 
  
import cn.cnn.info.service.UserService;
 
  
 
 
  
@RestController
 
  
@RequestMapping("user")
 
  
public class UserControlelr {
 
  
 
 
  
@Autowired
 
  
private UserService userService;
 
  
 
 
  
@RequestMapping("list")
 
  
public List queryUserAll() {
 
  
List list = this.userService.findAll();
 
  
return list;
 
  
}
 
  
 
 
  
@RequestMapping("list/{name}")
 
  
public List queryUserAll(@PathVariable String name) {
 
  
List list = this.userService.queryUserByName(name);
 
  
return list;
 
  
}
 
  
 
 
  
@RequestMapping("list/query")
 
  
public List queryUserAll2() {
 
  
List list = this.userService.queryAll();
 
  
return list;
 
  
}
 
  
 
 
  
@RequestMapping("list/{page}/{rows}")
 
  
public List queryUserAll(@PathVariable Integer page, @PathVariable Integer rows) {
 
  
List list = this.userService.queryUserByPage(page, rows);
 
  
return list;
 
  
}
 
  
 
 
  
}
 
  
 
 
  
3.2.2.5. 测试
 
  
测试使用UserMapper.xml
 
  
浏览器地址栏输入：http://127.0.0.1:8080/user/list/query
 
  
 
 
  
测试使用通用Mapper和分页助手
 
  
浏览器地址栏输入：http://127.0.0.1:8080/user/list/2/2
 
  
 
 
  
3.3. 整合Redis
 3.3.1. 注解方式实现添加缓存
 需求：基于上例代码，将列表数据缓存到Redis
 
  
3.3.1.1. 加入依赖
 
  
在pom.xml加入依赖
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-redis
 
  
 
  
 
 
  
3.3.1.2. 修改引导类
 
  
修改开启缓存，添加注解@EnableCaching
 
  
import org.springframework.boot.SpringApplication;
 
  
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
  
import org.springframework.cache.annotation.EnableCaching;
 
  
 
 
  
@SpringBootApplication
 
  
@EnableCaching
 
  
public class Application {
 
  
public static void main(String[] args) {
 
  
SpringApplication.run(Application.class, args);
 
  
}
 
  
 
 
  
}
 
  
 
 
  
3.3.1.3. 设置实现序列化接口
 
  
需要修改实体，让实体实现序列化接口
 
  
@Entity
 
  
public class User implements Serializable {
 
  
@Id
 
  
private Long id;
 
  
private String userName;
 
  
private String password;
 
  
private String name;
 
  
 
 
  
。。。。。。
 
  
}
 
  
 
 
  
3.3.1.4. 实现添加/删除缓存
 
  
修改UserServiceImpl，添加@Cacheable注解实现缓存添加
 
  
@Override
 
  
@Cacheable(value = "userCache", key = "'user.findAll'")
 
  
public List findAll() {
 
  
System.out.println("从Mysql中查询");
 
  
List list = this.userDao.findAll();
 
  
return list;
 
  
}
 
  
 
 
  
@Override
 
  
@CacheEvict(value = "userCache", key = "'user.findAll'")
 
  
public List queryUserByName(String name) {
 
  
System.out.println("缓存清理了！");
 
  
List list = this.userMapper.queryUserByName(name);
 
  
return list;
 
  
}
 
  
 
 
  
这样设置完成后，执行findAll()方法就会使用缓存，如果缓存没有就添加缓存，而queryUserByName(String name)方法则是删除缓存
 
  
 
 
  
@Cacheable：添加/使用缓存
 
  
@CacheEvict：删除缓存
 
  
参数value是缓存的名字，在执行的时候，会找叫这个名字的缓存使用/删除
 
  
参数key默认情况下是空串””,是Spring的一种表达式语言SpEL，我们这里可以随意指定，但是需要注意一定要加单引号
 
  
 
 
  
3.3.2. redis的深入使用
 3.3.2.1. 直接操作redis
 
  
redis除了作为缓存使用，还有很多其他的作用，例如利用redis的单线程获取唯一数，例如使用redis为单点登录系统存储用户登录信息等，我们就需要直接操作redis。
 
  
 
 
  
官网提供了三种接口RedisConnectionFactory, StringRedisTemplate 和 RedisTemplate，我们可以直接注入或者自己实现其他的实现类，来直接操作redis。我们这里使用RedisTemplate来操作Redis。
 
  
 
 
  
如下所示，我们只需要直接注入RedisTemplate即可使用以下方法操作redis的五种不同的数据类型
 
  
 
 
  
 
 
  
测试：
 
  
@Autowired
 
  
private RedisTemplate redisTemplate;
 
  
 
 
  
@Override
 
  
@CacheEvict(value = "userCache", key = "'user.findAll'")
 
  
public List queryUserByName(String name) {
 
  
// 保存数据
 
  
this.redisTemplate.boundValueOps("redis").set("Hello redis !");
 
  
// 设置有效时间为100秒
 
  
this.redisTemplate.boundValueOps("redis").expire(100l, TimeUnit.SECONDS);
 
  
// 给value每次执行加一操作
 
  
this.redisTemplate.boundValueOps("count").increment(1l);
 
  
 
 
  
System.out.println("缓存清理了！");
 
  
List list = this.userMapper.queryUserByName(name);
 
  
return list;
 
  
}
 
  
 
 
  
3.3.2.2. 设置redis连接属性
 
  
redis单机版
 
  
redis启动器默认情况下会找本地的redis服务，端口号默认是6379如果需要访问其他服务器的redis，则需要在application.properties中进行如下配置：
 
  
#Redis
 
  
spring.redis.host=192.168.37.161
 
  
spring.redis.port=6379
 
  
这表示会去找ip为192.168.37.161和端口为6379的服务
 
  
 
 
  
redis集群版
 
  
#Redis
 
  
#spring.redis.host=192.168.37.161
 
  
#spring.redis.port=6379
 
  
 
 
  
#Redis Cluster
 
  
spring.redis.cluster.nodes=192.168.37.161:7001,192.168.37.161:7002,192.168.37.161:7003,192.168.37.161:7004,192.168.37.161:7005,192.168.37.161:7006
 
  
切换到集群版只需要做以上配置，配置集群版节点信息，注释掉单机版信息
 
  
 
 
  
3.4. 整合ActiveMQ
 3.4.1. 加入依赖
 在pom.xml中加入以下配置
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-activemq
 
  
 
  
 
 
  
3.4.2. 创建队列
 在引导类中添加以下方法，设置队列
 
  
@SpringBootApplication
 
  
@EnableCaching
 
  
public class Application {
 
  
public static void main(String[] args) {
 
  
SpringApplication.run(Application.class, args);
 
  
}
 
  
 
 
  
@Bean
 
  
public Queue queue() {
 
  
return new ActiveMQQueue("cnn.queue");
 
  
}
 
  
 
 
  
}
 
  
 
 
  
3.4.3. 发送消息
 编写Controller，发送消息
 
  
import javax.jms.Destination;
 
  
import org.springframework.beans.factory.annotation.Autowired;
 
  
import org.springframework.jms.core.JmsTemplate;
 
  
import org.springframework.web.bind.annotation.PathVariable;
 
  
import org.springframework.web.bind.annotation.RequestMapping;
 
  
import org.springframework.web.bind.annotation.RestController;
 
  
 
 
  
@RestController
 
  
@RequestMapping("queue")
 
  
public class QueueController {
 
  
 
 
  
//注入发送消息的对象
 
  
@Autowired
 
  
private JmsTemplate jmsTemplate;
 
  
 
 
  
//注入消息队列
 
  
@Autowired
 
  
private Destination destination;
 
  
 
 
  
//编写发送消息的方法
 
  
@RequestMapping("send/{message}")
 
  
public String send(@PathVariable String message) {
 
  
this.jmsTemplate.convertAndSend(destination, message);
 
  
return "消息发送成功!消息内容：" + message;
 
  
}
 
  
 
 
  
}
 
  
 
 
  
3.4.4. 接收消息
 编写bean，加入@Component注解让spring管理这个bean，作为接收消息的消费者
 
  
import org.springframework.jms.annotation.JmsListener;
 
  
import org.springframework.stereotype.Component;
 
  
 
 
  
@Component
 
  
public class Consumer {
 
  
 
 
  
// 接受消息方法
 
  
@JmsListener(destination = "cnn.queue")
 
  
public void readMessage(String text) {
 
  
System.out.println("接受到的消息是：" + text);
 
  
}
 
  
}
 
  
 
 
  
测试：
 
  
启动服务后，在浏览器执行http://127.0.0.1:8080/queue/send/发消息了11
 
  
即可看到消息发送成功
 
  
同时可以在控制台看到打印信息
 
  
 
 
  
我们没有安装ActiveMQ，为什么可以使用？因为Spring Boot 内置了ActiveMQ 的服务，所以我们不用单独启动也可以实现消息的发送和接收。
 
  
 
 
  
3.4.5. 使用外部服务
 首先确认有一台外部ActiveMQ服务可以使用
 
  
 
 
  
在application.properties中加入以下配置
 
  
#ActiveMQ
 
  
spring.activemq.broker-url=tcp://192.168.37.161:61616
 
  
 
 
  
这样就加入了ActiveMQ服务的地址
 
  
 
 
  
3.5. 整合junit
 3.5.1. 加入依赖
 在pom.xml中加入测试依赖
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-test
 
  
test
 
  
 
  
 
 
  
3.5.2. 编写测试类
 import javax.jms.Destination;
 
  
import org.junit.Test;
 
  
import org.junit.runner.RunWith;
 
  
import org.springframework.beans.factory.annotation.Autowired;
 
  
import org.springframework.boot.test.context.SpringBootTest;
 
  
import org.springframework.jms.core.JmsTemplate;
 
  
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
  
 
 
  
import cn.cnn.info.Application;
 
  
 
 
  
@RunWith(SpringJUnit4ClassRunner.class)
 
  
@SpringBootTest(classes = Application.class)
 
  
public class MessageTest {
 
  
 
 
  
@Autowired
 
  
private Destination destination;
 
  
 
 
  
@Autowired
 
  
private JmsTemplate jmsTemplate;
 
  
 
 
  
@Test
 
  
public void test() {
 
  
System.out.println("我发消息了！");
 
  
this.jmsTemplate.convertAndSend(destination, "Hello ActiveMQ!");
 
  
}
 
  
 
 
  
}
 
  
SpringRunner 与SpringJUnit4ClassRunner 是继承关系，但是没有不同的地方，只是看起来子类SpringRunner要短一些而已。
 
  
 
 
  
@SpringBootTest 注解的class 属性要指定引导类的class
 
  
 
 
  
3.6. 整合dubbox
 3.6.1. 环境准备
 3.6.1.1. dubbox
 
  
dubbo是一个分布式的服务架构，可直接用于生产环境作为SOA服务框架。官网首页：http://dubbo.io/  
 
  
 
 
  
淘宝将这个项目开源出来以后，得到了不少同行的支持，包括：
 
  
当当网的扩展版本dubbox ：https://github.com/dangdangdotcom/dubbox
 
  
京东的扩展版本jd-hydra: http://www.oschina.NET/p/jd-hydra
 
  
 
 
  
不过，略有遗憾的是， dubbo由于某些原因导致dubbo团队已经解散，已经很牛没有更新了，反到是当当网的扩展版本仍在持续发展。因为dubbox支持更新的spring版本，所以我们使用dubbox。
 
  
 
 
  
Dubbox在maven中央仓库并没有对应的依赖,所以我们需要自己动手将其发布到我们的本地仓库来使用。
 
  
 
 
  
使用git从码云上把dubbox的代码clone下来，
 
  
地址：https://git.oschina.net/wuyu15255872976/dubbox.git
 
  
 
 
  
执行Maven命令把工程安装到本地仓库
 
  
命令：clean install -Dmaven.test.skip
 
  
 
 
  
课程资料提供的仓库已经安装好了，可以直接使用
 
  
 
 
  
3.6.1.2. spring-boot-starter-dubbo
 
  
我们以前在使用dubbo的时候都是用的xml配置。而在整合Spring Boot的时候可以使用@ImportResource注解来引入的dubbo的xml配置。
 
  
但是Spring Boot本身并不推荐xml配置。怎么解决这个矛盾,我们可以自己准备一个Spring Boot Starter dubbo的项目来引导Spring Boot对Dubbo的自动化配置。已经有人开发好了这个自动化配置项目，我们直接使用就行了
 
  
 
 
  
使用git从码云上把spring-boot-starter-dubbo的代码clone下来，
 
  
地址：https://git.oschina.net/wuyu15255872976/spring-boot-starter-dubbo.git
 
  
 
 
  
执行Maven命令把工程安装到本地仓库
 
  
命令：clean install -Dmaven.test.skip
 
  
 
 
  
为了统一管理，把pom.xml修改为如下：
 
  
 
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
  
4.0.0
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-parent
 
  
1.4.4.RELEASE
 
  
 
  
spring-boot-starter-dubbo
 
  
1.4.4.RELEASE
 
  
Spring Boot Dubbo Rpc
 
  
Spring Boot Dubbo Rpc
 
  
http://projects.spring.io/spring-boot/
 
  
 
  
Pivotal Software, Inc.
 
  
http://www.spring.io
 
  
 
  
 
  
UTF-8
 
  
1.7
 
  
 
  
 
 
  
    
 
  
 
  
org.springframework.boot
 
  
spring-boot-actuator
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-configuration-processor
 
  
 
  
 
  
com.alibaba
 
  
dubbo
 
  
2.8.5-SNAPSHOT
 
  
 
  
 
  
spring
 
  
org.springframework
 
  
 
  
 
  
 
  
 
  
 
  
com.github.sgroschupf
 
  
zkclient
 
  
0.1
 
  
 
  
 
  
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-dependencies
 
  
1.4.4.RELEASE
 
  
pom
 
  
import
 
  
 
  
 
  
 
  
 
 
  
 
  
 
  
 
  
maven-source-plugin
 
  
 
  
true
 
  
 
  
 
  
 
  
compile
 
  
 
  
jar
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
 
  
课程资料提供的仓库已经安装好了，可以直接使用
 
  
 
 
  
3.6.1.3. zookeeper注册中心
 
  
我们使用zookeeper作为dubbo的注册中心。
 
  
这里使用的zookeeper注册中心地址是：192.168.37.161:2181
 
  
修改hosts，配置注册中心的域名是zookeeper.taotao.com
 
  
 
 
  
3.6.2. 搭建项目
 taotao-parent作为所有工程的父工程
 
  
taotao- interface作为提供pojo和抽取服务接口的
 
  
taotao-provider作为服务提供者
 
  
taotao-consumer作为服务消费者
 
  
 
 
  
3.6.2.1. 搭建taotao-parent
 
  
创建taotao-parent，并打pom包，这里配置公共使用的依赖。
 
  
修改pom.xml为如下
 
  
 
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
  
4.0.0
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-parent
 
  
1.4.4.RELEASE
 
  
 
  
com.taotao
 
  
taotao-parent
 
  
0.0.1-SNAPSHOT
 
  
pom
 
  
 
 
  
 
  
 
  
1.7
 
  
 
  
 
 
  
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-test
 
  
test
 
  
 
  
 
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-web
 
  
true
 
  
 
  
 
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-dubbo
 
  
1.4.4.RELEASE
 
  
true
 
  
 
  
 
  
 
  
 
 
  
3.6.2.2. 搭建taotao-interface
 
  
创建taotao-interface，并打jar包。
 
  
修改pom.xml为如下，几乎不用配置
 
  
 
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
  
4.0.0
 
  
 
  
com.taotao
 
  
taotao-parent
 
  
0.0.1-SNAPSHOT
 
  
 
  
com.taotao
 
  
taotao-interface
 
  
0.0.1-SNAPSHOT
 
  
 
  
 
 
  
3.6.2.3. 搭建taotao-provider
 
  
创建taotao-provider，并打jar包。
 
  
修改pom.xml为如下
 
  
 
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
  
4.0.0
 
  
 
  
com.taotao
 
  
taotao-parent
 
  
0.0.1-SNAPSHOT
 
  
 
  
com.taotao
 
  
taotao-provider
 
  
0.0.1-SNAPSHOT
 
  
 
 
  
 
  
 
  
 
  
com.taotao
 
  
taotao-interface
 
  
0.0.1-SNAPSHOT
 
  
 
  
 
 
  
 
  
 
  
org.mybatis.spring.boot
 
  
mybatis-spring-boot-starter
 
  
1.1.1
 
  
 
  
 
 
  
 
  
 
  
mysql
 
  
mysql-connector-java
 
  
 
  
 
  
 
  
 
 
  
3.6.2.4. 搭建taotao-consumer
 
  
创建taotao-consumer，并打jar包。
 
  
修改pom.xml为如下
 
  
 
  
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
  
4.0.0
 
  
 
  
com.taotao
 
  
taotao-parent
 
  
0.0.1-SNAPSHOT
 
  
 
  
com.taotao
 
  
taotao-consumer
 
  
0.0.1-SNAPSHOT
 
  
 
 
  
 
  
 
  
 
  
com.taotao
 
  
taotao-interface
 
  
0.0.1-SNAPSHOT
 
  
 
  
 
  
 
  
 
 
  
3.7. 实现功能
 3.7.1. 实现taotao-interface
 编写pojo
 
  
import java.io.Serializable;
 
  
 
 
  
public class User implements Serializable {
 
  
private Long id;
 
  
private String userName;
 
  
private String password;
 
  
private String name;
 
  
get/set方法
 
  
}
 
  
 
 
  
编写Service接口
 
  
import com.taotao.common.pojo.User;
 
  
 
 
  
public interface UserService {
 
  
 
 
  
public User queryUserById(Long id);
 
  
}
 
  
 
 
  
3.7.2. 实现taotao-provider
 编写UserMapper
 
  
import org.apache.ibatis.annotations.Mapper;
 
  
import org.apache.ibatis.annotations.Select;
 
  
import com.taotao.common.pojo.User;
 
  
 
 
  
@Mapper
 
  
public interface UserMapper {
 
  
 
 
  
@Select("select * from user where id=#{id}")
 
  
public User queryUserById(Long id);
 
  
 
 
  
}
 
  
 
 
  
编写UserServiceImpl实现类
 
  
import org.springframework.beans.factory.annotation.Autowired;
 
  
import com.alibaba.dubbo.config.annotation.Service;
 
  
import com.taotao.common.consumer.UserService;
 
  
import com.taotao.common.pojo.User;
 
  
import com.taotao.mapper.UserMapper;
 
  
 
 
  
@Service
 
  
public class UserServiceImpl implements UserService {
 
  
 
 
  
@Autowired
 
  
private UserMapper userMapper;
 
  
 
 
  
@Override
 
  
public User queryUserById(Long id) {
 
  
User user = this.userMapper.queryUserById(id);
 
  
return user;
 
  
}
 
  
}
 
  
 
 
  
编写引导类
 
  
import org.springframework.boot.SpringApplication;
 
  
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
  
import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;
 
  
 
 
  
@SpringBootApplication
 
  
@EnableDubboAutoConfiguration
 
  
public class ProviderApplication {
 
  
public static void main(String[] args) {
 
  
SpringApplication.run(ProviderApplication.class, args);
 
  
}
 
  
}
 
  
 
 
  
在src/main/resources加入配置文件application.properties
 
  
#DB Configuration:
 
  
spring.datasource.driverClassName=com.mysql.jdbc.Driver
 
  
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao
 
  
spring.datasource.username=root
 
  
spring.datasource.password=root
 
  
 
 
  
#配置服务器访问端口号
 
  
server.port=8081
 
  
 
 
  
#配置dubbo信息
 
  
#配置服务名称
 
  
spring.dubbo.application.name=taotao-provider
 
  
#注册中心类型
 
  
spring.dubbo.registry.protocol=zookeeper
 
  
#注册中心连接方式
 
  
spring.dubbo.registry.address=manager.taotao.com:2181
 
  
#配置服务调用所使用的协议
 
  
spring.dubbo.protocol.name=dubbo
 
  
#配置服务端口号
 
  
spring.dubbo.protocol.port=20880
 
  
#配置服务访问地址
 
  
spring.dubbo.protocol.host=localhost
 
  
#配置dubbo扫描
 
  
spring.dubbo.scan=com.taotao.provider
 
  
 
 
  
 
 
  
3.7.3. 实现taotao-consumer
 编写Controller
 
  
import org.springframework.web.bind.annotation.PathVariable;
 
  
import org.springframework.web.bind.annotation.RequestMapping;
 
  
import org.springframework.web.bind.annotation.RestController;
 
  
import com.alibaba.dubbo.config.annotation.Reference;
 
  
import com.taotao.common.consumer.UserService;
 
  
import com.taotao.common.pojo.User;
 
  
 
 
  
@RestController
 
  
@RequestMapping("user")
 
  
public class UserController {
 
  
 
 
  
@Reference
 
  
private UserService userService;
 
  
 
 
  
@RequestMapping("{id}")
 
  
public User queryUserById(@PathVariable Long id) {
 
  
User user = this.userService.queryUserById(id);
 
  
return user;
 
  
}
 
  
}
 
  
 
 
  
编写引导类
 
  
import org.springframework.boot.SpringApplication;
 
  
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
  
import com.alibaba.boot.dubbo.EnableDubboAutoConfiguration;
 
  
 
 
  
@SpringBootApplication
 
  
@EnableDubboAutoConfiguration
 
  
public class ConsumerApplication {
 
  
public static void main(String[] args) {
 
  
SpringApplication.run(ConsumerApplication.class, args);
 
  
}
 
  
}
 
  
 
 
  
在src/main/resources加入配置文件application.properties
 
  
#配置服务器访问端口号
 
  
server.port=8080
 
  
 
 
  
#配置dubbo信息
 
  
#配置服务名称
 
  
spring.dubbo.application.name=taotao-consumer
 
  
#注册中心类型
 
  
spring.dubbo.registry.protocol=zookeeper
 
  
#注册中心连接方式
 
  
spring.dubbo.registry.address=manager.taotao.com:2181
 
  
#配置服务调用所使用的协议
 
  
spring.dubbo.protocol.name=dubbo
 
  
#配置服务端口号
 
  
spring.dubbo.protocol.port=20880
 
  
#配置服务访问地址
 
  
spring.dubbo.protocol.host=localhost
 
  
#配置dubbo扫描
 
  
spring.dubbo.scan=com.taotao.consumer
 
  
 
 
  
4. Spring Boot深入学习
 4.1. 读取配置文件
 4.1.1. .读取核心配置文件
 在工程的src/main/resources 下修改核心配置文件
 
  
application.properties, 添加内容如下
 
  
name=传智播客
 
  
url=http://www.cnn.cn
 
  
 
 
  
在Controller中添加：
 
  
@Resource
 
  
private Environment env;
 
  
 
 
  
@RequestMapping("list")
 
  
public List queryUserAll() {
 
  
System.out.println(env.getProperty("name"));
 
  
System.out.println(env.getProperty("url"));
 
  
List list = this.userService.findAll();
 
  
return list;
 
  
}
 
  
 
 
  
就可以直接把配置文件信息打印出来。
 
  
注意包名是：org.springframework.core.env.Environment
 
  
 
 
  
 
 
  
4.1.2. 读取自定义文件
 在工程的src/main/resources 下构建自定义配置文件mail.properties, 内容如下
 
  
mail.host=smtp.sina.com
 
  
mail.port=25
 
  
mail.username=cnn
 
  
mail.password=heima
 
  
 
 
  
编写JavaBean
 
  
import org.springframework.boot.context.properties.ConfigurationProperties;
 
  
import org.springframework.context.annotation.Configuration;
 
  
 
 
  
@Configuration
 
  
@ConfigurationProperties(locations = "classpath:mail.properties", prefix = "mail")
 
  
public class MailProperties {
 
  
private String host;
 
  
private Integer port;
 
  
private String username; 
 
  
private String password;
 
  
 
 
  
set/get
 
  
}
 
  
 
 
  
改造Controller
 
  
@Autowired
 
  
private MailProperties mailProperties;
 
  
 
 
  
@RequestMapping("/mailInfo")
 
  
public String mailInfo() {
 
  
return mailProperties.getHost() + "
" + mailProperties.getPort() + "
" + mailProperties.getUsername()
 
  
+ "
" + mailProperties.getPassword();
 
  
}
 
  
 
 
  
打印效果
 
  
 
 
  
4.2. 打jar包
 在工程的pom.xml中添加以下依赖
 
  
 
  
 
  
 
  
org.springframework.boot
 
  
spring-boot-maven-plugin
 
  
 
  
 
  
 
  
 
 
  
我们目前的工程采用的是jar 的打包方式，所以我们在执行package 命令后，
 
  
会产生一个jar 包。
 
  
我们进入到这个目录用压缩软件打开此jar 包，其中我们发现了一个叫lib 的文件夹，打开lib 文件夹发现此文件夹下全是工程依赖的jar包，甚至还有tomcat。这种包含有jar 包的jar包，我们称之为fatJAR( 胖jar 包)
 
  
 
 
  
由于fatJAR 本身就包括tomcat , 我们就不需要另外部署了，直接在命令行就可以把我们的应用启动起来，在命令行，进入到jar 包所在的目录，我们可以通过以下java –jar命令来执行此jar 包。
 
  
 
 
  
在控制台会出现启动信息，在浏览器访问程序
 
  
 
 
  
4.3. 打war包
 spring-boot 默认提供内嵌的tomcat，所以打包直接生成jar 包，用java
 
  
-jar 命令就可以启动。但是，有时候我们更希望一个tomcat 来管理多个项目，
 
  
这种情况下就需要项目是war 格式的包而不是jar 格式的包。
 
  
我们按照以下步骤完成对工程的改造
 
  
（1）修改pom.xml
 
  
将打包方式修改为war
 
  
war
 
  
 
 
  
添加依赖
 
  
 
  
org.springframework.boot
 
  
spring-boot-starter-tomcat
 
  
provided
 
  
 
  
 
 
  
spring-boot-starter-tomcat 是原来被传递过来的依赖，默认会打到包里，所
 
  
以我们再次引入此依赖，并指定依赖范围为provided，这样tomcat 相关的jar
 
  
就不会打包到war 里了.
 
  
 
 
  
（2）添加ServletInitializer
 
  
import org.springframework.boot.builder.SpringApplicationBuilder;
 
  
import
 
  
org.springframework.boot.context.web.SpringBootServletInitializer;
 
  
public class ServletInitializer extends SpringBootServletInitializer {
 
  
@Override
 
  
protected SpringApplicationBuilder configure(SpringApplicationBuilder
 
  
application) {
 
  
return application.sources(Application.class);
 
  
}
 
  
}
 
  
由于我们采用web3.0 规范，是没有web.xml 的，而此类的作用与web.xml
 
  
相同。
 
  
（3）运行package 打包命令生成war 包
 
  
生成后将war 包放入tomcat，启动tomcat，测试完成的功能是否可以使用。
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
 
 
  
附录1. Spring-boot的启动器
 (摘自Spring-boot 1.4.4官方文档)
 
  
1. Spring Boot application starters
 
  
spring-boot-starter-thymeleaf
 
  
使用Thymeleaf视图构建MVC Web应用程序
 
  
 
 
  
spring-boot-starter-ws
 
  
使用Spring Web服务。1.4不推荐使用，推荐使用spring-boot-starter-web-services
 
  
 
 
  
spring-boot-starter-data-couchbase
 
  
Starter for using Couchbase document-oriented database and Spring Data Couchbase
 
  
 
 
  
spring-boot-starter-artemis
 
  
使用Apache Artemis启动JMS消息传递
 
  
 
 
  
spring-boot-starter-web-services
 
  
使用Spring Web服务
 
  
 
 
  
spring-boot-starter-mail
 
  
支持使用Java Mail和Spring Framework发送电子邮件
 
  
 
 
  
spring-boot-starter-data-redis
 
  
使用Redis键值数据存储与Spring Data Redis和Jedis客户端
 
  
 
 
  
spring-boot-starter-web
 
  
启动器构建web，包括RESTful，使用Spring MVC的应用程序。使用Tomcat作为默认嵌入式容器
 
  
 
 
  
spring-boot-starter-data-gemfire
 
  
Starter for using GemFire distributed data store and Spring Data GemFire
 
  
 
 
  
spring-boot-starter-activemq
 
  
使用Apache ActiveMQ启动JMS消息传递
 
  
 
 
  
spring-boot-starter-data-elasticsearch
 
  
使用Elasticsearch搜索和分析引擎和Spring Data Elasticsearch
 
  
 
 
  
spring-boot-starter-integration
 
  
Starter for using Spring Integration
 
  
 
 
  
spring-boot-starter-test
 
  
Spring Boot应用程序用于测试包括JUnit，Hamcrest和Mockito
 
  
 
 
  
spring-boot-starter-hornetq
 
  
使用HornetQ启动JMS消息传递。1.4已弃用，推荐使用spring-boot-starter-artemis
 
  
 
 
  
spring-boot-starter-jdbc
 
  
使用JDBC与Tomcat JDBC连接池
 
  
 
 
  
spring-boot-starter-mobile
 
  
使用Spring Mobile构建Web应用程序的入门
 
  
 
 
  
spring-boot-starter-validation
 
  
使用Java Bean校验与Hibernate校验器
 
  
 
 
  
spring-boot-starter-hateoas
 
  
使用Spring MVC和Spring HATEOAS构建基于超媒体的RESTful Web应用程序的入门
 
  
 
 
  
spring-boot-starter-jersey
 
  
使用JAX-RS和Jersey构建RESTful Web应用程序的入门。 spring-boot-starter-web的替代品
 
  
 
 
  
spring-boot-starter-data-neo4j
 
  
使用Neo4j图数据库和Spring Data Neo4j
 
  
 
 
  
spring-boot-starter-websocket
 
  
使用Spring Framework的WebSocket支持构建WebSocket应用程序
 
  
 
 
  
spring-boot-starter-aop
 
  
使用Spring AOP和AspectJ进行面向方面编程
 
  
 
 
  
spring-boot-starter-amqp
 
  
使用Spring AMQP和Rabbit MQ的入门
 
  
 
 
  
spring-boot-starter-data-cassandra
 
  
使用Cassandra分布式数据库和Spring Data Cassandra
 
  
 
 
  
spring-boot-starter-social-facebook
 
  
使用Spring Social Facebook
 
  
 
 
  
spring-boot-starter-jta-atomikos
 
  
使用Atomikos进行JTA事务
 
  
 
 
  
spring-boot-starter-security
 
  
使用Spring Security
 
  
 
 
  
spring-boot-starter-mustache
 
  
使用Mustache视图构建MVC Web应用程序
 
  
 
 
  
spring-boot-starter-data-jpa
 
  
使用Spring Data JPA与Hibernate
 
  
 
 
  
spring-boot-starter
 
  
核心启动器，包括自动配置支持，日志记录和YAML
 
  
 
 
  
spring-boot-starter-velocity
 
  
使用Velocity视图构建MVC Web应用程序。1.4已弃用
 
  
 
 
  
spring-boot-starter-groovy-templates
 
  
使用Groovy模板视图构建MVC Web应用程序
 
  
 
 
  
spring-boot-starter-freemarker
 
  
使用FreeMarker视图构建MVC Web应用程序
 
  
 
 
  
spring-boot-starter-batch
 
  
使用Spring Batch
 
  
 
 
  
spring-boot-starter-redis
 
  
使用Redis键值数据存储与Spring Data Redis和Jedis客户端的入门。1.4已弃用，建议使用spring-boot-starter-data-redis
 
  
 
 
  
spring-boot-starter-social-linkedin
 
  
Stater for using Spring Social LinkedIn
 
  
 
 
  
spring-boot-starter-cache
 
  
支持使用Spring Framework的缓存
 
  
 
 
  
spring-boot-starter-data-solr
 
  
使用带有Spring Data Solr的Apache Solr搜索平台
 
  
 
 
  
spring-boot-starter-data-mongodb
 
  
使用MongoDB和Spring Data MongoDB
 
  
 
 
  
spring-boot-starter-jooq
 
  
使用jOOQ访问SQL数据库。 spring-boot-starter-data-jpa或spring-boot-starter-jdbc的替代方法
 
  
 
 
  
spring-boot-starter-jta-narayana
 
  
Spring Boot启动Narayana JTA
 
  
 
 
  
spring-boot-starter-cloud-connectors
 
  
启动者使用Spring Cloud连接器，简化了连接到云平台中的服务，如Cloud Foundry和Heroku
 
  
 
 
  
spring-boot-starter-jta-bitronix
 
  
使用Bitronix进行JTA事务
 
  
 
 
  
spring-boot-starter-social-twitter
 
  
使用Spring Social Twitter
 
  
 
 
  
spring-boot-starter-data-rest
 
  
使用Spring Data REST通过REST暴露Spring数据存储库
 
  
 
 
  
2. Spring Boot production starters
 
  
spring-boot-starter-actuator
 
  
使用Spring Boot的Actuator，提供生产就绪的功能，以帮助您监视和管理您的应用程序
 
  
 
 
  
spring-boot-starter-remote-shell
 
  
使用CRaSH远程shell通过SSH监视和管理您的应用程序
 
  
 
 
  
3. Spring Boot technical starters
 
  
spring-boot-starter-undertow
 
  
使用Undertow作为嵌入式servlet容器。 spring-boot-starter-tomcat的替代方法
 
  
 
 
  
spring-boot-starter-jetty
 
  
使用Jetty作为嵌入式servlet容器的。 spring-boot-starter-tomcat的替代方法
 
  
 
 
  
spring-boot-starter-logging
 
  
使用Logback进行日志记录。 默认日志启动器
 
  
 
 
  
spring-boot-starter-tomcat
 
  
使用Tomcat作为嵌入式servlet容器。 spring-boot-starter-web使用的默认servlet容器
 
  
 
 
  
spring-boot-starter-log4j2
 
  
使用Log4j2进行日志记录。 spring-boot-starter-logging的替代方法
  
 
  
 
  
SpringBoot为我们做的自动配置，确实方便快捷，但是对于新手来说，如果不大懂SpringBoot内部启动原理，以后难免会吃亏。所以这次博主就跟你们一起一步步揭开SpringBoot的神秘面纱，让它不在神秘。
 
  
 
  
 
 
  
正文
 
  
我们开发任何一个Spring Boot项目，都会用到如下的启动类
 
  
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
 
  
从上面代码可以看出，Annotation定义（@SpringBootApplication）和类定义（SpringApplication.run）最为耀眼，所以要揭开SpringBoot的神秘面纱，我们要从这两位开始就可以了。
 
  
SpringBootApplication背后的秘密
 
  
@Target(ElementType.TYPE)            // 注解的适用范围，其中TYPE用于描述类、接口（包括包注解类型）或enum声明
@Retention(RetentionPolicy.RUNTIME)  // 注解的生命周期，保留到class文件中（三个生命周期）
@Documented                          // 表明这个注解应该被javadoc记录
@Inherited                           // 子类可以继承该注解
@SpringBootConfiguration             // 继承了Configuration，表示当前是注解类
@EnableAutoConfiguration             // 开启springboot的注解功能，springboot的四大神器之一，其借助@import的帮助
@ComponentScan(excludeFilters = {    // 扫描路径设置（具体使用待确认）
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}
 
  
虽然定义使用了多个Annotation进行了原信息标注，但实际上重要的只有三个Annotation：
 
  
     
   
  • @Configuration（@SpringBootConfiguration点开查看发现里面还是应用了@Configuration）
    •  
   
  • @EnableAutoConfiguration
    •  
   
  • @ComponentScan
    •  
  
 
  
所以，如果我们使用如下的SpringBoot启动类，整个SpringBoot应用依然可以与之前的启动类功能对等：
 
  
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
 
  
每次写这3个比较累，所以写一个@SpringBootApplication方便点。接下来分别介绍这3个Annotation。
 
  
@Configuration
 
  
这里的@Configuration对我们来说不陌生，它就是JavaConfig形式的Spring Ioc容器的配置类使用的那个@Configuration，SpringBoot社区推荐使用基于JavaConfig的配置形式，所以，这里的启动类标注了@Configuration之后，本身其实也是一个IoC容器的配置类。
 举几个简单例子回顾下，XML跟config配置方式的区别：
 
  
     
   
  •  
    
       
     
    • 表达形式层面
       基于XML配置的方式是这样：
      •  
    
    •  
  
 
  


    

 
  
而基于JavaConfig的配置方式是这样：
 
  
@Configuration
public class MockConfiguration{
    //bean定义
}
 
  
任何一个标注了@Configuration的Java类定义都是一个JavaConfig配置类。
 
  
     
   
  •  
    
       
     
    • 注册bean定义层面
       基于XML的配置形式是这样：
      •  
    
    •  
  
 
  

    ...

 
  
而基于JavaConfig的配置形式是这样的：
 
  
@Configuration
public class MockConfiguration{
    @Bean
    public MockService mockService(){
        return new MockServiceImpl();
    }
}
 
  
任何一个标注了@Bean的方法，其返回值将作为一个bean定义注册到Spring的IoC容器，方法名将默认成该bean定义的id。
 
  
     
   
  •  
    
       
     
    • 表达依赖注入关系层面
       为了表达bean与bean之间的依赖关系，在XML形式中一般是这样：
      •  
    
    •  
  
 
  

    



 
  
而基于JavaConfig的配置形式是这样的：
 
  
@Configuration
public class MockConfiguration{
    @Bean
    public MockService mockService(){
        return new MockServiceImpl(dependencyService());
    }
    
    @Bean
    public DependencyService dependencyService(){
        return new DependencyServiceImpl();
    }
}
 
  
如果一个bean的定义依赖其他bean,则直接调用对应的JavaConfig类中依赖bean的创建方法就可以了。
 
  
@ComponentScan
 
  
@ComponentScan这个注解在Spring中很重要，它对应XML配置中的元素，@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（比如@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。
 
  
我们可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，如果不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。
 
  
 
 
  
     
   
  1.  
    注：所以SpringBoot的启动类最好是放在root package下，因为默认不指定basePackages。
     
    2.  
   
  2.  
    3.  
  
 
  
@EnableAutoConfiguration
 
  
个人感觉@EnableAutoConfiguration这个Annotation最为重要，所以放在最后来解读，大家是否还记得Spring框架提供的各种名字为@Enable开头的Annotation定义？比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等，@EnableAutoConfiguration的理念和做事方式其实一脉相承，简单概括一下就是，借助@Import的支持，收集和注册特定场景相关的bean定义。
 
  
     
   
  • @EnableScheduling是通过@Import将Spring调度框架相关的bean定义都加载到IoC容器。
    •  
   
  • @EnableMBeanExport是通过@Import将JMX相关的bean定义加载到IoC容器。
    •  
  
 
  
而@EnableAutoConfiguration也是借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，仅此而已！
 
  
@EnableAutoConfiguration作为一个复合Annotation,其自身定义关键信息如下：
 
  
@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}
 
  
两个比较重要的注解：
 
  
     
   
  •  
    @AutoConfigurationPackage：自动配置包
     
    •  
   
  •  
    @Import: 导入自动配置的组件
     
    •  
  
 
  
AutoConfigurationPackage注解：
 
  
复制代码
 
  
1     static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
2 
3         @Override
4         public void registerBeanDefinitions(AnnotationMetadata metadata,
5                 BeanDefinitionRegistry registry) {
6             register(registry, new PackageImport(metadata).getPackageName());
7         }
 
  
复制代码
 
  
它其实是注册了一个Bean的定义。
 
  
new PackageImport(metadata).getPackageName()，它其实返回了当前主程序类的 同级以及子级     的包组件。
 
  
 
  
以上图为例，DemoApplication是和demo包同级，但是demo2这个类是DemoApplication的父级，和example包同级
 
  
也就是说，DemoApplication启动加载的Bean中，并不会加载demo2，这也就是为什么，我们要把DemoApplication放在项目的最高级中。
 
  
Import(AutoConfigurationImportSelector.class)注解：
 
  
 
  
可以从图中看出  AutoConfigurationImportSelector 继承了 DeferredImportSelector 继承了 ImportSelector
 
  
ImportSelector有一个方法为：selectImports。
 
  
@Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                .loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List configurations = getCandidateConfigurations(annotationMetadata,
                attributes);
        configurations = removeDuplicates(configurations);
        Set exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return StringUtils.toStringArray(configurations);
    }
 
  
可以看到第九行，它其实是去加载  public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";外部文件。这个外部文件，有很多自动配置的类。如下：
 
  
 
  
其中，最关键的要属@Import(EnableAutoConfigurationImportSelector.class)，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器。就像一只“八爪鱼”一样。
 
  
 
 
  
 
 
  
自动配置幕后英雄：SpringFactoriesLoader详解
 
  
借助于Spring框架原有的一个工具类：SpringFactoriesLoader的支持，@EnableAutoConfiguration可以智能的自动配置功效才得以大功告成！
 
  
SpringFactoriesLoader属于Spring框架私有的一种扩展方案，其主要功能就是从指定的配置文件META-INF/spring.factories加载配置。
 
  
public abstract class SpringFactoriesLoader {
    //...
    public static  List loadFactories(Class factoryClass, ClassLoader classLoader) {
        ...
    }


    public static List loadFactoryNames(Class factoryClass, ClassLoader classLoader) {
        ....
    }
}
 
  
配合@EnableAutoConfiguration使用的话，它更多是提供一种配置查找的功能支持，即根据@EnableAutoConfiguration的完整类名org.springframework.boot.autoconfigure.EnableAutoConfiguration作为查找的Key,获取对应的一组@Configuration类
 
  
 
  
 
  
上图就是从SpringBoot的autoconfigure依赖包中的META-INF/spring.factories配置文件中摘录的一段内容，可以很好地说明问题。
 
  
所以，@EnableAutoConfiguration自动配置的魔法骑士就变成了：从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类，然后汇总为一个并加载到IoC容器。
 
  

 SpringBoot的启动原理基本算是讲完了，为了方便记忆，我根据上面的分析画了张图
 
  
 
  
 
 
  
深入探索SpringApplication执行流程
 
  
SpringApplication的run方法的实现是我们本次旅程的主要线路，该方法的主要流程大体可以归纳如下：
 
  
1） 如果我们使用的是SpringApplication的静态run方法，那么，这个方法里面首先要创建一个SpringApplication对象实例，然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候，它会提前做几件事情：
 
  
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
        return new SpringApplication(sources).run(args);
    }
 
  
     
   
  • 根据classpath里面是否存在某个特征类（org.springframework.web.context.ConfigurableWebApplicationContext）来决定是否应该创建一个为Web应用使用的ApplicationContext类型。
    •  
   
  • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer。
    •  
   
  • 使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationListener。
    •  
   
  • 推断并设置main方法的定义类。
    •  
  
 
  
@SuppressWarnings({ "unchecked", "rawtypes" })
    private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            this.sources.addAll(Arrays.asList(sources));
        }
        this.webEnvironment = deduceWebEnvironment();
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = deduceMainApplicationClass();
    }
 
  
2） SpringApplication实例初始化完成并且完成设置后，就开始执行run方法的逻辑了，方法执行伊始，首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法，告诉这些SpringApplicationRunListener，“嘿，SpringBoot应用要开始执行咯！”。
 
  
public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
　　　　　　　// 核心点：会打印springboot的启动标志，直到server.port端口启动
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            return context;
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }
 
  
3） 创建并配置当前Spring Boot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）。
 
  
private ConfigurableEnvironment prepareEnvironment(
            SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments) {
        // Create and configure the environment
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        listeners.environmentPrepared(environment);
        if (!this.webEnvironment) {
            environment = new EnvironmentConverter(getClassLoader())
                    .convertToStandardEnvironmentIfNecessary(environment);
        }
        return environment;
    }
 
  
4） 遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法，告诉他们：“当前SpringBoot应用使用的Environment准备好了咯！”。
 
  
public void environmentPrepared(ConfigurableEnvironment environment) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.environmentPrepared(environment);
        }
    }
 
  
5） 如果SpringApplication的showBanner属性被设置为true，则打印banner。
 
  
private Banner printBanner(ConfigurableEnvironment environment) {
        if (this.bannerMode == Banner.Mode.OFF) {
            return null;
        }
        ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader
                : new DefaultResourceLoader(getClassLoader());
        SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
                resourceLoader, this.banner);
        if (this.bannerMode == Mode.LOG) {
            return bannerPrinter.print(environment, this.mainApplicationClass, logger);
        }
        return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
    }
 
  
6） 根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果，决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成，然后根据条件决定是否添加ShutdownHook，决定是否使用自定义的BeanNameGenerator，决定是否使用自定义的ResourceLoader，当然，最重要的，将之前准备好的Environment设置给创建好的ApplicationContext使用。
 
  
 
 
  
7） ApplicationContext创建好之后，SpringApplication会再次借助Spring-FactoriesLoader，查找并加载classpath中所有可用的ApplicationContext-Initializer，然后遍历调用这些ApplicationContextInitializer的initialize（applicationContext）方法来对已经创建好的ApplicationContext进行进一步的处理。
 
  
@SuppressWarnings({ "rawtypes", "unchecked" })
    protected void applyInitializers(ConfigurableApplicationContext context) {
        for (ApplicationContextInitializer initializer : getInitializers()) {
            Class requiredType = GenericTypeResolver.resolveTypeArgument(
                    initializer.getClass(), ApplicationContextInitializer.class);
            Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
            initializer.initialize(context);
        }
    }
 
  
8） 遍历调用所有SpringApplicationRunListener的contextPrepared()方法。
 
  
private void prepareContext(ConfigurableApplicationContext context,
            ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
            ApplicationArguments applicationArguments, Banner printedBanner) {
        context.setEnvironment(environment);
        postProcessApplicationContext(context);
        applyInitializers(context);
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
            logStartupInfo(context.getParent() == null);
            logStartupProfileInfo(context);
        }

        // Add boot specific singleton beans
        context.getBeanFactory().registerSingleton("springApplicationArguments",
                applicationArguments);
        if (printedBanner != null) {
            context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
        }

        // Load the sources
        Set sources = getSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        load(context, sources.toArray(new Object[sources.size()]));
        listeners.contextLoaded(context);
    } 
  
9） 最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。
 
  
private void prepareAnalyzer(ConfigurableApplicationContext context,
            FailureAnalyzer analyzer) {
        if (analyzer instanceof BeanFactoryAware) {
            ((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
        }
    }
 
  
10） 遍历调用所有SpringApplicationRunListener的contextLoaded()方法。
 
  
public void contextLoaded(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.contextLoaded(context);
        }
    }
 
  
11） 调用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。
 
  
private void refreshContext(ConfigurableApplicationContext context) {
        refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            }
            catch (AccessControlException ex) {
                // Not allowed in some environments.
            }
        }
    }
 
  
12） 查找当前ApplicationContext中是否注册有CommandLineRunner，如果有，则遍历执行它们。
 
  
private void callRunners(ApplicationContext context, ApplicationArguments args) {
        List runners = new ArrayList();
        runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
        runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
        AnnotationAwareOrderComparator.sort(runners);
        for (Object runner : new LinkedHashSet(runners)) {
            if (runner instanceof ApplicationRunner) {
                callRunner((ApplicationRunner) runner, args);
            }
            if (runner instanceof CommandLineRunner) {
                callRunner((CommandLineRunner) runner, args);
            }
        }
    } 
  
13） 正常情况下，遍历执行SpringApplicationRunListener的finished()方法、（如果整个过程出现异常，则依然调用所有SpringApplicationRunListener的finished()方法，只不过这种情况下会将异常信息一并传入处理）
 去除事件通知点后，整个流程如下：
 
  
public void finished(ConfigurableApplicationContext context, Throwable exception) {
        for (SpringApplicationRunListener listener : this.listeners) {
            callFinishedListener(listener, context, exception);
        }
    }
 
  
 
  
 
  
 
 
  
总结
 
  
到此，SpringBoot的核心组件完成了基本的解析，综合来看，大部分都是Spring框架背后的一些概念和实践方式，SpringBoot只是在这些概念和实践上对特定的场景事先进行了固化和升华，而也恰恰是这些固化让我们开发基于Sping框架的应用更加方便高效。
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Springboot & Springcloud框架)

        

            

                
    
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 自我意识
                        徐立华

                        
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
    
                    
    • 
                    
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作
                        GPJnCrbBdl
python开发语言
                        
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • 今天是总结
                        薛帅

                        
    今天来个最后一天的总结。为什么要学习写作技巧呢？就如同建房子，如果想要住的安全、舒服，我们要先打地基，建房子的框架，这样才能随意的装修。那么我们要怎么建好才能建好写作的地基呢？1走直路，少弯路01利他：能够给别人带来价值。02吸引：吸住读者的眼球。03打动：打动人心，引起共鸣。04说服：用数据说话。05刻意：通过有意识的训练。06修改：好的文章至上修改10遍。07模仿：10万+的文章必有成功的道理
    
                    
    • 
                    
  • Python 课程10-单元测试
                        可愛小吉
Python教學python单元测试开发语言TDDunittest
                        
    前言在现代软件开发中，单元测试已成为一种必不可少的实践。通过测试，我们可以确保每个功能模块在开发和修改过程中按预期工作，从而减少软件缺陷，提高代码质量。而测试驱动开发（TDD）则进一步将测试作为开发的核心部分，先编写测试，再编写代码，以测试为指导开发出更稳定、更可靠的代码。Python提供了强大的unittest模块，它是Python标准库的一部分，专门用于编写和执行单元测试。与其他测试框架相比，
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • 【自动化测试】UI自动化的分类、如何选择合适的自动化测试工具以及其中appium的设计理念、引擎和引擎如何工作
                        Lossya
ui自动化测试工具自动化测试appium
                        
    引言UI自动化测试主要针对软件的用户界面进行测试，以确保用户界面元素的交互和功能符合预期文章目录引言一、UI自动化的分类1.1基于代码的自动化测试1.2基于录制/回放的自动化测试1.3基于框架的自动化测试1.4按测试对象分类1.5按测试层次分类1.6按测试执行方式分类1.7按测试目的分类二、如何选择合适的自动化测试工具2.1项目需求分析2.2工具特性评估2.3成本考虑2.4团队技能2.5试用和评估
    
                    
    • 
                    
  • python爬取微信小程序数据,python爬取小程序数据
                        2301_81900439
前端
                        
    大家好，小编来为大家解答以下问题，python爬取微信小程序数据，python爬取小程序数据，现在让我们一起来看看吧！Python爬虫系列之微信小程序实战基于Scrapy爬虫框架实现对微信小程序数据的爬取首先，你得需要安装抓包工具，这里推荐使用Charles，至于怎么使用后期有时间我会出一个事例最重要的步骤之一就是分析接口，理清楚每一个接口功能，然后连接起来形成接口串思路,再通过Spider的回调
    
                    
    • 
                    
  • 字节二面
                        Redstone Monstrosity
前端面试
                        
    1.假设你是正在面试前端开发工程师的候选人，面试官让你详细说出你上一段实习过程的收获和感悟。在上一段实习过程中，我获得了宝贵的实践经验和深刻的行业洞察，以下是我的主要收获和感悟：一、专业技能提升框架应用熟练度：通过实际项目，我深入掌握了React、Vue等前端框架的使用，不仅提升了编码效率，还学会了如何根据项目需求选择合适的框架。问题解决能力：在实习期间，我遇到了许多预料之外的技术难题。通过查阅文
    
                    
    • 
                    
  • 【Golang】实现 Excel 文件下载功能
                        RumIV
Golanggolangexcel开发语言
                        
    在当今的网络应用开发中，提供数据导出功能是一项常见的需求。Excel作为一种广泛使用的电子表格格式，通常是数据导出的首选格式之一。在本教程中，我们将学习如何使用Go语言和GinWeb框架来创建一个Excel文件，并允许用户通过HTTP请求下载该文件。准备工作在开始之前，请确保您的开发环境中已经安装了Go语言和相关的开发工具。此外，您还需要安装GinWeb框架和excelize包，这两个包都将用于我
    
                    
    • 
                    
  • golang 实现文件上传下载
                        wangwei830
go
                        
    Gin框架上传下载上传（支持批量上传）httpRouter.POST("/upload",func(ctx*gin.Context){forms,err:=ctx.MultipartForm()iferr!=nil{fmt.Println("error",err)}files:=forms.File["fileName"]for_,v:=rangefiles{iferr:=ctx.SaveUplo
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • Hadoop
                        傲雪凌霜，松柏长青
后端大数据hadoop大数据分布式
                        
    ApacheHadoop是一个开源的分布式计算框架，主要用于处理海量数据集。它具有高度的可扩展性、容错性和高效的分布式存储与计算能力。Hadoop核心由四个主要模块组成，分别是HDFS（分布式文件系统）、MapReduce（分布式计算框架）、YARN（资源管理）和HadoopCommon（公共工具和库）。1.HDFS（HadoopDistributedFileSystem）HDFS是Hadoop生
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •